chore(sdks/python): fix pyright errors from CI on 8d97a64

CI's Python SDK Quality (sandbox) job failed at the pyright step with 10
errors after I ignored that lint in earlier rounds. All on this PR's
new code; tests and ruff are unaffected.

### Three categories

**(1) ``timedelta | None`` not assignable to ``timedelta`` (4 errors)**

The auto-default change in 4e4f12c made ``PoolConfig.acquire_min_remaining_ttl``
declared as ``timedelta | None`` (``None`` means "auto-derive from idle_timeout"
at ``__post_init__``). Even though ``__post_init__`` always resolves it to a
concrete ``timedelta`` via ``object.__setattr__``, pyright can't see through
that, so passing it to the helper functions tripped.

Fix: widen the helper signatures to accept ``timedelta | None`` and treat
``None`` as zero. This matches what ``__post_init__`` would do anyway and
removes the need for ``cast`` at every call site.

**(2) ``_kill_sandbox_best_effort`` returns ``bool`` but reconciler wants
``Callable[[str], None]`` (2 errors)**

In 33ee6f3 ``_kill_sandbox_best_effort`` was changed to return ``bool`` so
``_kill_discarded_alive`` could fire the success debug log only on a confirmed
kill. But the reconciler's ``on_discard_sandbox`` parameter is typed
``Callable[[str], None]``, and ``bool`` is not a subtype of ``None``.

Fix: introduce a thin ``_discard_sandbox_callback`` adapter on both pool
facades that calls ``_kill_sandbox_best_effort`` and drops the return. The
reconciler now receives the adapter; the bool is still available to
``_kill_discarded_alive`` for the success-only log.

**(3) ``getattr(store, ...)`` returns ``object`` (4 errors)**

The Python ``hasattr``-based store-compat shim in ``pool_types.py`` uses
``getattr(store, "try_take_idle_min_ttl", None)``, which pyright types as
``object``. Calling that or awaiting it tripped four errors in the helpers.

Fix: ``cast`` each ``getattr`` result to the actual signature
(``Awaitable[TakeIdleResult]`` / ``Iterable[str] | None`` etc.). Behavior
unchanged at runtime — ``callable(method)`` still gates the call.

### Verification

- ``uv run pyright`` — 0 errors
- ``uv run ruff check`` — clean
- ``uv run pytest`` — 207 passed
- Kotlin ``:sandbox:test`` + ``:sandbox-pool-redis:test`` (real Redis 7) +
  ``spotlessCheck`` — all green

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: asiudgufgbukbsa

sdks/sandbox/python/src/opensandbox/pool_async.py

@@ -370,7 +370,7 @@ async def _run_reconcile_tick(self) -> None:
                     config=self._config.with_max_idle(await self._resolve_max_idle()),
                     state_store=self._state_store,
                     create_one=self._create_one_sandbox,
-                    on_discard_sandbox=self._kill_sandbox_best_effort,
+                    on_discard_sandbox=self._discard_sandbox_callback,
                     reconcile_state=self._reconcile_state,
                 )
             except Exception as exc:
@@ -484,6 +484,13 @@ def _connection_for_pool_resource(self) -> ConnectionConfig:
         config._owns_transport = True
         return config
 
+    async def _discard_sandbox_callback(self, sandbox_id: str) -> None:
+        """``Callable[[str], Awaitable[None]]`` adapter for the reconciler's
+        ``on_discard_sandbox`` hook. Drops the bool return value of
+        :meth:`_kill_sandbox_best_effort`.
+        """
+        await self._kill_sandbox_best_effort(sandbox_id)
+
     async def _kill_sandbox_best_effort(self, sandbox_id: str) -> bool:
         """Best-effort kill a sandbox via the pool's manager.
 

sdks/sandbox/python/src/opensandbox/pool_types.py

@@ -22,7 +22,7 @@
 from datetime import datetime, timedelta
 from enum import Enum
 from math import ceil
-from typing import TYPE_CHECKING, Protocol
+from typing import TYPE_CHECKING, Protocol, cast
 from uuid import uuid4
 
 from opensandbox.config.connection_sync import ConnectionConfigSync
@@ -34,7 +34,7 @@
 )
 
 if TYPE_CHECKING:
-    from collections.abc import Awaitable
+    from collections.abc import Awaitable, Iterable
 
     from opensandbox.config.connection import ConnectionConfig
     from opensandbox.sandbox import Sandbox
@@ -348,53 +348,55 @@ def _require_positive(value: timedelta, message: str) -> None:
 
 
 def try_take_idle_with_min_ttl(
-    store: PoolStateStore, pool_name: str, min_remaining_ttl: timedelta
+    store: PoolStateStore, pool_name: str, min_remaining_ttl: timedelta | None
 ) -> TakeIdleResult:
     """Call ``store.try_take_idle_min_ttl`` if available, else fall back to ``try_take_idle``.
 
     Pool stores added before #983 only implement :meth:`PoolStateStore.try_take_idle`.
     This helper preserves source compatibility for those stores: when the threshold is
-    zero/negative or the store does not implement the variant, the binary-expiry path
-    is used and the returned result has an empty ``discarded_alive_sandbox_ids``.
+    ``None``, zero, or negative — or the store does not implement the variant — the
+    binary-expiry path is used and the returned result has an empty
+    ``discarded_alive_sandbox_ids``.
     """
-    if min_remaining_ttl.total_seconds() <= 0:
+    if min_remaining_ttl is None or min_remaining_ttl.total_seconds() <= 0:
         return TakeIdleResult(sandbox_id=store.try_take_idle(pool_name))
     method = getattr(store, "try_take_idle_min_ttl", None)
     if callable(method):
-        return method(pool_name, min_remaining_ttl)
+        return cast(TakeIdleResult, method(pool_name, min_remaining_ttl))
     return TakeIdleResult(sandbox_id=store.try_take_idle(pool_name))
 
 
 async def try_take_idle_with_min_ttl_async(
-    store: AsyncPoolStateStore, pool_name: str, min_remaining_ttl: timedelta
+    store: AsyncPoolStateStore, pool_name: str, min_remaining_ttl: timedelta | None
 ) -> TakeIdleResult:
     """Async counterpart of :func:`try_take_idle_with_min_ttl`."""
-    if min_remaining_ttl.total_seconds() <= 0:
+    if min_remaining_ttl is None or min_remaining_ttl.total_seconds() <= 0:
         return TakeIdleResult(sandbox_id=await store.try_take_idle(pool_name))
     method = getattr(store, "try_take_idle_min_ttl", None)
     if callable(method):
-        return await method(pool_name, min_remaining_ttl)
+        coro = cast("Awaitable[TakeIdleResult]", method(pool_name, min_remaining_ttl))
+        return await coro
     return TakeIdleResult(sandbox_id=await store.try_take_idle(pool_name))
 
 
 def reap_expired_idle_with_min_ttl(
     store: PoolStateStore,
     pool_name: str,
     now: datetime,
-    min_remaining_ttl: timedelta,
+    min_remaining_ttl: timedelta | None,
 ) -> tuple[str, ...]:
     """Call ``store.reap_expired_idle_min_ttl`` if available, else fall back.
 
     Returns the IDs of alive sandboxes the store dropped because their remaining TTL fell
-    below the threshold, so callers can kill them. Stores predating this method return an
-    empty tuple.
+    below the threshold, so callers can kill them. Stores predating this method, or callers
+    passing ``None`` / zero / negative, get an empty tuple.
     """
-    if min_remaining_ttl.total_seconds() <= 0:
+    if min_remaining_ttl is None or min_remaining_ttl.total_seconds() <= 0:
         store.reap_expired_idle(pool_name, now)
         return ()
     method = getattr(store, "reap_expired_idle_min_ttl", None)
     if callable(method):
-        result = method(pool_name, now, min_remaining_ttl)
+        result = cast("Iterable[str] | None", method(pool_name, now, min_remaining_ttl))
         return tuple(result) if result else ()
     store.reap_expired_idle(pool_name, now)
     return ()
@@ -404,15 +406,18 @@ async def reap_expired_idle_with_min_ttl_async(
     store: AsyncPoolStateStore,
     pool_name: str,
     now: datetime,
-    min_remaining_ttl: timedelta,
+    min_remaining_ttl: timedelta | None,
 ) -> tuple[str, ...]:
     """Async counterpart of :func:`reap_expired_idle_with_min_ttl`."""
-    if min_remaining_ttl.total_seconds() <= 0:
+    if min_remaining_ttl is None or min_remaining_ttl.total_seconds() <= 0:
         await store.reap_expired_idle(pool_name, now)
         return ()
     method = getattr(store, "reap_expired_idle_min_ttl", None)
     if callable(method):
-        result = await method(pool_name, now, min_remaining_ttl)
+        coro = cast(
+            "Awaitable[Iterable[str] | None]", method(pool_name, now, min_remaining_ttl)
+        )
+        result = await coro
         return tuple(result) if result else ()
     await store.reap_expired_idle(pool_name, now)
     return ()

sdks/sandbox/python/src/opensandbox/sync/pool.py

@@ -357,7 +357,7 @@ def _run_reconcile_tick_locked(self, executor: ThreadPoolExecutor) -> None:
                 config=self._config.with_max_idle(self._resolve_max_idle()),
                 state_store=self._state_store,
                 create_one=self._create_one_sandbox,
-                on_discard_sandbox=self._kill_sandbox_best_effort,
+                on_discard_sandbox=self._discard_sandbox_callback,
                 reconcile_state=self._reconcile_state,
                 warmup_executor=executor,
             )
@@ -467,6 +467,14 @@ def _connection_for_pool_resource(self) -> ConnectionConfigSync:
         config._owns_transport = True
         return config
 
+    def _discard_sandbox_callback(self, sandbox_id: str) -> None:
+        """``Callable[[str], None]`` adapter for the reconciler's ``on_discard_sandbox``
+        hook. The reconciler does not care whether the kill succeeded — it only needs the
+        sandbox to be removed from the pool's bookkeeping — so we drop the bool return
+        value here.
+        """
+        self._kill_sandbox_best_effort(sandbox_id)
+
     def _kill_sandbox_best_effort(self, sandbox_id: str) -> bool:
         """Best-effort kill a sandbox via the pool's manager.