digitalkin 1.0.3.dev1__tar.gz → 1.0.4.dev0__tar.gz

{digitalkin-1.0.3.dev1 → digitalkin-1.0.4.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 1.0.3.dev1
+Version: 1.0.4.dev0
 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.dev1
 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.dev1 → digitalkin-1.0.4.dev0}/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.dev1",
         "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.dev1"
+    version = "1.0.4.dev0"
 
     [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.dev1 → digitalkin-1.0.4.dev0}/src/digitalkin/__version__.py

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

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

@@ -136,6 +136,9 @@ class SearchAction(RegistryAction):
                 "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],
+                # The shape of the configuration, so choosing a scope needs no second call:
+                # read a key from here and pass it to ``load``.
+                "structure": setup.structure,
             }
             for setup in usable[:cap]
         ]
@@ -166,6 +169,15 @@ class UpdateAction(RegistryAction):
         "without changing what the instance currently serves, then activate it later with "
         "``set_version``.",
     )
+    structure: dict[str, str] | None = Field(
+        default=None,
+        description="Refreshed map of key path -> one-line summary of what lives at it, "
+        "describing the content this call carries. Same form as on create: summarise what each "
+        'key is FOR, join nested keys with "." (llm.model), bracket-quote a key containing '
+        '. [ ] " or \\ (limits["max.tokens"]), index a list element (tools[0]). Omitting it '
+        "replaces the stored map with one derived from the raw values, losing every written "
+        "summary — supply it whenever the instance had one.",
+    )
 
     async def execute(self, ctx: RegistryActionCtx) -> Any:
         """Cut a new version of the setup's content and rename it.
@@ -184,6 +196,7 @@ class UpdateAction(RegistryAction):
             "name": self.name,
             "content": self.content,
             "set_as_current": self.set_as_current,
+            "structure": self.structure,
         })
 
 

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

@@ -346,7 +346,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.dev1 → digitalkin-1.0.4.dev0}/src/digitalkin/community/agno/toolkits/registry/loader/action.py

@@ -78,7 +78,63 @@ class LoadToolAction(LoadAction):
     action: Literal["tool"] = "tool"
     setup_id: str = Field(..., description="The tool's setup id (from a tools_manager search/get) to load.")
 
-    async def execute(self, ctx: LoadActionCtx) -> LoadOutcome:  # noqa: C901, PLR0911 — each return is a distinct, LLM-readable outcome
+    async def _duplicate_outcome(self, ctx: LoadActionCtx, module_id: str) -> LoadOutcome | None:
+        """Resolve the two "already there" cases, or ``None`` if this is a genuinely new load.
+
+        Runs BEFORE ``resolve_tool``: ``module_id`` is already known from the registry lookup, so
+        a repeat load costs no schema fetch. Reads ``base_tools`` — what is callable right now —
+        which after rehydration also covers a tool loaded on an earlier turn of this mission.
+
+        Args:
+            ctx: The load context carrying the live tool list and the module context.
+            module_id: The requested setup's module, from the registry lookup.
+
+        Returns:
+            An ``already_loaded`` success, a conflict failure, or ``None`` to continue loading.
+        """
+        # Imported here, not at module top: ModuleToolkit requires the optional agno dependency at
+        # import time, while this module must stay importable without it (same convention as the
+        # rest of community.agno).
+        from digitalkin.community.agno.module_toolkit import ModuleToolkit
+
+        loaded = [tool for tool in ctx.base_tools if isinstance(tool, ModuleToolkit)]
+        existing = next((tool for tool in loaded if tool.tool_module_info.setup_id == self.setup_id), None)
+        if existing is not None:
+            # Re-persist rather than just report: the id is only durable if an earlier turn's write
+            # actually landed, and that write is fail-soft. Without this, one failed persist makes
+            # the tool re-loadable forever but never durable — the model keeps getting "already
+            # loaded" and the record never appears. The upsert is a no-op when it did land.
+            # Setup-declared tools are excluded: they need no mission record.
+            if self.setup_id not in ctx.context.tool_cache.declared:
+                await ctx.context.persist_loaded_tool(self.setup_id)
+            info = existing.tool_module_info
+            name = info.tool_name or info.module_name or info.slug
+            # Name the callable functions (they ARE callable right now) so an already-loaded result
+            # is as verifiable as a fresh load, instead of an empty list reading as "nothing to call".
+            callable_names = sorted({*existing.functions, *existing.async_functions})
+            listed = f" You can now call: {', '.join(callable_names)}." if callable_names else ""
+            return LoadOutcome(
+                ok=True,
+                status="already_loaded",
+                tool_name=name,
+                loaded_functions=callable_names,
+                message=f"'{name}' is already loaded; call it directly.{listed}",
+            )
+        # A *different* setup of an already-loaded module cannot rebind — the live binding wins
+        # server-side, so appending it would only add duplicate tool names and confirm a change that
+        # never takes effect. Refuse explicitly instead of lying.
+        conflict = next((tool for tool in loaded if tool.tool_module_info.module_id == module_id), None)
+        if conflict is not None:
+            return LoadOutcome(
+                ok=False,
+                message=(
+                    f"could not load setup {self.setup_id}: its tool module is already loaded via setup "
+                    f"{conflict.tool_module_info.setup_id}, whose configuration stays in effect"
+                ),
+            )
+        return None
+
+    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
@@ -125,7 +181,11 @@ class LoadToolAction(LoadAction):
                 ),
             )
 
-        # Confirmed tool module — resolve it into a callable toolkit.
+        duplicate = await self._duplicate_outcome(ctx, setup.module_id)
+        if duplicate is not None:
+            return duplicate
+
+        # Confirmed tool module, not already loaded — resolve it into a callable toolkit.
         try:
             info = await ctx.context.resolve_tool(self.setup_id)
         except PermissionDeniedError:
@@ -140,42 +200,15 @@ class LoadToolAction(LoadAction):
                 ok=False, message=f"could not load setup {self.setup_id}: this tool module exposes no callable tools"
             )
 
-        # Imported here, not at module top: ModuleToolkit requires the optional agno dependency at
-        # import time, while this module must stay importable without it (same convention as the
-        # rest of community.agno).
         from digitalkin.community.agno.module_toolkit import ModuleToolkit
 
         name = info.tool_name or info.module_name or info.slug
-        loaded = [tool for tool in ctx.base_tools if isinstance(tool, ModuleToolkit)]
-        # Idempotent: re-loading the exact same setup is a no-op success. Still name the callable
-        # functions (they ARE callable right now) so an already-loaded result is as verifiable as a
-        # fresh load, instead of an empty ``loaded_functions`` that reads as "nothing to call".
-        existing = next((tool for tool in loaded if tool.tool_module_info.setup_id == self.setup_id), None)
-        if existing is not None:
-            callable_names = sorted({*existing.functions, *existing.async_functions})
-            listed = f" You can now call: {', '.join(callable_names)}." if callable_names else ""
-            return LoadOutcome(
-                ok=True,
-                status="already_loaded",
-                tool_name=name,
-                loaded_functions=callable_names,
-                message=f"'{name}' is already loaded; call it directly.{listed}",
-            )
-        # A *different* setup of an already-loaded module cannot rebind — the live binding wins
-        # server-side, so appending it would only add duplicate tool names and confirm a change that
-        # never takes effect. Refuse explicitly instead of lying.
-        conflict = next((tool for tool in loaded if tool.tool_module_info.module_id == info.module_id), None)
-        if conflict is not None:
-            return LoadOutcome(
-                ok=False,
-                message=(
-                    f"could not load setup {self.setup_id}: its tool module is already loaded via setup "
-                    f"{conflict.tool_module_info.setup_id}, whose configuration stays in effect"
-                ),
-            )
-
         toolkit = ModuleToolkit(ctx.context, info)
         ctx.base_tools.append(toolkit)
+        # Persist the id so the load outlives this turn. ``resolve_tool`` only reached the
+        # mission-scoped ``dynamic`` cache layer, which is rebuilt from scratch on the next
+        # user message; without this the tool would have to be re-loaded every turn.
+        await ctx.context.persist_loaded_tool(self.setup_id)
         await ctx.notify("tool_loaded", {"setup_id": self.setup_id, "tool_name": name})
         # Name the now-callable functions so the model can verify and call them directly.
         callable_names = sorted({*toolkit.functions, *toolkit.async_functions})

{digitalkin-1.0.3.dev1 → digitalkin-1.0.4.dev0}/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.dev0/src/digitalkin/community/agno/toolkits/registry/services/action.py

@@ -0,0 +1,151 @@
+"""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
+from digitalkin.utils.json_structure import JsonStructure
+
+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.",
+    )
+    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]). Paths that do not exist in '
+        "content are dropped.",
+    )
+
+    async def execute(self, ctx: RegistryActionCtx) -> Any:
+        """Create the service setup from its name, content and authored key map.
+
+        Returns:
+            The created service setup.
+        """
+        return await ctx.setup.create_service_setup(self.name, self.content, 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. Omit to load the whole document — do that only 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. That guard
+        already reads the whole setup, so the key is applied to the content in hand rather
+        than costing a second scoped fetch.
+
+        Returns:
+            The value at ``key``, or the whole configuration JSON object when no key is given.
+
+        Raises:
+            ValueError: ``key`` names a path the configuration does not have.
+        """
+        setup = await ctx.ensure_kind(self.setup_id)
+        content = setup.current_setup_version.content
+        if self.key is None:
+            return content
+        found = JsonStructure.resolve(content, [self.key])
+        if self.key not in found:
+            msg = f"{self.key!r} is not a key of this configuration; copy one from its structure"
+            raise ValueError(msg)
+        return found[self.key]
+
+
+ServiceActions = Annotated[
+    GetAction
+    | CreateServiceAction
+    | SearchAction
+    | StructureServiceAction
+    | LoadServiceAction
+    | UpdateAction
+    | DeleteAction
+    | ChangeVisibilityAction
+    | ListVersionsAction
+    | SetVersionAction,
+    Field(discriminator="action"),
+]

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

@@ -37,11 +37,15 @@ 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. 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.dev1 → digitalkin-1.0.4.dev0}/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.dev1 → digitalkin-1.0.4.dev0}/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.dev1 → digitalkin-1.0.4.dev0}/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.dev1 → digitalkin-1.0.4.dev0}/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)

{digitalkin-1.0.3.dev1 → digitalkin-1.0.4.dev0}/src/digitalkin/core/task_manager/module_runner.py

@@ -43,7 +43,7 @@ class ModuleRunner:
         self._redis_client = redis_client
         self._servicer = servicer
 
-    async def run(  # noqa: C901, PLR0914, PLR0915
+    async def run(  # ruff: ignore[complex-structure, too-many-locals, too-many-statements]
         self,
         query: struct_pb2.Struct,
         *,
@@ -80,11 +80,11 @@ class ModuleRunner:
 
         top_level_keys: list[str] = []
         query_byte_size = 0
-        try:  # noqa: PLW0717
+        try:  # ruff: ignore[too-many-statements-in-try-clause]
             timer.mark("entry")
             profiler.start()
 
-            try:  # noqa: PLW0717
+            try:  # ruff: ignore[too-many-statements-in-try-clause]
                 setup_version = await self._servicer.resolve_setup(setup_id, mission_id)
                 timer.mark("setup_resolve")
 
@@ -93,8 +93,8 @@ class ModuleRunner:
 
                 tool_cache = self._servicer.get_tool_cache(setup_version.setup_id)
                 if tool_cache is None:
-                    registry = self._servicer._get_registry()  # noqa: SLF001
-                    communication = self._servicer._get_communication()  # noqa: SLF001
+                    registry = self._servicer._get_registry()  # ruff: ignore[private-member-access]
+                    communication = self._servicer._get_communication()  # ruff: ignore[private-member-access]
                     if registry is not None and communication is not None:
                         tool_cache = await self._servicer.get_or_build_tool_cache(
                             setup_version.setup_id,
@@ -207,7 +207,7 @@ class ModuleRunner:
 
         except ValidationError as exc:
             input_format_cls = (
-                self._servicer.module_class._extended_input_format  # noqa: SLF001
+                self._servicer.module_class._extended_input_format  # ruff: ignore[private-member-access]
                 or self._servicer.module_class.input_format
             )
             model_name = input_format_cls.__name__ if input_format_cls is not None else "<unknown>"

{digitalkin-1.0.3.dev1 → digitalkin-1.0.4.dev0}/src/digitalkin/core/task_manager/redis/proto_streams.py

@@ -69,7 +69,7 @@ class ProtoStreamReader:
         """Persist the current cursor to Redis."""
         await self._redis_client.set(self._cursor_key, self._last_id, ex=get_gateway_settings().stream.redis_cursor_ttl)
 
-    async def read_structs(  # noqa: C901
+    async def read_structs(  # ruff: ignore[complex-structure]
         self,
         count: int = 50,
         cursor_save_interval: int = 100,

{digitalkin-1.0.3.dev1 → digitalkin-1.0.4.dev0}/src/digitalkin/core/task_manager/redis/redis_client.py

@@ -26,7 +26,7 @@ if TYPE_CHECKING:
     import builtins
 
 
-class RedisClient:  # noqa: PLR0904
+class RedisClient:  # ruff: ignore[too-many-public-methods]
     """Redis connection pool manager with split read/write pools.
 
     Attributes: