indexify 0.2.18__tar.gz → 0.2.20__tar.gz

{indexify-0.2.18 → indexify-0.2.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: indexify
-Version: 0.2.18
+Version: 0.2.20
 Summary: Python Client for Indexify
 Home-page: https://github.com/tensorlakeai/indexify
 License: Apache 2.0

{indexify-0.2.18 → indexify-0.2.20}/indexify/executor/agent.py

@@ -2,6 +2,7 @@ import asyncio
 import json
 import ssl
 from concurrent.futures.process import BrokenProcessPool
+from importlib.metadata import version
 from typing import Dict, List, Optional
 
 import httpx
@@ -115,9 +116,9 @@ class ExtractorAgent:
                 )
                 console.print(
                     Panel(
-                        f"Reporting outcome of task {task_outcome.task.id}\n"
+                        f"Reporting outcome of task: {task_outcome.task.id}, function: {task_outcome.task.compute_fn}\n"
                         f"Outcome: {style_outcome}\n"
-                        f"Outputs: {len(task_outcome.outputs or [])}  Router Output: {task_outcome.router_output}",
+                        f"Num Fn Outputs: {len(task_outcome.outputs or [])}  Router Output: {task_outcome.router_output}",
                         title="Task Completion",
                         border_style="info",
                     )
@@ -314,8 +315,10 @@ class ExtractorAgent:
                 # rewrite the image name
                 pass
 
+            executor_version = version("indexify")
             data = ExecutorMetadata(
                 id=self._executor_id,
+                executor_version=executor_version,
                 addr="",
                 image_name=runtime_probe.image_name,
                 labels=runtime_probe.labels,

{indexify-0.2.18 → indexify-0.2.20}/indexify/executor/api_objects.py

@@ -18,6 +18,7 @@ class Task(BaseModel):
 
 class ExecutorMetadata(BaseModel):
     id: str
+    executor_version: str
     addr: str
     image_name: str
     labels: Dict[str, Any]

{indexify-0.2.18 → indexify-0.2.20}/indexify/executor/task_reporter.py

@@ -28,11 +28,11 @@ class TaskReporter:
 
     def report_task_outcome(self, completed_task: CompletedTask):
         fn_outputs = []
-        print(
-            f"[bold]task-reporter[/bold] uploading output of size: {len(completed_task.outputs or [])}"
-        )
         for output in completed_task.outputs or []:
-            output_bytes = MsgPackSerializer.serialize(output)
+            print(
+                f"[bold]task-reporter[/bold] uploading output of size: {len(output_bytes)} bytes"
+            )
+            output_bytes = MsgPackSerializer.serialize(output) 
             fn_outputs.append(
                 ("node_outputs", (nanoid.generate(), io.BytesIO(output_bytes)))
             )

{indexify-0.2.18 → indexify-0.2.20}/indexify/functions_sdk/graph.py

@@ -96,9 +96,9 @@ class Graph:
             return self
 
         if issubclass(indexify_fn, IndexifyFunction) and indexify_fn.accumulate:
-            self.accumulator_zero_values[
-                indexify_fn.name
-            ] = indexify_fn.accumulate().model_dump()
+            self.accumulator_zero_values[indexify_fn.name] = (
+                indexify_fn.accumulate().model_dump()
+            )
 
         self.nodes[indexify_fn.name] = indexify_fn
         return self

{indexify-0.2.18 → indexify-0.2.20}/indexify/functions_sdk/indexify_functions.py

@@ -206,9 +206,9 @@ class RouterCallResult(BaseModel):
 
 class IndexifyFunctionWrapper:
     def __init__(self, indexify_function: Union[IndexifyFunction, IndexifyRouter]):
-        self.indexify_function: Union[
-            IndexifyFunction, IndexifyRouter
-        ] = indexify_function()
+        self.indexify_function: Union[IndexifyFunction, IndexifyRouter] = (
+            indexify_function()
+        )
 
     def get_output_model(self) -> Any:
         if not isinstance(self.indexify_function, IndexifyFunction):

indexify-0.2.20/indexify/remote_graph.py

@@ -0,0 +1,120 @@
+from typing import Any, List, Optional
+
+from indexify.functions_sdk.graph import Graph
+
+from .http_client import IndexifyClient
+from .settings import DEFAULT_SERVICE_URL
+
+
+class RemoteGraph:
+    def __init__(
+        self,
+        name: str,
+        server_url: Optional[str] = DEFAULT_SERVICE_URL,
+        client: Optional[IndexifyClient] = None,
+    ):
+        """
+        Create a handle to call a RemoteGraph by name.
+
+        Note: Use the class methods RemoteGraph.deploy or RemoteGraph.by_name to create a RemoteGraph object.
+
+        :param name: The name of the graph.
+        :param server_url: The URL of the server where the graph will be registered.
+            Not used if client is provided.
+        :param client: The IndexifyClient used to communicate with the server.
+            Prefered over server_url.
+        """
+        self._name = name
+        if client:
+            self._client = client
+        else:
+            self._client = IndexifyClient(service_url=server_url)
+
+    def run(self, block_until_done: bool = False, **kwargs) -> str:
+        """
+        Run the graph with the given inputs. The input is for the start function of the graph.
+
+        :param block_until_done: If True, the function will block until the graph execution is complete.
+        :param kwargs: The input to the start function of the graph. Pass the input as keyword arguments.
+        :return: The invocation ID of the graph execution.
+
+        Example:
+
+            @indexify_function()
+            def foo(x: int) -> int:
+                return x + 1
+
+            remote_graph = RemoteGraph.by_name("test")
+            invocation_id = remote_graph.run(x=1)
+        """
+        return self._client.invoke_graph_with_object(
+            self._name, block_until_done, **kwargs
+        )
+
+    def rerun(self):
+        """
+        Rerun the graph with the given invocation ID.
+
+        :param invocation_id: The invocation ID of the graph execution.
+        """
+        self._client.rerun_graph(self._name)
+
+    @classmethod
+    def deploy(
+        cls,
+        g: Graph,
+        additional_modules=[],
+        server_url: Optional[str] = DEFAULT_SERVICE_URL,
+        client: Optional[IndexifyClient] = None,
+    ):
+        """
+        Create a new RemoteGraph from a local Graph object.
+
+        :param g: The local Graph object.
+        :param additional_modules: List of additional modules to be registered with the graph.
+            Needed for modules that are imported outside of an indexify function.
+        :param server_url: The URL of the server where the graph will be registered.
+            Not used if client is provided.
+        :param client: The IndexifyClient used to communicate with the server.
+            Prefered over server_url.
+        """
+        if not client:
+            client = IndexifyClient(service_url=server_url)
+        client.register_compute_graph(g, additional_modules)
+        return cls(name=g.name, server_url=server_url, client=client)
+
+    @classmethod
+    def by_name(cls, name: str, server_url: Optional[str] = DEFAULT_SERVICE_URL, client: Optional[IndexifyClient] = None):
+        """
+        Create a handle to call a RemoteGraph by name.
+
+        :param name: The name of the graph.
+        :param server_url: The URL of the server where the graph will be registered.
+            Not used if client is provided.
+        :param client: The IndexifyClient used to communicate with the server.
+            Prefered over server_url.
+        :return: A RemoteGraph object.
+        """
+        return cls(name=name, server_url=server_url, client=client)
+
+    def output(
+        self,
+        invocation_id: str,
+        fn_name: str,
+    ) -> List[Any]:
+        """
+        Returns the extracted objects by a graph for an ingested object.
+ 
+        - If the extractor name is provided, only the objects extracted by that extractor are returned.
+        - If the extractor name is not provided, all the extracted objects are returned for the input object.
+
+        :param invocation_id (str): The ID of the ingested object
+        :param fn_name (Optional[str]): The name of the function whose output is to be returned if provided
+        :return (List[Any]): Output of the function.
+        """
+
+        return self._client.graph_outputs(
+            graph=self._name,
+            invocation_id=invocation_id,
+            fn_name=fn_name,
+        )

{indexify-0.2.18 → indexify-0.2.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "indexify"
-version = "0.2.18"
+version = "0.2.20"
 description = "Python Client for Indexify"
 authors = ["Tensorlake Inc. <support@tensorlake.ai>"]
 license = "Apache 2.0"

indexify-0.2.18/indexify/remote_graph.py

@@ -1,86 +0,0 @@
-from typing import Any, List, Optional
-
-from indexify.functions_sdk.graph import Graph
-
-from .http_client import IndexifyClient
-from .settings import DEFAULT_SERVICE_URL
-
-
-class RemoteGraph:
-    def __init__(
-        self,
-        name: str,
-        server_url: Optional[str] = DEFAULT_SERVICE_URL,
-    ):
-        self._name = name
-        self._client = IndexifyClient(service_url=server_url)
-
-    def run(self, block_until_done: bool = False, **kwargs) -> str:
-        """
-        Run the graph with the given inputs. The input is for the start function of the graph.
-        :param block_until_done: If True, the function will block until the graph execution is complete.
-        :param kwargs: The input to the start function of the graph. Pass the input as keyword arguments.
-        :return: The invocation ID of the graph execution.
-
-        Example:
-        @indexify_function()
-        def foo(x: int) -> int:
-            return x + 1
-        remote_graph = RemoteGraph.by_name("test")
-        invocation_id = remote_graph.run(x=1)
-        """
-        return self._client.invoke_graph_with_object(
-            self._name, block_until_done, **kwargs
-        )
-
-    def rerun(self):
-        """
-        Rerun the graph with the given invocation ID.
-        :param invocation_id: The invocation ID of the graph execution.
-        """
-        self._client.rerun_graph(self._name)
-
-    @classmethod
-    def deploy(
-        cls,
-        g: Graph,
-        additional_modules=[],
-        server_url: Optional[str] = "http://localhost:8900",
-    ):
-        """
-        Create a new RemoteGraph from a local Graph object.
-        :param g: The local Graph object.
-        :param server_url: The URL of the server where the graph will be registered.
-        """
-        client = IndexifyClient(service_url=server_url)
-        client.register_compute_graph(g, additional_modules)
-        return cls(name=g.name, server_url=server_url)
-
-    @classmethod
-    def by_name(cls, name: str, server_url: Optional[str] = "http://localhost:8900"):
-        """
-        Create a handle to call a RemoteGraph by name.
-        :param name: The name of the graph.
-        :param server_url: The URL of the server where the graph is registered.
-        :return: A RemoteGraph object.
-        """
-        return cls(name=name, server_url=server_url)
-
-    def output(
-        self,
-        invocation_id: str,
-        fn_name: str,
-    ) -> List[Any]:
-        """
-        Returns the extracted objects by a graph for an ingested object. If the extractor name is provided, only the objects extracted by that extractor are returned.
-        If the extractor name is not provided, all the extracted objects are returned for the input object.
-        invocation_id: str: The ID of the ingested object
-        fn_name: Optional[str]: The name of the function whose output is to be returned if provided
-        return: List[Any]: Output of the function.
-        """
-
-        return self._client.graph_outputs(
-            graph=self._name,
-            invocation_id=invocation_id,
-            fn_name=fn_name,
-        )