digitalkin 1.0.4.dev3__tar.gz → 1.0.4.dev5__tar.gz

{digitalkin-1.0.4.dev3 → digitalkin-1.0.4.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 1.0.4.dev3
+Version: 1.0.4.dev5
 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.dev2
 Requires-Dist: agno<3,>=2.8.0
 Requires-Dist: anyio>=4.13.0
 Requires-Dist: grpcio-health-checking==1.82.1

{digitalkin-1.0.4.dev3 → digitalkin-1.0.4.dev5}/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.dev2",
         "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.4.dev3"
+version = "1.0.4.dev5"
 
     [project.optional-dependencies]
         agno = [ "agno>=2.6" ]

{digitalkin-1.0.4.dev3 → digitalkin-1.0.4.dev5}/src/digitalkin/__version__.py

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

{digitalkin-1.0.4.dev3 → digitalkin-1.0.4.dev5}/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,
+            "documentation": (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.4.dev3 → digitalkin-1.0.4.dev5}/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.4.dev3 → digitalkin-1.0.4.dev5}/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.4.dev3 → digitalkin-1.0.4.dev5}/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.dev5/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.4.dev3 → digitalkin-1.0.4.dev5}/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.4.dev3 → digitalkin-1.0.4.dev5}/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.4.dev3 → digitalkin-1.0.4.dev5}/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.4.dev3 → digitalkin-1.0.4.dev5}/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.4.dev3 → digitalkin-1.0.4.dev5}/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.4.dev3 → digitalkin-1.0.4.dev5}/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.4.dev3 → digitalkin-1.0.4.dev5}/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.4.dev3 → digitalkin-1.0.4.dev5}/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:

{digitalkin-1.0.4.dev3 → digitalkin-1.0.4.dev5}/src/digitalkin/core/task_manager/redis/redis_signal.py

@@ -10,7 +10,7 @@ import uuid
 from typing import TYPE_CHECKING, Any, ClassVar
 
 from digitalkin.core.resilience.task_supervisor import log_unhandled
-from digitalkin.core.task_manager.redis.redis_client import RedisClient  # noqa: TC001
+from digitalkin.core.task_manager.redis.redis_client import RedisClient  # ruff: ignore[typing-only-first-party-import]
 from digitalkin.logger import logger
 from digitalkin.models.settings.redis import get_redis_settings
 
@@ -41,7 +41,7 @@ class SharedRedisListener:
         if key not in cls._instances:
             cls._instances[key] = cls(redis_client)
         inst = cls._instances[key]
-        inst._refcount += 1  # noqa: SLF001
+        inst._refcount += 1  # ruff: ignore[private-member-access]
         return inst
 
     @classmethod
@@ -50,8 +50,8 @@ class SharedRedisListener:
         inst = cls._instances.get(key)
         if inst is None:
             return
-        inst._refcount -= 1  # noqa: SLF001
-        if inst._refcount <= 0:  # noqa: SLF001
+        inst._refcount -= 1  # ruff: ignore[private-member-access]
+        if inst._refcount <= 0:  # ruff: ignore[private-member-access]
             cls._instances.pop(key, None)
             await inst.close()
 
@@ -244,7 +244,7 @@ class SharedRedisListener:
         """Drain PubSub messages; exponential-backoff retry on transient Redis errors."""
         backoff = 0.1
         while not self._stop_event.is_set():
-            try:  # noqa: PLW0717
+            try:  # ruff: ignore[too-many-statements-in-try-clause]
                 if self._pubsub is None:
                     self._pubsub = self._redis_client.pubsub()
                     psub_t0 = time.perf_counter_ns()
@@ -282,7 +282,7 @@ class SharedRedisListener:
                 backoff = min(backoff * 2, 10.0)
 
             now = time.monotonic()
-            if now - self._last_counters_log >= 60.0:  # noqa: PLR2004
+            if now - self._last_counters_log >= 60.0:  # ruff: ignore[magic-value-comparison]
                 c = self._counters
                 logger.debug(
                     "[perf] signal_counters: origin=%s received=%d deduped=%d evicted=%d "

{digitalkin-1.0.4.dev3 → digitalkin-1.0.4.dev5}/src/digitalkin/core/task_manager/redis/redis_state.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 from datetime import datetime, timezone
 from typing import Any
 
-from digitalkin.core.task_manager.redis.redis_client import RedisClient  # noqa: TC001
+from digitalkin.core.task_manager.redis.redis_client import RedisClient  # ruff: ignore[typing-only-first-party-import]
 from digitalkin.logger import logger
 from digitalkin.models.settings.redis import get_redis_settings
 

{digitalkin-1.0.4.dev3 → digitalkin-1.0.4.dev5}/src/digitalkin/core/task_manager/remote_task_manager.py

@@ -39,7 +39,7 @@ class RemoteTaskManager(BaseTaskManager):
         """
         await self._acquire_task_slot(coro)
         registered = False
-        try:  # noqa: PLW0717
+        try:  # ruff: ignore[too-many-statements-in-try-clause]
             # Validate and register session atomically
             async with self._tasks_lock:
                 await self._validate_task_creation(task_id, mission_id, coro)

{digitalkin-1.0.4.dev3 → digitalkin-1.0.4.dev5}/src/digitalkin/core/task_manager/task_executor.py

@@ -28,7 +28,7 @@ class TaskExecutor:
     """
 
     @staticmethod
-    async def execute_task(  # noqa: C901
+    async def execute_task(  # ruff: ignore[complex-structure]
         task_id: str,
         mission_id: str,
         coro: Coroutine[Any, Any, None],
@@ -73,11 +73,11 @@ class TaskExecutor:
                 action = session.pending_signal_action
                 session.pending_signal_action = ""
                 if action == "stop":
-                    await session._handle_stop()  # noqa: SLF001
+                    await session._handle_stop()  # ruff: ignore[private-member-access]
                 else:
                     if session.cancellation_reason == CancellationReason.UNKNOWN:
                         session.cancellation_reason = CancellationReason.SIGNAL_SERVICE_CANCEL
-                    await session._handle_cancel(session.cancellation_reason)  # noqa: SLF001
+                    await session._handle_cancel(session.cancellation_reason)  # ruff: ignore[private-member-access]
                 logger.info("Task cancelled (%s)", session.cancellation_reason.value, extra=ids)
             except Exception as e:
                 await session.set_status("failed")