esd-services-api-client 2.5.1a123.dev5__tar.gz → 2.5.3__tar.gz

{esd_services_api_client-2.5.1a123.dev5 → esd_services_api_client-2.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: esd-services-api-client
-Version: 2.5.1a123.dev5
+Version: 2.5.3
 Summary: Python clients for ESD services
 Home-page: https://github.com/SneaksAndData/esd-services-api-client
 License: Apache 2.0

{esd_services_api_client-2.5.1a123.dev5 → esd_services_api_client-2.5.3}/esd_services_api_client/__init__.py

@@ -17,4 +17,4 @@
  Root index.
 """
 
-__version__ = "0.0.0"
+__version__ = "2.5.3"

{esd_services_api_client-2.5.1a123.dev5 → esd_services_api_client-2.5.3}/esd_services_api_client/nexus/algorithms/forked_algorithm.py

@@ -64,19 +64,61 @@ class ForkedAlgorithm(NexusObject[TPayload, AlgorithmResult]):
         self,
         metrics_provider: MetricsProvider,
         logger_factory: LoggerFactory,
-        forks: list[RemoteAlgorithm],
         *input_processors: InputProcessor,
         cache: InputCache,
     ):
         super().__init__(metrics_provider, logger_factory)
         self._input_processors = input_processors
-        self._forks = forks
         self._cache = cache
+        self._inputs: dict = {}
+
+    @property
+    def inputs(self) -> dict:
+        """
+        Inputs generated for this algorithm run.
+        """
+        return self._inputs
+
+    @abstractmethod
+    async def _get_forks(self, **kwargs) -> list[RemoteAlgorithm]:
+        """
+        Resolve forks to be used in this run, if any
+        """
+
+    @abstractmethod
+    async def _main_run(self, **kwargs) -> AlgorithmResult:
+        """
+        Logic to use for the main run - if this node is the root node - **this result** will be returned to the client.
+        """
+
+    @abstractmethod
+    async def _fork_run(self, **kwargs) -> AlgorithmResult:
+        """
+        Logic to use for the fork - if this node is **NOT** the root node - **result will be ignored by the client**.
+        """
 
     @abstractmethod
-    async def _run(self, **kwargs) -> AlgorithmResult:
+    async def _is_forked(self, **kwargs) -> bool:
         """
-        Core logic for this algorithm. Implementing this method is mandatory.
+        Determine if this is the main run or a fork run.
+        """
+
+    async def _default_inputs(self, **kwargs) -> dict:
+        """
+        Generate inputs by invoking all processors.
+        """
+        return await self._cache.resolve(*self._input_processors, **kwargs)
+
+    @abstractmethod
+    async def _main_inputs(self, **kwargs) -> dict:
+        """
+        Sets inputs for the main run - if this node is the root node
+        """
+
+    @abstractmethod
+    async def _fork_inputs(self, **kwargs) -> dict:
+        """
+        Sets inputs for the forked run - if this node is **NOT** the root node
         """
 
     @property
@@ -96,29 +138,36 @@ class ForkedAlgorithm(NexusObject[TPayload, AlgorithmResult]):
             },
         )
         async def _measured_run(**run_args) -> AlgorithmResult:
-            return await self._run(**run_args)
+            if await self._is_forked(**run_args):
+                return await self._fork_run(**run_args)
+
+            return await self._main_run(**run_args)
 
-        if len(self._forks) > 0:
+        # evaluate if additional forks will be spawned
+        forks = await self._get_forks(**kwargs)
+
+        if len(forks) > 0:
             self._logger.info(
-                "This algorithm has forks attached: {forks}. They will be executed after the main run",
-                forks=",".join([fork.alias() for fork in self._forks]),
+                "Forking node with: {forks}, after the node run",
+                forks=",".join([fork.alias() for fork in forks]),
             )
         else:
-            self._logger.info(
-                "This algorithm supports forks but none were injected. Proceeding with a main run only"
-            )
+            self._logger.info("Leaf algorithm node: proceeding with this node run only")
 
-        results = await self._cache.resolve(*self._input_processors, **kwargs)
+        if self._is_forked(**kwargs):
+            self._inputs = await self._fork_inputs(**kwargs)
+        else:
+            self._inputs = await self._main_inputs(**kwargs)
 
         run_result = await partial(
             _measured_run,
-            **results,
+            **self._inputs,
             metric_tags=self._metric_tags,
             metrics_provider=self._metrics_provider,
             logger=self._logger,
         )()
 
         # now await callback scheduling
-        await asyncio.wait([fork.run(**kwargs) for fork in self._forks])
+        await asyncio.wait([fork.run(**kwargs) for fork in forks])
 
         return run_result

{esd_services_api_client-2.5.1a123.dev5 → esd_services_api_client-2.5.3}/esd_services_api_client/nexus/core/app_core.py

@@ -264,6 +264,8 @@ class Nexus:
             logger_type=self.__class__,
         )
 
+        root_logger.start()
+
         root_logger.info(
             "Running algorithm {algorithm} on Nexus version {version}",
             algorithm=algorithm.__class__.__name__,
@@ -322,6 +324,8 @@ class Nexus:
             qes = self._injector.get(QueryEnabledStore)
             qes.close()
 
+        root_logger.stop()
+
     @classmethod
     def create(cls) -> "Nexus":
         """

{esd_services_api_client-2.5.1a123.dev5 → esd_services_api_client-2.5.3}/esd_services_api_client/nexus/telemetry/recorder.py

@@ -67,32 +67,34 @@ class TelemetryRecorder(NexusCoreObject):
                 entity_name=entity_name,
                 run_id=run_id,
             )
-            if not isinstance(entity_to_record, dict) and not isinstance(
-                entity_to_record, DataFrame
-            ):
+
+            try:
+                serialization_format = self._serializer.get_serialization_format(
+                    entity_to_record
+                )
+            except KeyError:
                 self._logger.warning(
-                    "Unsupported data type: {telemetry_entity_type}. Telemetry recording skipped.",
-                    telemetry_entity_type=type(entity_to_record),
+                    "No telemetry serialization format injected for data type: {telemetry_entity_type}. Telemetry recording skipped.",
+                    telemetry_entity_type=str(type(entity_to_record)),
                 )
-            else:
-                self._storage_client.save_data_as_blob(
-                    data=entity_to_record,
-                    blob_path=DataSocket(
-                        alias="telemetry",
-                        data_path=os.path.join(
-                            self._telemetry_base_path,
-                            "telemetry_group=inputs",
-                            f"entity_name={entity_name}",
-                            f"request_id={run_id}",
-                            run_id,
-                        ),
-                        data_format="null",
-                    ).parse_data_path(),
-                    serialization_format=self._serializer.get_serialization_format(
-                        entity_to_record
+                return
+
+            self._storage_client.save_data_as_blob(
+                data=entity_to_record,
+                blob_path=DataSocket(
+                    alias="telemetry",
+                    data_path=os.path.join(
+                        self._telemetry_base_path,
+                        "telemetry_group=inputs",
+                        f"entity_name={entity_name}",
+                        f"request_id={run_id}",
+                        run_id,
                     ),
-                    overwrite=True,
-                )
+                    data_format="null",
+                ).parse_data_path(),
+                serialization_format=serialization_format,
+                overwrite=True,
+            )
 
         telemetry_tasks = [
             asyncio.create_task(

{esd_services_api_client-2.5.1a123.dev5 → esd_services_api_client-2.5.3}/esd_services_api_client/nexus/telemetry/user_telemetry_recorder.py

@@ -151,7 +151,9 @@ class UserTelemetryRecorder(Generic[TPayload, TResult], ABC):
                 ),
                 data_format="null",
             ).parse_data_path(),
-            serialization_format=self._serializer.get_serialization_format(telemetry),
+            serialization_format=self._serializer.get_serialization_format(
+                telemetry.telemetry
+            ),
             overwrite=True,
         )
 

{esd_services_api_client-2.5.1a123.dev5 → esd_services_api_client-2.5.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "esd-services-api-client"
-version = "v2.5.1a123.dev5"
+version = "2.5.3"
 description = "Python clients for ESD services"
 authors = ["ECCO Sneaks & Data <esdsupport@ecco.com>"]
 maintainers = ['GZU <gzu@ecco.com>', 'JRB <ext-jrb@ecco.com>', 'VISA <visa@ecco.com>']

esd_services_api_client-2.5.1a123.dev5/esd_services_api_client/_version.py

@@ -1 +0,0 @@
-__version__ = 'v2.5.1a123.dev5'