indexify 0.3.4__py3-none-any.whl → 0.3.6__py3-none-any.whl

indexify/function_executor/proto/function_executor_pb2.pyi

@@ -1,225 +0,0 @@
-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: str
-    function_name: str
-    graph: SerializedObject
-    def __init__(
-        self,
-        namespace: _Optional[str] = ...,
-        graph_name: _Optional[str] = ...,
-        graph_version: _Optional[str] = ...,
-        function_name: _Optional[str] = ...,
-        graph: _Optional[_Union[SerializedObject, _Mapping]] = ...,
-    ) -> None: ...
-
-class InitializeResponse(_message.Message):
-    __slots__ = ("success", "customer_error")
-    SUCCESS_FIELD_NUMBER: _ClassVar[int]
-    CUSTOMER_ERROR_FIELD_NUMBER: _ClassVar[int]
-    success: bool
-    customer_error: str
-    def __init__(
-        self, success: bool = ..., customer_error: _Optional[str] = ...
-    ) -> None: ...
-
-class SetInvocationStateRequest(_message.Message):
-    __slots__ = ("key", "value")
-    KEY_FIELD_NUMBER: _ClassVar[int]
-    VALUE_FIELD_NUMBER: _ClassVar[int]
-    key: str
-    value: SerializedObject
-    def __init__(
-        self,
-        key: _Optional[str] = ...,
-        value: _Optional[_Union[SerializedObject, _Mapping]] = ...,
-    ) -> None: ...
-
-class SetInvocationStateResponse(_message.Message):
-    __slots__ = ()
-    def __init__(self) -> None: ...
-
-class GetInvocationStateRequest(_message.Message):
-    __slots__ = ("key",)
-    KEY_FIELD_NUMBER: _ClassVar[int]
-    key: str
-    def __init__(self, key: _Optional[str] = ...) -> None: ...
-
-class GetInvocationStateResponse(_message.Message):
-    __slots__ = ("key", "value")
-    KEY_FIELD_NUMBER: _ClassVar[int]
-    VALUE_FIELD_NUMBER: _ClassVar[int]
-    key: str
-    value: SerializedObject
-    def __init__(
-        self,
-        key: _Optional[str] = ...,
-        value: _Optional[_Union[SerializedObject, _Mapping]] = ...,
-    ) -> None: ...
-
-class InvocationStateRequest(_message.Message):
-    __slots__ = ("request_id", "task_id", "set", "get")
-    REQUEST_ID_FIELD_NUMBER: _ClassVar[int]
-    TASK_ID_FIELD_NUMBER: _ClassVar[int]
-    SET_FIELD_NUMBER: _ClassVar[int]
-    GET_FIELD_NUMBER: _ClassVar[int]
-    request_id: str
-    task_id: str
-    set: SetInvocationStateRequest
-    get: GetInvocationStateRequest
-    def __init__(
-        self,
-        request_id: _Optional[str] = ...,
-        task_id: _Optional[str] = ...,
-        set: _Optional[_Union[SetInvocationStateRequest, _Mapping]] = ...,
-        get: _Optional[_Union[GetInvocationStateRequest, _Mapping]] = ...,
-    ) -> None: ...
-
-class InvocationStateResponse(_message.Message):
-    __slots__ = ("request_id", "success", "set", "get")
-    REQUEST_ID_FIELD_NUMBER: _ClassVar[int]
-    SUCCESS_FIELD_NUMBER: _ClassVar[int]
-    SET_FIELD_NUMBER: _ClassVar[int]
-    GET_FIELD_NUMBER: _ClassVar[int]
-    request_id: str
-    success: bool
-    set: SetInvocationStateResponse
-    get: GetInvocationStateResponse
-    def __init__(
-        self,
-        request_id: _Optional[str] = ...,
-        success: bool = ...,
-        set: _Optional[_Union[SetInvocationStateResponse, _Mapping]] = ...,
-        get: _Optional[_Union[GetInvocationStateResponse, _Mapping]] = ...,
-    ) -> 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__ = (
-        "namespace",
-        "graph_name",
-        "graph_version",
-        "function_name",
-        "graph_invocation_id",
-        "task_id",
-        "function_input",
-        "function_init_value",
-    )
-    NAMESPACE_FIELD_NUMBER: _ClassVar[int]
-    GRAPH_NAME_FIELD_NUMBER: _ClassVar[int]
-    GRAPH_VERSION_FIELD_NUMBER: _ClassVar[int]
-    FUNCTION_NAME_FIELD_NUMBER: _ClassVar[int]
-    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]
-    namespace: str
-    graph_name: str
-    graph_version: str
-    function_name: str
-    graph_invocation_id: str
-    task_id: str
-    function_input: SerializedObject
-    function_init_value: SerializedObject
-    def __init__(
-        self,
-        namespace: _Optional[str] = ...,
-        graph_name: _Optional[str] = ...,
-        graph_version: _Optional[str] = ...,
-        function_name: _Optional[str] = ...,
-        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: ...
-
-class HealthCheckRequest(_message.Message):
-    __slots__ = ()
-    def __init__(self) -> None: ...
-
-class HealthCheckResponse(_message.Message):
-    __slots__ = ("healthy",)
-    HEALTHY_FIELD_NUMBER: _ClassVar[int]
-    healthy: bool
-    def __init__(self, healthy: bool = ...) -> None: ...

indexify/function_executor/proto/function_executor_pb2_grpc.py

@@ -1,260 +0,0 @@
-# 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.initialize_invocation_state_server = channel.stream_stream(
-            "/function_executor_service.FunctionExecutor/initialize_invocation_state_server",
-            request_serializer=indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.InvocationStateResponse.SerializeToString,
-            response_deserializer=indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.InvocationStateRequest.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,
-        )
-        self.check_health = channel.unary_unary(
-            "/function_executor_service.FunctionExecutor/check_health",
-            request_serializer=indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.HealthCheckRequest.SerializeToString,
-            response_deserializer=indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.HealthCheckResponse.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 initialize_invocation_state_server(self, request_iterator, context):
-        """Initializes a server that sends requests to the client to perform actions on
-        a task's graph invocation state. This method is called only once per Function Executor
-        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 check_health(self, request, context):
-        """Health check method to check if the Function Executor is healthy."""
-        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,
-        ),
-        "initialize_invocation_state_server": grpc.stream_stream_rpc_method_handler(
-            servicer.initialize_invocation_state_server,
-            request_deserializer=indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.InvocationStateResponse.FromString,
-            response_serializer=indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.InvocationStateRequest.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,
-        ),
-        "check_health": grpc.unary_unary_rpc_method_handler(
-            servicer.check_health,
-            request_deserializer=indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.HealthCheckRequest.FromString,
-            response_serializer=indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.HealthCheckResponse.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 initialize_invocation_state_server(
-        request_iterator,
-        target,
-        options=(),
-        channel_credentials=None,
-        call_credentials=None,
-        insecure=False,
-        compression=None,
-        wait_for_ready=None,
-        timeout=None,
-        metadata=None,
-    ):
-        return grpc.experimental.stream_stream(
-            request_iterator,
-            target,
-            "/function_executor_service.FunctionExecutor/initialize_invocation_state_server",
-            indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.InvocationStateResponse.SerializeToString,
-            indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.InvocationStateRequest.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,
-        )
-
-    @staticmethod
-    def check_health(
-        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/check_health",
-            indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.HealthCheckRequest.SerializeToString,
-            indexify_dot_function__executor_dot_proto_dot_function__executor__pb2.HealthCheckResponse.FromString,
-            options,
-            channel_credentials,
-            insecure,
-            call_credentials,
-            compression,
-            wait_for_ready,
-            timeout,
-            metadata,
-            _registered_method=True,
-        )

indexify/function_executor/proto/message_validator.py

@@ -1,38 +0,0 @@
-from typing import Any
-
-from .function_executor_pb2 import SerializedObject
-
-
-class MessageValidator:
-    def __init__(self, message: Any):
-        self._message = message
-
-    def required_field(self, field_name: str) -> "MessageValidator":
-        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) -> "MessageValidator":
-        """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) -> "MessageValidator":
-        """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 required in SerializedObject")
-        if not serializedObject.HasField("content_type"):
-            raise ValueError("Field 'content_type' is required in SerializedObject")
-        return self

indexify/function_executor/server.py

@@ -1,29 +0,0 @@
-from concurrent.futures import ThreadPoolExecutor
-
-import grpc
-
-from .proto.configuration import GRPC_SERVER_OPTIONS
-from .proto.function_executor_pb2_grpc import add_FunctionExecutorServicer_to_server
-from .service import Service
-
-# 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: Service):
-        self._server_address: str = server_address
-        self._service: Service = 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/function_executor/service.py

@@ -1,133 +0,0 @@
-from typing import Iterator, Optional, Union
-
-import grpc
-import structlog
-from tensorlake.functions_sdk.functions import TensorlakeCompute
-from tensorlake.functions_sdk.object_serializer import get_serializer
-
-from .handlers.run_function.handler import Handler as RunTaskHandler
-from .handlers.run_function.request_validator import (
-    RequestValidator as RunTaskRequestValidator,
-)
-from .initialize_request_validator import InitializeRequestValidator
-from .invocation_state.invocation_state_proxy_server import InvocationStateProxyServer
-from .invocation_state.proxied_invocation_state import ProxiedInvocationState
-from .proto.function_executor_pb2 import (
-    HealthCheckRequest,
-    HealthCheckResponse,
-    InitializeRequest,
-    InitializeResponse,
-    InvocationStateResponse,
-    RunTaskRequest,
-    RunTaskResponse,
-)
-from .proto.function_executor_pb2_grpc import FunctionExecutorServicer
-
-
-class Service(FunctionExecutorServicer):
-    def __init__(self):
-        self._logger = structlog.get_logger(module=__name__)
-        self._namespace: Optional[str] = None
-        self._graph_name: Optional[str] = None
-        self._graph_version: Optional[str] = None
-        self._function_name: Optional[str] = None
-        self._function: Optional[Union[TensorlakeCompute, TensorlakeCompute]] = None
-        self._invocation_state_proxy_server: Optional[InvocationStateProxyServer] = None
-
-    def initialize(
-        self, request: InitializeRequest, context: grpc.ServicerContext
-    ) -> InitializeResponse:
-        request_validator: InitializeRequestValidator = InitializeRequestValidator(
-            request
-        )
-        request_validator.check()
-
-        self._namespace = request.namespace
-        self._graph_name = request.graph_name
-        self._graph_version = request.graph_version
-        self._function_name = request.function_name
-        # The function is only loaded once per Function Executor. It's important to use a single
-        # loaded function so all the tasks when executed are sharing the same memory. This allows
-        # implementing smart caching in customer code. E.g. load a model into GPU only once and
-        # share the model's file descriptor between all tasks or download function configuration
-        # only once.
-        self._logger = self._logger.bind(
-            namespace=request.namespace,
-            graph_name=request.graph_name,
-            graph_version=request.graph_version,
-            function_name=request.function_name,
-        )
-        graph_serializer = get_serializer(request.graph.content_type)
-        try:
-            # Process user controlled input in a try-except block to not treat errors here as our
-            # internal platform errors.
-            graph = graph_serializer.deserialize(request.graph.bytes)
-            self._function = graph_serializer.deserialize(graph[request.function_name])
-        except Exception as e:
-            return InitializeResponse(success=False, customer_error=str(e))
-
-        self._logger.info("initialized function executor service")
-        return InitializeResponse(success=True)
-
-    def initialize_invocation_state_server(
-        self,
-        client_responses: Iterator[InvocationStateResponse],
-        context: grpc.ServicerContext,
-    ):
-        self._invocation_state_proxy_server = InvocationStateProxyServer(
-            client_responses, self._logger
-        )
-        self._logger.info("initialized invocation proxy server")
-        yield from self._invocation_state_proxy_server.run()
-
-    def run_task(
-        self, request: RunTaskRequest, context: grpc.ServicerContext
-    ) -> RunTaskResponse:
-        # Customer function code never raises an exception because we catch all of them and add
-        # their details to the response. We can only get an exception here if our own code failed.
-        # If our code raises an exception the grpc framework converts it into GRPC_STATUS_UNKNOWN
-        # error with the exception message. Differentiating errors is not needed for now.
-        RunTaskRequestValidator(request=request).check()
-        self._check_task_routed_correctly(request)
-
-        return RunTaskHandler(
-            request=request,
-            graph_name=self._graph_name,
-            graph_version=self._graph_version,
-            function_name=self._function_name,
-            function=self._function,
-            invocation_state=ProxiedInvocationState(
-                request.task_id, self._invocation_state_proxy_server
-            ),
-            logger=self._logger,
-        ).run()
-
-    def _check_task_routed_correctly(self, request: RunTaskRequest):
-        # Fail with internal error as this happened due to wrong task routing to this Server.
-        # If we run the wrongly routed task then it can steal data from this Server if it belongs
-        # to a different customer.
-        if request.namespace != self._namespace:
-            raise ValueError(
-                f"This Function Executor is not initialized for this namespace {request.namespace}"
-            )
-        if request.graph_name != self._graph_name:
-            raise ValueError(
-                f"This Function Executor is not initialized for this graph_name {request.graph_name}"
-            )
-        if request.graph_version != self._graph_version:
-            raise ValueError(
-                f"This Function Executor is not initialized for this graph_version {request.graph_version}"
-            )
-        if request.function_name != self._function_name:
-            raise ValueError(
-                f"This Function Executor is not initialized for this function_name {request.function_name}"
-            )
-
-    def check_health(
-        self, request: HealthCheckRequest, context: grpc.ServicerContext
-    ) -> HealthCheckResponse:
-        # This health check validates that the Server:
-        # - Has its process alive (not exited).
-        # - Didn't exhaust its thread pool.
-        # - Is able to communicate over its server socket.
-        return HealthCheckResponse(healthy=True)

indexify/utils/README.md

@@ -1,3 +0,0 @@
-## Overview
-
-Put here common functionality that is useful for code written in Python.