Merge pull request #737 from ScrapeGraphAI/prompt-refactoring

Author: VinciGit00

scrapegraphai/nodes/conditional_node.py

@@ -2,8 +2,8 @@
 Module for implementing the conditional node
 """
 from typing import Optional, List
-from .base_node import BaseNode
 from simpleeval import simple_eval, EvalWithCompoundTypes
+from .base_node import BaseNode
 
 class ConditionalNode(BaseNode):
     """

scrapegraphai/nodes/generate_code_node.py

@@ -140,7 +140,17 @@ def execute(self, state: dict) -> dict:
 
     def overall_reasoning_loop(self, state: dict) -> dict:
         """
-        overrall_reasoning_loop
+        Executes the overall reasoning loop to generate and validate the code.
+
+        Args:
+            state (dict): The current state of the reasoning process.
+
+        Returns:
+            dict: The final state after the reasoning loop.
+
+        Raises:
+            RuntimeError: If the maximum number of iterations 
+            is reached without obtaining the desired code.
         """
         self.logger.info(f"--- (Generating Code) ---")
         state["generated_code"] = self.generate_initial_code(state)
@@ -166,7 +176,8 @@ def overall_reasoning_loop(self, state: dict) -> dict:
             if state["errors"]["validation"]:
                 continue
 
-            self.logger.info(f"--- (Checking if the informations exctrcated are the ones Requested) ---")
+            self.logger.info(f"""--- (Checking if the informations
+                             exctrcated are the ones Requested) ---""")
             state = self.semantic_comparison_loop(state)
             if state["errors"]["semantic"]:
                 continue
@@ -183,7 +194,13 @@ def overall_reasoning_loop(self, state: dict) -> dict:
 
     def syntax_reasoning_loop(self, state: dict) -> dict:
         """
-        syntax reasoning loop
+        Executes the syntax reasoning loop to ensure the generated code has correct syntax.
+
+        Args:
+            state (dict): The current state of the reasoning process.
+
+        Returns:
+            dict: The updated state after the syntax reasoning loop.
         """
         for _ in range(self.max_iterations["syntax"]):
             syntax_valid, syntax_message = self.syntax_check(state["generated_code"])
@@ -203,10 +220,17 @@ def syntax_reasoning_loop(self, state: dict) -> dict:
 
     def execution_reasoning_loop(self, state: dict) -> dict:
         """
-        execution of the reasoning loop
+        Executes the execution reasoning loop to ensure the generated code runs without errors.
+
+        Args:
+            state (dict): The current state of the reasoning process.
+
+        Returns:
+            dict: The updated state after the execution reasoning loop.
         """
         for _ in range(self.max_iterations["execution"]):
-            execution_success, execution_result = self.create_sandbox_and_execute(state["generated_code"])
+            execution_success, execution_result = self.create_sandbox_and_execute(
+                                                                                state["generated_code"])
             if execution_success:
                 state["execution_result"] = execution_result
                 state["errors"]["execution"] = []
@@ -222,6 +246,16 @@ def execution_reasoning_loop(self, state: dict) -> dict:
         return state
 
     def validation_reasoning_loop(self, state: dict) -> dict:
+        """
+        Executes the validation reasoning loop to ensure the 
+        generated code's output matches the desired schema.
+
+        Args:
+            state (dict): The current state of the reasoning process.
+
+        Returns:
+            dict: The updated state after the validation reasoning loop.
+        """
         for _ in range(self.max_iterations["validation"]):
             validation, errors = self.validate_dict(state["execution_result"],
                                                     self.output_schema.schema())
@@ -232,12 +266,24 @@ def validation_reasoning_loop(self, state: dict) -> dict:
             state["errors"]["validation"] = errors
             self.logger.info(f"--- (Code Output not compliant to the deisred Output Schema) ---")
             analysis = validation_focused_analysis(state, self.llm_model)
-            self.logger.info(f"--- (Regenerating Code to make the Output compliant to the deisred Output Schema) ---")
-            state["generated_code"] = validation_focused_code_generation(state, analysis, self.llm_model)
+            self.logger.info(f"""--- (Regenerating Code to make the
+                             Output compliant to the deisred Output Schema) ---""")
+            state["generated_code"] = validation_focused_code_generation(state,
+                                                                         analysis, self.llm_model)
             state["generated_code"] = extract_code(state["generated_code"])
         return state
 
     def semantic_comparison_loop(self, state: dict) -> dict:
+        """
+        Executes the semantic comparison loop to ensure the generated code's
+          output is semantically equivalent to the reference answer.
+
+        Args:
+            state (dict): The current state of the reasoning process.
+
+        Returns:
+            dict: The updated state after the semantic comparison loop.
+        """
         for _ in range(self.max_iterations["semantic"]):
             comparison_result = self.semantic_comparison(state["execution_result"],
                                                          state["reference_answer"])
@@ -246,16 +292,25 @@ def semantic_comparison_loop(self, state: dict) -> dict:
                 return state
 
             state["errors"]["semantic"] = comparison_result["differences"]
-            self.logger.info(f"--- (The informations exctrcated are not the all ones requested) ---")
+            self.logger.info(f"""--- (The informations exctrcated
+                             are not the all ones requested) ---""")
             analysis = semantic_focused_analysis(state, comparison_result, self.llm_model)
-            self.logger.info(f"--- (Regenerating Code to obtain all the infromation requested) ---")
-            state["generated_code"] = semantic_focused_code_generation(state, analysis, self.llm_model)
+            self.logger.info(f"""--- (Regenerating Code to
+                                obtain all the infromation requested) ---""")
+            state["generated_code"] = semantic_focused_code_generation(state,
+                                                                       analysis, self.llm_model)
             state["generated_code"] = extract_code(state["generated_code"])
         return state
 
     def generate_initial_code(self, state: dict) -> str:
         """
-        function for generating the initial code
+        Generates the initial code based on the provided state.
+
+        Args:
+            state (dict): The current state of the reasoning process.
+
+        Returns:
+            str: The initially generated code.
         """
         prompt = PromptTemplate(
             template=TEMPLATE_INIT_CODE_GENERATION,
@@ -275,7 +330,15 @@ def generate_initial_code(self, state: dict) -> str:
 
     def semantic_comparison(self, generated_result: Any, reference_result: Any) -> Dict[str, Any]:
         """
-        semtantic comparison formula
+        Performs a semantic comparison between the generated result and the reference result.
+
+        Args:
+            generated_result (Any): The result generated by the code.
+            reference_result (Any): The reference result for comparison.
+
+        Returns:
+            Dict[str, Any]: A dictionary containing the comparison result, 
+            differences, and explanation.
         """
         reference_result_dict = self.output_schema(**reference_result).dict()
         if are_content_equal(generated_result, reference_result_dict):
@@ -312,7 +375,13 @@ def semantic_comparison(self, generated_result: Any, reference_result: Any) -> D
 
     def syntax_check(self, code):
         """
-        syntax checker
+        Checks the syntax of the provided code.
+
+        Args:
+            code (str): The code to be checked for syntax errors.
+
+        Returns:
+            tuple: A tuple containing a boolean indicating if the syntax is correct and a message.
         """
         try:
             ast.parse(code)
@@ -322,7 +391,14 @@ def syntax_check(self, code):
 
     def create_sandbox_and_execute(self, function_code):
         """
-        Create a sandbox environment
+        Creates a sandbox environment and executes the provided function code.
+
+        Args:
+            function_code (str): The code to be executed in the sandbox.
+
+        Returns:
+            tuple: A tuple containing a boolean indicating if 
+            the execution was successful and the result or error message.
         """
         sandbox_globals = {
             'BeautifulSoup': BeautifulSoup,
@@ -350,7 +426,15 @@ def create_sandbox_and_execute(self, function_code):
 
     def validate_dict(self, data: dict, schema):
         """
-        validate_dict method
+        Validates the provided data against the given schema.
+
+        Args:
+            data (dict): The data to be validated.
+            schema (dict): The schema against which the data is validated.
+
+        Returns:
+            tuple: A tuple containing a boolean indicating 
+            if the validation was successful and a list of errors if any.
         """
         try:
             validate(instance=data, schema=schema)

scrapegraphai/prompts/description_node_prompts.py

@@ -5,6 +5,6 @@
 DESCRIPTION_NODE_PROMPT = """
 You are a  scraper and you have just scraped the
 following content from a website. \n
-Please provide a description summary of maximum of 20 words 
-Content of the website: {content}
+Please provide a description summary of maximum of 20 words. \n
+CONTENT OF THE WEBSITE: {content}
 """

scrapegraphai/prompts/generate_answer_node_csv_prompts.py

@@ -36,4 +36,4 @@
 Output instructions: {format_instructions}\n 
 User question: {question}\n
 csv content: {context}\n 
-"""
+"""

scrapegraphai/prompts/generate_answer_node_omni_prompts.py

@@ -40,4 +40,4 @@
 User question: {question}\n
 Website content: {context}\n 
 Image descriptions: {img_desc}\n
-"""
+"""

scrapegraphai/prompts/generate_code_node_prompts.py

@@ -209,4 +209,4 @@
 {reference_result}
 
 Generate the corrected code, applying the suggestions from the analysis to make the output semantically equivalent to the reference result. Output ONLY the corrected Python code, WITHOUT ANY ADDITIONAL TEXT.
-"""
+"""

scrapegraphai/prompts/html_analyzer_node_prompts.py

@@ -67,4 +67,4 @@
 Focus on providing a concise, step-by-step analysis of the HTML structure and the key elements needed for data extraction. Do not include any code examples or implementation logic. Keep the response focused and avoid general statements.**
 In your code do not include backticks.
 **HTML Analysis for Data Extraction**:
-"""
+"""

scrapegraphai/prompts/merge_answer_node_prompts.py

@@ -13,4 +13,4 @@
 OUTPUT INSTRUCTIONS: {format_instructions}\n
 USER PROMPT: {user_prompt}\n
 WEBSITE CONTENT: {website_content}
-"""
+"""

scrapegraphai/prompts/prompt_refiner_node_prompts.py

@@ -60,4 +60,4 @@
 Please generate only the analysis and no other text.
 
 **Response**:
-"""
+"""

scrapegraphai/prompts/reasoning_node_prompts.py

@@ -1,5 +1,5 @@
 """
-Reasoning prompts helper
+Reasoning prompts helper module
 """
 
 TEMPLATE_REASONING = """