graphai-lib 0.0.2__tar.gz → 0.0.4__tar.gz

graphai_lib-0.0.4/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: graphai-lib
+Version: 0.0.4
+Summary: Not an AI framework
+Requires-Python: <3.14,>=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: semantic-router>=0.1.5
+Requires-Dist: networkx>=3.4.2
+Requires-Dist: matplotlib>=3.10.0
+Provides-Extra: dev
+Requires-Dist: ipykernel>=6.25.0; extra == "dev"
+Requires-Dist: ruff>=0.1.5; extra == "dev"
+Requires-Dist: pytest>=8.2.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.12.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: pytest-xdist>=3.5.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24.0; extra == "dev"
+Requires-Dist: mypy>=1.7.1; extra == "dev"
+Requires-Dist: black[jupyter]<24.5.0,>=23.12.1; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: pydoc-markdown>=4.8.2; python_version < "3.12" and extra == "docs"
+
+# Philosophy
+
+1. Async-first
+2. Minimize abstractions
+3. One way to do one thing
+4. Graph-based AI
+
+## Installation
+
+```
+pip install -qU graphai-lib
+```

{graphai_lib-0.0.2 → graphai_lib-0.0.4}/README.md

@@ -3,4 +3,10 @@
 1. Async-first
 2. Minimize abstractions
 3. One way to do one thing
-4. Graph-based AI
+4. Graph-based AI
+
+## Installation
+
+```
+pip install -qU graphai-lib
+```

{graphai_lib-0.0.2 → graphai_lib-0.0.4}/graphai/graph.py

@@ -1,21 +1,41 @@
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Optional
 from graphai.nodes.base import _Node
 from graphai.callback import Callback
 from semantic_router.utils.logger import logger
 
 
 class Graph:
-    def __init__(self, max_steps: int = 10):
-        self.nodes = []
-        self.edges = []
-        self.start_node = None
-        self.end_nodes = []
+    def __init__(self, max_steps: int = 10, initial_state: Optional[Dict[str, Any]] = None):
+        self.nodes: Dict[str, _Node] = {}
+        self.edges: List[Any] = []
+        self.start_node: Optional[_Node] = None
+        self.end_nodes: List[_Node] = []
         self.Callback = Callback
         self.callback = None
         self.max_steps = max_steps
+        self.state = initial_state or {}
+
+    # Allow getting and setting the graph's internal state
+    def get_state(self) -> Dict[str, Any]:
+        """Get the current graph state."""
+        return self.state
+
+    def set_state(self, state: Dict[str, Any]):
+        """Set the graph state."""
+        self.state = state
+
+    def update_state(self, values: Dict[str, Any]):
+        """Update the graph state with new values."""
+        self.state.update(values)
+
+    def reset_state(self):
+        """Reset the graph state to an empty dict."""
+        self.state = {}
 
     def add_node(self, node):
-        self.nodes.append(node)
+        if node.name in self.nodes:
+            raise Exception(f"Node with name '{node.name}' already exists.")
+        self.nodes[node.name] = node
         if node.is_start:
             if self.start_node is not None:
                 raise Exception(
@@ -27,10 +47,37 @@ class Graph:
         if node.is_end:
             self.end_nodes.append(node)
 
-    def add_edge(self, source: _Node, destination: _Node):
-        # TODO add logic to check that source and destination are nodes
-        # and they exist in the graph object already
-        edge = Edge(source, destination)
+    def add_edge(self, source: _Node | str, destination: _Node | str):
+        """Adds an edge between two nodes that already exist in the graph.
+        
+        Args:
+            source: The source node or its name.
+            destination: The destination node or its name.
+        """
+        source_node, destination_node = None, None
+        # get source node from graph
+        if isinstance(source, str):
+            source_node = self.nodes.get(source)
+        else:
+            # Check if it's a node-like object by looking for required attributes
+            if hasattr(source, 'name'):
+                source_node = self.nodes.get(source.name)
+        if source_node is None:
+            raise ValueError(
+                f"Node with name '{source.name if hasattr(source, 'name') else source}' not found."
+            )
+        # get destination node from graph
+        if isinstance(destination, str):
+            destination_node = self.nodes.get(destination)
+        else:
+            # Check if it's a node-like object by looking for required attributes
+            if hasattr(destination, 'name'):
+                destination_node = self.nodes.get(destination.name)
+        if destination_node is None:
+            raise ValueError(
+                f"Node with name '{destination.name if hasattr(destination, 'name') else destination}' not found."
+            )
+        edge = Edge(source_node, destination_node)
         self.edges.append(edge)
 
     def add_router(self, sources: list[_Node], router: _Node, destinations: List[_Node]):
@@ -71,17 +118,20 @@ class Graph:
             self.callback = self.get_callback()
         current_node = self.start_node
         state = input
+        # Don't reset the graph state if it was initialized with initial_state
         steps = 0
         while True:
             # we invoke the node here
             if current_node.stream:
                 # add callback tokens and param here if we are streaming
                 await self.callback.start_node(node_name=current_node.name)
-                output = await current_node.invoke(input=state, callback=self.callback)
+                # Include graph's internal state in the node execution context
+                output = await current_node.invoke(input=state, callback=self.callback, state=self.state)
                 self._validate_output(output=output, node_name=current_node.name)
                 await self.callback.end_node(node_name=current_node.name)
             else:
-                output = await current_node.invoke(input=state)
+                # Include graph's internal state in the node execution context
+                output = await current_node.invoke(input=state, state=self.state)
                 self._validate_output(output=output, node_name=current_node.name)
             # add output to state
             state = {**state, **output}
@@ -113,10 +163,21 @@ class Graph:
         return self.callback
 
     def _get_node_by_name(self, node_name: str) -> _Node:
-        for node in self.nodes:
-            if node.name == node_name:
-                return node
-        raise Exception(f"Node with name {node_name} not found.")
+        """Get a node by its name.
+        
+        Args:
+            node_name: The name of the node to find.
+            
+        Returns:
+            The node with the given name.
+            
+        Raises:
+            Exception: If no node with the given name is found.
+        """
+        node = self.nodes.get(node_name)
+        if node is None:
+            raise Exception(f"Node with name {node_name} not found.")
+        return node
 
     def _get_next_node(self, current_node):
         for edge in self.edges:
@@ -139,7 +200,7 @@ class Graph:
 
         G = nx.DiGraph()
 
-        for node in self.nodes:
+        for node in self.nodes.values():
             G.add_node(node.name)
 
         for edge in self.edges:
@@ -173,10 +234,11 @@ class Graph:
                     pos[node] = (pos[node][0] - x_center, pos[node][1])
 
             # Scale the layout
-            max_x = max(abs(p[0]) for p in pos.values())
-            max_y = max(abs(p[1]) for p in pos.values())
-            scale = min(0.8 / max_x, 0.8 / max_y)
-            pos = {node: (x * scale, y * scale) for node, (x, y) in pos.items()}
+            max_x = max(abs(p[0]) for p in pos.values()) if pos else 1
+            max_y = max(abs(p[1]) for p in pos.values()) if pos else 1
+            if max_x > 0 and max_y > 0:
+                scale = min(0.8 / max_x, 0.8 / max_y)
+                pos = {node: (x * scale, y * scale) for node, (x, y) in pos.items()}
 
         else:
             print("Warning: The graph contains cycles. Visualization will use a spring layout.")

{graphai_lib-0.0.2 → graphai_lib-0.0.4}/graphai/nodes/base.py

@@ -31,6 +31,7 @@ class _Node:
         start: bool = False,
         end: bool = False,
         stream: bool = False,
+        name: str | None = None,
     ) -> Callable:
         """Decorator validating node structure.
         """
@@ -104,7 +105,7 @@ class _Node:
                 return "\n".join(signature_components)
 
             @classmethod
-            async def invoke(cls, input: Dict[str, Any], callback: Optional[Callback] = None):
+            async def invoke(cls, input: Dict[str, Any], callback: Optional[Callback] = None, state: Optional[Dict[str, Any]] = None):
                 if callback:
                     if stream:
                         input["callback"] = callback
@@ -112,12 +113,16 @@ class _Node:
                         raise ValueError(
                             f"Error in node {func.__name__}. When callback provided, stream must be True."
                         )
+                # Add state to the input if present and the parameter exists in the function signature
+                if state is not None and "state" in cls._func_signature.parameters:
+                    input["state"] = state
+                
                 instance = cls()
                 out = await instance.execute(**input)
                 return out
 
         NodeClass.__name__ = func.__name__
-        NodeClass.name = func.__name__
+        NodeClass.name = name or func.__name__
         NodeClass.__doc__ = func.__doc__
         NodeClass.is_start = start
         NodeClass.is_end = end
@@ -132,14 +137,15 @@ class _Node:
         start: bool = False,
         end: bool = False,
         stream: bool = False,
+        name: str | None = None,
     ):
         # We must wrap the call to the decorator in a function for it to work
         # correctly with or without parenthesis
-        def wrap(func: Callable, start=start, end=end, stream=stream) -> Callable:
-            return self._node(func=func, start=start, end=end, stream=stream)
+        def wrap(func: Callable, start=start, end=end, stream=stream, name=name) -> Callable:
+            return self._node(func=func, start=start, end=end, stream=stream, name=name)
         if func:
             # Decorator is called without parenthesis
-            return wrap(func=func, start=start, end=end, stream=stream)
+            return wrap(func=func, start=start, end=end, stream=stream, name=name)
         # Decorator is called with parenthesis
         return wrap
 

graphai_lib-0.0.4/graphai_lib.egg-info/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: graphai-lib
+Version: 0.0.4
+Summary: Not an AI framework
+Requires-Python: <3.14,>=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: semantic-router>=0.1.5
+Requires-Dist: networkx>=3.4.2
+Requires-Dist: matplotlib>=3.10.0
+Provides-Extra: dev
+Requires-Dist: ipykernel>=6.25.0; extra == "dev"
+Requires-Dist: ruff>=0.1.5; extra == "dev"
+Requires-Dist: pytest>=8.2.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.12.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: pytest-xdist>=3.5.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.24.0; extra == "dev"
+Requires-Dist: mypy>=1.7.1; extra == "dev"
+Requires-Dist: black[jupyter]<24.5.0,>=23.12.1; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: pydoc-markdown>=4.8.2; python_version < "3.12" and extra == "docs"
+
+# Philosophy
+
+1. Async-first
+2. Minimize abstractions
+3. One way to do one thing
+4. Graph-based AI
+
+## Installation
+
+```
+pip install -qU graphai-lib
+```

graphai_lib-0.0.4/graphai_lib.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+graphai/__init__.py
+graphai/callback.py
+graphai/graph.py
+graphai/utils.py
+graphai/nodes/__init__.py
+graphai/nodes/base.py
+graphai_lib.egg-info/PKG-INFO
+graphai_lib.egg-info/SOURCES.txt
+graphai_lib.egg-info/dependency_links.txt
+graphai_lib.egg-info/requires.txt
+graphai_lib.egg-info/top_level.txt

graphai_lib-0.0.4/graphai_lib.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

graphai_lib-0.0.4/graphai_lib.egg-info/requires.txt

@@ -0,0 +1,19 @@
+semantic-router>=0.1.5
+networkx>=3.4.2
+matplotlib>=3.10.0
+
+[dev]
+ipykernel>=6.25.0
+ruff>=0.1.5
+pytest>=8.2.0
+pytest-mock>=3.12.0
+pytest-cov>=4.1.0
+pytest-xdist>=3.5.0
+pytest-asyncio>=0.24.0
+mypy>=1.7.1
+black[jupyter]<24.5.0,>=23.12.1
+
+[docs]
+
+[docs:python_version < "3.12"]
+pydoc-markdown>=4.8.2

graphai_lib-0.0.4/graphai_lib.egg-info/top_level.txt

@@ -0,0 +1 @@
+graphai

graphai_lib-0.0.4/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "graphai-lib"
+version = "0.0.4"
+description = "Not an AI framework"
+readme = "README.md"
+requires-python = ">=3.10,<3.14"
+dependencies = [
+    "semantic-router>=0.1.5",
+    "networkx>=3.4.2",
+    "matplotlib>=3.10.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "ipykernel>=6.25.0",
+    "ruff>=0.1.5",
+    "pytest>=8.2.0",
+    "pytest-mock>=3.12.0",
+    "pytest-cov>=4.1.0",
+    "pytest-xdist>=3.5.0",
+    "pytest-asyncio>=0.24.0",
+    "mypy>=1.7.1",
+    "black[jupyter]>=23.12.1,<24.5.0",
+]
+docs = ["pydoc-markdown>=4.8.2 ; python_version < '3.12'"]
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["graphai", "graphai.nodes"]

graphai_lib-0.0.4/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

graphai_lib-0.0.2/PKG-INFO

@@ -1,25 +0,0 @@
-Metadata-Version: 2.1
-Name: graphai-lib
-Version: 0.0.2
-Summary: 
-License: MIT
-Author: Aurelio AI
-Author-email: hello@aurelio.ai
-Requires-Python: >=3.10,<3.14
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: matplotlib (>=3.10.0,<4.0.0)
-Requires-Dist: networkx (>=3.4.2,<4.0.0)
-Requires-Dist: semantic-router (>=0.1.0.dev4)
-Description-Content-Type: text/markdown
-
-# Philosophy
-
-1. Async-first
-2. Minimize abstractions
-3. One way to do one thing
-4. Graph-based AI

graphai_lib-0.0.2/pyproject.toml

@@ -1,29 +0,0 @@
-[tool.poetry]
-name = "graphai-lib"
-version = "0.0.2"
-description = ""
-authors = ["Aurelio AI <hello@aurelio.ai>"]
-readme = "README.md"
-packages = [{include = "graphai"}]
-license = "MIT"
-
-[tool.poetry.dependencies]
-python = ">=3.10,<3.14"
-semantic-router = ">=0.1.0.dev4"
-networkx = "^3.4.2"
-matplotlib = "^3.10.0"
-
-[tool.poetry.group.dev.dependencies]
-ipykernel = "^6.25.0"
-ruff = "^0.1.5"
-pytest = "^8.2"
-pytest-mock = "^3.12.0"
-pytest-cov = "^4.1.0"
-pytest-xdist = "^3.5.0"
-pytest-asyncio = "^0.24.0"
-mypy = "^1.7.1"
-black = {extras = ["jupyter"], version = ">=23.12.1,<24.5.0"}
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"