refactoring of the example and add 2 new nodes

Author: VinciGit00

examples/custom_graph.py examples/fetch_html_node_example.py

@@ -1,52 +1,52 @@
-"""
-Example of custom graph using existing nodes
-"""
-
-import os
-from dotenv import load_dotenv
-
-from langchain_openai import ChatOpenAI
-from scrapegraphai.graphs import BaseGraph
-from scrapegraphai.nodes import FetchHTMLNode, ParseHTMLNode, GenerateAnswerNode
-
-# load the environment variables
-load_dotenv()
-openai_key = os.getenv("API_KEY")
-if not openai_key:
-    print("Error: OpenAI API key not found in environment variables.")
-
-# Define the configuration for the language model
-llm_config = {
-    "api_key": openai_key,
-    "model_name": "gpt-3.5-turbo",
-    "temperature": 0,
-    "streaming": True
-}
-model = ChatOpenAI(**llm_config)
-
-# define the nodes for the graph
-fetch_html_node = FetchHTMLNode("fetch_html")
-parse_document_node = ParseHTMLNode("parse_document")
-generate_answer_node = GenerateAnswerNode(model, "generate_answer")
-
-# create the graph
-graph = BaseGraph(
-    nodes={
-        fetch_html_node,
-        parse_document_node,
-        generate_answer_node
-    },
-    edges={
-        (fetch_html_node, parse_document_node),
-        (parse_document_node, generate_answer_node)
-    },
-    entry_point=fetch_html_node
-)
-
-# execute the graph
-inputs = {"keys": {"user_input": "What is the title of the page?", "url": "https://example.com"}}
-result = graph.execute(inputs)
-
-# get the answer from the result
-answer = result["keys"].get("answer", "No answer found.")
-print(answer)
+"""
+Example of custom graph using existing nodes
+"""
+
+import os
+from dotenv import load_dotenv
+
+from langchain_openai import ChatOpenAI
+from scrapegraphai.graphs import BaseGraph
+from scrapegraphai.nodes import FetchHTMLNode, ParseHTMLNode, GenerateAnswerNode
+
+# load the environment variables
+load_dotenv()
+openai_key = os.getenv("API_KEY")
+if not openai_key:
+    print("Error: OpenAI API key not found in environment variables.")
+
+# Define the configuration for the language model
+llm_config = {
+    "api_key": openai_key,
+    "model_name": "gpt-3.5-turbo",
+    "temperature": 0,
+    "streaming": True
+}
+model = ChatOpenAI(**llm_config)
+
+# define the nodes for the graph
+fetch_html_node = FetchHTMLNode("fetch_html")
+parse_document_node = ParseHTMLNode("parse_document")
+generate_answer_node = GenerateAnswerNode(model, "generate_answer")
+
+# create the graph
+graph = BaseGraph(
+    nodes={
+        fetch_html_node,
+        parse_document_node,
+        generate_answer_node
+    },
+    edges={
+        (fetch_html_node, parse_document_node),
+        (parse_document_node, generate_answer_node)
+    },
+    entry_point=fetch_html_node
+)
+
+# execute the graph
+inputs = {"keys": {"user_input": "What is the title of the page?", "url": "https://example.com"}}
+result = graph.execute(inputs)
+
+# get the answer from the result
+answer = result["keys"].get("answer", "No answer found.")
+print(answer)

examples/graph_example.py

@@ -0,0 +1,90 @@
+""" 
+Module for creating the basic node
+"""
+from abc import ABC, abstractmethod
+from openai import OpenAI
+
+
+class ImageToTextNode(ABC):
+    """
+    An abstract base class for nodes in a graph-based workflow. Each node is 
+    intended to perform a specific action when executed as part of the graph's 
+    processing flow.
+
+    Attributes:
+        node_name (str): A unique identifier for the node.
+        node_type (str): Specifies the node's type, which influences how the 
+                         node interacts within the graph. Valid values are 
+                         "node" for standard nodes and "conditional_node" for 
+                         nodes that determine the flow based on conditions.
+
+    Methods:
+        execute(state): An abstract method that subclasses must implement. This 
+                        method should contain the logic that the node executes 
+                        when it is reached in the graph's flow. It takes the 
+                        graph's current state as input and returns the updated 
+                        state after execution.
+
+    Args:
+        node_name (str): The unique identifier name for the node. This name is 
+                         used to reference the node within the graph.
+        node_type (str): The type of the node, limited to "node" or 
+                         "conditional_node". This categorization helps in 
+                         determining the node's role and behavior within the 
+                         graph.
+
+    Raises:
+        ValueError: If the provided `node_type` is not one of the allowed 
+                    values ("node" or "conditional_node"), a ValueError is 
+                    raised to indicate the incorrect usage.
+    """
+
+    def __init__(self, llm, node_name: str = "ParseImageToText"):
+        """
+        Initialize the node with a unique identifier and a specified node type.
+
+        Args:
+            node_name (str): The unique identifier name for the node.
+            node_type (str): The type of the node, limited to "node" or "conditional_node".
+
+        Raises:
+            ValueError: If node_type is not "node" or "conditional_node".
+        """
+        super().__init__(node_name, "node")
+        self.llm = llm
+
+    @abstractmethod
+    def execute(self, state: dict, url: str) -> str:
+        """
+        Execute the node's logic and return the updated state.
+        Args:
+            state (dict): The current state of the graph.
+            url (str): url of the image where to 
+        :return: The updated state after executing this node.
+        """
+        # Da fixare
+        client = OpenAI(api_key=self.llm.openai_api_key)
+
+        if not self.llm.model_name == "gpt-4-vision-preview":
+            raise ValueError("Model is not gpt-4-vision-preview")
+
+        response = client.chat.completions.create(
+            model=self.llm.model_name,
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": "What’s in this image?"},
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": url,
+                            },
+                        },
+                    ],
+                }
+            ],
+            max_tokens=300,
+        )
+
+        return response.choices[0]

scrapegraphai/nodes/image_to_text_node.py

@@ -9,10 +9,8 @@
 
 class TextToSpeachNode(BaseNode):
     """
-    A node responsible for parsing HTML content from a document using specified tags. 
-    It uses BeautifulSoupTransformer for parsing, providing flexibility in extracting
-    specific parts of an HTML document based on the tags provided in the state.
-
+    A node responsible for parsing text content from a document using specified tags and readinf 
+    it with the selected voiceq.
     This node enhances the scraping workflow by allowing for targeted extraction of 
     content, thereby optimizing the processing of large HTML documents.
 
@@ -29,14 +27,14 @@ class TextToSpeachNode(BaseNode):
         the specified tags, if provided, and updates the state with the parsed content.
     """
 
-    def __init__(self, llm, node_name="ParseTextToSpeach"):
+    def __init__(self, llm, node_name: str = "ParseTextToSpeach"):
         """
         Initializes the ParseHTMLNode with a node name.
         """
         super().__init__(node_name, "node")
         self.llm = llm
 
-    def execute(self, state: dict, text: str, output_path: str = str, model: str = "tts-1", voice="alloy"):
+    def execute(self, state: dict, text: str, output_path: str = str, model: str = "tts-1", voice="alloy") -> dict:
         """
         Executes the node's logic to parse the HTML document based on specified tags. 
         If tags are provided in the state, the document is parsed accordingly; otherwise,