indexify 0.2.39__py3-none-any.whl → 0.2.41__py3-none-any.whl

indexify/function_executor/proto/function_executor_pb2.py

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: indexify/function_executor/proto/function_executor.proto
+# Protobuf Python Version: 5.28.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    28,
+    1,
+    "",
+    "indexify/function_executor/proto/function_executor.proto",
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
+    b'\n8indexify/function_executor/proto/function_executor.proto\x12\x19\x66unction_executor_service"i\n\x10SerializedObject\x12\x0f\n\x05\x62ytes\x18\x01 \x01(\x0cH\x00\x12\x10\n\x06string\x18\x02 \x01(\tH\x00\x12\x19\n\x0c\x63ontent_type\x18\x03 \x01(\tH\x01\x88\x01\x01\x42\x06\n\x04\x64\x61taB\x0f\n\r_content_type"\x88\x02\n\x11InitializeRequest\x12\x16\n\tnamespace\x18\x01 \x01(\tH\x00\x88\x01\x01\x12\x17\n\ngraph_name\x18\x02 \x01(\tH\x01\x88\x01\x01\x12\x1a\n\rgraph_version\x18\x03 \x01(\x05H\x02\x88\x01\x01\x12\x1a\n\rfunction_name\x18\x05 \x01(\tH\x03\x88\x01\x01\x12?\n\x05graph\x18\x07 \x01(\x0b\x32+.function_executor_service.SerializedObjectH\x04\x88\x01\x01\x42\x0c\n\n_namespaceB\r\n\x0b_graph_nameB\x10\n\x0e_graph_versionB\x10\n\x0e_function_nameB\x08\n\x06_graph"6\n\x12InitializeResponse\x12\x14\n\x07success\x18\x01 \x01(\x08H\x00\x88\x01\x01\x42\n\n\x08_success"N\n\x0e\x46unctionOutput\x12<\n\x07outputs\x18\x01 \x03(\x0b\x32+.function_executor_service.SerializedObject"\x1d\n\x0cRouterOutput\x12\r\n\x05\x65\x64ges\x18\x01 \x03(\t"\xb0\x02\n\x0eRunTaskRequest\x12 \n\x13graph_invocation_id\x18\x04 \x01(\tH\x00\x88\x01\x01\x12\x14\n\x07task_id\x18\x06 \x01(\tH\x01\x88\x01\x01\x12H\n\x0e\x66unction_input\x18\t \x01(\x0b\x32+.function_executor_service.SerializedObjectH\x02\x88\x01\x01\x12M\n\x13\x66unction_init_value\x18\n \x01(\x0b\x32+.function_executor_service.SerializedObjectH\x03\x88\x01\x01\x42\x16\n\x14_graph_invocation_idB\n\n\x08_task_idB\x11\n\x0f_function_inputB\x16\n\x14_function_init_value"\xf1\x02\n\x0fRunTaskResponse\x12\x14\n\x07task_id\x18\x01 \x01(\tH\x00\x88\x01\x01\x12G\n\x0f\x66unction_output\x18\x02 \x01(\x0b\x32).function_executor_service.FunctionOutputH\x01\x88\x01\x01\x12\x43\n\rrouter_output\x18\x03 \x01(\x0b\x32\'.function_executor_service.RouterOutputH\x02\x88\x01\x01\x12\x13\n\x06stdout\x18\x04 \x01(\tH\x03\x88\x01\x01\x12\x13\n\x06stderr\x18\x05 \x01(\tH\x04\x88\x01\x01\x12\x17\n\nis_reducer\x18\x06 \x01(\x08H\x05\x88\x01\x01\x12\x14\n\x07success\x18\x07 \x01(\x08H\x06\x88\x01\x01\x42\n\n\x08_task_idB\x12\n\x10_function_outputB\x10\n\x0e_router_outputB\t\n\x07_stdoutB\t\n\x07_stderrB\r\n\x0b_is_reducerB\n\n\x08_success2\xe0\x01\n\x10\x46unctionExecutor\x12i\n\ninitialize\x12,.function_executor_service.InitializeRequest\x1a-.function_executor_service.InitializeResponse\x12\x61\n\x08run_task\x12).function_executor_service.RunTaskRequest\x1a*.function_executor_service.RunTaskResponseb\x06proto3'
+)
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(
+    DESCRIPTOR, "indexify.function_executor.proto.function_executor_pb2", _globals
+)
+if not _descriptor._USE_C_DESCRIPTORS:
+    DESCRIPTOR._loaded_options = None
+    _globals["_SERIALIZEDOBJECT"]._serialized_start = 87
+    _globals["_SERIALIZEDOBJECT"]._serialized_end = 192
+    _globals["_INITIALIZEREQUEST"]._serialized_start = 195
+    _globals["_INITIALIZEREQUEST"]._serialized_end = 459
+    _globals["_INITIALIZERESPONSE"]._serialized_start = 461
+    _globals["_INITIALIZERESPONSE"]._serialized_end = 515
+    _globals["_FUNCTIONOUTPUT"]._serialized_start = 517
+    _globals["_FUNCTIONOUTPUT"]._serialized_end = 595
+    _globals["_ROUTEROUTPUT"]._serialized_start = 597
+    _globals["_ROUTEROUTPUT"]._serialized_end = 626
+    _globals["_RUNTASKREQUEST"]._serialized_start = 629
+    _globals["_RUNTASKREQUEST"]._serialized_end = 933
+    _globals["_RUNTASKRESPONSE"]._serialized_start = 936
+    _globals["_RUNTASKRESPONSE"]._serialized_end = 1305
+    _globals["_FUNCTIONEXECUTOR"]._serialized_start = 1308
+    _globals["_FUNCTIONEXECUTOR"]._serialized_end = 1532
+# @@protoc_insertion_point(module_scope)

indexify/function_executor/proto/function_executor_pb2.pyi

@@ -0,0 +1,125 @@
+from typing import ClassVar as _ClassVar
+from typing import Iterable as _Iterable
+from typing import Mapping as _Mapping
+from typing import Optional as _Optional
+from typing import Union as _Union
+
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf.internal import containers as _containers
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class SerializedObject(_message.Message):
+    __slots__ = ("bytes", "string", "content_type")
+    BYTES_FIELD_NUMBER: _ClassVar[int]
+    STRING_FIELD_NUMBER: _ClassVar[int]
+    CONTENT_TYPE_FIELD_NUMBER: _ClassVar[int]
+    bytes: bytes
+    string: str
+    content_type: str
+    def __init__(
+        self,
+        bytes: _Optional[bytes] = ...,
+        string: _Optional[str] = ...,
+        content_type: _Optional[str] = ...,
+    ) -> None: ...
+
+class InitializeRequest(_message.Message):
+    __slots__ = ("namespace", "graph_name", "graph_version", "function_name", "graph")
+    NAMESPACE_FIELD_NUMBER: _ClassVar[int]
+    GRAPH_NAME_FIELD_NUMBER: _ClassVar[int]
+    GRAPH_VERSION_FIELD_NUMBER: _ClassVar[int]
+    FUNCTION_NAME_FIELD_NUMBER: _ClassVar[int]
+    GRAPH_FIELD_NUMBER: _ClassVar[int]
+    namespace: str
+    graph_name: str
+    graph_version: int
+    function_name: str
+    graph: SerializedObject
+    def __init__(
+        self,
+        namespace: _Optional[str] = ...,
+        graph_name: _Optional[str] = ...,
+        graph_version: _Optional[int] = ...,
+        function_name: _Optional[str] = ...,
+        graph: _Optional[_Union[SerializedObject, _Mapping]] = ...,
+    ) -> None: ...
+
+class InitializeResponse(_message.Message):
+    __slots__ = ("success",)
+    SUCCESS_FIELD_NUMBER: _ClassVar[int]
+    success: bool
+    def __init__(self, success: bool = ...) -> None: ...
+
+class FunctionOutput(_message.Message):
+    __slots__ = ("outputs",)
+    OUTPUTS_FIELD_NUMBER: _ClassVar[int]
+    outputs: _containers.RepeatedCompositeFieldContainer[SerializedObject]
+    def __init__(
+        self, outputs: _Optional[_Iterable[_Union[SerializedObject, _Mapping]]] = ...
+    ) -> None: ...
+
+class RouterOutput(_message.Message):
+    __slots__ = ("edges",)
+    EDGES_FIELD_NUMBER: _ClassVar[int]
+    edges: _containers.RepeatedScalarFieldContainer[str]
+    def __init__(self, edges: _Optional[_Iterable[str]] = ...) -> None: ...
+
+class RunTaskRequest(_message.Message):
+    __slots__ = (
+        "graph_invocation_id",
+        "task_id",
+        "function_input",
+        "function_init_value",
+    )
+    GRAPH_INVOCATION_ID_FIELD_NUMBER: _ClassVar[int]
+    TASK_ID_FIELD_NUMBER: _ClassVar[int]
+    FUNCTION_INPUT_FIELD_NUMBER: _ClassVar[int]
+    FUNCTION_INIT_VALUE_FIELD_NUMBER: _ClassVar[int]
+    graph_invocation_id: str
+    task_id: str
+    function_input: SerializedObject
+    function_init_value: SerializedObject
+    def __init__(
+        self,
+        graph_invocation_id: _Optional[str] = ...,
+        task_id: _Optional[str] = ...,
+        function_input: _Optional[_Union[SerializedObject, _Mapping]] = ...,
+        function_init_value: _Optional[_Union[SerializedObject, _Mapping]] = ...,
+    ) -> None: ...
+
+class RunTaskResponse(_message.Message):
+    __slots__ = (
+        "task_id",
+        "function_output",
+        "router_output",
+        "stdout",
+        "stderr",
+        "is_reducer",
+        "success",
+    )
+    TASK_ID_FIELD_NUMBER: _ClassVar[int]
+    FUNCTION_OUTPUT_FIELD_NUMBER: _ClassVar[int]
+    ROUTER_OUTPUT_FIELD_NUMBER: _ClassVar[int]
+    STDOUT_FIELD_NUMBER: _ClassVar[int]
+    STDERR_FIELD_NUMBER: _ClassVar[int]
+    IS_REDUCER_FIELD_NUMBER: _ClassVar[int]
+    SUCCESS_FIELD_NUMBER: _ClassVar[int]
+    task_id: str
+    function_output: FunctionOutput
+    router_output: RouterOutput
+    stdout: str
+    stderr: str
+    is_reducer: bool
+    success: bool
+    def __init__(
+        self,
+        task_id: _Optional[str] = ...,
+        function_output: _Optional[_Union[FunctionOutput, _Mapping]] = ...,
+        router_output: _Optional[_Union[RouterOutput, _Mapping]] = ...,
+        stdout: _Optional[str] = ...,
+        stderr: _Optional[str] = ...,
+        is_reducer: bool = ...,
+        success: bool = ...,
+    ) -> None: ...

indexify/function_executor/proto/function_executor_pb2_grpc.py

@@ -0,0 +1,163 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import warnings
+
+import grpc
+
+from indexify.function_executor.proto import (
+    function_executor_pb2 as indexify_dot_function__executor_dot_proto_dot_function__executor__pb2,
+)
+
+GRPC_GENERATED_VERSION = "1.68.1"
+GRPC_VERSION = grpc.__version__
+_version_not_supported = False
+
+try:
+    from grpc._utilities import first_version_is_lower
+
+    _version_not_supported = first_version_is_lower(
+        GRPC_VERSION, GRPC_GENERATED_VERSION
+    )
+except ImportError:
+    _version_not_supported = True
+
+if _version_not_supported:
+    raise RuntimeError(
+        f"The grpc package installed is at version {GRPC_VERSION},"
+        + f" but the generated code in indexify/function_executor/proto/function_executor_pb2_grpc.py depends on"
+        + f" grpcio>={GRPC_GENERATED_VERSION}."
+        + f" Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}"
+        + f" or downgrade your generated code using grpcio-tools<={GRPC_VERSION}."
+    )
+
+
+class FunctionExecutorStub(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.initialize = channel.unary_unary(
+            "/function_executor_service.FunctionExecutor/initialize",
+            request_serializer=indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.InitializeRequest.SerializeToString,
+            response_deserializer=indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.InitializeResponse.FromString,
+            _registered_method=True,
+        )
+        self.run_task = channel.unary_unary(
+            "/function_executor_service.FunctionExecutor/run_task",
+            request_serializer=indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.RunTaskRequest.SerializeToString,
+            response_deserializer=indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.RunTaskResponse.FromString,
+            _registered_method=True,
+        )
+
+
+class FunctionExecutorServicer(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def initialize(self, request, context):
+        """Initializes the Function Executor to run tasks
+        for a particular function. This method is called only
+        once per Function Executor as it can only run a single function.
+        It should be called before calling RunTask for the function.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details("Method not implemented!")
+        raise NotImplementedError("Method not implemented!")
+
+    def run_task(self, request, context):
+        """Executes the task defined in the request.
+        Multiple tasks can be running in parallel.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details("Method not implemented!")
+        raise NotImplementedError("Method not implemented!")
+
+
+def add_FunctionExecutorServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+        "initialize": grpc.unary_unary_rpc_method_handler(
+            servicer.initialize,
+            request_deserializer=indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.InitializeRequest.FromString,
+            response_serializer=indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.InitializeResponse.SerializeToString,
+        ),
+        "run_task": grpc.unary_unary_rpc_method_handler(
+            servicer.run_task,
+            request_deserializer=indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.RunTaskRequest.FromString,
+            response_serializer=indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.RunTaskResponse.SerializeToString,
+        ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+        "function_executor_service.FunctionExecutor", rpc_method_handlers
+    )
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers(
+        "function_executor_service.FunctionExecutor", rpc_method_handlers
+    )
+
+
+# This class is part of an EXPERIMENTAL API.
+class FunctionExecutor(object):
+    """Missing associated documentation comment in .proto file."""
+
+    @staticmethod
+    def initialize(
+        request,
+        target,
+        options=(),
+        channel_credentials=None,
+        call_credentials=None,
+        insecure=False,
+        compression=None,
+        wait_for_ready=None,
+        timeout=None,
+        metadata=None,
+    ):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            "/function_executor_service.FunctionExecutor/initialize",
+            indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.InitializeRequest.SerializeToString,
+            indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.InitializeResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True,
+        )
+
+    @staticmethod
+    def run_task(
+        request,
+        target,
+        options=(),
+        channel_credentials=None,
+        call_credentials=None,
+        insecure=False,
+        compression=None,
+        wait_for_ready=None,
+        timeout=None,
+        metadata=None,
+    ):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            "/function_executor_service.FunctionExecutor/run_task",
+            indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.RunTaskRequest.SerializeToString,
+            indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.RunTaskResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True,
+        )

indexify/function_executor/proto/message_validator.py

@@ -0,0 +1,38 @@
+from typing import Any, Self
+
+from .function_executor_pb2 import SerializedObject
+
+
+class MessageValidator:
+    def __init__(self, message: Any):
+        self._message = message
+
+    def required_field(self, field_name: str) -> Self:
+        if not self._message.HasField(field_name):
+            raise ValueError(
+                f"Field '{field_name}' is required in {type(self._message).__name__}"
+            )
+        return self
+
+    def required_serialized_object(self, field_name: str) -> Self:
+        """Validates the SerializedObject.
+
+        Raises: ValueError: If the SerializedObject is invalid or not present."""
+        self.required_field(field_name)
+        return self.optional_serialized_object(field_name)
+
+    def optional_serialized_object(self, field_name: str) -> Self:
+        """Validates the SerializedObject.
+
+        Raises: ValueError: If the SerializedObject is invalid."""
+        if not self._message.HasField(field_name):
+            return self
+
+        serializedObject: SerializedObject = getattr(self._message, field_name)
+        if not serializedObject.HasField("string") and not serializedObject.HasField(
+            "bytes"
+        ):
+            raise ValueError("oneof 'data' is requred in SerializedObject")
+        if not serializedObject.HasField("content_type"):
+            raise ValueError("Field 'content_type' is requred in SerializedObject")
+        return self

indexify/function_executor/server.py

@@ -0,0 +1,31 @@
+from concurrent.futures import ThreadPoolExecutor
+
+import grpc
+
+from .function_executor_service import FunctionExecutorService
+from .proto.configuration import GRPC_SERVER_OPTIONS
+from .proto.function_executor_pb2_grpc import (
+    add_FunctionExecutorServicer_to_server,
+)
+
+# Temporary limit until we have a better way to control this.
+# This limits the number of concurrent tasks that Function Executor can run.
+MAX_RPC_CONCURRENCY = 100
+
+
+class Server:
+    def __init__(self, server_address: str, service: FunctionExecutorService):
+        self._server_address: str = server_address
+        self._service: FunctionExecutorService = service
+
+    def run(self):
+        """Runs Function Executor Service at the configured address."""
+        server = grpc.server(
+            thread_pool=ThreadPoolExecutor(max_workers=MAX_RPC_CONCURRENCY),
+            maximum_concurrent_rpcs=MAX_RPC_CONCURRENCY,
+            options=GRPC_SERVER_OPTIONS,
+        )
+        add_FunctionExecutorServicer_to_server(self._service, server)
+        server.add_insecure_port(self._server_address)
+        server.start()
+        server.wait_for_termination()

indexify/functions_sdk/data_objects.py

@@ -20,15 +20,6 @@ class IndexifyData(BaseModel):
     encoder: Literal["cloudpickle", "json"] = "cloudpickle"
 
 
-class FunctionWorkerOutput(BaseModel):
-    fn_outputs: Optional[List[IndexifyData]]
-    router_output: Optional[RouterOutput]
-    stdout: Optional[str]
-    stderr: Optional[str]
-    reducer: bool = False
-    success: bool = True
-
-
 class File(BaseModel):
     data: bytes
     mime_type: Optional[str] = None

indexify/functions_sdk/graph.py

@@ -1,4 +1,4 @@
-import json
+import importlib
 import sys
 from collections import defaultdict
 from queue import deque
@@ -65,7 +65,11 @@ def is_pydantic_model_from_annotation(type_annotation):
 
 class Graph:
     def __init__(
-        self, name: str, start_node: IndexifyFunction, description: Optional[str] = None
+        self,
+        name: str,
+        start_node: IndexifyFunction,
+        description: Optional[str] = None,
+        tags: Dict[str, str] = {},
     ):
         self.name = name
         self.description = description
@@ -73,6 +77,7 @@ class Graph:
         self.routers: Dict[str, List[str]] = defaultdict(list)
         self.edges: Dict[str, List[str]] = defaultdict(list)
         self.accumulator_zero_values: Dict[str, Any] = {}
+        self.tags = tags
 
         self.add_node(start_node)
         if issubclass(start_node, IndexifyRouter):
@@ -169,7 +174,6 @@ class Graph:
             fn_name=start_node.name,
             description=start_node.description,
             reducer=is_reducer,
-            image_name=start_node.image._image_name,
             image_information=start_node.image.to_image_information(),
             input_encoder=start_node.input_encoder,
             output_encoder=start_node.output_encoder,
@@ -186,7 +190,6 @@ class Graph:
                         target_fns=self.routers[node_name],
                         input_encoder=node.input_encoder,
                         output_encoder=node.output_encoder,
-                        image_name=node.image._image_name,
                         image_information=node.image.to_image_information(),
                     )
                 )
@@ -197,7 +200,6 @@ class Graph:
                         fn_name=node.name,
                         description=node.description,
                         reducer=node.accumulate is not None,
-                        image_name=node.image._image_name,
                         image_information=node.image.to_image_information(),
                         input_encoder=node.input_encoder,
                         output_encoder=node.output_encoder,
@@ -210,9 +212,11 @@ class Graph:
             start_node=NodeMetadata(compute_fn=start_node),
             nodes=metadata_nodes,
             edges=metadata_edges,
+            tags=self.tags,
             runtime_information=RuntimeInformation(
                 major_version=sys.version_info.major,
                 minor_version=sys.version_info.minor,
+                sdk_version=importlib.metadata.version("indexify"),
             ),
         )
 
@@ -257,9 +261,14 @@ class Graph:
             current_node_name = queue.popleft()
             neighbours = (
                 self.edges[current_node_name]
-                if self.edges[current_node_name]
-                else self.routers[current_node_name]
+                if current_node_name in self.edges
+                else (
+                    self.routers[current_node_name]
+                    if current_node_name in self.routers
+                    else []
+                )
             )
+
             for neighbour in neighbours:
                 if neighbour in visited:
                     continue
@@ -269,9 +278,7 @@ class Graph:
 
         if total_number_of_nodes != len(visited):
             # all the nodes are not reachable from the start_node.
-            raise Exception(
-                "Some nodes in the graph are not reachable from start node."
-            )
+            raise Exception("Some nodes in the graph are not reachable from start node")
 
     def _run(
         self,

indexify/functions_sdk/graph_definition.py

@@ -12,7 +12,6 @@ class FunctionMetadata(BaseModel):
     fn_name: str
     description: str
     reducer: bool = False
-    image_name: str
     image_information: ImageInformation
     input_encoder: str = "cloudpickle"
     output_encoder: str = "cloudpickle"
@@ -23,7 +22,6 @@ class RouterMetadata(BaseModel):
     description: str
     source_fn: str
     target_fns: List[str]
-    image_name: str
     image_information: ImageInformation
     input_encoder: str = "cloudpickle"
     output_encoder: str = "cloudpickle"
@@ -38,17 +36,20 @@ class NodeMetadata(BaseModel):
 class RuntimeInformation(BaseModel):
     major_version: int
     minor_version: int
+    sdk_version: str
 
 
 class ComputeGraphMetadata(BaseModel):
     name: str
     description: str
     start_node: NodeMetadata
+    tags: Dict[str, str] = {}
     nodes: Dict[str, NodeMetadata]
     edges: Dict[str, List[str]]
     accumulator_zero_values: Dict[str, bytes] = {}
     runtime_information: RuntimeInformation
     replaying: bool = False
+    version: Optional[int] = -1
 
     def get_input_payload_serializer(self):
         return get_serializer(self.start_node.compute_fn.input_encoder)

indexify/functions_sdk/image.py

@@ -1,34 +1,29 @@
-from typing import List
+import hashlib
+import importlib
+import sys
+from typing import List, Optional
 
 from pydantic import BaseModel
 
 
-def python_version_to_image(python_version):
-    if python_version.startswith("3.9"):
-        return "python:3.9.20-bookworm"
-    elif python_version.startswith("3.10"):
-        return "python:3.10.15-bookworm"
-    elif python_version.startswith("3.11"):
-        return "python:3.11.10-bookworm"
-    else:
-        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]
+    image_url: Optional[str] = ""
+    sdk_version: str
 
 
 class Image:
-    def __init__(self, python="3.10"):
+    def __init__(self):
         self._image_name = None
         self._tag = "latest"
-        self._base_image = python_version_to_image(python)
-        self._python_version = python
+        self._base_image = BASE_IMAGE_NAME
+        self._python_version = LOCAL_PYTHON_VERSION
         self._run_strs = []
+        self._sdk_version = importlib.metadata.version("indexify")
 
     def name(self, image_name):
         self._image_name = image_name
@@ -52,21 +47,31 @@ class Image:
             tag=self._tag,
             base_image=self._base_image,
             run_strs=self._run_strs,
+            sdk_version=self._sdk_version,
         )
 
+    def hash(self) -> str:
+        hash = hashlib.sha256(
+            self._image_name.encode()
+        )  # Make a hash of the image name
+        hash.update(self._base_image.encode())
+        hash.update("".join(self._run_strs).encode())
+        hash.update(self._sdk_version.encode())
+
+        return hash.hexdigest()
+
+
+LOCAL_PYTHON_VERSION = f"{sys.version_info.major}.{sys.version_info.minor}"
+BASE_IMAGE_NAME = f"python:{LOCAL_PYTHON_VERSION}-slim-bookworm"
+
+
+def GetDefaultPythonImage(python_version: str):
+    return (
+        Image()
+        .name("tensorlake/indexify-executor-default")
+        .base_image(f"python:{python_version}-slim-bookworm")
+        .tag(python_version)
+    )
+
 
-DEFAULT_IMAGE_3_10 = (
-    Image()
-    .name("tensorlake/indexify-executor-default")
-    .base_image("python:3.10.15-slim-bookworm")
-    .tag("3.10")
-    .run("pip install indexify")
-)
-
-DEFAULT_IMAGE_3_11 = (
-    Image()
-    .name("tensorlake/indexify-executor-default")
-    .base_image("python:3.11.10-slim-bookworm")
-    .tag("3.11")
-    .run("pip install indexify")
-)
+DEFAULT_IMAGE = GetDefaultPythonImage(LOCAL_PYTHON_VERSION)