digitalkin 1.0.3.dev2__tar.gz → 1.0.4__tar.gz

{digitalkin-1.0.3.dev2 → digitalkin-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 1.0.3.dev2
+Version: 1.0.4
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International
@@ -453,7 +453,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: ag-ui-protocol==0.1.21.dev1787220377
-Requires-Dist: agentic-mesh-protocol==1.0.1
+Requires-Dist: agentic-mesh-protocol==1.0.2
 Requires-Dist: agno<3,>=2.8.0
 Requires-Dist: anyio>=4.13.0
 Requires-Dist: grpcio-health-checking==1.82.1

{digitalkin-1.0.3.dev2 → digitalkin-1.0.4}/examples/services/filesystem_module.py

@@ -10,7 +10,8 @@ from pydantic import BaseModel, Field
 from digitalkin.logger import logger
 from digitalkin.models.module import ModuleStatus
 from digitalkin.modules.archetype_module import ArchetypeModule
-from digitalkin.services.filesystem.filesystem_strategy import FileFilter, UploadFileData
+from digitalkin.models.services.filesystem import FileType
+from digitalkin.services.filesystem import FileFilter, UploadFileData
 from digitalkin.services.services_config import ServicesConfig
 from digitalkin.services.services_models import ServicesMode
 
@@ -118,9 +119,9 @@ class ExampleModule(ArchetypeModule[ExampleInput, ExampleOutput, ExampleSetup, E
         file = UploadFileData(
             content=b"%s\n%s" % (processed_message.encode(), str(processed_number).encode()),
             name="example_output.txt",
-            file_type="text/plain",
+            type=FileType.DOCUMENT,
             content_type="text/plain",
-            metadata={"example_key": "example_value"},
+            metadata={"sdk_created": True},
             replace_if_exists=True,
         )
 
@@ -176,10 +177,10 @@ async def test_module() -> None:
     # Check the storage
     if module.status == ModuleStatus.STOPPED:
         files, _nb_results = await module.filesystem.get_files(
-            filters=FileFilter(name="example_output.txt", context="test-mission-123"),
+            filters=FileFilter(names=["example_output.txt"]),
         )
         for file in files:
-            await module.filesystem.update_file(file.id, file_type="updated")
+            await module.filesystem.update_file(file.id, type=FileType.OTHER)
             # module.filesystem.delete_files(filters=FileFilter(name="example_output.txt", context="test-mission-123"), permanent=True)
 
             logger.info("Retrieved file: %s with ID: %s", file.name, file.id)
@@ -188,7 +189,7 @@ async def test_module() -> None:
                 if file_record:
                     logger.info("File ID: %s", file_record.id)
                     logger.info("File name: %s", file_record.name)
-                    logger.info("File type: %s", file_record.file_type)
+                    logger.info("File type: %s", file_record.type)
                     logger.info("File status: %s", file_record.status)
                     logger.info("File content: %s", file_record.content.decode())
             except Exception:

{digitalkin-1.0.3.dev2 → digitalkin-1.0.4}/pyproject.toml

@@ -31,7 +31,7 @@
         # which is how a nested run's output is attributed to its author. Pinned exactly
         # because it is a dated prerelease; move to >=0.1.21 once that ships stable.
         "ag-ui-protocol==0.1.21.dev1787220377",
-        "agentic-mesh-protocol==1.0.1",
+        "agentic-mesh-protocol==1.0.2",
         "agno>=2.8.0,<3",
         "anyio>=4.13.0",
         "grpcio-health-checking==1.82.1",
@@ -41,7 +41,7 @@
         "pydantic>=2.12.4",
         "redis[hiredis]>=7.4.0,<9",
     ]
-    version = "1.0.3.dev2"
+    version = "1.0.4"
 
     [project.optional-dependencies]
         agno = [ "agno>=2.6" ]
@@ -208,15 +208,15 @@
         ]
 
         ignore = [
-            "ANN401",  # Allow typing.Any — gRPC stubs, callbacks, and dynamic APIs require it
-            "COM812",  # Disable because of formatter incompatibility
-            "DOC502",  # Allow extraneous-exception in docstring
-            "F401",    # Allow unused imports — used for availability checks
-            "N802",    # Allow PascalCase methods — gRPC servicer convention
-            "PLC0415", # Allow lazy imports — needed to break circular dependencies
-            "PLW3201", # Allow __get_pydantic_core_schema__ — Pydantic dunder hook
-            "S105",    # Hardcoded-password
-            "S403",    # Allow pickle import
+            "any-type",                       # Allow typing.Any — gRPC stubs, callbacks, and dynamic APIs require it
+            "missing-trailing-comma",         # Disable because of formatter incompatibility
+            "docstring-extraneous-exception", # Allow extraneous-exception in docstring
+            "unused-import",                  # Allow unused imports — used for availability checks
+            "invalid-function-name",          # Allow PascalCase methods — gRPC servicer convention
+            "import-outside-top-level",       # Allow lazy imports — needed to break circular dependencies
+            "bad-dunder-method-name",         # Allow __get_pydantic_core_schema__ — Pydantic dunder hook
+            "hardcoded-password-string",      # Hardcoded-password
+            "suspicious-pickle-import",       # Allow pickle import
         ]
 
         fixable = [ "ALL" ]
@@ -226,40 +226,40 @@
 
         [tool.ruff.lint.per-file-ignores]
             "tests/**/*.py" = [
-                "ANN001",
-                "ANN002",
-                "ANN003",
-                "ANN201",
-                "ANN401",
-                "ARG001",
-                "ARG002",
-                "C901",
-                "D100",
-                "D101",
-                "D102",
-                "D103",
-                "D107",
-                "D417",
-                "DOC201",
-                "DOC501",
-                "E501",
-                "ERA001",
-                "FBT001",
-                "FBT002",
-                "G004",
-                "N802",
-                "PERF203",
-                "PLC2701",
-                "PLR0911",
-                "PLR0912",
-                "PLR0914",
-                "PLR0915",
-                "PLR1702",
-                "PLR2004",
-                "PLR6301",
-                "S101",
-                "SLF001",
-                "TRY002",
+                "missing-type-function-argument",
+                "missing-type-args",
+                "missing-type-kwargs",
+                "missing-return-type-undocumented-public-function",
+                "any-type",
+                "unused-function-argument",
+                "unused-method-argument",
+                "complex-structure",
+                "undocumented-public-module",
+                "undocumented-public-class",
+                "undocumented-public-method",
+                "undocumented-public-function",
+                "undocumented-public-init",
+                "undocumented-param",
+                "docstring-missing-returns",
+                "docstring-missing-exception",
+                "line-too-long",
+                "commented-out-code",
+                "boolean-type-hint-positional-argument",
+                "boolean-default-value-positional-argument",
+                "logging-f-string",
+                "invalid-function-name",
+                "try-except-in-loop",
+                "import-private-name",
+                "too-many-return-statements",
+                "too-many-branches",
+                "too-many-locals",
+                "too-many-statements",
+                "too-many-nested-blocks",
+                "magic-value-comparison",
+                "no-self-use",
+                "assert",
+                "private-member-access",
+                "raise-vanilla-class",
             ]
 
         [tool.ruff.lint.pylint]

{digitalkin-1.0.3.dev2 → digitalkin-1.0.4}/src/digitalkin/__version__.py

@@ -5,4 +5,4 @@ from importlib.metadata import PackageNotFoundError, version
 try:
     __version__ = version("digitalkin")
 except PackageNotFoundError:
-    __version__ = "1.0.3.dev2"
+    __version__ = "1.0.4"

{digitalkin-1.0.3.dev2 → digitalkin-1.0.4}/src/digitalkin/community/agno/toolkits/registry/action.py

@@ -23,6 +23,7 @@ from digitalkin.models.services.registry import (
 
 if TYPE_CHECKING:
     from digitalkin.community.agno.toolkits.registry.base import RegistryActionCtx
+    from digitalkin.models.services.registry import SetupSummary
 
 
 class GetAction(RegistryAction):
@@ -124,23 +125,36 @@ class SearchAction(RegistryAction):
         # would both contradict ``total_returned`` and, at exactly ``cap`` rows, promise an empty
         # next page.
         truncated = len(usable) > cap
-        rows = [
-            {
-                "setup_id": setup.setup_id,
-                "name": setup.name,
-                "module_name": setup.module_name,
-                "version": setup.setup_version,
-                # Echoed because they are filterable: a caller cannot use the ``tags``,
-                # ``visibilities`` or ``statuses`` filters without first seeing the values in use.
-                "tags": setup.tags,
-                "visibility": setup.visibility.value if setup.visibility else None,
-                "status": setup.status.value if setup.status else None,
-                "description": (setup.documentation or "")[: self._DOC_PREVIEW_CHARS],
-            }
-            for setup in usable[:cap]
-        ]
+        rows = [self._row(setup) for setup in usable[:cap]]
         return {"total_returned": len(rows), "truncated": truncated, "offset": self.offset, "setups": rows}
 
+    def _row(self, setup: SetupSummary) -> dict[str, Any]:
+        """Trim one search hit to the fields a caller can act on.
+
+        Args:
+            setup: The summary returned by the registry.
+
+        Returns:
+            The rendered row.
+        """
+        row: dict[str, Any] = {
+            "setup_id": setup.setup_id,
+            "name": setup.name,
+            "module_name": setup.module_name,
+            "version": setup.setup_version,
+            # Echoed because they are filterable: a caller cannot use the ``tags``,
+            # ``visibilities`` or ``statuses`` filters without first seeing the values in use.
+            "tags": setup.tags,
+            "visibility": setup.visibility.value if setup.visibility else None,
+            "status": setup.status.value if setup.status else None,
+            "description": (setup.documentation or "")[: self._DOC_PREVIEW_CHARS],
+        }
+        # Only service setups carry a map. Omitting the key rather than rendering an empty
+        # one keeps the feature out of the tools and kins surfaces entirely.
+        if setup.structure:
+            row["structure"] = setup.structure
+        return row
+
 
 class UpdateAction(RegistryAction):
     """Update an instance: cut a new version of its configuration, and rename it.
@@ -166,6 +180,20 @@ class UpdateAction(RegistryAction):
         "without changing what the instance currently serves, then activate it later with "
         "``set_version``.",
     )
+    documentation: str | None = Field(
+        default=None,
+        description="Free text describing what this instance is for, indexed by ``search``. "
+        "Omit to keep the text the instance already has; pass a string to replace it, or an "
+        "empty string to clear it.",
+    )
+
+    def _type_payload(self) -> dict[str, Any]:  # ruff: ignore[no-self-use]
+        """Fields this object type adds to the update.
+
+        Returns:
+            Nothing by default; ``services_manager`` overrides it to refresh the structure map.
+        """
+        return {}
 
     async def execute(self, ctx: RegistryActionCtx) -> Any:
         """Cut a new version of the setup's content and rename it.
@@ -184,6 +212,10 @@ class UpdateAction(RegistryAction):
             "name": self.name,
             "content": self.content,
             "set_as_current": self.set_as_current,
+            "documentation": (
+                setup.current_setup_version.documentation if self.documentation is None else self.documentation
+            ),
+            **self._type_payload(),
         })
 
 

{digitalkin-1.0.3.dev2 → digitalkin-1.0.4}/src/digitalkin/community/agno/toolkits/registry/base.py

@@ -171,22 +171,23 @@ class RegistryAction(BaseAction[RegistryActionCtx], ABC):
 
     writes: ClassVar[bool] = False
 
-    @field_validator("name", check_fields=False)
+    @field_validator("name", "documentation", check_fields=False)
     @classmethod
-    def _name_has_no_control_chars(cls, value: str) -> str:
-        """Reject control characters in a user-facing ``name`` so it fails loudly, not silently.
+    def _text_has_no_control_chars(cls, value: str | None) -> str | None:
+        """Reject control characters in user-facing free text so it fails loudly, not silently.
 
-        The action's ``name`` bypasses the content validator, so without this a NUL byte or ANSI
-        escape would reach persistence and be stripped there, altering the value without telling
-        the caller. Applies to any action declaring ``name`` (update, service create).
+        ``name`` and ``documentation`` bypass the content validator, so without this a NUL byte
+        or ANSI escape would reach persistence and be stripped there, altering the value without
+        telling the caller. Applies to any action declaring either (update, service create).
+        ``None`` is the "leave unchanged" marker on update and has nothing to check.
 
         Returns:
-            The name unchanged when clean.
+            The value unchanged when clean.
 
         Raises:
-            ValueError: The name carries a control character.
+            ValueError: The value carries a control character.
         """
-        return SetupContentValidator.reject_control_chars(value)
+        return value if value is None else SetupContentValidator.reject_control_chars(value)
 
     @field_validator("content", check_fields=False)
     @classmethod
@@ -346,7 +347,11 @@ class RegistryObjectToolKit(DkToolkit):
         Also echoes ``visibility`` back in the caller's vocabulary — the input enum is
         ``public``/``private``/``internal`` but the backend returns the proto name
         ``VISIBILITY_INTERNAL``, so a naive round-trip fails. Strip the prefix and
-        lower-case it so the field read back matches the field written.
+        lower-case it so the field read back matches the field written. Confined to the
+        model branch on purpose: every action carrying a real setup visibility returns a
+        ``SetupData``, while the actions returning a plain dict return a *configuration*
+        (``load``) or its key map (``structure``), where a key called ``visibility`` is the
+        service's own data and rewriting it would corrupt what the caller asked for.
 
         Args:
             value: A Pydantic model, proto message, or plain scalar/collection.

{digitalkin-1.0.3.dev2 → digitalkin-1.0.4}/src/digitalkin/community/agno/toolkits/registry/loader/action.py

@@ -134,7 +134,7 @@ class LoadToolAction(LoadAction):
             )
         return None
 
-    async def execute(self, ctx: LoadActionCtx) -> LoadOutcome:  # noqa: C901, PLR0911 — each return is a distinct, LLM-readable outcome
+    async def execute(self, ctx: LoadActionCtx) -> LoadOutcome:  # ruff: ignore[complex-structure, too-many-return-statements] — each return is a distinct, LLM-readable outcome
         """Resolve the setup into a ModuleToolkit and append it to the live tool list.
 
         Idempotent per ``setup_id``; never raises. The setup's family is read first so a

{digitalkin-1.0.3.dev2 → digitalkin-1.0.4}/src/digitalkin/community/agno/toolkits/registry/loader/kit.py

@@ -63,7 +63,7 @@ class LoadManager(DkToolkit):
         """
         self._base_tools = base_tools
 
-    async def load_manager(self, action: LoadActions) -> str:  # noqa: ARG002 — schema-only stub, never run
+    async def load_manager(self, action: LoadActions) -> str:  # ruff: ignore[unused-method-argument] — schema-only stub, never run
         """Load a discovered object into the agent so it becomes usable right now.
 
         Loading is a two-step flow, and this is step two: first DISCOVER the object with its

digitalkin-1.0.4/src/digitalkin/community/agno/toolkits/registry/services/action.py

@@ -0,0 +1,175 @@
+"""Actions for the ``services_manager`` dispatcher.
+
+Adds the two service-specific actions to the shared CRUD + search set:
+
+- ``create`` — create a shareable service from a name + configuration JSON;
+- ``structure`` — show a service's key paths and what lives at each, without its content;
+- ``load`` — return the service's stored JSON configuration content, whole or one key of
+  it (distinct from Tool.load, which loads a live tool into the agent).
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Annotated, Any, ClassVar, Literal
+
+from pydantic import Field
+
+from digitalkin.community.agno.toolkits.registry.action import (
+    ChangeVisibilityAction,
+    DeleteAction,
+    GetAction,
+    ListVersionsAction,
+    SearchAction,
+    SetVersionAction,
+    UpdateAction,
+)
+from digitalkin.community.agno.toolkits.registry.base import RegistryAction
+
+if TYPE_CHECKING:
+    from digitalkin.community.agno.toolkits.registry.base import RegistryActionCtx
+
+
+class CreateServiceAction(RegistryAction):
+    """Create a shareable service other kins can discover.
+
+    Only a name and the configuration JSON are needed — owner, organisation and kind
+    are derived server-side. Once created it is discoverable via ``search`` and
+    readable via ``load``.
+    The service is always created *private* (owner only): visibility is not a creation
+    parameter. Widening it to ``internal`` (whole organisation) or ``public`` (everyone)
+    requires a separate ``change_visibility`` call.
+    """
+
+    action: Literal["create"] = "create"
+    writes: ClassVar[bool] = True
+    name: str = Field(..., description="Human-readable service name.")
+    content: dict[str, Any] = Field(
+        ...,
+        min_length=1,
+        description="The service configuration (a non-empty JSON object). "
+        "Note: JSON numbers round-trip as floats over the wire.",
+    )
+    documentation: str = Field(
+        default="",
+        description="Free text describing what this service is for and when to use it. It is "
+        "what ``search`` matches on and previews back, so a service created without it is "
+        "findable only by name.",
+    )
+    structure: dict[str, str] = Field(
+        ...,
+        description="Map of key path -> one-line summary of what lives at it. This is what "
+        "another agent reads to decide which part of the configuration to fetch, so summarise "
+        "what the key is FOR, not what its value is, and keep every line far shorter than the "
+        "content it describes. Cover each key worth finding on its own; point at a whole "
+        "section instead when it is only ever read as a unit. Path syntax: join nested keys "
+        'with "." (llm.model); bracket-quote a key containing . [ ] " or \\ '
+        '(limits["max.tokens"]); index a list element (tools[0]). Keep each description under '
+        "512 characters — longer ones are trimmed.",
+    )
+
+    async def execute(self, ctx: RegistryActionCtx) -> Any:
+        """Create the service setup from its name, content, documentation and authored key map.
+
+        Returns:
+            The created service setup.
+        """
+        return await ctx.setup.create_service_setup(
+            self.name, self.content, documentation=self.documentation, structure=self.structure
+        )
+
+
+class StructureServiceAction(RegistryAction):
+    """Show a service's shape — key paths and what lives at each — without its content.
+
+    Use it on a setup id you already hold; ``search`` already returns the same map on
+    every row, so there is no need to call this straight after a search. Feed a key from
+    it to ``load`` to read just that part of the configuration.
+    """
+
+    action: Literal["structure"] = "structure"
+    setup_id: str = Field(..., description="The service setup id whose shape to show.")
+
+    async def execute(self, ctx: RegistryActionCtx) -> Any:
+        """Return the stored ``{key path: summary}`` map, with no configuration content.
+
+        The map is written by whoever created or updated the setup, and the only read that
+        carries it is the setup search — so this restates a search for one id rather than
+        deriving a map locally, which would discard the written summaries. A setup stored
+        before the map existed returns an empty one.
+
+        Returns:
+            The key map, or an empty dict when the setup carries none.
+        """
+        await ctx.ensure_kind(self.setup_id)
+        found = await ctx.registry.search_setups(setup_ids=[self.setup_id], module_types=[ctx.module_type], limit=1)
+        return found[0].structure if found else {}
+
+
+class LoadServiceAction(RegistryAction):
+    """Load a service's configuration — one key from its structure, or the whole document."""
+
+    action: Literal["load"] = "load"
+    setup_id: str = Field(..., description="The service setup id to load (from a search result).")
+    key: str | None = Field(
+        default=None,
+        description="One key path copied verbatim from the service's structure map, to read just "
+        "that part of the configuration. Copy it, do not compose it: a key the configuration "
+        "does not have is not an error, it returns the whole document. Omit the key to load "
+        "everything deliberately, when the configuration is small or genuinely needed in full.",
+    )
+
+    async def execute(self, ctx: RegistryActionCtx) -> Any:
+        """Return the service's configuration content, or the part ``key`` names.
+
+        Guards the object type first: without it ``load`` would happily return a tool's
+        internal configuration — the most dangerous type-confusion, since the response
+        carries no field the caller could use to notice it read the wrong kind. The read
+        itself passes ``key`` to the setup service, so the narrowing happens where the
+        document lives; a key the configuration does not have returns the whole document
+        rather than an error, which is what the wire does.
+
+        Returns:
+            ``{key: value}`` for a key that resolves, otherwise the whole configuration.
+        """
+        await ctx.ensure_kind(self.setup_id)
+        setup = await ctx.setup.get_setup({"setup_id": self.setup_id, "structure_key": self.key or ""})
+        return setup.current_setup_version.content
+
+
+class UpdateServiceAction(UpdateAction):
+    """Update a service, refreshing the key map alongside the configuration.
+
+    The map belongs to the content it describes, so a new revision needs a new one; the
+    stored map is replaced by whatever this call carries.
+    """
+
+    structure: dict[str, str] | None = Field(
+        default=None,
+        description="Refreshed map of key path -> one-line description of what lives at that "
+        "leaf, describing the content this call carries. Same form and same 512-character limit "
+        "as on create. Omitting it leaves the new revision without a map, so other agents can no "
+        "longer see the service's shape — resupply it whenever the service had one.",
+    )
+
+    def _type_payload(self) -> dict[str, Any]:
+        """Carry the refreshed map onto the new revision.
+
+        Returns:
+            The ``structure`` entry for the update payload.
+        """
+        return {"structure": self.structure}
+
+
+ServiceActions = Annotated[
+    GetAction
+    | CreateServiceAction
+    | SearchAction
+    | StructureServiceAction
+    | LoadServiceAction
+    | UpdateServiceAction
+    | DeleteAction
+    | ChangeVisibilityAction
+    | ListVersionsAction
+    | SetVersionAction,
+    Field(discriminator="action"),
+]

{digitalkin-1.0.3.dev2 → digitalkin-1.0.4}/src/digitalkin/community/agno/toolkits/registry/services/kit.py

@@ -37,11 +37,17 @@ class ServicesManager(RegistryObjectToolKit):
             name="services_manager",
             actions=ServiceActions,
             description=(
-                "Manage Service SETUPS: create, search, load, update, delete, change_visibility, plus "
-                "list_versions / set_version to inspect the configuration history and undo a bad "
-                "update. The "
-                "action discriminator selects the operation; 'load' returns a service's configuration "
-                "content for use."
+                "Manage Service SETUPS: create, search, structure, load, update, delete, "
+                "change_visibility, plus list_versions / set_version to inspect the configuration "
+                "history and undo a bad update. The action discriminator selects the operation. "
+                "Configurations can be large, so read them in two steps: 'search' returns each "
+                "result with a 'structure' map of key path -> what lives there ('structure' fetches "
+                "the same map for an id you already hold), then 'load' with a key copied verbatim "
+                "from it returns just that part. Copy the key, never invent one: a key the "
+                "configuration does not have quietly returns everything. Load without a key only when "
+                "the whole document is genuinely needed. On create and update you write that map "
+                "yourself, describing what "
+                "each key is for — it is how other agents find their way around the configuration."
             ),
             entrypoint=self.services_manager,
         )

{digitalkin-1.0.3.dev2 → digitalkin-1.0.4}/src/digitalkin/core/job_manager/single_job_manager.py

@@ -186,7 +186,7 @@ class SingleJobManager(BaseJobManager[InputModelT, OutputModelT, SetupModelT]):
         data = output_data.model_dump(mode="json")
 
         # Lock guards only the session validity check; queue.put() runs outside.
-        async with session._write_lock:  # noqa: SLF001
+        async with session._write_lock:  # ruff: ignore[private-member-access]
             if self.tasks_sessions.get(job_id) is None:
                 logger.debug("Queue write rejected - session removed during lock wait", extra={"job_id": job_id})
                 return

{digitalkin-1.0.3.dev2 → digitalkin-1.0.4}/src/digitalkin/core/profiling/task_profiler.py

@@ -55,7 +55,7 @@ class TaskProfiler:
         for stale in candidates[keep_n:]:
             try:
                 stale.unlink()
-            except OSError:  # noqa: PERF203
+            except OSError:  # ruff: ignore[try-except-in-loop]
                 logger.debug("Profiler rotation: could not delete %s", stale)
 
     def start(self) -> None:
@@ -63,7 +63,7 @@ class TaskProfiler:
         if self._mode == ProfilerMode.NONE:
             return
 
-        try:  # noqa: PLW0717
+        try:  # ruff: ignore[too-many-statements-in-try-clause]
             os.makedirs(self._output_dir, exist_ok=True)
 
             if self._mode == ProfilerMode.VIZTRACER:
@@ -100,7 +100,7 @@ class TaskProfiler:
         if self._profiler is None and not self._yappi_started:
             return
 
-        try:  # noqa: PLW0717
+        try:  # ruff: ignore[too-many-statements-in-try-clause]
             timestamp = datetime.datetime.now(datetime.timezone.utc).strftime("%Y%m%dT%H%M%S%f")
             base = f"{self._task_id}_{timestamp}"
 

{digitalkin-1.0.3.dev2 → digitalkin-1.0.4}/src/digitalkin/core/resilience/bulkhead.py

@@ -15,13 +15,12 @@ Usage in ModuleContext or service wrapper::
 from __future__ import annotations
 
 import asyncio
-import os
 from typing import ClassVar
 
 from typing_extensions import Self
 
 from digitalkin.core.exceptions import BulkheadFullError
-from digitalkin.models.settings.resilience import get_bulkhead_settings
+from digitalkin.models.settings.resilience import BulkheadServiceSettings, get_bulkhead_settings
 
 
 class Bulkhead:
@@ -62,10 +61,10 @@ class Bulkhead:
             del cls._instances[oldest]
 
         settings = get_bulkhead_settings()
-        # Per-service override has a dynamic env-var suffix, so it cannot be a
-        # static settings field — read it directly, falling back to the setting.
-        env_max = os.environ.get(f"DIGITALKIN_BULKHEAD_{service_id.upper()}_MAX")
-        max_concurrent = int(env_max) if env_max is not None else settings.default_max
+        # The override carries the service id in the variable name; the settings
+        # class builds that prefix itself, so nothing here touches the environment.
+        override = BulkheadServiceSettings(service_id).max
+        max_concurrent = override if override is not None else settings.default_max
 
         inst = cls(
             service_id=service_id,

{digitalkin-1.0.3.dev2 → digitalkin-1.0.4}/src/digitalkin/core/task_manager/base_task_manager.py

@@ -78,7 +78,7 @@ class BaseTaskManager(ABC):
         session = self.tasks_sessions.get(task_id)
         if session is not None:
             # Close stream under the write lock so pending writes see stream_closed.
-            async with session._write_lock:  # noqa: SLF001
+            async with session._write_lock:  # ruff: ignore[private-member-access]
                 session.close_stream()
 
         session = self.tasks_sessions.pop(task_id, None)

{digitalkin-1.0.3.dev2 → digitalkin-1.0.4}/src/digitalkin/core/task_manager/local_task_manager.py

@@ -49,7 +49,7 @@ class LocalTaskManager(BaseTaskManager):
         """
         await self._acquire_task_slot(coro)
         registered = False
-        try:  # noqa: PLW0717
+        try:  # ruff: ignore[too-many-statements-in-try-clause]
             async with self._tasks_lock:
                 await self._validate_task_creation(task_id, mission_id, coro)
                 session = self._create_session(task_id, mission_id, module)