indexify 0.2.16__tar.gz → 0.2.18__tar.gz

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

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

{indexify-0.2.16 → indexify-0.2.18}/indexify/cli.py

@@ -261,7 +261,7 @@ WORKDIR /app
         docker_file += f"\nRUN pip install indexify"
 
     console.print("Creating image using Dockerfile contents:", style="cyan bold")
-    console.print(f"{docker_file}", style="magenta")
+    print(f"{docker_file}")
 
     client = docker.from_env()
     image_name = f"{image._image_name}:{image._tag}"

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

@@ -307,6 +307,13 @@ class ExtractorAgent:
                 return words[0].capitalize() + "" + " ".join(words[1:])
 
             runtime_probe: ProbeInfo = self._probe.probe()
+
+            # Inspect the image
+            if runtime_probe.is_default_executor:
+                # install dependencies
+                # rewrite the image name
+                pass
+
             data = ExecutorMetadata(
                 id=self._executor_id,
                 addr="",

{indexify-0.2.16 → indexify-0.2.18}/indexify/executor/function_worker.py

@@ -1,6 +1,5 @@
-import asyncio
+import sys
 import traceback
-from concurrent.futures.process import BrokenProcessPool
 from typing import Dict, List, Optional
 
 import cloudpickle
@@ -12,7 +11,11 @@ from indexify.functions_sdk.data_objects import (
     IndexifyData,
     RouterOutput,
 )
-from indexify.functions_sdk.indexify_functions import IndexifyFunctionWrapper
+from indexify.functions_sdk.indexify_functions import (
+    FunctionCallResult,
+    IndexifyFunctionWrapper,
+    RouterCallResult,
+)
 
 function_wrapper_map: Dict[str, IndexifyFunctionWrapper] = {}
 
@@ -62,6 +65,7 @@ class FunctionWorker:
         self._executor: concurrent.futures.ProcessPoolExecutor = (
             concurrent.futures.ProcessPoolExecutor(max_workers=workers)
         )
+        self._workers = workers
 
     async def async_submit(
         self,
@@ -74,22 +78,11 @@ class FunctionWorker:
         init_value: Optional[IndexifyData] = None,
     ) -> FunctionWorkerOutput:
         try:
-            result = await asyncio.get_running_loop().run_in_executor(
-                self._executor,
-                _run_function,
-                namespace,
-                graph_name,
-                fn_name,
-                input,
-                code_path,
-                version,
-                init_value,
+            result = _run_function(
+                namespace, graph_name, fn_name, input, code_path, version, init_value
             )
-        except BrokenProcessPool as mp:
-            self._executor.shutdown(wait=True, cancel_futures=True)
-            traceback.print_exc()
-            raise mp
-        except FunctionRunException as e:
+            # TODO - bring back running in a separate process
+        except Exception as e:
             return FunctionWorkerOutput(
                 exception=str(e),
                 stdout=e.stdout,
@@ -122,7 +115,6 @@ def _run_function(
     init_value: Optional[IndexifyData] = None,
 ) -> FunctionOutput:
     import io
-    import traceback
     from contextlib import redirect_stderr, redirect_stdout
 
     stdout_capture = io.StringIO()
@@ -146,14 +138,23 @@ def _run_function(
                 str(type(fn.indexify_function))
                 == "<class 'indexify.functions_sdk.indexify_functions.IndexifyRo'>"
             ):
-                router_output = fn.invoke_router(fn_name, input)
+                router_call_result: RouterCallResult = fn.invoke_router(fn_name, input)
+                router_output = RouterOutput(edges=router_call_result.edges)
+                if router_call_result.traceback_msg is not None:
+                    print(router_call_result.traceback_msg, file=sys.stderr)
+                    has_failed = True
+                    exception_msg = router_call_result.traceback_msg
             else:
-                fn_output = fn.invoke_fn_ser(fn_name, input, init_value)
-
+                fn_call_result: FunctionCallResult = fn.invoke_fn_ser(
+                    fn_name, input, init_value
+                )
                 is_reducer = fn.indexify_function.accumulate is not None
+                fn_output = fn_call_result.ser_outputs
+                if fn_call_result.traceback_msg is not None:
+                    print(fn_call_result.traceback_msg, file=sys.stderr)
+                    has_failed = True
+                    exception_msg = fn_call_result.traceback_msg
         except Exception as e:
-            import sys
-
             print(traceback.format_exc(), file=sys.stderr)
             has_failed = True
             exception_msg = str(e)

{indexify-0.2.16 → indexify-0.2.18}/indexify/executor/runtime_probes.py

@@ -5,11 +5,14 @@ from typing import Any, Dict, Tuple
 
 from pydantic import BaseModel
 
+DEFAULT_EXECUTOR = "tensorlake/indexify-executor-default"
+
 
 class ProbeInfo(BaseModel):
     image_name: str
     python_major_version: int
     labels: Dict[str, Any] = {}
+    is_default_executor: bool
 
 
 class RuntimeProbes:
@@ -27,12 +30,15 @@ class RuntimeProbes:
         if os.path.exists(file_path):
             with open(file_path, "r") as file:
                 return file.read().strip()
-        return "tensorlake/indexify-executor-default"
+        return DEFAULT_EXECUTOR
 
     def _get_python_version(self) -> Tuple[int, int]:
         version_info = sys.version_info
         return version_info.major, version_info.minor
 
+    def _is_default_executor(self):
+        return True if self._read_image_name() == DEFAULT_EXECUTOR else False
+
     def probe(self) -> ProbeInfo:
         labels = {
             "os": self._os_name,
@@ -41,8 +47,10 @@ class RuntimeProbes:
             "python_major_version": self._python_version_major,
             "python_minor_version": self._python_version_minor,
         }
+
         return ProbeInfo(
             image_name=self._image_name,
             python_major_version=self._python_version_major,
             labels=labels,
+            is_default_executor=self._is_default_executor(),
         )

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

@@ -29,6 +29,7 @@ from .graph_definition import (
 )
 from .graph_validation import validate_node, validate_route
 from .indexify_functions import (
+    FunctionCallResult,
     IndexifyFunction,
     IndexifyFunctionWrapper,
     IndexifyRouter,
@@ -157,6 +158,7 @@ class Graph:
             description=start_node.description,
             reducer=start_node.accumulate is not None,
             image_name=start_node.image._image_name,
+            image_information=start_node.image.to_image_information(),
         )
         metadata_edges = self.edges.copy()
         metadata_nodes = {}
@@ -170,6 +172,7 @@ class Graph:
                         target_fns=self.routers[node_name],
                         payload_encoder=node.payload_encoder,
                         image_name=node.image._image_name,
+                        image_information=node.image.to_image_information(),
                     )
                 )
             else:
@@ -180,6 +183,7 @@ class Graph:
                         description=node.description,
                         reducer=node.accumulate is not None,
                         image_name=node.image._image_name,
+                        image_information=node.image.to_image_information(),
                     )
                 )
 
@@ -209,57 +213,37 @@ class Graph:
                 k: IndexifyData(payload=serializer.serialize(v))
             }
         self._results[input.id] = outputs
-        enable_cache = kwargs.get('enable_cache', True)
-        self._run(input, outputs,enable_cache)
+        enable_cache = kwargs.get("enable_cache", True)
+        self._run(input, outputs, enable_cache)
         return input.id
 
     def _run(
         self,
         initial_input: IndexifyData,
         outputs: Dict[str, List[bytes]],
-        enable_cache: bool
+        enable_cache: bool,
     ):
         accumulator_values = self._accumulator_values[initial_input.id]
         queue = deque([(self._start_node, initial_input)])
         while queue:
             node_name, input = queue.popleft()
             node = self.nodes[node_name]
-            serializer = get_serializer(node.payload_encoder)
-            input_bytes = serializer.serialize(input)
-            cached_output_bytes: Optional[bytes] = self._cache.get(
-                self.name, node_name, input_bytes
-            )
-            if cached_output_bytes is not None and enable_cache:
-                print(
-                    f"ran {node_name}: num outputs: {len(cached_output_bytes)} (cache hit)"
-                )
-                function_outputs: List[IndexifyData] = []
-                cached_output_list = serializer.deserialize_list(cached_output_bytes)
-                if accumulator_values.get(node_name, None) is not None:
-                    accumulator_values[node_name] = cached_output_list[-1].model_copy()
-                    outputs[node_name] = []
-                function_outputs.extend(cached_output_list)
-                outputs[node_name].extend(cached_output_list)
-            else:
-                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)}")
-                if accumulator_values.get(node_name, None) is not None:
-                    accumulator_values[node_name] = function_outputs[-1].model_copy()
-                    outputs[node_name] = []
-                outputs[node_name].extend(function_outputs)
-                function_outputs_bytes: List[bytes] = [
-                    serializer.serialize_list(function_outputs)
-                ]
-                self._cache.set(
-                    self.name,
-                    node_name,
-                    input_bytes,
-                    function_outputs_bytes,
-                )
+            function_outputs: FunctionCallResult = IndexifyFunctionWrapper(
+                node
+            ).invoke_fn_ser(node_name, input, accumulator_values.get(node_name, None))
+            if function_outputs.traceback_msg is not None:
+                print(function_outputs.traceback_msg)
+                import os
+
+                print("exiting local execution due to error")
+                os._exit(1)
+            fn_outputs = function_outputs.ser_outputs
+            print(f"ran {node_name}: num outputs: {len(fn_outputs)}")
+            if accumulator_values.get(node_name, None) is not None:
+                accumulator_values[node_name] = fn_outputs[-1].model_copy()
+                outputs[node_name] = []
+            if fn_outputs:
+                outputs[node_name].extend(fn_outputs)
             if accumulator_values.get(node_name, None) is not None and queue:
                 print(
                     f"accumulator not none for {node_name}, continuing, len queue: {len(queue)}"
@@ -271,7 +255,7 @@ class Graph:
             for i, edge in enumerate(out_edges):
                 if edge in self.routers:
                     out_edges.remove(edge)
-                    for output in function_outputs:
+                    for output in fn_outputs:
                         dynamic_edges = self._route(edge, output) or []
                         for dynamic_edge in dynamic_edges.edges:
                             if dynamic_edge in self.nodes:
@@ -280,7 +264,7 @@ class Graph:
                                 )
                                 out_edges.append(dynamic_edge)
             for out_edge in out_edges:
-                for output in function_outputs:
+                for output in fn_outputs:
                     queue.append((out_edge, output))
 
     def _route(self, node_name: str, input: IndexifyData) -> Optional[RouterOutput]:

{indexify-0.2.16 → indexify-0.2.18}/indexify/functions_sdk/graph_definition.py

@@ -2,6 +2,8 @@ from typing import Dict, List, Optional
 
 from pydantic import BaseModel
 
+from indexify.functions_sdk.image import ImageInformation
+
 from .object_serializer import get_serializer
 
 
@@ -11,6 +13,7 @@ class FunctionMetadata(BaseModel):
     description: str
     reducer: bool = False
     image_name: str
+    image_information: ImageInformation
     payload_encoder: str = "cloudpickle"
 
 
@@ -20,6 +23,7 @@ class RouterMetadata(BaseModel):
     source_fn: str
     target_fns: List[str]
     image_name: str
+    image_information: ImageInformation
     payload_encoder: str = "cloudpickle"
 
 

{indexify-0.2.16 → indexify-0.2.18}/indexify/functions_sdk/image.py

@@ -1,3 +1,8 @@
+from typing import List
+
+from pydantic import BaseModel
+
+
 def python_version_to_image(python_version):
     if python_version.startswith("3.9"):
         return "python:3.9.20-bookworm"
@@ -9,6 +14,14 @@ def python_version_to_image(python_version):
         raise ValueError(f"unsupported Python version: {python_version}")
 
 
+# Pydantic object for API
+class ImageInformation(BaseModel):
+    image_name: str
+    tag: str
+    base_image: str
+    run_strs: List[str]
+
+
 class Image:
     def __init__(self, python="3.10"):
         self._image_name = None
@@ -33,6 +46,14 @@ class Image:
         self._run_strs.append(run_str)
         return self
 
+    def to_image_information(self):
+        return ImageInformation(
+            image_name=self._image_name,
+            tag=self._tag,
+            base_image=self._base_image,
+            run_strs=self._run_strs,
+        )
+
 
 DEFAULT_IMAGE_3_10 = (
     Image()

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

@@ -1,4 +1,7 @@
 import inspect
+import re
+import sys
+import traceback
 from abc import ABC, abstractmethod
 from functools import update_wrapper
 from typing import (
@@ -7,6 +10,7 @@ from typing import (
     Dict,
     List,
     Optional,
+    Tuple,
     Type,
     Union,
     get_args,
@@ -22,6 +26,37 @@ from .image import DEFAULT_IMAGE_3_10, Image
 from .object_serializer import CloudPickleSerializer, get_serializer
 
 
+def format_filtered_traceback(exc_info=None):
+    """
+    Format a traceback excluding indexify_functions.py lines.
+    Can be used in exception handlers to replace traceback.format_exc()
+    """
+    if exc_info is None:
+        exc_info = sys.exc_info()
+
+    # Get the full traceback as a string
+    full_traceback = traceback.format_exception(*exc_info)
+
+    # Filter out lines containing indexify_functions.py
+    filtered_lines = []
+    skip_next = False
+
+    for line in full_traceback:
+        if "indexify_functions.py" in line:
+            skip_next = True
+            continue
+        if skip_next:
+            if line.strip().startswith("File "):
+                skip_next = False
+            else:
+                continue
+        filtered_lines.append(line)
+
+    # Clean up any double blank lines that might have been created
+    cleaned = re.sub(r"\n\s*\n\s*\n", "\n\n", "".join(filtered_lines))
+    return cleaned
+
+
 def is_pydantic_model_from_annotation(type_annotation):
     # If it's a string representation
     if isinstance(type_annotation, str):
@@ -49,12 +84,6 @@ def is_pydantic_model_from_annotation(type_annotation):
     return False
 
 
-class EmbeddingIndexes(BaseModel):
-    dim: int
-    distance: Optional[str] = "cosine"
-    database_url: Optional[str] = None
-
-
 class PlacementConstraints(BaseModel):
     min_python_version: Optional[str] = "3.9"
     max_python_version: Optional[str] = None
@@ -62,7 +91,7 @@ class PlacementConstraints(BaseModel):
     image_name: Optional[str] = None
 
 
-class IndexifyFunction(ABC):
+class IndexifyFunction:
     name: str = ""
     description: str = ""
     image: Optional[Image] = DEFAULT_IMAGE_3_10
@@ -70,7 +99,6 @@ class IndexifyFunction(ABC):
     accumulate: Optional[Type[Any]] = None
     payload_encoder: Optional[str] = "cloudpickle"
 
-    @abstractmethod
     def run(self, *args, **kwargs) -> Union[List[Any], Any]:
         pass
 
@@ -84,14 +112,14 @@ class IndexifyFunction(ABC):
         serializer = get_serializer(cls.payload_encoder)
         return serializer.deserialize(output.payload)
 
-class IndexifyRouter(ABC):
+
+class IndexifyRouter:
     name: str = ""
     description: str = ""
     image: Optional[Image] = DEFAULT_IMAGE_3_10
     placement_constraints: List[PlacementConstraints] = []
     payload_encoder: Optional[str] = "cloudpickle"
 
-    @abstractmethod
     def run(self, *args, **kwargs) -> Optional[List[IndexifyFunction]]:
         pass
 
@@ -166,6 +194,16 @@ def indexify_function(
     return construct
 
 
+class FunctionCallResult(BaseModel):
+    ser_outputs: List[IndexifyData]
+    traceback_msg: Optional[str] = None
+
+
+class RouterCallResult(BaseModel):
+    edges: List[str]
+    traceback_msg: Optional[str] = None
+
+
 class IndexifyFunctionWrapper:
     def __init__(self, indexify_function: Union[IndexifyFunction, IndexifyRouter]):
         self.indexify_function: Union[
@@ -189,7 +227,9 @@ class IndexifyFunctionWrapper:
                 )
         return return_type
 
-    def run_router(self, input: Union[Dict, Type[BaseModel]]) -> List[str]:
+    def run_router(
+        self, input: Union[Dict, Type[BaseModel]]
+    ) -> Tuple[List[str], Optional[str]]:
         kwargs = input if isinstance(input, dict) else {"input": input}
         args = []
         kwargs = {}
@@ -197,17 +237,20 @@ class IndexifyFunctionWrapper:
             kwargs = input
         else:
             args.append(input)
-        extracted_data = self.indexify_function.run(*args, **kwargs)
+        try:
+            extracted_data = self.indexify_function.run(*args, **kwargs)
+        except Exception as e:
+            return [], format_filtered_traceback()
         if not isinstance(extracted_data, list) and extracted_data is not None:
-            return [extracted_data.name]
+            return [extracted_data.name], None
         edges = []
         for fn in extracted_data or []:
             edges.append(fn.name)
-        return edges
+        return edges, None
 
     def run_fn(
         self, input: Union[Dict, Type[BaseModel]], acc: Type[Any] = None
-    ) -> List[IndexifyData]:
+    ) -> Tuple[List[Any], Optional[str]]:
         args = []
         kwargs = {}
         if acc is not None:
@@ -217,15 +260,21 @@ class IndexifyFunctionWrapper:
         else:
             args.append(input)
 
-        extracted_data = self.indexify_function.run(*args, **kwargs)
+        try:
+            extracted_data = self.indexify_function.run(*args, **kwargs)
+        except Exception as e:
+            return [], format_filtered_traceback()
         if extracted_data is None:
-            return []
+            return [], None
 
-        return extracted_data if isinstance(extracted_data, list) else [extracted_data]
+        output = (
+            extracted_data if isinstance(extracted_data, list) else [extracted_data]
+        )
+        return output, None
 
     def invoke_fn_ser(
         self, name: str, input: IndexifyData, acc: Optional[Any] = None
-    ) -> List[IndexifyData]:
+    ) -> FunctionCallResult:
         input = self.deserialize_input(name, input)
         serializer = get_serializer(self.indexify_function.payload_encoder)
         if acc is not None:
@@ -236,14 +285,16 @@ class IndexifyFunctionWrapper:
             acc = self.indexify_function.accumulate.model_validate(
                 self.indexify_function.accumulate()
             )
-        outputs: Optional[List[Any]] = self.run_fn(input, acc=acc)
-        return [
+        outputs, err = self.run_fn(input, acc=acc)
+        ser_outputs = [
             IndexifyData(payload=serializer.serialize(output)) for output in outputs
         ]
+        return FunctionCallResult(ser_outputs=ser_outputs, traceback_msg=err)
 
-    def invoke_router(self, name: str, input: IndexifyData) -> Optional[RouterOutput]:
+    def invoke_router(self, name: str, input: IndexifyData) -> RouterCallResult:
         input = self.deserialize_input(name, input)
-        return RouterOutput(edges=self.run_router(input))
+        edges, err = self.run_router(input)
+        return RouterCallResult(edges=edges, traceback_msg=err)
 
     def deserialize_input(self, compute_fn: str, indexify_data: IndexifyData) -> Any:
         if self.indexify_function.payload_encoder == "cloudpickle":

{indexify-0.2.16 → indexify-0.2.18}/indexify/http_client.py

@@ -220,11 +220,11 @@ class IndexifyClient:
         self._post("namespaces", json={"name": namespace})
 
     def logs(
-        self, invocation_id: str, cg_name: str, fn_name: str, file: str
+        self, invocation_id: str, cg_name: str, fn_name: str, task_id: str, file: str
     ) -> Optional[str]:
         try:
             response = self._get(
-                f"namespaces/{self.namespace}/compute_graphs/{cg_name}/invocations/{invocation_id}/fn/{fn_name}/logs/{file}"
+                f"namespaces/{self.namespace}/compute_graphs/{cg_name}/invocations/{invocation_id}/fn/{fn_name}/tasks/{task_id}/logs/{file}"
             )
             response.raise_for_status()
             return response.content.decode("utf-8")
@@ -272,12 +272,14 @@ class IndexifyClient:
                                 event.payload.invocation_id,
                                 graph,
                                 event.payload.fn_name,
+                                event.payload.task_id,
                                 "stdout",
                             )
                             stderr = self.logs(
                                 event.payload.invocation_id,
                                 graph,
                                 event.payload.fn_name,
+                                event.payload.task_id,
                                 "stderr",
                             )
                             if stdout:

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

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