digitalkin 1.0.4.dev2__tar.gz → 1.0.4.dev3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 1.0.4.dev2
+Version: 1.0.4.dev3
 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.2.dev2
+Requires-Dist: agentic-mesh-protocol==1.0.1
 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.dev2 → digitalkin-1.0.4.dev3}/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.2.dev2",
+        "agentic-mesh-protocol==1.0.1",
         "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.dev2"
+version = "1.0.4.dev3"
 
     [project.optional-dependencies]
         agno = [ "agno>=2.6" ]
@@ -208,15 +208,15 @@
         ]
 
         ignore = [
-            "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
+            "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
         ]
 
         fixable = [ "ALL" ]
@@ -226,40 +226,40 @@
 
         [tool.ruff.lint.per-file-ignores]
             "tests/**/*.py" = [
-                "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",
+                "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",
             ]
 
         [tool.ruff.lint.pylint]

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

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

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

@@ -23,7 +23,6 @@ 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):
@@ -125,36 +124,23 @@ class SearchAction(RegistryAction):
         # would both contradict ``total_returned`` and, at exactly ``cap`` rows, promise an empty
         # next page.
         truncated = len(usable) > cap
-        rows = [self._row(setup) for setup in 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]
+        ]
         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.
@@ -180,20 +166,6 @@ 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.
@@ -212,10 +184,6 @@ 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.dev2 → digitalkin-1.0.4.dev3}/src/digitalkin/community/agno/toolkits/registry/base.py

@@ -171,23 +171,22 @@ class RegistryAction(BaseAction[RegistryActionCtx], ABC):
 
     writes: ClassVar[bool] = False
 
-    @field_validator("name", "documentation", check_fields=False)
+    @field_validator("name", check_fields=False)
     @classmethod
-    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.
+    def _name_has_no_control_chars(cls, value: str) -> str:
+        """Reject control characters in a user-facing ``name`` so it fails loudly, not silently.
 
-        ``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.
+        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).
 
         Returns:
-            The value unchanged when clean.
+            The name unchanged when clean.
 
         Raises:
-            ValueError: The value carries a control character.
+            ValueError: The name carries a control character.
         """
-        return value if value is None else SetupContentValidator.reject_control_chars(value)
+        return SetupContentValidator.reject_control_chars(value)
 
     @field_validator("content", check_fields=False)
     @classmethod
@@ -347,11 +346,7 @@ 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. 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.
+        lower-case it so the field read back matches the field written.
 
         Args:
             value: A Pydantic model, proto message, or plain scalar/collection.

{digitalkin-1.0.4.dev2 → digitalkin-1.0.4.dev3}/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:  # ruff: ignore[complex-structure, too-many-return-statements] — each return is a distinct, LLM-readable outcome
+    async def execute(self, ctx: LoadActionCtx) -> LoadOutcome:  # noqa: C901, PLR0911 — 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.dev2 → digitalkin-1.0.4.dev3}/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:  # ruff: ignore[unused-method-argument] — schema-only stub, never run
+    async def load_manager(self, action: LoadActions) -> str:  # noqa: ARG002 — 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.dev3/src/digitalkin/community/agno/toolkits/registry/services/action.py

@@ -0,0 +1,92 @@
+"""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;
+- ``load`` — return the service's stored JSON configuration content (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.",
+    )
+
+    async def execute(self, ctx: RegistryActionCtx) -> Any:
+        """Create the service setup from its name and content.
+
+        Returns:
+            The created service setup.
+        """
+        return await ctx.setup.create_service_setup(self.name, self.content)
+
+
+class LoadServiceAction(RegistryAction):
+    """Load a service: return its stored JSON configuration content."""
+
+    action: Literal["load"] = "load"
+    setup_id: str = Field(..., description="The service setup id to load (from a search result).")
+
+    async def execute(self, ctx: RegistryActionCtx) -> Any:
+        """Return the service's configuration content (latest version).
+
+        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.
+
+        Returns:
+            The service configuration JSON object, or ``None`` when not found.
+        """
+        setup = await ctx.ensure_kind(self.setup_id)
+        return setup.current_setup_version.content
+
+
+ServiceActions = Annotated[
+    GetAction
+    | CreateServiceAction
+    | SearchAction
+    | LoadServiceAction
+    | UpdateAction
+    | DeleteAction
+    | ChangeVisibilityAction
+    | ListVersionsAction
+    | SetVersionAction,
+    Field(discriminator="action"),
+]

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

@@ -37,17 +37,11 @@ class ServicesManager(RegistryObjectToolKit):
             name="services_manager",
             actions=ServiceActions,
             description=(
-                "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."
+                "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."
             ),
             entrypoint=self.services_manager,
         )

{digitalkin-1.0.4.dev2 → digitalkin-1.0.4.dev3}/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:  # ruff: ignore[private-member-access]
+        async with session._write_lock:  # noqa: SLF001
             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.dev2 → digitalkin-1.0.4.dev3}/src/digitalkin/core/profiling/task_profiler.py

@@ -55,7 +55,7 @@ class TaskProfiler:
         for stale in candidates[keep_n:]:
             try:
                 stale.unlink()
-            except OSError:  # ruff: ignore[try-except-in-loop]
+            except OSError:  # noqa: PERF203
                 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:  # ruff: ignore[too-many-statements-in-try-clause]
+        try:  # noqa: PLW0717
             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:  # ruff: ignore[too-many-statements-in-try-clause]
+        try:  # noqa: PLW0717
             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.dev2 → digitalkin-1.0.4.dev3}/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.4.dev2 → digitalkin-1.0.4.dev3}/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:  # ruff: ignore[private-member-access]
+            async with session._write_lock:  # noqa: SLF001
                 session.close_stream()
 
         session = self.tasks_sessions.pop(task_id, None)

{digitalkin-1.0.4.dev2 → digitalkin-1.0.4.dev3}/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:  # ruff: ignore[too-many-statements-in-try-clause]
+        try:  # noqa: PLW0717
             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.dev2 → digitalkin-1.0.4.dev3}/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(  # ruff: ignore[complex-structure, too-many-locals, too-many-statements]
+    async def run(  # noqa: C901, PLR0914, PLR0915
         self,
         query: struct_pb2.Struct,
         *,
@@ -80,11 +80,11 @@ class ModuleRunner:
 
         top_level_keys: list[str] = []
         query_byte_size = 0
-        try:  # ruff: ignore[too-many-statements-in-try-clause]
+        try:  # noqa: PLW0717
             timer.mark("entry")
             profiler.start()
 
-            try:  # ruff: ignore[too-many-statements-in-try-clause]
+            try:  # noqa: PLW0717
                 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()  # ruff: ignore[private-member-access]
-                    communication = self._servicer._get_communication()  # ruff: ignore[private-member-access]
+                    registry = self._servicer._get_registry()  # noqa: SLF001
+                    communication = self._servicer._get_communication()  # noqa: SLF001
                     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  # ruff: ignore[private-member-access]
+                self._servicer.module_class._extended_input_format  # noqa: SLF001
                 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.dev2 → digitalkin-1.0.4.dev3}/src/digitalkin/core/task_manager/redis/proto_streams.py

@@ -43,7 +43,7 @@ class ProtoStreamReader:
         """Initialize proto stream reader.
 
         Cursor TTL comes from ``GatewayStreamSettings.redis_cursor_ttl`` (env
-        ``DIGITALKIN_REDIS_CURSOR_TTL``).
+        ``DIGITALKIN_GATEWAY_STREAM_REDIS_CURSOR_TTL``).
 
         Args:
             task_id: Unique task identifier.
@@ -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(  # ruff: ignore[complex-structure]
+    async def read_structs(  # noqa: C901
         self,
         count: int = 50,
         cursor_save_interval: int = 100,

{digitalkin-1.0.4.dev2 → digitalkin-1.0.4.dev3}/src/digitalkin/core/task_manager/redis/redis_client.py

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

{digitalkin-1.0.4.dev2 → digitalkin-1.0.4.dev3}/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  # ruff: ignore[typing-only-first-party-import]
+from digitalkin.core.task_manager.redis.redis_client import RedisClient  # noqa: TC001
 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  # ruff: ignore[private-member-access]
+        inst._refcount += 1  # noqa: SLF001
         return inst
 
     @classmethod
@@ -50,8 +50,8 @@ class SharedRedisListener:
         inst = cls._instances.get(key)
         if inst is None:
             return
-        inst._refcount -= 1  # ruff: ignore[private-member-access]
-        if inst._refcount <= 0:  # ruff: ignore[private-member-access]
+        inst._refcount -= 1  # noqa: SLF001
+        if inst._refcount <= 0:  # noqa: SLF001
             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:  # ruff: ignore[too-many-statements-in-try-clause]
+            try:  # noqa: PLW0717
                 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:  # ruff: ignore[magic-value-comparison]
+            if now - self._last_counters_log >= 60.0:  # noqa: PLR2004
                 c = self._counters
                 logger.debug(
                     "[perf] signal_counters: origin=%s received=%d deduped=%d evicted=%d "

{digitalkin-1.0.4.dev2 → digitalkin-1.0.4.dev3}/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  # ruff: ignore[typing-only-first-party-import]
+from digitalkin.core.task_manager.redis.redis_client import RedisClient  # noqa: TC001
 from digitalkin.logger import logger
 from digitalkin.models.settings.redis import get_redis_settings
 

{digitalkin-1.0.4.dev2 → digitalkin-1.0.4.dev3}/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:  # ruff: ignore[too-many-statements-in-try-clause]
+        try:  # noqa: PLW0717
             # Validate and register session atomically
             async with self._tasks_lock:
                 await self._validate_task_creation(task_id, mission_id, coro)