bec-lib 4.3.0__tar.gz → 4.3.2__tar.gz

{bec_lib-4.3.0 → bec_lib-4.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bec_lib
-Version: 4.3.0
+Version: 4.3.2
 Summary: BEC library
 Project-URL: Bug Tracker, https://github.com/bec-project/bec/issues
 Project-URL: Homepage, https://github.com/bec-project/bec

{bec_lib-4.3.0 → bec_lib-4.3.2}/bec_lib/bec_service.py

@@ -83,8 +83,8 @@ def parse_cmdline_args(parser=None, config_name: Literal["client", "server"] | s
     parser.add_argument(
         "--use-subprocess-proc-worker",
         action="store_true",
-        default=False,
-        help="Use the in process procedure worker for local testing",
+        default=None,
+        help="Use the subprocess procedure worker for local testing",
     )
 
     args, extra_args = parser.parse_known_args()

{bec_lib-4.3.0 → bec_lib-4.3.2}/bec_lib/endpoints.py

@@ -1470,15 +1470,19 @@ class MessageEndpoints:
         )
 
     @staticmethod
-    def procedure_request():
+    def procedure_request(username: str) -> EndpointInfo:
         """
-        Endpoint for requesting new procedures.
+        Endpoint for requesting new procedures, scoped to the submitting user through Redis ACLs.
         The request is sent using a messages.ProcedureRequestMessage message.
+        Its metadata.client_info.acl_user must match the username in this endpoint.
+
+        Args:
+            username (str): Username of the user making the request.
 
         Returns:
             EndpointInfo: Endpoint for procedure request.
         """
-        endpoint = f"{EndpointType.USER.value}/procedures/procedure_request"
+        endpoint = f"{EndpointType.PERSONAL.value}/{username}/procedures/procedure_request"
         return EndpointInfo(
             endpoint=endpoint,
             message_type=messages.ProcedureRequestMessage,
@@ -1503,6 +1507,32 @@ class MessageEndpoints:
             message_op=MessageOp.SEND,
         )
 
+    @staticmethod
+    def procedure_workers() -> EndpointInfo:
+        """Return the public registry of workers and their owning queues.
+
+        Returns:
+            EndpointInfo: Worker registry.
+        """
+        return EndpointInfo(
+            endpoint=f"{EndpointType.INFO.value}/procedures/workers",
+            message_type=messages.AvailableResourceMessage,
+            message_op=MessageOp.KEY_VALUE,
+        )
+
+    @staticmethod
+    def procedure_queues() -> EndpointInfo:
+        """Return the registry of logical queues, including empty queues.
+
+        Returns:
+            EndpointInfo: Queue registry.
+        """
+        return EndpointInfo(
+            endpoint=f"{EndpointType.INFO.value}/procedures/queues",
+            message_type=messages.AvailableResourceMessage,
+            message_op=MessageOp.KEY_VALUE,
+        )
+
     @staticmethod
     def procedure_execution(queue_id: str):
         """

{bec_lib-4.3.0 → bec_lib-4.3.2}/bec_lib/messages.py

@@ -1937,9 +1937,11 @@ class ProcedureWorkerStatusMessage(BECMessage):
     """Message type for sending procedure worker status updates
 
     Args:
-        worker_queue (str): Worker queue ID
+        worker_queue (str): Worker identifier; legacy actor workers use their queue ID.
         status (str): Worker status
         current_execution_id (str | None): ID of the current job, only allowed for RUNNING
+        completed_execution_id (str | None): Completed pooled execution, if any.
+        error (str | None): Error from the completed execution.
     """
 
     msg_type: ClassVar[str] = "procedure_worker_status_message"
@@ -1947,6 +1949,9 @@ class ProcedureWorkerStatusMessage(BECMessage):
     status: ProcedureWorkerStatus
     current_execution_id: str | None = None
 
+    completed_execution_id: str | None = None
+    error: str | None = None
+
     @model_validator(mode="after")
     def check_id(self) -> Self:
         if self.current_execution_id is not None and self.status != ProcedureWorkerStatus.RUNNING:

{bec_lib-4.3.0 → bec_lib-4.3.2}/bec_lib/procedures/helper.py

@@ -87,6 +87,11 @@ class ProcedureStatus:
             return
         # The request can be accepted or denied
         if self._state is ProcedureState.REQUESTED:
+            # Cancellation can finish an admission before its acknowledgement arrives.
+            if state == ProcedureState.FAILED:
+                self._state = state
+                self._done.set()
+                return
             if state not in [ProcedureState.REJECTED, ProcedureState.SCHEDULED]:
                 raise ValueError(f"Improper transition from {self._state} to {state}")
             self._state = state
@@ -185,9 +190,14 @@ class _Request(_HelperBase):
         return self._procedure(msg)
 
     def _procedure(self, msg):
+        from bec_lib.acl_login import BECAccess
+
+        credentials = BECAccess(self._conn).current_credentials()
+        username = credentials["username"] or "default"
+        msg.metadata["client_info"] = {"acl_user": username, "acl_token": credentials["token"]}
         st = ProcedureStatus(self._conn, msg.execution_id, msg.identifier)
         self._set_callbacks(msg.execution_id, st)
-        self._conn.send(ME.procedure_request(), msg)
+        self._conn.send(ME.procedure_request(username), msg)
         return st
 
     def abort_execution(self, execution_id: str):
@@ -256,7 +266,29 @@ class _Get(_HelperBase):
             else ME.unhandled_procedure_execution
         )
         raw: list[str] = [s.decode() for s in self._conn.keys(ep("*"))]
-        return [s.split("/")[-1] for s in raw]
+        names = {s.split("/")[-1] for s in raw}
+        if queue_type == "execution":
+            registry = self._conn.get(ME.procedure_queues())
+            if registry is not None:
+                names.update(registry.resource)
+        return sorted(names)
+
+    def workers(self, queue: str | None = None) -> dict[str, dict]:
+        """Return workers, optionally filtered by their owning logical queue.
+
+        Args:
+            queue (str | None): Queue name, or None for all queues.
+        Returns:
+            dict[str, dict]: Worker IDs mapped to queue, status, and current execution.
+        """
+        registry = self._conn.get(ME.procedure_workers())
+        if registry is None:
+            return {}
+        return {
+            identifier: worker
+            for identifier, worker in registry.resource.items()
+            if queue is None or worker["queue"] == queue
+        }
 
     def log_queue_names(self) -> list[str]:
         """Get the names of queues currently containing logs from procedures."""

{bec_lib-4.3.0 → bec_lib-4.3.2}/bec_lib/service_config.py

@@ -7,7 +7,7 @@ import os
 import re
 from getpass import getuser
 from pathlib import Path
-from typing import Any, ClassVar, Self
+from typing import Any, ClassVar
 
 import yaml
 from pydantic import BaseModel, Field, model_validator
@@ -114,21 +114,20 @@ class ServiceConfigModel(BaseModel):
     procedures: ProcedureConfig = Field(default_factory=ProcedureConfig)
 
     @model_validator(mode="before")
-    def apply_cmdline_args(self, data: Any) -> Self:
-        if isinstance(data, dict):
-            if cmdline_args := data.get("cmdline_args"):
-                for arg in cmdline_args.items():
-                    self._update_data_for_arg(arg, data)
-        return self
-
-    def _update_data_for_arg(self, arg: tuple[str, Any], data: dict):
-        argname, argval = arg
-        if argname not in self._CMDLINE_ARGS:
+    @classmethod
+    def apply_cmdline_args(cls, data: Any) -> Any:
+        """Apply supplied CLI overrides before validating the configuration."""
+        if not isinstance(data, dict):
             return data
-        subconfig, variable = self._CMDLINE_ARGS[argname]
-        if subconfig not in data:
-            data[subconfig] = {}
-        data[subconfig][variable] = argval
+        data = data.copy()
+        for argname, argval in (data.get("cmdline_args") or {}).items():
+            if argname not in cls._CMDLINE_ARGS or argval is None:
+                continue
+            subconfig, variable = cls._CMDLINE_ARGS[argname]
+            values = data.get(subconfig, {})
+            if isinstance(values, BaseModel):
+                values = values.model_dump()
+            data[subconfig] = {**values, variable: argval}
         return data
 
 

{bec_lib-4.3.0 → bec_lib-4.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "bec_lib"
-version = "4.3.0"
+version = "4.3.2"
 description = "BEC library"
 requires-python = ">=3.11"
 classifiers = [

{bec_lib-4.3.0 → bec_lib-4.3.2}/tests/test_bec_service.py

@@ -408,7 +408,7 @@ def test_parse_cmdline_args_with_config():
                     "file_log_level": None,
                     "redis_log_level": None,
                     "bec_server": None,
-                    "use_subprocess_proc_worker": False,
+                    "use_subprocess_proc_worker": None,
                 },
                 config_name="server",
             )
@@ -429,7 +429,7 @@ def test_parse_cmdline_args_with_user():
                     "file_log_level": None,
                     "redis_log_level": None,
                     "bec_server": None,
-                    "use_subprocess_proc_worker": False,
+                    "use_subprocess_proc_worker": None,
                 },
                 acl={"user": "admin"},
                 config_name="server",

bec_lib-4.3.2/tests/test_procedure_submission.py

@@ -0,0 +1,39 @@
+"""Procedure requests use the authenticated user's personal endpoint."""
+
+from unittest.mock import MagicMock
+
+from bec_lib.endpoints import MessageEndpoints
+from bec_lib.messages import ProcedureRequestMessage
+from bec_lib.procedures.helper import FrontendProcedureHelper
+
+
+def test_procedure_submission_tracks_current_acl_user():
+    conn = MagicMock()
+    conn._managed_connection._redis_conn.connection_pool.connection_kwargs = {"password": "secret"}
+    helper = FrontendProcedureHelper(conn)
+    for username in ["alice", "bob", "default"]:
+        conn.username = username
+        status = helper.request.procedure("sleep", args_kwargs=((), {"time_s": 1}))
+        endpoint, message = conn.send.call_args.args
+        assert endpoint == MessageEndpoints.procedure_request(username)
+        assert endpoint.endpoint == f"personal/{username}/procedures/procedure_request"
+        assert message.metadata["client_info"]["acl_user"] == username
+        assert message.execution_id == status._id
+        assert message.args_kwargs == ((), {"time_s": 1})
+
+
+def test_submission_replaces_untrusted_acl_identity():
+    conn = MagicMock()
+    conn._managed_connection._redis_conn.connection_pool.connection_kwargs = {"password": "secret"}
+    conn.username = "alice"
+    helper = FrontendProcedureHelper(conn)
+    message = ProcedureRequestMessage(
+        identifier="sleep", metadata={"client_info": {"acl_user": "bob"}, "custom": "preserved"}
+    )
+    helper.request._procedure(message)
+    endpoint, submitted = conn.send.call_args.args
+    assert endpoint == MessageEndpoints.procedure_request("alice")
+    assert submitted.metadata == {
+        "client_info": {"acl_user": "alice", "acl_token": "secret"},
+        "custom": "preserved",
+    }

bec_lib-4.3.2/tests/test_service_config.py

@@ -0,0 +1,55 @@
+"""Regression tests for service configuration CLI overrides."""
+
+from __future__ import annotations
+
+import sys
+
+import pytest
+
+from bec_lib.bec_service import parse_cmdline_args
+from bec_lib.service_config import ProcedureConfig, ServiceConfig, ServiceConfigModel
+
+
+@pytest.mark.parametrize("configured", [True, False])
+@pytest.mark.parametrize("override", [True, False, None])
+def test_procedure_cli_override(configured, override):
+    config = ServiceConfig(
+        config={"procedures": {"use_subprocess_worker": configured}},
+        cmdline_args={"use_subprocess_proc_worker": override},
+    )
+    assert config.model.procedures.use_subprocess_worker is (
+        configured if override is None else override
+    )
+
+
+def test_cli_override_preserves_config_input():
+    data = {"procedures": {"enable_procedures": False, "use_subprocess_worker": False}}
+    model = ServiceConfigModel.model_validate(
+        data | {"cmdline_args": {"use_subprocess_proc_worker": True, "unknown": True}}
+    )
+    assert model.procedures.use_subprocess_worker
+    assert not model.procedures.enable_procedures
+    assert data["procedures"]["use_subprocess_worker"] is False
+
+
+def test_cli_override_without_procedure_section():
+    config = ServiceConfigModel(cmdline_args={"use_subprocess_proc_worker": True})
+    assert config.procedures.use_subprocess_worker
+
+
+def test_cli_override_with_model_section():
+    config = ServiceConfigModel(
+        procedures=ProcedureConfig(enable_procedures=False),
+        cmdline_args={"use_subprocess_proc_worker": True},
+    )
+    assert config.procedures.use_subprocess_worker
+    assert not config.procedures.enable_procedures
+
+
+@pytest.mark.parametrize("flag", [[], ["--use-subprocess-proc-worker"]])
+def test_procedure_worker_cli_selection(monkeypatch, tmp_path, flag):
+    path = tmp_path / "server.yaml"
+    path.write_text("procedures:\n  use_subprocess_worker: true\n")
+    monkeypatch.setattr(sys, "argv", ["scan-server", "--config", str(path), *flag])
+    _, _, config = parse_cmdline_args()
+    assert config.model.procedures.use_subprocess_worker