threadmill 0.8.0__tar.gz → 0.8.1__tar.gz

{threadmill-0.8.0 → threadmill-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: threadmill
-Version: 0.8.0
+Version: 0.8.1
 Summary: The most reliable backend for Django's task framework.
 Keywords: Django,tasks,worker
 Author-email: Johannes Maron <johannes@maron.family>
@@ -179,17 +179,18 @@ uv run manage.py threadmill inspector
 The `RedisTaskBackend` accepts the following options under `OPTIONS` in your
 `TASKS` configuration:
 
-| Option              | Default                   | Description                                                                               |
-| ------------------- | ------------------------- | ----------------------------------------------------------------------------------------- |
-| `lease_ttl`         | `timedelta(hours=1)`      | Max time from acquisition to acknowledgement before the task is retried or marked FAILED. |
-| `result_ttl`        | `timedelta(days=1)`       | How long task results are retained before automatic removal.                              |
-| `broker_interval`   | `timedelta(seconds=1)`    | Interval between background broker maintenance passes.                                    |
-| `batch_size`        | `100`                     | Max tasks to move or reap per broker pass.                                                |
-| `poll_interval`     | `timedelta(seconds=0.01)` | Base wait between idle acquire attempts, doubled after each empty poll.                   |
-| `poll_max_interval` | `timedelta(seconds=1)`    | Max wait between idle acquire attempts.                                                   |
+| Option                     | Default                   | Description                                                                               |
+| -------------------------- | ------------------------- | ----------------------------------------------------------------------------------------- |
+| `lease_ttl`                | `timedelta(hours=1)`      | Max time from acquisition to acknowledgement before the task is retried or marked FAILED. |
+| `result_ttl`               | `timedelta(days=1)`       | How long task results are retained before automatic removal.                              |
+| `broker_interval`          | `timedelta(seconds=1)`    | Interval between background broker maintenance passes.                                    |
+| `batch_size`               | `100`                     | Max tasks to move or reap per broker pass.                                                |
+| `poll_interval`            | `timedelta(seconds=0.01)` | Base wait between idle acquire attempts, doubled after each empty poll.                   |
+| `poll_max_interval`        | `timedelta(seconds=1)`    | Max wait between idle acquire attempts.                                                   |
+| `redis_connection_retries` | `3`                       | Retries per command when its Redis connection fails before the error surfaces.            |
 
 A task whose lease expired reaches the `retry` callback as an
-`AcknowledgementTimeout` error, or is marked FAILED when nothing retries it.
+`AcknowledgementTimeoutError` error, or is marked FAILED when nothing retries it.
 A claimed task whose stored payload cannot be read any more is dropped with the
 read error logged. A dropped task records no result, so it leaves the inspector
 and cannot be requeued.
@@ -226,7 +227,7 @@ import datetime
 from django.tasks import task
 from requests import HTTPError
 
-from threadmill.exceptions import AcknowledgementTimeout
+from threadmill.exceptions import AcknowledgementTimeoutError
 from threadmill.retry import ExponentialBackoff
 
 
@@ -236,7 +237,7 @@ from threadmill.retry import ExponentialBackoff
         max_delay=datetime.timedelta(minutes=5),
         factor=2.0,
         max_retries=5,
-        expected_exceptions=(HTTPError, AcknowledgementTimeout),
+        expected_exceptions=(HTTPError, AcknowledgementTimeoutError),
     )
 )
 def fetch_github_api(url: str): ...

{threadmill-0.8.0 → threadmill-0.8.1}/README.md

@@ -139,17 +139,18 @@ uv run manage.py threadmill inspector
 The `RedisTaskBackend` accepts the following options under `OPTIONS` in your
 `TASKS` configuration:
 
-| Option              | Default                   | Description                                                                               |
-| ------------------- | ------------------------- | ----------------------------------------------------------------------------------------- |
-| `lease_ttl`         | `timedelta(hours=1)`      | Max time from acquisition to acknowledgement before the task is retried or marked FAILED. |
-| `result_ttl`        | `timedelta(days=1)`       | How long task results are retained before automatic removal.                              |
-| `broker_interval`   | `timedelta(seconds=1)`    | Interval between background broker maintenance passes.                                    |
-| `batch_size`        | `100`                     | Max tasks to move or reap per broker pass.                                                |
-| `poll_interval`     | `timedelta(seconds=0.01)` | Base wait between idle acquire attempts, doubled after each empty poll.                   |
-| `poll_max_interval` | `timedelta(seconds=1)`    | Max wait between idle acquire attempts.                                                   |
+| Option                     | Default                   | Description                                                                               |
+| -------------------------- | ------------------------- | ----------------------------------------------------------------------------------------- |
+| `lease_ttl`                | `timedelta(hours=1)`      | Max time from acquisition to acknowledgement before the task is retried or marked FAILED. |
+| `result_ttl`               | `timedelta(days=1)`       | How long task results are retained before automatic removal.                              |
+| `broker_interval`          | `timedelta(seconds=1)`    | Interval between background broker maintenance passes.                                    |
+| `batch_size`               | `100`                     | Max tasks to move or reap per broker pass.                                                |
+| `poll_interval`            | `timedelta(seconds=0.01)` | Base wait between idle acquire attempts, doubled after each empty poll.                   |
+| `poll_max_interval`        | `timedelta(seconds=1)`    | Max wait between idle acquire attempts.                                                   |
+| `redis_connection_retries` | `3`                       | Retries per command when its Redis connection fails before the error surfaces.            |
 
 A task whose lease expired reaches the `retry` callback as an
-`AcknowledgementTimeout` error, or is marked FAILED when nothing retries it.
+`AcknowledgementTimeoutError` error, or is marked FAILED when nothing retries it.
 A claimed task whose stored payload cannot be read any more is dropped with the
 read error logged. A dropped task records no result, so it leaves the inspector
 and cannot be requeued.
@@ -186,7 +187,7 @@ import datetime
 from django.tasks import task
 from requests import HTTPError
 
-from threadmill.exceptions import AcknowledgementTimeout
+from threadmill.exceptions import AcknowledgementTimeoutError
 from threadmill.retry import ExponentialBackoff
 
 
@@ -196,7 +197,7 @@ from threadmill.retry import ExponentialBackoff
         max_delay=datetime.timedelta(minutes=5),
         factor=2.0,
         max_retries=5,
-        expected_exceptions=(HTTPError, AcknowledgementTimeout),
+        expected_exceptions=(HTTPError, AcknowledgementTimeoutError),
     )
 )
 def fetch_github_api(url: str): ...

{threadmill-0.8.0 → threadmill-0.8.1}/pyproject.toml

@@ -72,18 +72,51 @@ module.name = "threadmill"
 
 [tool.ruff]
 src = [ "benchmarks", "tests", "threadmill" ]
-lint.select = [
-  "B",  # flake8-bugbear
-  "C",  # flake8-comprehensions
-  "D",  # pydocstyle
-  "E",  # pycodestyle errors
-  "F",  # pyflakes
-  "I",  # isort
-  "S",  # flake8-bandit
-  "UP", # pyupgrade
-  "W",  # pycodestyle warnings
+lint.extend-select = [
+  "C90",
+  "D",
+  "D213",
+  "DJ",
+  "E",
+  "G",
+  "N",
+  "PERF",
+  "PT",
+  "PTH",
+  "RET",
+  "S",
+  "SIM",
+  "SLOT",
+  "T20",
+  "TRY",
+  "UP",
+  "W",
+]
+lint.ignore = [ "D1", "D203", "D212", "E501", "RUF01" ]
+lint.per-file-ignores."benchmarks/**" = [
+  "DJ006",
+  "DJ007",
+  "DJ008",
+  "PLR2004",
+  "S101",
+  "S105",
+  "S106",
+  "S311",
+  "S603",
+  "S607"
+]
+lint.per-file-ignores."tests/**" = [
+  "DJ006",
+  "DJ007",
+  "DJ008",
+  "PLR2004",
+  "S101",
+  "S105",
+  "S106",
+  "S311",
+  "S603",
+  "S607"
 ]
-lint.ignore = [ "B904", "D1", "E501", "S101" ]
 lint.isort.combine-as-imports = true
 lint.isort.force-wrap-aliases = true
 lint.isort.known-first-party = [ "threadmill", "tests" ]

{threadmill-0.8.0 → threadmill-0.8.1}/threadmill/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.8.0'
-__version_tuple__ = version_tuple = (0, 8, 0)
+__version__ = version = '0.8.1'
+__version_tuple__ = version_tuple = (0, 8, 1)
 
-__commit_id__ = commit_id = 'gd8270af5a'
+__commit_id__ = commit_id = 'g9c8ce3fb9'

{threadmill-0.8.0 → threadmill-0.8.1}/threadmill/backends/base.py

@@ -22,7 +22,8 @@ logger = logging.getLogger(__name__)
 
 @dataclasses.dataclass(frozen=True, slots=True, kw_only=True)
 class RetryTask(Task):
-    """Task with an optional retry callback for backoff scheduling.
+    """
+    Task with an optional retry callback for backoff scheduling.
 
     Usage:
 
@@ -47,6 +48,7 @@ class RetryTask(Task):
             if hasattr(self.retry, "deconstruct"):
                 return self.retry.deconstruct()
             return f"{self.retry.__module__}.{self.retry.__qualname__}"
+        return None
 
     @classmethod
     def _reconstruct(cls, kwargs):
@@ -184,12 +186,11 @@ class TaskResultEncoder(DjangoJSONEncoder):
                 for field in dataclasses.fields(TaskError)
             }
         if isinstance(o, RetryTask):
-            data = {
+            return {
                 field.name: getattr(o, field.name)
                 for field in dataclasses.fields(RetryTask)
                 if field.name not in {"func", "retry"}
             } | {"func": o.module_path, "retry": o.retry_path}
-            return data
         return super().default(o)
 
 
@@ -231,9 +232,11 @@ class ThreadmillTaskBackend(BaseTaskBackend, ABC):
         if task.retry is not None and not (
             is_module_level_function(task.retry) or hasattr(task.retry, "deconstruct")
         ):
-            raise InvalidTask(
-                "Task's retry function must be defined at a module level or be a deconstructible callable."
+            message = (
+                "Task's retry function must be defined at a module level or be a "
+                "deconstructible callable."
             )
+            raise InvalidTask(message)
 
     @staticmethod
     def create_task_error(exception: BaseException) -> TaskError:
@@ -254,6 +257,7 @@ class ThreadmillTaskBackend(BaseTaskBackend, ABC):
                     task_result.id,
                     task_result.task.module_path,
                 )
+        return None
 
     def acquire(
         self,
@@ -290,7 +294,8 @@ class ThreadmillTaskBackend(BaseTaskBackend, ABC):
         raise NotImplementedError
 
     def requeue(self, task_result: TaskResult, run_after: datetime.datetime) -> None:
-        """Re-queue a failed task result for a retry attempt after `run_after`.
+        """
+        Re-queue a failed task result for a retry attempt after `run_after`.
 
         Cleans up any persisted failed result so the method works both for
         in-flight retries (task still running) and inspector-driven requeues
@@ -308,6 +313,10 @@ class ThreadmillTaskBackend(BaseTaskBackend, ABC):
         """
         Yield up to `count` tasks from a queue in the given status segment.
 
+        Pending work comes back in queue order, so the first READY task is the
+        next one a worker picks up. Finished results come back most recently
+        finished first.
+
         Args:
             queue_name: The name of the queue to peek into.
             status: The status of the tasks to yield.
@@ -332,7 +341,8 @@ class ThreadmillTaskBackend(BaseTaskBackend, ABC):
         raise NotImplementedError
 
     def purge(self, queue_name: str) -> None:
-        """Delete every task across all segments of a queue.
+        """
+        Delete every task across all segments of a queue.
 
         Args:
             queue_name: The queue to purge.

{threadmill-0.8.0 → threadmill-0.8.1}/threadmill/backends/redis.py

@@ -14,6 +14,8 @@ from pathlib import Path
 
 import redis
 import redis.asyncio
+import redis.asyncio.retry
+import redis.retry
 from django.tasks import DEFAULT_TASK_QUEUE_NAME, TaskResult, TaskResultStatus
 from django.tasks.exceptions import TaskResultDoesNotExist
 from django.tasks.signals import task_enqueued
@@ -30,7 +32,7 @@ from threadmill.backends.base import (
     ThreadmillTaskBackend,
     ThreadmillTaskResult,
 )
-from threadmill.exceptions import AcknowledgementTimeout
+from threadmill.exceptions import AcknowledgementTimeoutError
 
 logger = logging.getLogger(__name__)
 
@@ -52,7 +54,8 @@ def _parse_lease_started_at(value: str | None) -> datetime.datetime | None:
 
 @dataclasses.dataclass(kw_only=True, slots=True)
 class _IdleBackoff:
-    """Idle polling state for a single worker thread.
+    """
+    Idle polling state for a single worker thread.
 
     Every worker thread backs off and rotates independently, so one thread's
     misses never reset or double another thread's delay. Private, so it is not
@@ -139,7 +142,7 @@ class RedisBroker(Broker):
             errors=[
                 *task_result.errors,
                 self.backend.create_task_error(
-                    AcknowledgementTimeout("Task processing lease expired.")
+                    AcknowledgementTimeoutError("Task processing lease expired.")
                 ),
             ],
         )
@@ -159,17 +162,18 @@ class RedisBroker(Broker):
         for queue_name in self.backend.queues:
             try:
                 self._move_queue(queue_name)
-            except Exception:  # noqa: BLE001
+            except Exception:
                 logger.exception("Mover error for queue %r", queue_name)
 
             try:
                 self._reap_running_queue(queue_name)
-            except Exception:  # noqa: BLE001
+            except Exception:
                 logger.exception("Running reaper error for queue %r", queue_name)
 
 
 class RedisTaskBackend(ThreadmillTaskBackend):
-    """Redis-backed durable priority queue backend.
+    """
+    Redis-backed durable priority queue backend.
 
     Uses sorted sets for priority ordering, a running set for in-flight
     tracking, and a deferred set for scheduled tasks. All multi-step operations
@@ -225,10 +229,19 @@ class RedisTaskBackend(ThreadmillTaskBackend):
         try:
             redis_url = params["REDIS_URL"]
         except KeyError as e:
-            raise ValueError(
-                f"REDIS_URL must be specified in your settings for the {type(self).__name__}."
-            ) from e
-        self.client = redis.from_url(redis_url, decode_responses=True)
+            message = (
+                "REDIS_URL must be specified in your settings for the "
+                f"{type(self).__name__}."
+            )
+            raise ValueError(message) from e
+        self.redis_connection_retries = self.options.get("redis_connection_retries", 3)
+        self.client = redis.from_url(
+            redis_url,
+            decode_responses=True,
+            retry=redis.retry.Retry(
+                redis.default_backoff(), self.redis_connection_retries
+            ),
+        )
         self._async_client: redis.asyncio.Redis | None = None
         self.redis_url = redis_url
         self.key_prefix = f"threadmill:{{{alias}}}"
@@ -262,12 +275,17 @@ class RedisTaskBackend(ThreadmillTaskBackend):
         """Lazily-created async Redis client, reused across calls."""
         if self._async_client is None:
             self._async_client = redis.asyncio.Redis.from_url(
-                self.redis_url, decode_responses=True
+                self.redis_url,
+                decode_responses=True,
+                retry=redis.asyncio.retry.Retry(
+                    redis.default_backoff(), self.redis_connection_retries
+                ),
             )
         return self._async_client
 
     def _compute_score(self, priority: int, enqueued_at: datetime.datetime) -> float:
-        """Compute a ZSET score for priority-ordered FIFO queueing.
+        """
+        Compute a ZSET score for priority-ordered FIFO queueing.
 
         Higher priority (more positive) tasks are popped first. Within the same
         priority, earlier enqueued tasks are popped first.
@@ -281,7 +299,8 @@ class RedisTaskBackend(ThreadmillTaskBackend):
         args: Sequence | None = None,
         kwargs: dict | None = None,
     ) -> TaskResult:
-        """Enqueue a task for execution.
+        """
+        Enqueue a task for execution.
 
         If the task has a run_after datetime, it is stored in the deferred set
         instead of the active priority queue.
@@ -391,9 +410,11 @@ class RedisTaskBackend(ThreadmillTaskBackend):
             try:
                 remaining = deadline - time.monotonic()
             except TypeError:
-                raise queue.Empty("No task available.")
+                message = "No task available."
+                raise queue.Empty(message)
             if remaining <= 0:
-                raise TimeoutError("No task available within the specified timeout.")
+                message = "No task available within the specified timeout."
+                raise TimeoutError(message)
             # Stop doubling once the interval reaches poll_max_interval; larger
             # exponents would only overflow the float math.
             cap = int(self.poll_max_interval / self.poll_interval).bit_length()
@@ -414,7 +435,8 @@ class RedisTaskBackend(ThreadmillTaskBackend):
         lease_started_at: datetime.datetime | None,
         lease_token: str | None,
     ) -> ThreadmillTaskResult:
-        """Return a stored task result as a running attempt.
+        """
+        Return a stored task result as a running attempt.
 
         `worker=None` means the lease records no worker; an empty string still
         counts as an attempt, and a task that already records a start keeps it.
@@ -556,10 +578,6 @@ class RedisTaskBackend(ThreadmillTaskBackend):
     def _peek_tasks(
         self, zset_key: str, count: int, *, leased: bool
     ) -> Generator[TaskResult]:
-        """Yield up to `count` stored tasks in queue order.
-
-        Leased tasks are yielded as their lease reports them.
-        """
         pipe = self.client.pipeline()
         for task_id in self.client.zrange(zset_key, 0, count - 1):
             task_key = self.TASK_KEY.format(prefix=self.key_prefix, task_id=task_id)
@@ -584,9 +602,8 @@ class RedisTaskBackend(ThreadmillTaskBackend):
                 yield self.deserialize_task_result(stored)
 
     def _peek_results(self, zset_key: str, count: int) -> Generator[TaskResult]:
-        """Yield up to `count` finished results in finish order."""
         pipe = self.client.pipeline()
-        for result_id in self.client.zrange(zset_key, 0, count - 1):
+        for result_id in self.client.zrange(zset_key, 0, count - 1, desc=True):
             result_key = self.RESULT_KEY.format(
                 prefix=self.key_prefix, result_id=result_id
             )
@@ -600,7 +617,8 @@ class RedisTaskBackend(ThreadmillTaskBackend):
             self.RESULT_KEY.format(prefix=self.key_prefix, result_id=result_id)
         ):
             return self.deserialize_task_result(data)
-        raise TaskResultDoesNotExist(f"Task result {result_id!r} does not exist.")
+        message = f"Task result {result_id!r} does not exist."
+        raise TaskResultDoesNotExist(message)
 
     async def queue_stats(
         self, *, interval: datetime.timedelta = datetime.timedelta(seconds=60)

{threadmill-0.8.0 → threadmill-0.8.1}/threadmill/exceptions.py

@@ -1,5 +1,5 @@
 """Custom exceptions for the threadmill task framework."""
 
 
-class AcknowledgementTimeout(Exception):
+class AcknowledgementTimeoutError(Exception):
     """Raised when a task's lease has expired before it could be acknowledged."""

{threadmill-0.8.0 → threadmill-0.8.1}/threadmill/executor.py

@@ -101,7 +101,8 @@ def configure_logging(formatter: logging.Formatter) -> None:
 
 
 def warn_when_free_threading_is_unavailable() -> None:
-    """Warn when a free-threaded build runs with the GIL enabled.
+    """
+    Warn when a free-threaded build runs with the GIL enabled.
 
     A C extension that has not declared free-threading support re-enables the GIL
     for the whole process, which silently costs the parallelism the build exists
@@ -150,6 +151,7 @@ class TaskExecutor:
         if self.max_tasks:
             jitter = random.randint(0, self.max_tasks_jitter)  # noqa: S311
             return max((self.max_tasks + jitter) // self.thread_count, 1)
+        return None
 
     def create_worker_process(self) -> WorkerProcess:
         """Create and start a new worker process."""
@@ -325,7 +327,8 @@ class TaskPrefetcher(threading.Thread):
     def run(self) -> None:
         try:
             self.fill_buffer()
-        except Exception as exception:
+        # Prefetcher failures must reach the consumer, and a thread cannot raise.
+        except Exception as exception:  # noqa: BLE001
             self.completion.set_exception(exception)
         finally:
             if not self.completion.done():

{threadmill-0.8.0 → threadmill-0.8.1}/threadmill/inspector/app.py

@@ -163,8 +163,7 @@ class TaskDetail(Static):
             lines.append("[b]Errors:[/b]")
             for error in result.errors:
                 lines.append(f"  {error.exception_class_path}")
-                for line in error.traceback.splitlines():
-                    lines.append(f"    {line}")
+                lines.extend(f"    {line}" for line in error.traceback.splitlines())
         return "\n".join(lines)
 
 
@@ -291,7 +290,7 @@ class TaskList(Vertical):
         if confirmed:
             try:
                 self.backend.requeue(task, datetime.datetime.now(datetime.UTC))
-            except Exception:  # noqa: BLE001
+            except Exception:
                 logger.exception("Requeue failed for task %s", task.id)
                 self.app.notify("Requeue failed.", severity="error")
             else:
@@ -313,7 +312,7 @@ class TaskList(Vertical):
         if confirmed:
             try:
                 self.backend.dequeue(task)
-            except Exception:  # noqa: BLE001
+            except Exception:
                 logger.exception("Delete failed for task %s", task.id)
                 self.app.notify("Delete failed.", severity="error")
             else:
@@ -341,7 +340,7 @@ class TaskList(Vertical):
             self._current_results = list(
                 backend.peek(queue_name=queue_name, status=status, count=100)
             )
-        except Exception:  # noqa: BLE001
+        except Exception:
             logger.exception("Failed to peek tasks for %r", queue_name)
             self._current_results = []
         columns = TAB_COLUMNS[tab_id]
@@ -435,7 +434,7 @@ class QueueList(ListView):
         if confirmed:
             try:
                 self.app.backend.purge(queue_name)
-            except Exception:  # noqa: BLE001
+            except Exception:
                 logger.exception("Purge failed for %r", queue_name)
                 self.app.notify("Purge failed.", severity="error")
             else:
@@ -577,7 +576,7 @@ class InspectorApp(App):
         """Fetch queue counts and merge live pub/sub rates into the telemetry."""
         try:
             telemetry = await self.backend.queue_stats()
-        except Exception:  # noqa: BLE001
+        except Exception:
             logger.exception("Failed to refresh queue stats")
         else:
             for queue_name, stats in telemetry.queues.items():
@@ -617,8 +616,5 @@ class InspectorApp(App):
             pass
         else:
             if stream is not None:
-                try:
-                    async for event in stream:
-                        self.telemetry_buffer.record(event, now=time.monotonic())
-                except asyncio.CancelledError:
-                    raise
+                async for event in stream:
+                    self.telemetry_buffer.record(event, now=time.monotonic())

{threadmill-0.8.0 → threadmill-0.8.1}/threadmill/management/commands/threadmill.py

@@ -18,7 +18,8 @@ from ...executor import JsonFormatter, TaskExecutor
 def kill_softly(signum, frame):
     """Raise a KeyboardInterrupt to stop the worker gracefully."""
     signame = signal.Signals(signum).name
-    raise KeyboardInterrupt(f"Received {signame} ({signum}), shutting down…")
+    message = f"Received {signame} ({signum}), shutting down…"
+    raise KeyboardInterrupt(message)
 
 
 class WorkerCommand(DjangoBaseCommand):
@@ -130,11 +131,11 @@ class WorkerCommand(DjangoBaseCommand):
         try:
             backend = task_backends[backend]
         except InvalidTaskBackend:
-            raise CommandError(f"Invalid backend: {backend!r}")
+            message = f"Invalid backend: {backend!r}"
+            raise CommandError(message)
         if _non_queues := set(queues) - set(backend.queues):
-            raise CommandError(
-                f"Backend does not support all specified queues: {_non_queues!r}"
-            )
+            message = f"Backend does not support all specified queues: {_non_queues!r}"
+            raise CommandError(message)
         try:
             log_formatter = (
                 JsonFormatter() if log_format is None else logging.Formatter(log_format)
@@ -145,9 +146,11 @@ class WorkerCommand(DjangoBaseCommand):
                 )
             )
         except (TypeError, ValueError) as e:
-            raise CommandError(f"Invalid log format: {log_format!r}") from e
+            message = f"Invalid log format: {log_format!r}"
+            raise CommandError(message) from e
         if prefetch_count is not None and prefetch_count < 0:
-            raise CommandError(f"Invalid prefetch count: {prefetch_count!r}")
+            message = f"Invalid prefetch count: {prefetch_count!r}"
+            raise CommandError(message)
         exe = TaskExecutor(
             backend=backend,
             workers=workers,
@@ -187,18 +190,17 @@ class InspectorCommand(DjangoBaseCommand):
             from ...backends.base import ThreadmillTaskBackend
             from ...inspector.app import InspectorApp
         except ImportError:
-            raise CommandError(
-                "Optional dependency missing. Install: threadmill[inspector]"
-            )
+            message = "Optional dependency missing. Install: threadmill[inspector]"
+            raise CommandError(message)
         try:
             backend = task_backends[backend]
         except InvalidTaskBackend as e:
-            raise CommandError(f"Invalid backend: {backend!r}") from e
+            message = f"Invalid backend: {backend!r}"
+            raise CommandError(message) from e
 
         if not isinstance(backend, ThreadmillTaskBackend):
-            raise CommandError(
-                f"Backend {backend.alias!r} does not support inspection."
-            )
+            message = f"Backend {backend.alias!r} does not support inspection."
+            raise CommandError(message)
 
         InspectorApp(backend=backend).run()
 

{threadmill-0.8.0 → threadmill-0.8.1}/threadmill/retry.py

@@ -10,7 +10,8 @@ if typing.TYPE_CHECKING:
 
 @dataclasses.dataclass(frozen=True, slots=True, kw_only=True)
 class ExponentialBackoff:
-    """Delay retries exponentially, capped at ``max_delay`` and limited to ``max_retries`` attempts.
+    """
+    Delay retries exponentially, capped at ``max_delay`` and limited to ``max_retries`` attempts.
 
     Only retry exceptions listed in ``expected_exceptions``.
 
@@ -57,6 +58,7 @@ class ExponentialBackoff:
                 self.max_delay.total_seconds(),
             )
             return datetime.timedelta(seconds=delay_secs)
+        return None
 
     def deconstruct(self):
         return (