indexify 0.2.7__tar.gz → 0.2.8__tar.gz

{indexify-0.2.7 → indexify-0.2.8}/PKG-INFO

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

{indexify-0.2.7 → indexify-0.2.8}/indexify/cli.py

@@ -9,7 +9,6 @@ import threading
 import time
 from typing import Annotated, List, Optional
 
-import docker
 import nanoid
 import typer
 from rich.console import Console
@@ -119,7 +118,9 @@ def server_dev_mode():
 
 
 @app.command(help="Build image for function names")
-def build_image(workflow_file_path: str, func_names: List[str]):
+def build_image(
+    workflow_file_path: str, func_names: List[str], python_sdk_path: Optional[str] = None
+):
     globals_dict = {}
 
     # Add the folder in the workflow file path to the current Python path
@@ -139,7 +140,9 @@ def build_image(workflow_file_path: str, func_names: List[str]):
         for func_name in func_names:
             if name == func_name:
                 found_funcs.append(name)
-                _create_image_for_func(func_name=func_name, func_obj=obj)
+                _create_image_for_func(
+                    func_name=func_name, func_obj=obj, python_sdk_path=python_sdk_path
+                )
 
     console.print(
         Text(f"Processed functions: ", style="cyan"),
@@ -205,16 +208,18 @@ def executor(
         console.print(Text(f"Exiting gracefully: {ex}", style="bold yellow"))
 
 
-def _create_image_for_func(func_name, func_obj):
+def _create_image_for_func(func_name, func_obj, python_sdk_path):
     console.print(
         Text("Creating container for ", style="cyan"),
         Text(f"`{func_name}`", style="cyan bold"),
     )
-    _build_image(image=func_obj.image, func_name=func_name)
+    _build_image(image=func_obj.image, python_sdk_path=python_sdk_path)
 
 
-def _build_image(image: Image, func_name: str = None):
+def _build_image(image: Image, python_sdk_path: Optional[str] = None):
     try:
+        import docker
+
         client = docker.from_env()
         client.ping()
     except Exception as e:
@@ -240,15 +245,36 @@ WORKDIR /app
     run_strs = ["RUN " + i for i in image._run_strs]
 
     docker_file += "\n".join(run_strs)
+    print(os.getcwd())
+    import docker
+    import docker.api.build
+
+    docker.api.build.process_dockerfile = lambda dockerfile, path: (
+        "Dockerfile",
+        dockerfile,
+    )
+
+    if python_sdk_path is not None:
+        if not os.path.exists(python_sdk_path):
+            print(f"error: {python_sdk_path} does not exist")
+            os.exit(1)
+        docker_file += f"\nCOPY {python_sdk_path} /app/python-sdk"
+        docker_file += f"\nRUN (cd /app/python-sdk && pip install .)"
+    else:
+        docker_file += f"\nRUN pip install indexify"
 
     console.print("Creating image using Dockerfile contents:", style="cyan bold")
     console.print(f"{docker_file}", style="magenta")
 
     client = docker.from_env()
     image_name = f"{image._image_name}:{image._tag}"
-    client.images.build(
-        fileobj=io.BytesIO(docker_file.encode()),
+    (_image, generator) = client.images.build(
+        path=".",
+        dockerfile=docker_file,
         tag=image_name,
         rm=True,
     )
+    for result in generator:
+        print(result)
+
     print(f"built image: {image_name}")

{indexify-0.2.7 → indexify-0.2.8}/indexify/executor/function_worker.py

@@ -1,8 +1,9 @@
 import asyncio
 import traceback
 from concurrent.futures.process import BrokenProcessPool
-from typing import Dict, List, Optional, Union
+from typing import Dict, List, Optional
 
+import cloudpickle
 from pydantic import BaseModel
 from rich import print
 
@@ -11,18 +12,11 @@ from indexify.functions_sdk.data_objects import (
     IndexifyData,
     RouterOutput,
 )
-from indexify.functions_sdk.graph import Graph
 from indexify.functions_sdk.indexify_functions import IndexifyFunctionWrapper
 
-graphs: Dict[str, Graph] = {}
 function_wrapper_map: Dict[str, IndexifyFunctionWrapper] = {}
 
 import concurrent.futures
-import io
-from contextlib import redirect_stderr, redirect_stdout
-
-from .runtime_probes import RuntimeProbes
-
 
 class FunctionRunException(Exception):
     def __init__(
@@ -53,12 +47,13 @@ def _load_function(
     key = f"{namespace}/{graph_name}/{version}/{fn_name}"
     if key in function_wrapper_map:
         return
-    image_name = RuntimeProbes().probe().image_name
-    graph = Graph.from_path(code_path, image_name)
-    function_wrapper = graph.get_function(fn_name)
+    with open(code_path, "rb") as f:
+        code = f.read()
+        pickled_functions = cloudpickle.loads(code)
+    function_wrapper = IndexifyFunctionWrapper(
+        cloudpickle.loads(pickled_functions[fn_name])
+    )
     function_wrapper_map[key] = function_wrapper
-    graph_key = f"{namespace}/{graph_name}/{version}"
-    graphs[graph_key] = graph
 
 
 class FunctionWorker:
@@ -94,8 +89,6 @@ class FunctionWorker:
             traceback.print_exc()
             raise mp
         except FunctionRunException as e:
-            print(e)
-            print(traceback.format_exc())
             return FunctionWorkerOutput(
                 exception=str(e),
                 stdout=e.stdout,
@@ -138,26 +131,23 @@ def _run_function(
     fn_output = None
     has_failed = False
     exception_msg = None
-    print(
-        f"[bold] function_worker: [/bold] invoking function {fn_name} in graph {graph_name}"
-    )
+    print(f"[bold] function_worker: [/bold] invoking function {fn_name} in graph {graph_name}")
     with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
         try:
             key = f"{namespace}/{graph_name}/{version}/{fn_name}"
             if key not in function_wrapper_map:
                 _load_function(namespace, graph_name, fn_name, code_path, version)
 
-            graph: Graph = graphs[f"{namespace}/{graph_name}/{version}"]
-            if fn_name in graph.routers:
-                router_output = graph.invoke_router(fn_name, input)
+            fn = function_wrapper_map[key]
+            if str(type(fn.indexify_function)) == "<class 'indexify.functions_sdk.indexify_functions.IndexifyRo'>":
+                router_output = fn.invoke_router(fn_name, input)
             else:
-                fn_output = graph.invoke_fn_ser(fn_name, input, init_value)
+                fn_output = fn.invoke_fn_ser(fn_name, input, init_value)
 
-                is_reducer = (
-                    graph.get_function(fn_name).indexify_function.accumulate is not None
-                )
+                is_reducer = fn.indexify_function.accumulate is not None
         except Exception as e:
-            print(traceback.format_exc())
+            import sys
+            print(traceback.format_exc(), file=sys.stderr)
             has_failed = True
             exception_msg = str(e)
 

{indexify-0.2.7 → indexify-0.2.8}/indexify/functions_sdk/data_objects.py

@@ -17,7 +17,7 @@ class RouterOutput(BaseModel):
 class IndexifyData(BaseModel):
     id: Optional[str] = None
     payload: bytes
-    payload_encoding: str = "msgpack"
+    payload_encoding: str = "cloudpickle"
 
 
 class FunctionWorkerOutput(BaseModel):

{indexify-0.2.7 → indexify-0.2.8}/indexify/functions_sdk/graph.py

@@ -1,4 +1,3 @@
-import inspect
 import sys
 from collections import defaultdict
 from queue import deque
@@ -16,7 +15,6 @@ from typing import (
 )
 
 import cloudpickle
-import msgpack
 from nanoid import generate
 from pydantic import BaseModel
 from typing_extensions import get_args, get_origin
@@ -36,7 +34,7 @@ from .indexify_functions import (
     IndexifyRouter,
 )
 from .local_cache import CacheAwareFunctionWrapper
-from .object_serializer import CloudPickleSerializer, get_serializer
+from .object_serializer import get_serializer
 
 RouterFn = Annotated[
     Callable[[IndexifyData], Optional[List[IndexifyFunction]]], "RouterFn"
@@ -45,26 +43,16 @@ GraphNode = Annotated[Union[IndexifyFunctionWrapper, RouterFn], "GraphNode"]
 
 
 def is_pydantic_model_from_annotation(type_annotation):
-    # If it's a string representation
     if isinstance(type_annotation, str):
-        # Extract the class name from the string
         class_name = type_annotation.split("'")[-2].split(".")[-1]
-        # This part is tricky and might require additional context or imports
-        # You might need to import the actual class or module where it's defined
-        # For example:
-        # from indexify.functions_sdk.data_objects import File
-        # return issubclass(eval(class_name), BaseModel)
         return False  # Default to False if we can't evaluate
 
-    # If it's a Type object
     origin = get_origin(type_annotation)
     if origin is not None:
-        # Handle generic types like List[File], Optional[File], etc.
         args = get_args(type_annotation)
         if args:
             return is_pydantic_model_from_annotation(args[0])
 
-    # If it's a direct class reference
     if isinstance(type_annotation, type):
         return issubclass(type_annotation, BaseModel)
 
@@ -98,10 +86,6 @@ class Graph:
     def get_accumulators(self) -> Dict[str, Any]:
         return self.accumulator_zero_values
 
-    def deserialize_fn_output(self, name: str, output: IndexifyData) -> Any:
-        serializer = get_serializer(self.nodes[name].payload_encoder)
-        return serializer.deserialize(output.payload)
-
     def add_node(
         self, indexify_fn: Union[Type[IndexifyFunction], Type[IndexifyRouter]]
     ) -> "Graph":
@@ -133,37 +117,14 @@ class Graph:
             self.routers[from_node.name].append(node.name)
         return self
 
-    def serialize(self) -> Dict[str, bytes]:
+    def serialize(self):
         # Get all unique modules from nodes and edges
-        modules_by_images = defaultdict(set)
+        pickled_functions = {}
         for node in self.nodes.values():
-            modules_by_images[node.image._image_name].add(node.__module__)
-
-        pickled_nodes_by_image = {}
-        for image_name, modules in modules_by_images.items():
-            for module in modules:
-                print(f"registering module {module} with cloudpickle")
-                cloudpickle.register_pickle_by_value(sys.modules[module])
-            pickled_nodes_by_image[image_name] = cloudpickle.dumps(self)
-            for module in modules:
-                cloudpickle.unregister_pickle_by_value(sys.modules[module])
-
-        # Register each module with cloudpickle
-        for module_name in modules:
-            module = sys.modules[module_name]
-            print(f"registering module {module_name} with cloudpickle")
-            cloudpickle.register_pickle_by_value(module)
-        return pickled_nodes_by_image
-
-    @staticmethod
-    def deserialize(serialized_code_by_images: Dict[str, bytes], image: str) -> "Graph":
-        return cloudpickle.loads(serialized_code_by_images[image])
-
-    @staticmethod
-    def from_path(path: str, image: str) -> "Graph":
-        with open(path, "rb") as f:
-            pickled_code_by_images: Dict[str, bytes] = cloudpickle.load(f)
-        return Graph.deserialize(pickled_code_by_images, image)
+            cloudpickle.register_pickle_by_value(sys.modules[node.__module__])
+            pickled_functions[node.name] = cloudpickle.dumps(node)
+            cloudpickle.unregister_pickle_by_value(sys.modules[node.__module__])
+        return pickled_functions
 
     def add_edge(
         self,
@@ -173,60 +134,6 @@ class Graph:
         self.add_edges(from_node, [to_node])
         return self
 
-    def invoke_fn_ser(
-        self, name: str, input: IndexifyData, acc: Optional[Any] = None
-    ) -> List[IndexifyData]:
-        fn_wrapper = self.get_function(name)
-        input = self.deserialize_input(name, input)
-        serializer = get_serializer(fn_wrapper.indexify_function.payload_encoder)
-        if acc is not None:
-            acc = fn_wrapper.indexify_function.accumulate.model_validate(
-                serializer.deserialize(acc.payload)
-            )
-        if acc is None and fn_wrapper.indexify_function.accumulate is not None:
-            acc = fn_wrapper.indexify_function.accumulate.model_validate(
-                self.accumulator_zero_values[name]
-            )
-        outputs: List[Any] = fn_wrapper.run_fn(input, acc=acc)
-        return [
-            IndexifyData(payload=serializer.serialize(output)) for output in outputs
-        ]
-
-    def invoke_router(self, name: str, input: IndexifyData) -> Optional[RouterOutput]:
-        fn_wrapper = self.get_function(name)
-        input = self.deserialize_input(name, input)
-        return RouterOutput(edges=fn_wrapper.run_router(input))
-
-    def deserialize_input(self, compute_fn: str, indexify_data: IndexifyData) -> Any:
-        compute_fn = self.nodes[compute_fn]
-        if not compute_fn:
-            raise ValueError(f"Compute function {compute_fn} not found in graph")
-        if compute_fn.payload_encoder == "cloudpickle":
-            return CloudPickleSerializer.deserialize(indexify_data.payload)
-        payload = msgpack.unpackb(indexify_data.payload)
-        signature = inspect.signature(compute_fn.run)
-        arg_types = {}
-        for name, param in signature.parameters.items():
-            if (
-                param.annotation != inspect.Parameter.empty
-                and param.annotation != getattr(compute_fn, "accumulate", None)
-            ):
-                arg_types[name] = param.annotation
-        if len(arg_types) > 1:
-            raise ValueError(
-                f"Compute function {compute_fn} has multiple arguments, but only one is supported"
-            )
-        elif len(arg_types) == 0:
-            raise ValueError(f"Compute function {compute_fn} has no arguments")
-        arg_name, arg_type = next(iter(arg_types.items()))
-        if arg_type is None:
-            raise ValueError(f"Argument {arg_name} has no type annotation")
-        if is_pydantic_model_from_annotation(arg_type):
-            if len(payload.keys()) == 1 and isinstance(list(payload.values())[0], dict):
-                payload = list(payload.values())[0]
-            return arg_type.model_validate(payload)
-        return payload
-
     def add_edges(
         self,
         from_node: Union[Type[IndexifyFunction], Type[IndexifyRouter]],
@@ -329,7 +236,9 @@ class Graph:
                 function_outputs.extend(cached_output_list)
                 outputs[node_name].extend(cached_output_list)
             else:
-                function_outputs: List[IndexifyData] = self.invoke_fn_ser(
+                function_outputs: List[IndexifyData] = IndexifyFunctionWrapper(
+                    node
+                ).invoke_fn_ser(
                     node_name, input, accumulator_values.get(node_name, None)
                 )
                 print(f"ran {node_name}: num outputs: {len(function_outputs)}")
@@ -370,9 +279,10 @@ class Graph:
                     queue.append((out_edge, output))
 
     def _route(self, node_name: str, input: IndexifyData) -> Optional[RouterOutput]:
-        return self.invoke_router(node_name, input)
+        router = self.nodes[node_name]
+        return IndexifyFunctionWrapper(router).invoke_router(node_name, input)
 
-    def get_output(
+    def output(
         self,
         invocation_id: str,
         fn_name: str,

{indexify-0.2.7 → indexify-0.2.8}/indexify/functions_sdk/graph_definition.py

@@ -27,11 +27,6 @@ class NodeMetadata(BaseModel):
     dynamic_router: Optional[RouterMetadata] = None
     compute_fn: Optional[FunctionMetadata] = None
 
-    def image_name(self):
-        if self.dynamic_router:
-            return self.dynamic_router.image_name
-        return self.compute_fn.image_name
-
 
 # RuntimeInformation is a class that holds data about the environment in which the graph should run.
 class RuntimeInformation(BaseModel):

{indexify-0.2.7 → indexify-0.2.8}/indexify/functions_sdk/image.py

@@ -6,7 +6,7 @@ class Image:
 
         self._base_image = "python:3.10.15-slim-bookworm"
 
-        self._run_strs = ["pip install indexify"]
+        self._run_strs = []
 
     def name(self, image_name):
         self._image_name = image_name

{indexify-0.2.7 → indexify-0.2.8}/indexify/functions_sdk/indexify_functions.py

@@ -1,3 +1,4 @@
+import inspect
 from abc import ABC, abstractmethod
 from functools import update_wrapper
 from typing import (
@@ -12,11 +13,40 @@ from typing import (
     get_origin,
 )
 
+import msgpack
 from pydantic import BaseModel
 from typing_extensions import get_type_hints
 
 from .data_objects import IndexifyData, RouterOutput
 from .image import DEFAULT_IMAGE, Image
+from .object_serializer import CloudPickleSerializer, get_serializer
+
+
+def is_pydantic_model_from_annotation(type_annotation):
+    # If it's a string representation
+    if isinstance(type_annotation, str):
+        # Extract the class name from the string
+        class_name = type_annotation.split("'")[-2].split(".")[-1]
+        # This part is tricky and might require additional context or imports
+        # You might need to import the actual class or module where it's defined
+        # For example:
+        # from indexify.functions_sdk.data_objects import File
+        # return issubclass(eval(class_name), BaseModel)
+        return False  # Default to False if we can't evaluate
+
+    # If it's a Type object
+    origin = get_origin(type_annotation)
+    if origin is not None:
+        # Handle generic types like List[File], Optional[File], etc.
+        args = get_args(type_annotation)
+        if args:
+            return is_pydantic_model_from_annotation(args[0])
+
+    # If it's a direct class reference
+    if isinstance(type_annotation, type):
+        return issubclass(type_annotation, BaseModel)
+
+    return False
 
 
 class EmbeddingIndexes(BaseModel):
@@ -186,3 +216,56 @@ class IndexifyFunctionWrapper:
         extracted_data = self.indexify_function.run(*args, **kwargs)
 
         return extracted_data if isinstance(extracted_data, list) else [extracted_data]
+
+    def invoke_fn_ser(
+        self, name: str, input: IndexifyData, acc: Optional[Any] = None
+    ) -> List[IndexifyData]:
+        input = self.deserialize_input(name, input)
+        serializer = get_serializer(self.indexify_function.payload_encoder)
+        if acc is not None:
+            acc = self.indexify_function.accumulate.model_validate(
+                serializer.deserialize(acc.payload)
+            )
+        if acc is None and self.indexify_function.accumulate is not None:
+            acc = self.indexify_function.accumulate.model_validate(
+                self.indexify_function.accumulate()
+            )
+        outputs: List[Any] = self.run_fn(input, acc=acc)
+        return [
+            IndexifyData(payload=serializer.serialize(output)) for output in outputs
+        ]
+
+    def invoke_router(self, name: str, input: IndexifyData) -> Optional[RouterOutput]:
+        input = self.deserialize_input(name, input)
+        return RouterOutput(edges=self.run_router(input))
+
+    def deserialize_input(self, compute_fn: str, indexify_data: IndexifyData) -> Any:
+        if self.indexify_function.payload_encoder == "cloudpickle":
+            return CloudPickleSerializer.deserialize(indexify_data.payload)
+        payload = msgpack.unpackb(indexify_data.payload)
+        signature = inspect.signature(self.indexify_function.run)
+        arg_types = {}
+        for name, param in signature.parameters.items():
+            if (
+                param.annotation != inspect.Parameter.empty
+                and param.annotation != getattr(compute_fn, "accumulate", None)
+            ):
+                arg_types[name] = param.annotation
+        if len(arg_types) > 1:
+            raise ValueError(
+                f"Compute function {compute_fn} has multiple arguments, but only one is supported"
+            )
+        elif len(arg_types) == 0:
+            raise ValueError(f"Compute function {compute_fn} has no arguments")
+        arg_name, arg_type = next(iter(arg_types.items()))
+        if arg_type is None:
+            raise ValueError(f"Argument {arg_name} has no type annotation")
+        if is_pydantic_model_from_annotation(arg_type):
+            if len(payload.keys()) == 1 and isinstance(list(payload.values())[0], dict):
+                payload = list(payload.values())[0]
+            return arg_type.model_validate(payload)
+        return payload
+
+    def deserialize_fn_output(self, output: IndexifyData) -> Any:
+        serializer = get_serializer(self.indexify_function.payload_encoder)
+        return serializer.deserialize(output.payload)

{indexify-0.2.7 → indexify-0.2.8}/indexify/http_client.py

@@ -13,6 +13,7 @@ from rich import print
 from indexify.error import ApiException
 from indexify.functions_sdk.data_objects import IndexifyData
 from indexify.functions_sdk.graph import ComputeGraphMetadata, Graph
+from indexify.functions_sdk.indexify_functions import IndexifyFunctionWrapper
 from indexify.settings import DEFAULT_SERVICE_URL, DEFAULT_SERVICE_URL_HTTPS
 
 
@@ -70,6 +71,7 @@ class IndexifyClient:
         self._service_url = service_url
         self._timeout = kwargs.get("timeout")
         self._graphs: Dict[str, Graph] = {}
+        self._fns = {}
 
     def _request(self, method: str, **kwargs) -> httpx.Response:
         try:
@@ -168,6 +170,8 @@ class IndexifyClient:
         )
         response.raise_for_status()
         self._graphs[graph.name] = graph
+        for fn_name, fn in graph.nodes.items():
+            self._fns[f"{graph.name}/{fn_name}"] = fn
 
     def graphs(self) -> List[str]:
         response = self._get(f"graphs")
@@ -177,14 +181,14 @@ class IndexifyClient:
         response = self._get(f"namespaces/{self.namespace}/compute_graphs/{name}")
         return ComputeGraphMetadata(**response.json())
 
-    def load_graph(self, name: str, fn_name: str) -> Graph:
+    def load_fn_wrapper(self, name: str, fn_name: str) -> IndexifyFunctionWrapper:
         response = self._get(
             f"internal/namespaces/{self.namespace}/compute_graphs/{name}/code"
         )
-        cg_metadata: ComputeGraphMetadata = self.graph(name)
-        fn_metadata = cg_metadata.nodes[fn_name]
-        pickled_bytes_by_image = cloudpickle.loads(response.content)
-        return Graph.deserialize(pickled_bytes_by_image, fn_metadata.image_name())
+        pickled_functions_by_name = cloudpickle.loads(response.content)
+        return IndexifyFunctionWrapper(
+            cloudpickle.loads(pickled_functions_by_name[fn_name])
+        )
 
     def namespaces(self) -> List[str]:
         response = self._get(f"namespaces")
@@ -193,9 +197,28 @@ class IndexifyClient:
         for item in namespaces_dict:
             namespaces.append(item["name"])
         return namespaces
+    
+    @classmethod
+    def new_namespace(cls, namespace: str, server_addr: Optional[str] = "http://localhost:8900"):
+        # Create a new client instance with the specified server address
+        client = cls(service_url=server_addr)
+
+        try:
+            # Create the new namespace using the client
+            client.create_namespace(namespace)
+        except ApiException as e:
+            print(f"Failed to create namespace '{namespace}': {e}")
+            raise
+
+        # Set the namespace for the newly created client
+        client.namespace = namespace
+        
+        # Return the client instance with the new namespace
+        return client
+
 
     def create_namespace(self, namespace: str):
-        self._post("namespaces", json={"namespace": namespace})
+        self._post("namespaces", json={"name": namespace})
 
     def logs(
         self, invocation_id: str, cg_name: str, fn_name: str, file: str
@@ -289,8 +312,9 @@ class IndexifyClient:
         block_until_done: bool = True: If True, the method will block until the extraction is done. If False, the method will return immediately.
         return: Union[Dict[str, List[Any]], List[Any]]: The extracted objects. If the extractor name is provided, the output is a list of extracted objects by the extractor. If the extractor name is not provided, the output is a dictionary with the extractor name as the key and the extracted objects as the value. If no objects are found, an empty list is returned.
         """
-        if graph not in self._graphs:
-            self._graphs[graph] = self.load_graph(graph, fn_name)
+        fn_key = f"{graph}/{fn_name}"
+        if fn_key not in self._fns:
+            self._fns[fn_key] = self.load_fn_wrapper(graph, fn_name)
         response = self._get(
             f"namespaces/{self.namespace}/compute_graphs/{graph}/invocations/{invocation_id}/outputs",
         )
@@ -302,9 +326,7 @@ class IndexifyClient:
                 indexify_data = self._download_output(
                     self.namespace, graph, invocation_id, fn_name, output.id
                 )
-                output = self._graphs[graph].deserialize_fn_output(
-                    fn_name, indexify_data
-                )
+                output = self._fns[fn_key].deserialize_fn_output(indexify_data)
                 outputs.append(output)
         return outputs
 

{indexify-0.2.7 → indexify-0.2.8}/indexify/remote_graph.py

@@ -32,21 +32,22 @@ class RemoteGraph:
         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",
-    ):
+    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.
         """
         import cloudpickle
-
         for module in additional_modules:
             cloudpickle.register_pickle_by_value(module)
         client = IndexifyClient(service_url=server_url)
@@ -63,7 +64,7 @@ class RemoteGraph:
         """
         return cls(name=name, server_url=server_url)
 
-    def get_output(
+    def output(
         self,
         invocation_id: str,
         fn_name: str,

{indexify-0.2.7 → indexify-0.2.8}/pyproject.toml

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