graphai-lib 0.0.3__py3-none-any.whl → 0.0.4__py3-none-any.whl

graphai/nodes/__init__.py

@@ -0,0 +1,3 @@
+from graphai.nodes.base import node, router
+
+__all__ = ["node", "router"]

graphai/nodes/base.py

@@ -0,0 +1,154 @@
+import inspect
+from typing import Any, Callable, Dict, Optional
+
+from graphai.callback import Callback
+from graphai.utils import FunctionSchema
+
+
+class NodeMeta(type):
+    @staticmethod
+    def positional_to_kwargs(cls_type, args) -> Dict[str, Any]:
+        init_signature = inspect.signature(cls_type.__init__)
+        init_params = {name: arg for name, arg in init_signature.parameters.items() if name != "self"}
+        return init_params
+
+    def __call__(cls, *args, **kwargs):
+        named_positional_args = NodeMeta.positional_to_kwargs(cls, args)
+        kwargs.update(named_positional_args)
+        return super().__call__(**kwargs)
+
+
+class _Node:
+    def __init__(
+        self,
+        is_router: bool = False,
+    ):
+        self.is_router = is_router
+
+    def _node(
+        self,
+        func: Callable,
+        start: bool = False,
+        end: bool = False,
+        stream: bool = False,
+        name: str | None = None,
+    ) -> Callable:
+        """Decorator validating node structure.
+        """
+        if not callable(func):
+            raise ValueError("Node must be a callable function.")
+        
+        func_signature = inspect.signature(func)
+        schema = FunctionSchema(func)
+
+        class NodeClass:
+            _func_signature = func_signature
+            is_router = None
+            _stream = stream
+
+            def __init__(self):
+                self._expected_params = set(self._func_signature.parameters.keys())
+
+            async def execute(self, *args, **kwargs):
+                # Prepare arguments, including callback if stream is True
+                params_dict = await self._parse_params(*args, **kwargs)
+                return await func(**params_dict)  # Pass only the necessary arguments
+
+            async def _parse_params(self, *args, **kwargs) -> Dict[str, Any]:
+                # filter out unexpected keyword args
+                expected_kwargs = {k: v for k, v in kwargs.items() if k in self._expected_params}
+                # Convert args to kwargs based on the function signature
+                args_names = list(self._func_signature.parameters.keys())[1:len(args)+1]  # skip 'self'
+                expected_args_kwargs = dict(zip(args_names, args))
+                # Combine filtered args and kwargs
+                combined_params = {**expected_args_kwargs, **expected_kwargs}
+
+                # Bind the current instance attributes to the function signature
+                if "callback" in self._expected_params and not stream:
+                    raise ValueError(
+                        f"Node {func.__name__}: requires stream=True when callback is defined."
+                    )
+                bound_params = self._func_signature.bind_partial(**combined_params)
+                # get the default parameters (if any)
+                bound_params.apply_defaults()
+                params_dict = bound_params.arguments.copy()
+                # Filter arguments to match the next node's parameters
+                filtered_params = {
+                    k: v for k, v in params_dict.items() if k in self._expected_params
+                }
+                # confirm all required parameters are present
+                missing_params = [
+                    p for p in self._expected_params if p not in filtered_params
+                ]
+                # if anything is missing we raise an error
+                if missing_params:
+                    raise ValueError(
+                        f"Missing required parameters for the {func.__name__} node: {', '.join(missing_params)}"
+                    )
+                return filtered_params
+
+
+            @classmethod
+            def get_signature(cls):
+                """Returns the signature of the decorated function as LLM readable
+                string.
+                """
+                signature_components = []
+                if NodeClass._func_signature:
+                    for param in NodeClass._func_signature.parameters.values():
+                        if param.default is param.empty:
+                            signature_components.append(f"{param.name}: {param.annotation}")
+                        else:
+                            signature_components.append(f"{param.name}: {param.annotation} = {param.default}")
+                else:
+                    return "No signature"
+                return "\n".join(signature_components)
+
+            @classmethod
+            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
+                    else:
+                        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 = name or func.__name__
+        NodeClass.__doc__ = func.__doc__
+        NodeClass.is_start = start
+        NodeClass.is_end = end
+        NodeClass.is_router = self.is_router
+        NodeClass.stream = stream
+        NodeClass.schema = schema
+        return NodeClass
+
+    def __call__(
+        self,
+        func: Optional[Callable] = None,
+        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, 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, name=name)
+        # Decorator is called with parenthesis
+        return wrap
+
+
+node = _Node()
+router = _Node(is_router=True)

{graphai_lib-0.0.3.dist-info → graphai_lib-0.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphai-lib
-Version: 0.0.3
+Version: 0.0.4
 Summary: Not an AI framework
 Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
@@ -17,6 +17,8 @@ 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
 

graphai_lib-0.0.4.dist-info/RECORD

@@ -0,0 +1,10 @@
+graphai/__init__.py,sha256=EHigFOWewDXLZXbdfjZH9kdLPhw6NT0ChS77lNAVAA8,109
+graphai/callback.py,sha256=K-h44pyL2VLXwJzIB_bcVYp5R6xv8zNca5FmN6994Uk,7598
+graphai/graph.py,sha256=EALHEhbXAaJmTvm7cL3Tdh0moRIw7lIyJDCNnCts2QA,10335
+graphai/utils.py,sha256=zrgpk82rIn7lwh631KhN-OgMAJMdbm0k5GPL1eMf2sQ,4522
+graphai/nodes/__init__.py,sha256=4826Ubk5yUfbVH7F8DmoTKQyax624Q2QJHsGxqgQ_ng,73
+graphai/nodes/base.py,sha256=SZdYhFfXdtFmabFbMRcEGd8_h8w-g6s4I7hMEo6JCk8,6331
+graphai_lib-0.0.4.dist-info/METADATA,sha256=wfxK82ZO-slBl-xVNmdbYGVvPo7YKm8-SLfdrkNWtKs,982
+graphai_lib-0.0.4.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+graphai_lib-0.0.4.dist-info/top_level.txt,sha256=TXlqmhLViX-3xGH2g5w6cavRd-QMf229Hl88jdMOGt8,8
+graphai_lib-0.0.4.dist-info/RECORD,,

graphai_lib-0.0.3.dist-info/RECORD

@@ -1,8 +0,0 @@
-graphai/__init__.py,sha256=EHigFOWewDXLZXbdfjZH9kdLPhw6NT0ChS77lNAVAA8,109
-graphai/callback.py,sha256=K-h44pyL2VLXwJzIB_bcVYp5R6xv8zNca5FmN6994Uk,7598
-graphai/graph.py,sha256=EALHEhbXAaJmTvm7cL3Tdh0moRIw7lIyJDCNnCts2QA,10335
-graphai/utils.py,sha256=zrgpk82rIn7lwh631KhN-OgMAJMdbm0k5GPL1eMf2sQ,4522
-graphai_lib-0.0.3.dist-info/METADATA,sha256=fOjGeptDi6YD-fYZD9NtFv4_lzLWjMtvBnfwoQ9zLfo,879
-graphai_lib-0.0.3.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-graphai_lib-0.0.3.dist-info/top_level.txt,sha256=TXlqmhLViX-3xGH2g5w6cavRd-QMf229Hl88jdMOGt8,8
-graphai_lib-0.0.3.dist-info/RECORD,,