indexify 0.2.5__tar.gz → 0.2.7__tar.gz

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

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

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

@@ -122,6 +122,11 @@ def server_dev_mode():
 def build_image(workflow_file_path: str, func_names: List[str]):
     globals_dict = {}
 
+    # Add the folder in the workflow file path to the current Python path
+    folder_path = os.path.dirname(workflow_file_path)
+    if folder_path not in sys.path:
+        sys.path.append(folder_path)
+
     try:
         exec(open(workflow_file_path).read(), globals_dict)
     except FileNotFoundError as e:
@@ -240,8 +245,10 @@ WORKDIR /app
     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()),
-        tag=f"{image._image_name}:{image._tag}",
+        tag=image_name,
         rm=True,
     )
+    print(f"built image: {image_name}")

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

@@ -21,6 +21,8 @@ import concurrent.futures
 import io
 from contextlib import redirect_stderr, redirect_stdout
 
+from .runtime_probes import RuntimeProbes
+
 
 class FunctionRunException(Exception):
     def __init__(
@@ -51,7 +53,8 @@ def _load_function(
     key = f"{namespace}/{graph_name}/{version}/{fn_name}"
     if key in function_wrapper_map:
         return
-    graph = Graph.from_path(code_path)
+    image_name = RuntimeProbes().probe().image_name
+    graph = Graph.from_path(code_path, image_name)
     function_wrapper = graph.get_function(fn_name)
     function_wrapper_map[key] = function_wrapper
     graph_key = f"{namespace}/{graph_name}/{version}"
@@ -135,7 +138,9 @@ 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}"

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

@@ -132,32 +132,38 @@ class Graph:
             self.add_node(node)
             self.routers[from_node.name].append(node.name)
         return self
-    
-    
-    def _register_cloudpickle(self):
+
+    def serialize(self) -> Dict[str, bytes]:
         # Get all unique modules from nodes and edges
-        modules = set()
+        modules_by_images = defaultdict(set)
         for node in self.nodes.values():
-            modules.add(node.__module__)
+            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)
-
-
-    def serialize(self):
-        self._register_cloudpickle()
-        return cloudpickle.dumps(self)
+        return pickled_nodes_by_image
 
     @staticmethod
-    def deserialize(graph: bytes) -> "Graph":
-        return cloudpickle.loads(graph)
+    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) -> "Graph":
+    def from_path(path: str, image: str) -> "Graph":
         with open(path, "rb") as f:
-            return cloudpickle.load(f)
+            pickled_code_by_images: Dict[str, bytes] = cloudpickle.load(f)
+        return Graph.deserialize(pickled_code_by_images, image)
 
     def add_edge(
         self,

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

@@ -27,6 +27,11 @@ 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.5 → indexify-0.2.7}/indexify/functions_sdk/image.py

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

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

@@ -99,7 +99,7 @@ class IndexifyClient:
         service_url: str = DEFAULT_SERVICE_URL_HTTPS,
         *args,
         **kwargs,
-    ) -> "RemoteClient":
+    ) -> "IndexifyClient":
         """
         Create a client with mutual TLS authentication. Also enables HTTP/2,
         which is required for mTLS.
@@ -127,7 +127,7 @@ class IndexifyClient:
 
         client_certs = (cert_path, key_path)
         verify_option = ca_bundle_path if ca_bundle_path else True
-        client = RemoteClient(
+        client = IndexifyClient(
             *args,
             **kwargs,
             service_url=service_url,
@@ -160,7 +160,7 @@ class IndexifyClient:
 
     def register_compute_graph(self, graph: Graph):
         graph_metadata = graph.definition()
-        serialized_code = graph.serialize()
+        serialized_code = cloudpickle.dumps(graph.serialize())
         response = self._post(
             f"namespaces/{self.namespace}/compute_graphs",
             files={"code": serialized_code},
@@ -177,11 +177,14 @@ class IndexifyClient:
         response = self._get(f"namespaces/{self.namespace}/compute_graphs/{name}")
         return ComputeGraphMetadata(**response.json())
 
-    def load_graph(self, name: str) -> Graph:
+    def load_graph(self, name: str, fn_name: str) -> Graph:
         response = self._get(
             f"internal/namespaces/{self.namespace}/compute_graphs/{name}/code"
         )
-        return Graph.deserialize(response.content)
+        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())
 
     def namespaces(self) -> List[str]:
         response = self._get(f"namespaces")
@@ -287,7 +290,7 @@ class IndexifyClient:
         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)
+            self._graphs[graph] = self.load_graph(graph, fn_name)
         response = self._get(
             f"namespaces/{self.namespace}/compute_graphs/{graph}/invocations/{invocation_id}/outputs",
         )

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

@@ -34,13 +34,19 @@ class RemoteGraph:
         )
 
     @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)

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

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