opengris-scaler 1.12.11__tar.gz → 1.12.12__tar.gz

{opengris_scaler-1.12.11 → opengris_scaler-1.12.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: opengris-scaler
-Version: 1.12.11
+Version: 1.12.12
 Summary: OpenGRIS Scaler Distribution Framework
 Author-Email: Citi <opensource@citi.com>
 License: Apache 2.0
@@ -365,6 +365,8 @@ with Client(address="tcp://127.0.0.1:2345") as client:
     print(future.result())  # 21
 ```
 
+**Note**: When creating a `Client` inside a task (nested client), the `address` parameter is optional. If omitted, the client automatically uses the scheduler address from the worker context. If provided, the specified address takes precedence.
+
 ## Task Routing and Capability Management
 
 > **Note**: This feature is experimental and may change in future releases.

{opengris_scaler-1.12.11 → opengris_scaler-1.12.12}/README.md

@@ -322,6 +322,8 @@ with Client(address="tcp://127.0.0.1:2345") as client:
     print(future.result())  # 21
 ```
 
+**Note**: When creating a `Client` inside a task (nested client), the `address` parameter is optional. If omitted, the client automatically uses the scheduler address from the worker context. If provided, the specified address takes precedence.
+
 ## Task Routing and Capability Management
 
 > **Note**: This feature is experimental and may change in future releases.

{opengris_scaler-1.12.11 → opengris_scaler-1.12.12}/docs/source/tutorials/features.rst

@@ -118,6 +118,28 @@ Tasks can depend on other tasks' result without using graph.
 .. literalinclude:: ../../../examples/nested_client.py
    :language: python
 
+Nested Client Scheduler Address
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+When creating a ``Client`` inside a task (nested client), the scheduler ``address`` parameter is optional. If omitted, the client automatically detects and uses the scheduler address from the worker context. This is particularly useful when workers are behind firewalls or NAT, where the scheduler address accessible from inside the worker may differ from external addresses.
+
+**Automatic Address Detection:**
+
+.. code:: python
+
+    from scaler import Client
+
+    def nested_task():
+        # Automatically uses worker's scheduler address if no address is provided to Client()
+        with Client() as client:
+            result = client.submit(lambda x: x * 2, 5).result()
+        return result
+
+    # Main client
+    client = Client(address="tcp://127.0.0.1:2345")
+    future = client.submit(nested_task)
+    print(future.result())  # 10
+
 Dynamically Building Graph Within a Task
 ----------------------------------------
 

{opengris_scaler-1.12.11 → opengris_scaler-1.12.12}/scaler/client/client.py

@@ -51,7 +51,7 @@ class _CallNode:
 class Client:
     def __init__(
         self,
-        address: str,
+        address: Optional[str] = None,
         profiling: bool = False,
         timeout_seconds: int = DEFAULT_CLIENT_TIMEOUT_SECONDS,
         heartbeat_interval_seconds: int = DEFAULT_HEARTBEAT_INTERVAL_SECONDS,
@@ -61,8 +61,9 @@ class Client:
         """
         The Scaler Client used to send tasks to a scheduler.
 
-        :param address: Address of Scheduler to submit work to
-        :type address: str
+        :param address: Address of Scheduler to submit work to. If None, will attempt to auto-detect
+                       when running inside a worker context.
+        :type address: Optional[str]
         :param profiling: If True, the returned futures will have the `task_duration()` property enabled.
         :type profiling: bool
         :param timeout_seconds: Seconds until heartbeat times out
@@ -72,6 +73,7 @@ class Client:
         :param stream_output: If True, stdout/stderr will be streamed to client during task execution
         :type stream_output: bool
         """
+        address = self._resolve_scheduler_address(address)
         self.__initialize__(address, profiling, timeout_seconds, heartbeat_interval_seconds, serializer, stream_output)
 
     def __initialize__(
@@ -380,6 +382,10 @@ class Client:
         disconnect from connected scheduler, this will not shut down the scheduler
         """
 
+        # Handle case where client wasn't fully initialized
+        if not hasattr(self, "_stop_event"):
+            return
+
         if self._stop_event.is_set():
             self.__destroy()
             return
@@ -633,3 +639,20 @@ class Client:
         assert current_task is not None
 
         return retrieve_task_flags_from_task(current_task).priority
+
+    def _resolve_scheduler_address(self, address: Optional[str]) -> str:
+        """Resolve the scheduler address based on the provided address and worker context."""
+        # Provided address always takes precedence
+        if address is not None:
+            return address
+
+        # No address provided, check if we're running inside a worker context
+        current_processor = Processor.get_current_processor()
+        if current_processor is None:
+            raise ValueError(
+                "No scheduler address provided and not running inside a worker context. "
+                "Please provide a scheduler address when creating the Client outside of a worker."
+            )
+
+        # Return the scheduler address from the current processor
+        return current_processor.scheduler_address().to_address()

opengris_scaler-1.12.12/scaler/version.txt

@@ -0,0 +1 @@
+1.12.12

{opengris_scaler-1.12.11 → opengris_scaler-1.12.12}/scaler/worker/agent/processor/processor.py

@@ -37,6 +37,7 @@ class Processor(multiprocessing.get_context("spawn").Process):  # type: ignore
         self,
         event_loop: str,
         agent_address: ZMQConfig,
+        scheduler_address: ZMQConfig,
         storage_address: ObjectStorageConfig,
         preload: Optional[str],
         resume_event: Optional[EventType],
@@ -50,6 +51,7 @@ class Processor(multiprocessing.get_context("spawn").Process):  # type: ignore
 
         self._event_loop = event_loop
         self._agent_address = agent_address
+        self._scheduler_address = scheduler_address
         self._storage_address = storage_address
         self._preload = preload
 
@@ -74,6 +76,10 @@ class Processor(multiprocessing.get_context("spawn").Process):  # type: ignore
         """Returns the current Processor instance controlling the current process, if any."""
         return _current_processor.get()
 
+    def scheduler_address(self) -> ZMQConfig:
+        """Returns the scheduler address this processor's worker is connected to."""
+        return self._scheduler_address
+
     def current_task(self) -> Optional[Task]:
         return self._current_task
 

{opengris_scaler-1.12.11 → opengris_scaler-1.12.12}/scaler/worker/agent/processor_holder.py

@@ -19,6 +19,7 @@ class ProcessorHolder:
         self,
         event_loop: str,
         agent_address: ZMQConfig,
+        scheduler_address: ZMQConfig,
         storage_address: ObjectStorageConfig,
         preload: Optional[str],
         garbage_collect_interval_seconds: int,
@@ -43,6 +44,7 @@ class ProcessorHolder:
         self._processor = Processor(
             event_loop=event_loop,
             agent_address=agent_address,
+            scheduler_address=scheduler_address,
             storage_address=storage_address,
             preload=preload,
             resume_event=self._resume_event,

{opengris_scaler-1.12.11 → opengris_scaler-1.12.12}/scaler/worker/agent/processor_manager.py

@@ -23,6 +23,7 @@ class VanillaProcessorManager(ProcessorManager):
         identity: WorkerID,
         event_loop: str,
         address_internal: ZMQConfig,
+        scheduler_address: ZMQConfig,
         preload: Optional[str],
         garbage_collect_interval_seconds: int,
         trim_memory_threshold_bytes: int,
@@ -34,6 +35,7 @@ class VanillaProcessorManager(ProcessorManager):
 
         self._identity = identity
         self._event_loop = event_loop
+        self._scheduler_address = scheduler_address
         self._preload = preload
 
         self._garbage_collect_interval_seconds = garbage_collect_interval_seconds
@@ -299,6 +301,7 @@ class VanillaProcessorManager(ProcessorManager):
         self._current_holder = ProcessorHolder(
             self._event_loop,
             self._address_internal,
+            self._scheduler_address,
             storage_address,
             self._preload,
             self._garbage_collect_interval_seconds,

{opengris_scaler-1.12.11 → opengris_scaler-1.12.12}/scaler/worker/worker.py

@@ -139,6 +139,7 @@ class Worker(multiprocessing.get_context("spawn").Process):  # type: ignore
             identity=self._ident,
             event_loop=self._event_loop,
             address_internal=self._address_internal,
+            scheduler_address=self._address,
             preload=self._preload,
             garbage_collect_interval_seconds=self._garbage_collect_interval_seconds,
             trim_memory_threshold_bytes=self._trim_memory_threshold_bytes,

{opengris_scaler-1.12.11 → opengris_scaler-1.12.12}/tests/test_client.py

@@ -320,6 +320,14 @@ class TestClient(unittest.TestCase):
             # but new tasks should work fine
             self.assertEqual(client.submit(round, 3.14).result(), 3.0)
 
+    def test_client_no_address_outside_worker(self):
+        """Test that creating a Client without an address outside worker context raises ValueError."""
+        with self.assertRaises(ValueError) as context:
+            Client()
+
+        self.assertIn("No scheduler address provided", str(context.exception))
+        self.assertIn("not running inside a worker context", str(context.exception))
+
 
 class TestClientPreload(unittest.TestCase):
     # Separate class for preload functionality with separate cluster to avoid interfering with time-sensitive tests

{opengris_scaler-1.12.11 → opengris_scaler-1.12.12}/tests/test_nested_task.py

@@ -34,6 +34,18 @@ class TestNestedTask(unittest.TestCase):
             result = client.submit(fibonacci, client, 8).result()
             self.assertEqual(result, 21)
 
+    def test_nested_task_auto_address(self) -> None:
+        """Test nested task with automatic scheduler address detection."""
+        with Client(self.address) as client:
+            result = client.submit(nested_task_auto_address, 5).result()
+            self.assertEqual(result, 25)
+
+    def test_nested_task_explicit_address(self) -> None:
+        """Test nested task with explicit scheduler address (honors user-provided address)."""
+        with Client(self.address) as client:
+            result = client.submit(nested_task_explicit_address, self.address, 7).result()
+            self.assertEqual(result, 49)
+
 
 def parent_task_arg_client(client: Client) -> int:
     iterable = [(v,) for v in range(0, N_TASKS)]
@@ -60,3 +72,25 @@ def fibonacci(client: Client, n: int):
         a = client.submit(fibonacci, client, n - 1)
         b = client.submit(fibonacci, client, n - 2)
         return a.result() + b.result()
+
+
+def nested_task_auto_address(value: int) -> int:
+    """Test function that creates a nested client without providing an address."""
+    # Client should automatically detect worker context and use worker's scheduler address
+    client = Client()
+    try:
+        result = client.submit(nested_task, value).result()
+        return result
+    finally:
+        client.disconnect()
+
+
+def nested_task_explicit_address(scheduler_address: str, value: int) -> int:
+    """Test function that creates a nested client with an explicit address."""
+    # Client should honor the explicitly provided address even though running in worker context
+    client = Client(address=scheduler_address)
+    try:
+        result = client.submit(nested_task, value).result()
+        return result
+    finally:
+        client.disconnect()

opengris_scaler-1.12.11/scaler/version.txt

@@ -1 +0,0 @@
-1.12.11