esd-services-api-client 2.0.1__py3-none-any.whl → 2.0.2__py3-none-any.whl

esd_services_api_client/_version.py

@@ -1 +1 @@
-__version__ = '2.0.1'
+__version__ = '2.0.2'

esd_services_api_client/nexus/README.md

@@ -6,6 +6,7 @@ NEXUS__ALGORITHM_OUTPUT_PATH=abfss://container@account.dfs.core.windows.net/path
 NEXUS__METRIC_PROVIDER_CONFIGURATION={"metric_namespace": "test"}
 NEXUS__QES_CONNECTION_STRING=qes://engine\=DELTA\;plaintext_credentials\={"auth_client_class":"adapta.security.clients.AzureClient"}\;settings\={}
 NEXUS__STORAGE_CLIENT_CLASS=adapta.storage.blob.azure_storage_client.AzureStorageClient
+NEXUS__ALGORITHM_INPUT_EXTERNAL_DATA_SOCKETS=[{"alias": "x", "data_path": "test/x", "data_format": "test"}, {"alias": "y", "data_path": "test/y", "data_format": "test"}]
 PROTEUS__USE_AZURE_CREDENTIAL=1
 ```
 
@@ -13,20 +14,30 @@ Example usage:
 
 ```python
 import asyncio
-from typing import Dict
+import json
+import socketserver
+import threading
+from dataclasses import dataclass
+from http.server import ThreadingHTTPServer, BaseHTTPRequestHandler
+from typing import Dict, Optional
 
 import pandas
 from adapta.metrics import MetricsProvider
-from adapta.process_communication import DataSocket
 from adapta.storage.query_enabled_store import QueryEnabledStore
+from dataclasses_json import DataClassJsonMixin
 from injector import inject
 
 from esd_services_api_client.nexus.abstractions.logger_factory import LoggerFactory
+from esd_services_api_client.nexus.abstractions.socket_provider import (
+    ExternalSocketProvider,
+)
 from esd_services_api_client.nexus.core.app_core import Nexus
 from esd_services_api_client.nexus.algorithms import MinimalisticAlgorithm
 from esd_services_api_client.nexus.input import InputReader, InputProcessor
 from pandas import DataFrame as PandasDataFrame
 
+from esd_services_api_client.nexus.input.payload_reader import AlgorithmPayload
+
 
 async def my_on_complete_func_1(**kwargs):
     pass
@@ -36,7 +47,72 @@ async def my_on_complete_func_2(**kwargs):
     pass
 
 
-class XReader(InputReader):
+@dataclass
+class MyAlgorithmPayload(AlgorithmPayload, DataClassJsonMixin):
+    x: Optional[list[int]] = None
+    y: Optional[list[int]] = None
+
+
+@dataclass
+class MyAlgorithmPayload2(AlgorithmPayload, DataClassJsonMixin):
+    z: list[int]
+    x: Optional[list[int]] = None
+    y: Optional[list[int]] = None
+
+
+class MockRequestHandler(BaseHTTPRequestHandler):
+    """
+    HTTPServer Mock Request handler
+    """
+
+    def __init__(
+        self,
+        request: bytes,
+        client_address: tuple[str, int],
+        server: socketserver.BaseServer,
+    ):
+        """
+         Initialize request handler
+        :param request:
+        :param client_address:
+        :param server:
+        """
+        self._responses = {
+            "some/payload": (
+                {
+                    # "x": [-1, 0, 2],
+                    # "y": [10, 11, 12],
+                    "z": [1, 2, 3]
+                },
+                200,
+            )
+        }
+        super().__init__(request, client_address, server)
+
+    def do_GET(self):  # pylint: disable=invalid-name
+        """Handle POST requests"""
+        current_url = self.path.removeprefix("/")
+
+        if current_url not in self._responses:
+            self.send_response(500, "Unknown URL")
+            return
+
+        self.send_response(self._responses[current_url][1])
+        self.send_header("Content-Type", "application/json")
+        self.end_headers()
+        self.wfile.write(json.dumps(self._responses[current_url][0]).encode("utf-8"))
+
+    def log_request(self, code=None, size=None):
+        """
+         Don't log anything
+        :param code:
+        :param size:
+        :return:
+        """
+        pass
+
+
+class XReader(InputReader[MyAlgorithmPayload]):
     async def _context_open(self):
         pass
 
@@ -44,15 +120,34 @@ class XReader(InputReader):
         pass
 
     @inject
-    def __init__(self, store: QueryEnabledStore, metrics_provider: MetricsProvider, logger_factory: LoggerFactory,
-                 *readers: "InputReader"):
-        super().__init__(DataSocket(alias="x", data_path="testx", data_format='delta'), store, metrics_provider, logger_factory, *readers)
+    def __init__(
+        self,
+        store: QueryEnabledStore,
+        metrics_provider: MetricsProvider,
+        logger_factory: LoggerFactory,
+        payload: MyAlgorithmPayload,
+        socket_provider: ExternalSocketProvider,
+        *readers: "InputReader"
+    ):
+        super().__init__(
+            socket_provider.socket("x"),
+            store,
+            metrics_provider,
+            logger_factory,
+            payload,
+            *readers
+        )
 
     async def _read_input(self) -> PandasDataFrame:
-        return pandas.DataFrame([{'a': 1, 'b': 2}, {'a': 2, 'b': 3}])
+        self._logger.info(
+            "Payload: {payload}; Socket path: {socket_path}",
+            payload=self._payload.to_json(),
+            socket_path=self.socket.data_path,
+        )
+        return pandas.DataFrame([{"a": 1, "b": 2}, {"a": 2, "b": 3}])
 
 
-class YReader(InputReader):
+class YReader(InputReader[MyAlgorithmPayload2]):
     async def _context_open(self):
         pass
 
@@ -60,12 +155,31 @@ class YReader(InputReader):
         pass
 
     @inject
-    def __init__(self, store: QueryEnabledStore, metrics_provider: MetricsProvider, logger_factory: LoggerFactory,
-                 *readers: "InputReader"):
-        super().__init__(DataSocket(alias="y", data_path="testy", data_format='delta'), store, metrics_provider, logger_factory, *readers)
+    def __init__(
+        self,
+        store: QueryEnabledStore,
+        metrics_provider: MetricsProvider,
+        logger_factory: LoggerFactory,
+        payload: MyAlgorithmPayload2,
+        socket_provider: ExternalSocketProvider,
+        *readers: "InputReader"
+    ):
+        super().__init__(
+            socket_provider.socket("y"),
+            store,
+            metrics_provider,
+            logger_factory,
+            payload,
+            *readers
+        )
 
     async def _read_input(self) -> PandasDataFrame:
-        return pandas.DataFrame([{'a': 10, 'b': 12}, {'a': 11, 'b': 13}])
+        self._logger.info(
+            "Payload: {payload}; Socket path: {socket_path}",
+            payload=self._payload.to_json(),
+            socket_path=self.socket.data_path,
+        )
+        return pandas.DataFrame([{"a": 10, "b": 12}, {"a": 11, "b": 13}])
 
 
 class MyInputProcessor(InputProcessor):
@@ -76,14 +190,26 @@ class MyInputProcessor(InputProcessor):
         pass
 
     @inject
-    def __init__(self, x: XReader, y: YReader, metrics_provider: MetricsProvider, logger_factory: LoggerFactory,):
-        super().__init__(x, y, metrics_provider=metrics_provider, logger_factory=logger_factory)
+    def __init__(
+        self,
+        x: XReader,
+        y: YReader,
+        metrics_provider: MetricsProvider,
+        logger_factory: LoggerFactory,
+    ):
+        super().__init__(
+            x,
+            y,
+            metrics_provider=metrics_provider,
+            logger_factory=logger_factory,
+            payload=None,
+        )
 
     async def process_input(self, **_) -> Dict[str, PandasDataFrame]:
         inputs = await self._read_input()
         return {
-            'x_ready': inputs["x"].assign(c=[-1, 1]),
-            'y_ready': inputs["y"].assign(c=[-1, 1])
+            "x_ready": inputs["x"].assign(c=[-1, 1]),
+            "y_ready": inputs["y"].assign(c=[-1, 1]),
         }
 
 
@@ -95,22 +221,41 @@ class MyAlgorithm(MinimalisticAlgorithm):
         pass
 
     @inject
-    def __init__(self, input_processor: MyInputProcessor, metrics_provider: MetricsProvider, logger_factory: LoggerFactory,):
+    def __init__(
+        self,
+        input_processor: MyInputProcessor,
+        metrics_provider: MetricsProvider,
+        logger_factory: LoggerFactory,
+    ):
         super().__init__(input_processor, metrics_provider, logger_factory)
 
-    async def _run(self, x_ready: PandasDataFrame, y_ready: PandasDataFrame, **kwargs) -> PandasDataFrame:
+    async def _run(
+        self, x_ready: PandasDataFrame, y_ready: PandasDataFrame, **kwargs
+    ) -> PandasDataFrame:
         return pandas.concat([x_ready, y_ready])
 
 
 async def main():
-    nexus = Nexus.create() \
-        .add_reader(XReader) \
-        .add_reader(YReader) \
-        .use_processor(MyInputProcessor) \
-        .use_algorithm(MyAlgorithm)
+    """
+     Mock HTTP Server
+    :return:
+    """
+    with ThreadingHTTPServer(("localhost", 9876), MockRequestHandler) as server:
+        server_thread = threading.Thread(target=server.serve_forever)
+        server_thread.daemon = True
+        server_thread.start()
+        nexus = (
+            await Nexus.create()
+            .add_reader(XReader)
+            .add_reader(YReader)
+            .use_processor(MyInputProcessor)
+            .use_algorithm(MyAlgorithm)
+            .inject_payload(MyAlgorithmPayload, MyAlgorithmPayload2)
+        )
+
+        await nexus.activate()
+        server.shutdown()
 
-    await nexus.activate()
-    
 
 if __name__ == "__main__":
     asyncio.run(main())
@@ -120,5 +265,16 @@ if __name__ == "__main__":
 Run this code as `sample.py`:
 
 ```shell
-python3 sample.py --sas-uri 'https://localhost' --request-id test
+python3 sample.py --sas-uri http://localhost:9876/some/payload --request-id test
+```
+
+Produces the following:
+
+```
+Running _read
+Payload: {"x": null, "y": null}; Socket path: test/x
+Finished reading X from path test/x in 0.00s seconds
+Running _read
+Payload: {"z": [1, 2, 3], "x": null, "y": null}; Socket path: test/y
+Finished reading Y from path test/y in 0.00s seconds
 ```

esd_services_api_client/nexus/abstractions/nexus_object.py

@@ -19,13 +19,17 @@
 
 
 from abc import ABC, abstractmethod
+from typing import Generic, TypeVar
 
 from adapta.metrics import MetricsProvider
 
 from esd_services_api_client.nexus.abstractions.logger_factory import LoggerFactory
 
 
-class NexusObject(ABC):
+TPayload = TypeVar("TPayload")  # pylint: disable=C0103
+
+
+class NexusObject(Generic[TPayload], ABC):
     """
     Base class for all Nexus objects.
     """

esd_services_api_client/nexus/abstractions/socket_provider.py

@@ -0,0 +1,51 @@
+"""
+ Socket provider for all data sockets used by algorithms.
+"""
+import json
+
+#  Copyright (c) 2023. ECCO Sneaks & Data
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+from typing import final, Optional
+
+from adapta.process_communication import DataSocket
+
+
+@final
+class ExternalSocketProvider:
+    """
+    Wraps a socket collection
+    """
+
+    def __init__(self, *sockets: DataSocket):
+        self._sockets = {socket.alias: socket for socket in sockets}
+
+    def socket(self, name: str) -> Optional[DataSocket]:
+        """
+        Retrieve a socket if it exists.
+        """
+        return self._sockets.get(name, None)
+
+    @classmethod
+    def from_serialized(cls, socket_list_ser: str) -> "ExternalSocketProvider":
+        """
+        Creates a SocketProvider from a list of serialized sockets
+        """
+        return cls(
+            *[
+                DataSocket.from_dict(socket_dict)
+                for socket_dict in json.loads(socket_list_ser)
+            ]
+        )

esd_services_api_client/nexus/core/app_core.py

@@ -51,6 +51,10 @@ from esd_services_api_client.nexus.core.app_dependencies import (
 )
 from esd_services_api_client.nexus.input.input_processor import InputProcessor
 from esd_services_api_client.nexus.input.input_reader import InputReader
+from esd_services_api_client.nexus.input.payload_reader import (
+    AlgorithmPayloadReader,
+    AlgorithmPayload,
+)
 
 
 def is_transient_exception(exception: Optional[BaseException]) -> Optional[bool]:
@@ -141,6 +145,24 @@ class Nexus:
         self._algorithm_class = algorithm
         return self
 
+    async def inject_payload(self, *payload_types: Type[AlgorithmPayload]) -> "Nexus":
+        """
+        Adds payloads processed into the specified types to the DI container
+        """
+        for payload_type in payload_types:
+
+            async def get_payload() -> payload_type:  # pylint: disable=W0640
+                async with AlgorithmPayloadReader(
+                    payload_uri=self._run_args.sas_uri,
+                    payload_type=payload_type,  # pylint: disable=W0640
+                ) as reader:
+                    return reader.payload
+
+            # pylint warnings are silenced here because closure is called inside the same loop it is defined, thus each value of a loop variable is used
+
+            self._configurator = self._configurator.with_payload((await get_payload()))
+        return self
+
     async def _submit_result(
         self,
         result: Optional[PandasDataFrame] = None,

esd_services_api_client/nexus/core/app_dependencies.py

@@ -29,11 +29,17 @@ from injector import Module, singleton, provider
 
 from esd_services_api_client.crystal import CrystalConnector
 from esd_services_api_client.nexus.abstractions.logger_factory import LoggerFactory
+from esd_services_api_client.nexus.abstractions.socket_provider import (
+    ExternalSocketProvider,
+)
 from esd_services_api_client.nexus.exceptions.startup_error import (
     FatalStartupConfigurationError,
 )
 from esd_services_api_client.nexus.input.input_processor import InputProcessor
 from esd_services_api_client.nexus.input.input_reader import InputReader
+from esd_services_api_client.nexus.input.payload_reader import (
+    AlgorithmPayload,
+)
 
 
 class MetricsModule(Module):
@@ -127,6 +133,28 @@ class StorageClientModule(Module):
         )
 
 
+@final
+class ExternalSocketsModule(Module):
+    """
+    Storage client module.
+    """
+
+    @singleton
+    @provider
+    def provide(self) -> ExternalSocketProvider:
+        """
+        Dependency provider.
+        """
+        if "NEXUS__ALGORITHM_INPUT_EXTERNAL_DATA_SOCKETS" not in os.environ:
+            raise FatalStartupConfigurationError(
+                "NEXUS__ALGORITHM_INPUT_EXTERNAL_DATA_SOCKETS"
+            )
+
+        return ExternalSocketProvider.from_serialized(
+            os.getenv("NEXUS__ALGORITHM_INPUT_EXTERNAL_DATA_SOCKETS")
+        )
+
+
 @final
 class ServiceConfigurator:
     """
@@ -139,6 +167,7 @@ class ServiceConfigurator:
             CrystalReceiverClientModule(),
             QueryEnabledStoreModule(),
             StorageClientModule(),
+            ExternalSocketsModule(),
         ]
 
     @property
@@ -165,3 +194,12 @@ class ServiceConfigurator:
             type(f"{input_processor.__name__}Module", (Module,), {})()
         )
         return self
+
+    def with_payload(self, payload: AlgorithmPayload) -> "ServiceConfigurator":
+        """
+        Adds the specified payload instance to the DI container.
+        """
+        self._injection_binds.append(
+            lambda binder: binder.bind(payload.__class__, to=payload, scope=singleton)
+        )
+        return self

esd_services_api_client/nexus/input/input_processor.py

@@ -26,10 +26,12 @@ from adapta.metrics import MetricsProvider
 
 import azure.core.exceptions
 
-from injector import inject
 from pandas import DataFrame as PandasDataFrame
 
-from esd_services_api_client.nexus.abstractions.nexus_object import NexusObject
+from esd_services_api_client.nexus.abstractions.nexus_object import (
+    NexusObject,
+    TPayload,
+)
 from esd_services_api_client.nexus.abstractions.logger_factory import LoggerFactory
 from esd_services_api_client.nexus.exceptions.input_reader_error import (
     FatalInputReaderError,
@@ -38,20 +40,21 @@ from esd_services_api_client.nexus.exceptions.input_reader_error import (
 from esd_services_api_client.nexus.input.input_reader import InputReader
 
 
-class InputProcessor(NexusObject):
+class InputProcessor(NexusObject[TPayload]):
     """
     Base class for raw data processing into algorithm input.
     """
 
-    @inject
     def __init__(
         self,
         *readers: InputReader,
+        payload: TPayload,
         metrics_provider: MetricsProvider,
         logger_factory: LoggerFactory,
     ):
         super().__init__(metrics_provider, logger_factory)
         self._readers = readers
+        self._payload = payload
 
     def _get_exc_type(
         self, ex: BaseException

esd_services_api_client/nexus/input/input_reader.py

@@ -29,11 +29,14 @@ from adapta.utils.decorators._logging import run_time_metrics_async
 
 from pandas import DataFrame as PandasDataFrame
 
-from esd_services_api_client.nexus.abstractions.nexus_object import NexusObject
+from esd_services_api_client.nexus.abstractions.nexus_object import (
+    NexusObject,
+    TPayload,
+)
 from esd_services_api_client.nexus.abstractions.logger_factory import LoggerFactory
 
 
-class InputReader(NexusObject):
+class InputReader(NexusObject[TPayload]):
     """
     Base class for a raw data reader.
     """
@@ -44,6 +47,7 @@ class InputReader(NexusObject):
         store: QueryEnabledStore,
         metrics_provider: MetricsProvider,
         logger_factory: LoggerFactory,
+        payload: TPayload,
         *readers: "InputReader"
     ):
         super().__init__(metrics_provider, logger_factory)
@@ -51,6 +55,7 @@ class InputReader(NexusObject):
         self._store = store
         self._data: Optional[PandasDataFrame] = None
         self._readers = readers
+        self._payload = payload
 
     @property
     def data(self) -> Optional[PandasDataFrame]:
@@ -82,7 +87,14 @@ class InputReader(NexusObject):
         Coroutine that reads the data from external store and converts it to a dataframe.
         """
 
-        @run_time_metrics_async(metric_name="read_input")
+        @run_time_metrics_async(
+            metric_name="read_input",
+            on_finish_message_template="Finished reading {entity} from path {data_path} in {elapsed:.2f}s seconds",
+            template_args={
+                "entity": self._metric_name.upper(),
+                "data_path": self.socket.data_path,
+            },
+        )
         async def _read(**_) -> PandasDataFrame:
             if not self._data:
                 self._data = await self._read_input()

esd_services_api_client/nexus/input/payload_reader.py

@@ -0,0 +1,83 @@
+"""
+ Code infrastructure for manipulating payload received from Crystal SAS URI
+"""
+
+#  Copyright (c) 2023. ECCO Sneaks & Data
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+
+from dataclasses import dataclass
+
+from typing import final, Optional, Type
+
+from adapta.storage.models.format import DictJsonSerializationFormat
+from adapta.utils import session_with_retries
+
+from dataclasses_json import DataClassJsonMixin
+
+
+@dataclass
+class AlgorithmPayload(DataClassJsonMixin):
+    """
+    Base class for algorithm payload
+    """
+
+    def validate(self):
+        """
+        Optional post-validation of the data. Define this method to analyze class contents after payload has been read and deserialized.
+        """
+
+    def __post_init__(self):
+        self.validate()
+
+
+@final
+class AlgorithmPayloadReader:
+    """
+    Crystal Payload Reader - receives the payload from the URI and deserializes it into the specified type
+    """
+
+    async def __aenter__(self):
+        if not self._http:
+            self._http = session_with_retries()
+        http_response = self._http.get(url=self._payload_uri)
+        http_response.raise_for_status()
+        self._payload = self._payload_type.from_dict(
+            DictJsonSerializationFormat().deserialize(http_response.content)
+        )
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        self._http.close()
+        self._http = None
+
+    def __init__(self, payload_uri: str, payload_type: Type[AlgorithmPayload]):
+        self._http = session_with_retries()
+        self._payload: Optional[AlgorithmPayload] = None
+        self._payload_uri = payload_uri
+        self._payload_type = payload_type
+
+    @property
+    def payload_uri(self) -> str:
+        """
+        Uri of the paylod for the algorithm
+        """
+        return self._payload_uri
+
+    @property
+    def payload(self) -> Optional[AlgorithmPayload]:
+        """
+        Payload data deserialized into the user class.
+        """
+        return self._payload

{esd_services_api_client-2.0.1.dist-info → esd_services_api_client-2.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: esd-services-api-client
-Version: 2.0.1
+Version: 2.0.2
 Summary: Python clients for ESD services
 Home-page: https://github.com/SneaksAndData/esd-services-api-client
 License: Apache 2.0
@@ -16,7 +16,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Provides-Extra: azure
 Provides-Extra: nexus
-Requires-Dist: adapta[azure,datadog,storage] (>=2.6.5,<3.0.0)
+Requires-Dist: adapta[azure,datadog,storage] (>=2.6.6,<3.0.0)
 Requires-Dist: azure-identity (>=1.7,<1.8) ; extra == "azure"
 Requires-Dist: dataclasses-json (>=0.6.0,<0.7.0)
 Requires-Dist: httpx (>=0.26.0,<0.27.0) ; extra == "nexus"

{esd_services_api_client-2.0.1.dist-info → esd_services_api_client-2.0.2.dist-info}/RECORD

@@ -1,5 +1,5 @@
 esd_services_api_client/__init__.py,sha256=rP0njtEgVSMm-sOVayVfcRUrrubl4lme7HI2zS678Lo,598
-esd_services_api_client/_version.py,sha256=HVx0XJJ9OYFWBBPBCUFYb8Nm43ChPg9GZLh_dkxh9qI,22
+esd_services_api_client/_version.py,sha256=kumiGImhzOTlTrRM-6jDo2mNnVHGO_2vxtrhB0nzAiw,22
 esd_services_api_client/beast/__init__.py,sha256=NTaz_7YoLPK8MCLwbwqH7rW1zDWLxXu2T7fGmMmRxyg,718
 esd_services_api_client/beast/v3/__init__.py,sha256=TRjB4-T6eIORpMvdylb32_GinrIpYNFmAdshSC1HqHg,749
 esd_services_api_client/beast/v3/_connector.py,sha256=oPizDQ1KOKOfiyh-jAofKodlpRzrRiELv-rmP_o_oio,11473
@@ -15,27 +15,29 @@ esd_services_api_client/crystal/__init__.py,sha256=afSGQRkDic0ECsJfgu3b291kX8CyU
 esd_services_api_client/crystal/_api_versions.py,sha256=2BMiQRS0D8IEpWCCys3dge5alVBRCZrOuCR1QAn8UIM,832
 esd_services_api_client/crystal/_connector.py,sha256=WjfMezWXia41Z8aiNupaT577fk9Sx6uy6V23O6y9hfI,12870
 esd_services_api_client/crystal/_models.py,sha256=eRhGAl8LjglCyIFwf1bcFBhjbpSuRYucuF2LO388L2E,4025
-esd_services_api_client/nexus/README.md,sha256=3peKAEc8_rPc0-k5PbkMMPCp1VstaXWbmvm_2i3T_mc,3872
+esd_services_api_client/nexus/README.md,sha256=6fGBYTvzkmZH9Yk9VcPqWCtqU_D2zleG1rv1U3GA3IM,7721
 esd_services_api_client/nexus/__init__.py,sha256=e7RPs-qJNQqDHj121TeYx-_YadZSOIyJuAPyhSSXRsE,622
 esd_services_api_client/nexus/abstractions/__init__.py,sha256=e7RPs-qJNQqDHj121TeYx-_YadZSOIyJuAPyhSSXRsE,622
 esd_services_api_client/nexus/abstractions/logger_factory.py,sha256=JHl_t0d0ra_k-EixZlkw-s746wHUdBhSU6preqoARtk,2031
-esd_services_api_client/nexus/abstractions/nexus_object.py,sha256=mAQnAY_Y4ymZA2sL_7iSaqaRygRs5UDH1JvqYcck-qw,1667
+esd_services_api_client/nexus/abstractions/nexus_object.py,sha256=E9iYmjYjkmS0Uv-VS1ixRhi3zdtQfcSNx4gxad5_aZ0,1780
+esd_services_api_client/nexus/abstractions/socket_provider.py,sha256=Mv9BWdxw8VY4Gi4EOrdxWK1zsR3-fqIbpyF1xHWchbE,1495
 esd_services_api_client/nexus/algorithms/__init__.py,sha256=uWX24NHUnUcnOJN2IIp1kaaozCC0rOmB36WxHBCapCY,823
 esd_services_api_client/nexus/algorithms/_baseline_algorithm.py,sha256=4Gqp8qV5nunZ_DwZyHAu0vLuF1rls8nnq2zoHy2orME,1825
 esd_services_api_client/nexus/algorithms/distributed.py,sha256=iWjx9D6g-ASwTWPkQ9GmInTLymVlxl7UkfEBcEfnkmc,1628
 esd_services_api_client/nexus/algorithms/minimalistic.py,sha256=9KvIXXsiOZ9wAOvrIZuOlNYcJLB-SjlQoNpICJu-qeQ,1366
 esd_services_api_client/nexus/algorithms/recursive.py,sha256=2YuAeYZ6-K5hcY8NEAAJVyGhtVVQMTZ7wjkWPPo8qeE,1829
 esd_services_api_client/nexus/core/__init__.py,sha256=e7RPs-qJNQqDHj121TeYx-_YadZSOIyJuAPyhSSXRsE,622
-esd_services_api_client/nexus/core/app_core.py,sha256=qfeZf9XKAod5f09XY8cUpxCeIG0nFiZhkyQQOz7yrJU,7936
-esd_services_api_client/nexus/core/app_dependencies.py,sha256=haQ9UderKYowAtGVcBBZsXXZJ9BJOv1p8BW9XzDZvNA,4557
+esd_services_api_client/nexus/core/app_core.py,sha256=bwbFzbjx8PwZWHfHsEYDCGAjJuTzmVKuunSeMU54tHs,8877
+esd_services_api_client/nexus/core/app_dependencies.py,sha256=afX7QrUEuaLnFssaCTohXBt7QCeGJ0MuovF62CZTZ34,5672
 esd_services_api_client/nexus/exceptions/__init__.py,sha256=JgPXhrvBIi0U1QOF90TYHS8jv_SBQEoRLsEg6rrtRoc,691
 esd_services_api_client/nexus/exceptions/_nexus_error.py,sha256=b3L8JnNvV2jdxNfuFWh9-j4kVb_VX7gNH5WHKcC-R78,890
 esd_services_api_client/nexus/exceptions/input_reader_error.py,sha256=D-xYTKRNREQ2-NGhc88GHOmXCvLNsIVQsH8wf0LLC_0,1760
 esd_services_api_client/nexus/exceptions/startup_error.py,sha256=f2PIOSdLgT-42eKD6ec8p7nROADshMawCsDGDUbxO_w,1546
 esd_services_api_client/nexus/input/__init__.py,sha256=0k_HMIP4NPC5O2ixKJPgKsLzYeHS14DhibF_MUtez1c,753
-esd_services_api_client/nexus/input/input_processor.py,sha256=98yrsHZuhSd_9Xto29x2UiuGH6ABLiNxZr536C2GKuw,3135
-esd_services_api_client/nexus/input/input_reader.py,sha256=OieTnYZQFGf8SK0fKLHo9j3_Ka0To3MlJ_7tBbw88To,2890
-esd_services_api_client-2.0.1.dist-info/LICENSE,sha256=0gS6zXsPp8qZhzi1xaGCIYPzb_0e8on7HCeFJe8fOpw,10693
-esd_services_api_client-2.0.1.dist-info/METADATA,sha256=UPoipS0Elt4IIrvAwd0dTu3fvPZgeNlrr_m25YhCaqE,1236
-esd_services_api_client-2.0.1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-esd_services_api_client-2.0.1.dist-info/RECORD,,
+esd_services_api_client/nexus/input/input_processor.py,sha256=MiXXd_APrG85Pi-Ke68_UHNEV7T_QHN1hU1WAPWoTsw,3187
+esd_services_api_client/nexus/input/input_reader.py,sha256=uxTAGX5xNhjTFpEsVQnr8BkVgpIH_U_om54hh3pvJ3s,3269
+esd_services_api_client/nexus/input/payload_reader.py,sha256=__r_QjIFRAWwx56X5WUK1qensJUae0vZEb422dzOgSY,2511
+esd_services_api_client-2.0.2.dist-info/LICENSE,sha256=0gS6zXsPp8qZhzi1xaGCIYPzb_0e8on7HCeFJe8fOpw,10693
+esd_services_api_client-2.0.2.dist-info/METADATA,sha256=rNOu2tUM-mWp4kQbt13EpUweANcI808ZNCFmMdcqQRM,1236
+esd_services_api_client-2.0.2.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+esd_services_api_client-2.0.2.dist-info/RECORD,,