Fix whitespace formatting errors (W291, W292, W293)

Co-authored-by: VinciGit00 <88108002+VinciGit00@users.noreply.github.com>

Author: Copilot

scrapegraphai/graphs/markdownify_graph.py

@@ -80,4 +80,4 @@ def execute(
                 - Dictionary with the markdown result in the "markdown" key
                 - List of execution logs
         """
-        return super().execute(initial_state) 
+        return super().execute(initial_state)

scrapegraphai/helpers/models_tokens.py

@@ -32,7 +32,6 @@
         "o1-preview": 128000,
         "o1-mini": 128000,
         "o1": 128000,
-        "gpt-4.5-preview": 128000,
         "o3-mini": 200000,
     },
     "azure_openai": {

scrapegraphai/models/xai.py

@@ -19,4 +19,4 @@ def __init__(self, **llm_config):
             llm_config["openai_api_key"] = llm_config.pop("api_key")
         llm_config["openai_api_base"] = "https://api.x.ai/v1"
 
-        super().__init__(**llm_config) 
+        super().__init__(**llm_config)

scrapegraphai/nodes/markdownify_node.py

@@ -64,4 +64,4 @@ def execute(self, state: dict) -> dict:
         # Update state with markdown content
         state.update({self.output[0]: markdown_content})
 
-        return state 
+        return state

scrapegraphai/utils/code_error_analysis.py

@@ -80,10 +80,10 @@ def validate_validation_errors(cls, v):
 def get_optimal_analysis_template(error_type: str) -> str:
     """
     Returns the optimal prompt template based on the error type.
-    
+
     Args:
         error_type (str): Type of error to analyze.
-        
+
     Returns:
         str: The prompt template text.
     """
@@ -106,10 +106,10 @@ def syntax_focused_analysis(state: Dict[str, Any], llm_model) -> str:
 
     Returns:
         str: The result of the syntax error analysis.
-        
+
     Raises:
         InvalidStateError: If state is missing required keys.
-        
+
     Example:
         >>> state = {
             'generated_code': 'print("Hello World")',
@@ -123,24 +123,24 @@ def syntax_focused_analysis(state: Dict[str, Any], llm_model) -> str:
             generated_code=state.get("generated_code", ""),
             errors=state.get("errors", {})
         )
-        
+
         # Check if syntax errors exist
         if "syntax" not in validated_state.errors:
             raise InvalidStateError("No syntax errors found in state dictionary")
-        
+
         # Create prompt template and chain
         prompt = PromptTemplate(
             template=get_optimal_analysis_template("syntax"),
             input_variables=["generated_code", "errors"]
         )
         chain = prompt | llm_model | StrOutputParser()
-        
+
         # Execute chain with validated state
         return chain.invoke({
             "generated_code": validated_state.generated_code,
             "errors": validated_state.errors["syntax"]
         })
-    
+
     except KeyError as e:
         raise InvalidStateError(f"Missing required key in state dictionary: {e}")
     except Exception as e:
@@ -157,10 +157,10 @@ def execution_focused_analysis(state: Dict[str, Any], llm_model) -> str:
 
     Returns:
         str: The result of the execution error analysis.
-        
+
     Raises:
         InvalidStateError: If state is missing required keys.
-        
+
     Example:
         >>> state = {
             'generated_code': 'print(x)',
@@ -178,22 +178,22 @@ def execution_focused_analysis(state: Dict[str, Any], llm_model) -> str:
             html_code=state.get("html_code", ""),
             html_analysis=state.get("html_analysis", "")
         )
-        
+
         # Create prompt template and chain
         prompt = PromptTemplate(
             template=get_optimal_analysis_template("execution"),
             input_variables=["generated_code", "errors", "html_code", "html_analysis"],
         )
         chain = prompt | llm_model | StrOutputParser()
-        
+
         # Execute chain with validated state
         return chain.invoke({
             "generated_code": validated_state.generated_code,
             "errors": validated_state.errors["execution"],
             "html_code": validated_state.html_code,
             "html_analysis": validated_state.html_analysis,
         })
-    
+
     except KeyError as e:
         raise InvalidStateError(f"Missing required key in state dictionary: {e}")
     except Exception as e:
@@ -211,10 +211,10 @@ def validation_focused_analysis(state: Dict[str, Any], llm_model) -> str:
 
     Returns:
         str: The result of the validation error analysis.
-        
+
     Raises:
         InvalidStateError: If state is missing required keys.
-        
+
     Example:
         >>> state = {
             'generated_code': 'return {"name": "John"}',
@@ -232,22 +232,22 @@ def validation_focused_analysis(state: Dict[str, Any], llm_model) -> str:
             json_schema=state.get("json_schema", {}),
             execution_result=state.get("execution_result", {})
         )
-        
+
         # Create prompt template and chain
         prompt = PromptTemplate(
             template=get_optimal_analysis_template("validation"),
             input_variables=["generated_code", "errors", "json_schema", "execution_result"],
         )
         chain = prompt | llm_model | StrOutputParser()
-        
+
         # Execute chain with validated state
         return chain.invoke({
             "generated_code": validated_state.generated_code,
             "errors": validated_state.errors["validation"],
             "json_schema": validated_state.json_schema,
             "execution_result": validated_state.execution_result,
         })
-    
+
     except KeyError as e:
         raise InvalidStateError(f"Missing required key in state dictionary: {e}")
     except Exception as e:
@@ -268,10 +268,10 @@ def semantic_focused_analysis(
 
     Returns:
         str: The result of the semantic error analysis.
-        
+
     Raises:
         InvalidStateError: If state or comparison_result is missing required keys.
-        
+
     Example:
         >>> state = {
             'generated_code': 'def add(a, b): return a + b'
@@ -288,28 +288,28 @@ def semantic_focused_analysis(
             generated_code=state.get("generated_code", ""),
             errors=state.get("errors", {})
         )
-        
+
         # Validate comparison_result
         if "differences" not in comparison_result:
             raise InvalidStateError("comparison_result missing 'differences' key")
         if "explanation" not in comparison_result:
             raise InvalidStateError("comparison_result missing 'explanation' key")
-        
+
         # Create prompt template and chain
         prompt = PromptTemplate(
             template=get_optimal_analysis_template("semantic"),
             input_variables=["generated_code", "differences", "explanation"],
         )
         chain = prompt | llm_model | StrOutputParser()
-        
+
         # Execute chain with validated inputs
         return chain.invoke({
             "generated_code": validated_state.generated_code,
             "differences": json.dumps(comparison_result["differences"], indent=2),
             "explanation": comparison_result["explanation"],
         })
-    
+
     except KeyError as e:
         raise InvalidStateError(f"Missing required key: {e}")
     except Exception as e:
-        raise AnalysisError(f"Semantic analysis failed: {str(e)}")
+        raise AnalysisError(f"Semantic analysis failed: {str(e)}")