processes 3.0.1__tar.gz → 3.1.0__tar.gz

{processes-3.0.1 → processes-3.1.0}/.github/workflows/docs.yml

@@ -20,8 +20,8 @@ jobs:
   deploy:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: astral-sh/setup-uv@v5
+      - uses: actions/checkout@v6
+      - uses: astral-sh/setup-uv@v6
       - name: Install dependencies
         run: uv sync --all-groups
       - name: Build and Deploy

{processes-3.0.1 → processes-3.1.0}/.github/workflows/lint.yml

@@ -14,10 +14,10 @@ jobs:
   lint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
         with:
           enable-cache: true # Speeds up future runs
 

{processes-3.0.1 → processes-3.1.0}/.github/workflows/mypy.yml

@@ -14,10 +14,10 @@ jobs:
   lint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
         with:
           enable-cache: true # Speeds up future runs
 

{processes-3.0.1 → processes-3.1.0}/.github/workflows/publish.yml

@@ -8,9 +8,9 @@ jobs:
   quality-gate:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - name: Install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
 
       - name: Install dependencies
         run: uv sync --all-extras --dev
@@ -33,9 +33,9 @@ jobs:
       contents: read
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - name: Install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
 
       - name: Build package
         run: uv build

{processes-3.0.1 → processes-3.1.0}/.github/workflows/tags.yml

@@ -15,10 +15,10 @@ jobs:
 
     steps:
       - name: Checkout Code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
         with:
           enable-cache: true
 

{processes-3.0.1 → processes-3.1.0}/.github/workflows/tests.yml

@@ -16,10 +16,10 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
         with:
           version: "latest"
           enable-cache: true

{processes-3.0.1 → processes-3.1.0}/CHANGELOG.md

@@ -1,3 +1,15 @@
+## v3.1.0 (2026-06-13)
+
+### Feat
+
+- **logging**: include failure context in task logfiles
+
+### Refactor
+
+- extract typed _ErrorData from task_context via shared base formatter
+- inline single-use _task_context_lines helper
+- move task logfile formatting out of _email_internals
+
 ## v3.0.1 (2026-06-13)
 
 ### Refactor

{processes-3.0.1 → processes-3.1.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: processes
-Version: 3.0.1
-Summary: A Python library for managing and executing dependent tasks in parallel or sequential order with automatic dependency resolution and topological sorting
+Version: 3.1.0
+Summary: Orchestrate graphs of callables in Python with automatic dependency resolution, parallel execution, retries, timeouts, and HTML email alerts on failure — zero dependencies
 Project-URL: Homepage, https://github.com/oliverm91/processes
 Project-URL: Documentation, https://oliverm91.github.io/processes/
 Project-URL: Repository, https://github.com/oliverm91/processes
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 

processes-3.1.0/RELEASE_NOTES.md

@@ -0,0 +1,36 @@
+# v3.0.1 — Email API Overhaul, Task Retries & Timeouts
+
+## ⚠️ Breaking Changes
+
+- **Removed `HTMLSMTPHandler` and `html_mail_handler`**. Email alerting is now configured with two plain dataclasses passed to `Task`:
+  - `SMTPConfig` — SMTP transport settings (host, credentials, sender/recipients, TLS).
+  - `HTMLEmailStyle` — presentation settings (style, color palette, language, traced-vars frame filter).
+
+  ```python
+  Task(..., smtp_config=SMTPConfig(...), email_style=HTMLEmailStyle(style="modern", palette="catppuccin"))
+  ```
+
+## ✨ New Features
+
+- **Per-task timeouts**: `Task(..., timeout=30)` raises `TimeoutError` if an attempt exceeds the limit.
+- **Automatic retries**: `Task(..., retries=3, retry_on=(ConnectionError, TimeoutError))` retries failed attempts on the specified exception types (defaults to `ConnectionError`/`TimeoutError`).
+- **Structured exceptions**: `DependencyNotFoundError`, `TaskNotFoundError`, and `CircularDependencyError` now carry structured attributes (`task_name`, `missing_dep`) instead of plain messages.
+- **Traced variables in error emails**: failure emails include a "Traced Variables" section showing local variables at the relevant stack frame, with a configurable `traced_vars_frame_filter` to target a specific module.
+
+## 🔧 Refactoring
+
+- Centralized failure-context extraction: `Task._resolve_args` and `Task._build_failure_context` cleanly separate dependency-result injection from failure reporting.
+- Split traceback/frame-walking utilities (`_tb_utils.py`) from email-rendering internals (`_email_internals.py`) — each module now has a single responsibility.
+- Each `Task` now gets a unique per-instance logger, preventing handler leakage between tasks with the same name.
+- Minor cleanups in `Process`: bare `raise` for re-raised exceptions, extracted `_is_done()` helper for the parallel runner loop.
+
+## 🐛 Bug Fixes
+
+- Fixed a logging bug where `logger.exception(...)` was called outside an `except` block, resulting in empty exception details (`None`) in failure emails. Errors now log with full `exc_info` and a structured `task_context` payload.
+- Fixed `Task.run()` not reporting the actual exception when retries were exhausted.
+
+## 🧪 Testing & CI
+
+- Migrated the test suite to a shared `BaseTest` base class with consistent per-test log directories and cleanup.
+- Added dedicated tests for timeout and retry behavior.
+- Bumped GitHub Actions (`actions/checkout` → v6, `astral-sh/setup-uv` → v6) to silence deprecation warnings.

{processes-3.0.1 → processes-3.1.0}/docs/examples/advanced.md

@@ -217,4 +217,41 @@ style = HTMLEmailStyle(
 )
 
 t = Task("task_name", "logfile", func_to_run, smtp_config=smtp, email_style=style)
-```
+```
+
+## ⏱️ Retries & Timeouts
+
+Two `Task` constructor arguments make individual steps more resilient to
+transient failures, without any extra wiring:
+
+- **`timeout`** — seconds allowed for a single attempt. If `func` doesn't
+  return in time, a `TimeoutError` is raised for that attempt. `None`
+  (the default) means no limit. When a timeout fires, the underlying
+  thread is detached rather than killed — a Python threading limitation.
+- **`retries`** — additional attempts after the first failure. `0` or
+  `None` (the default) means a single attempt with no retry.
+- **`retry_on`** — tuple of exception types that trigger a retry. Only
+  evaluated when `retries >= 1`. When `None`, defaults at call time to
+  `(ConnectionError, TimeoutError)`.
+
+```python
+from processes import Task
+
+def call_flaky_api() -> dict:
+    """May raise ConnectionError on a bad network blip."""
+    ...
+
+t_fetch = Task(
+    "fetch_remote_data",
+    "logs/fetch.log",
+    call_flaky_api,
+    timeout=5,                              # give up an attempt after 5s
+    retries=3,                              # up to 3 extra attempts (4 total)
+    retry_on=(ConnectionError, TimeoutError),  # retry on these exceptions only
+)
+```
+
+If every attempt fails, the task is marked failed with the **last**
+exception raised — `retries` only controls how many times `func` is
+retried, not whether the failure is eventually reported. Combine with
+`smtp_config` to be paged only once all attempts are exhausted.

{processes-3.0.1 → processes-3.1.0}/docs/index.md

@@ -71,16 +71,20 @@ Define your tasks and their dependencies. **Processes** will handle the executio
 ```python
 from datetime import date
 
-from processes import Process, Task, TaskDependency, HTMLSMTPHandler
+from processes import Process, Task, TaskDependency, SMTPConfig, HTMLEmailStyle
 
 # 1. Setup Email Alerts (Optional)
-smtp_handler = HTMLSMTPHandler(
-    ('smtp_server', 587), 'sender@example.com', ['admin@example.com', 'user@example.com'],
+smtp_config = SMTPConfig(
+    mailhost=('smtp_server', 587),
+    fromaddr='sender@example.com',
+    toaddrs=['admin@example.com', 'user@example.com'],
     credentials=('user', 'pass'),
     secure=(),                       # () = STARTTLS; omit for no encryption
-    email_style='modern',            # classic | modern | compact
-    color_palette='neutral',         # neutral | catppuccin | neobones | slate
-    email_language='en',             # en | es | pt | fr | de | it
+)
+email_style = HTMLEmailStyle(
+    style='modern',                  # classic | modern | compact
+    palette='neutral',                # neutral | catppuccin | neobones | slate
+    language='en',                    # en | es | pt | fr | de | it
 )
 
 # 2. If necessary, create wrappers for your Tasks.
@@ -96,7 +100,7 @@ def sum_data_from_csv_and_x(x, a=1, b=2):
 # 3. Create the Task Graph (order is irrelevant, that is handled by Process)
 tasks = [
     Task("t-1", "etl.log", get_previous_working_day),
-    Task("intependent", "indep.log", indep_task, html_mail_handler=smtp_handler),  # This task will send email on failure
+    Task("intependent", "indep.log", indep_task, smtp_config=smtp_config, email_style=email_style),  # This task will send email on failure
     Task("sum_csv", "etl.log", search_and_sum_csv,
             dependencies= [
                 TaskDependency("t-1",
@@ -123,36 +127,48 @@ with Process(tasks) as process: # Context Manager ensures correct disposal of lo
 
 ## 📧 Customizing the HTML email
 
-When a task with an `HTMLSMTPHandler` raises, the alert is a **styled HTML
+When a task with an `smtp_config` raises, the alert is a **styled HTML
 email** built from a bundled template. The body includes the exception,
 the traceback (with the user-frame highlighted), the task context, the
 list of downstream tasks that were skipped because of the failure, and
 the local variables at the failing frame (see [Traced Variables](#traced-variables) below).
 
-Four keyword-only arguments on `HTMLSMTPHandler` control the look, the language, and which frame's locals appear in the email body:
+Email delivery and presentation are configured with two separate dataclasses:
+
+- **`SMTPConfig`** — transport settings (host, credentials, sender/recipients, TLS).
+- **`HTMLEmailStyle`** — presentation settings, all optional:
 
-| Argument | Values | Default |
+| Field | Values | Default |
 |---|---|---|
-| `email_style` | `classic`, `modern`, `compact` | `modern` |
-| `color_palette` | `neutral`, `catppuccin`, `neobones`, `slate` | `neutral` |
-| `email_language` | `en`, `es`, `pt`, `fr`, `de`, `it` | `en` |
-| `last_path_traced_vars` | any path substring, or `None` | `None` (outermost user frame) |
+| `style` | `classic`, `modern`, `compact` | `modern` |
+| `palette` | `neutral`, `catppuccin`, `neobones`, `slate` | `neutral` |
+| `language` | `en`, `es`, `pt`, `fr`, `de`, `it` | `en` |
+| `traced_vars_frame_filter` | any path substring, or `None` | `None` (outermost user frame) |
 
 ```python
-from processes import HTMLSMTPHandler
+from processes import SMTPConfig, HTMLEmailStyle, Task
 
-smtp = HTMLSMTPHandler(
+smtp = SMTPConfig(
     mailhost=("smtp.example.com", 587),
     fromaddr="alerts@example.com",
     toaddrs=["oncall@example.com"],
     credentials=("user", "pass"),
     secure=(),                          # () = STARTTLS; omit for no encryption
-    email_style="compact",              # classic | modern | compact
-    color_palette="catppuccin",         # neutral | catppuccin | neobones | slate
-    email_language="es",                # en | es | pt | fr | de | it
 )
+
+style = HTMLEmailStyle(
+    style="compact",                    # classic | modern | compact
+    palette="catppuccin",               # neutral | catppuccin | neobones | slate
+    language="es",                      # en | es | pt | fr | de | it
+)
+
+t = Task("task_name", "logfile", func_to_run, smtp_config=smtp, email_style=style)
 ```
 
+If `smtp_config` is set and `email_style` is omitted, `HTMLEmailStyle()` defaults
+(modern, neutral, English) are used. If `smtp_config` is `None`, `email_style` is ignored
+and no email handler is attached.
+
 All assets ship inside the wheel — the styles are Jinja-style HTML
 templates at `src/processes/themes/styles/` and the palettes are CSS
 fragments at `src/processes/themes/palettes/`. No template engine or

{processes-3.0.1 → processes-3.1.0}/mkdocs.yml

@@ -46,6 +46,16 @@ plugins:
       handlers:
         python:
           paths: [src]
+          options:
+            docstring_style: numpy
+            show_source: true
+            show_root_heading: true
+            show_root_full_path: false
+            heading_level: 2
+            members_order: source
+            separate_signature: true
+            show_signature_annotations: true
+            merge_init_into_class: true
   - social:
       cards_layout: default/variant
       cards_layout_options:

{processes-3.0.1 → processes-3.1.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 [project]
 name = "processes"
 dynamic = ["version"]
-description = "A Python library for managing and executing dependent tasks in parallel or sequential order with automatic dependency resolution and topological sorting"
+description = "Orchestrate graphs of callables in Python with automatic dependency resolution, parallel execution, retries, timeouts, and HTML email alerts on failure — zero dependencies"
 readme = "README.md"
 requires-python = ">=3.10"
 license = "MIT"
@@ -22,6 +22,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
+    "Typing :: Typed",
 ]
 
 dependencies = []
@@ -45,10 +46,9 @@ packages = ["src/processes"]
 
 [tool.commitizen]
 name = "cz_conventional_commits"
-version_provider = "scm" 
+version_provider = "scm"
 tag_format = "v$version"
 update_map_description = true
-version_files = ["pyproject.toml:version"]
 update_changelog_on_bump = true
 
 [tool.mypy]

{processes-3.0.1 → processes-3.1.0}/src/processes/_email_internals.py

@@ -10,6 +10,7 @@ from email.mime.text import MIMEText
 from email.utils import formatdate
 from typing import cast
 
+from ._error_data import _ErrorContextFormatter
 from .email_config import HTMLEmailStyle, SMTPConfig
 
 _THEMES_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "themes")
@@ -27,7 +28,7 @@ def _load_language_strings(language: str) -> dict[str, str]:
         return cast(dict[str, str], json.load(fh))
 
 
-class _HTMLEmailFormatter(logging.Formatter):
+class _HTMLEmailFormatter(_ErrorContextFormatter):
     """Pure renderer: reads all error context from ``record.task_context`` and
     fills the HTML template.  No exception-info parsing or frame walking here.
     """
@@ -83,37 +84,31 @@ class _HTMLEmailFormatter(logging.Formatter):
 
     def format(self, record: logging.LogRecord) -> str:
         """Render a log record as a complete HTML email body."""
-        ctx = getattr(record, "task_context", None) or {}
-
-        exception = ctx.get("exception", record.getMessage())
-        tb_str = ctx.get("traceback_str", "")
-        traced_vars = ctx.get("traced_vars", "")
-        traced_vars_location = ctx.get("traced_vars_location", "")
+        error = self._error_data(record)
 
         tb_before, tb_highlight, tb_after = self._split_traceback_at_target(
-            tb_str, traced_vars_location
+            error.traceback_str, error.traced_vars_location
         )
 
-        downstream = ctx.get("downstream_impact", []) or []
         downstream_items = "".join(
-            f"<li>{html.escape(str(name), quote=True)}</li>" for name in downstream
+            f"<li>{html.escape(str(name), quote=True)}</li>" for name in error.downstream_impact
         )
 
         substitutions = dict(_load_language_strings(self._email_language))
         substitutions["lang_traced_vars_blurb"] = substitutions.get(
             "lang_traced_vars_blurb", ""
-        ).replace("{location}", traced_vars_location)
+        ).replace("{location}", error.traced_vars_location)
         substitutions.update(
             {
-                "task_name": html.escape(str(ctx.get("task_name", "?")), quote=True),
-                "function": html.escape(str(ctx.get("function", "?")), quote=True),
-                "args": html.escape(repr(ctx.get("args", ())), quote=True),
-                "kwargs": html.escape(repr(ctx.get("kwargs", {})), quote=True),
-                "exception": html.escape(exception, quote=True),
+                "task_name": html.escape(error.task_name, quote=True),
+                "function": html.escape(error.function, quote=True),
+                "args": html.escape(repr(error.args), quote=True),
+                "kwargs": html.escape(repr(error.kwargs), quote=True),
+                "exception": html.escape(error.exception, quote=True),
                 "traceback_before": html.escape(tb_before, quote=True),
                 "traceback_highlight": html.escape(tb_highlight, quote=True),
                 "traceback_after": html.escape(tb_after, quote=True),
-                "traced_vars": traced_vars,
+                "traced_vars": error.traced_vars,
                 "downstream_items": downstream_items,
             }
         )

processes-3.1.0/src/processes/_error_data.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(frozen=True)
+class _ErrorData:
+    """Typed view of a task failure, extracted from ``record.task_context``."""
+
+    task_name: str = "?"
+    function: str = "?"
+    args: tuple[Any, ...] = ()
+    kwargs: dict[str, Any] = field(default_factory=dict)
+    downstream_impact: list[str] = field(default_factory=list)
+    exception: str = ""
+    traceback_str: str = ""
+    traced_vars: str = ""
+    traced_vars_location: str = ""
+
+
+class _ErrorContextFormatter(logging.Formatter):
+    """Base formatter providing typed access to a record's failure context."""
+
+    def _error_data(self, record: logging.LogRecord) -> _ErrorData:
+        ctx = getattr(record, "task_context", None) or {}
+        return _ErrorData(
+            task_name=str(ctx.get("task_name", "?")),
+            function=str(ctx.get("function", "?")),
+            args=ctx.get("args", ()),
+            kwargs=ctx.get("kwargs", {}),
+            downstream_impact=ctx.get("downstream_impact", []) or [],
+            exception=ctx.get("exception", record.getMessage()),
+            traceback_str=ctx.get("traceback_str", ""),
+            traced_vars=ctx.get("traced_vars", ""),
+            traced_vars_location=ctx.get("traced_vars_location", ""),
+        )

processes-3.1.0/src/processes/_log_formatting.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import logging
+
+from ._error_data import _ErrorContextFormatter
+
+_LOG_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+
+
+class _TaskLogFormatter(_ErrorContextFormatter):
+    """Plain-text formatter for task logfiles.
+
+    On failure, appends the same failure context shown in the HTML email
+    (function, args, kwargs, downstream impact, traced-vars location,
+    traceback) as readable text.
+    """
+
+    def __init__(self) -> None:
+        super().__init__(_LOG_FORMAT)
+
+    def format(self, record: logging.LogRecord) -> str:
+        if not getattr(record, "task_context", None):
+            return super().format(record)
+
+        exc_info, record.exc_info = record.exc_info, None
+        try:
+            base = super().format(record)
+        finally:
+            record.exc_info = exc_info
+
+        error = self._error_data(record)
+        lines = [
+            base,
+            "",
+            f"Function: {error.function}",
+            f"Args: {error.args!r}",
+            f"Kwargs: {error.kwargs!r}",
+            f"Downstream impact: {', '.join(error.downstream_impact) or '-'}",
+            f"Traced vars location: {error.traced_vars_location or '-'}",
+        ]
+        if error.traceback_str:
+            lines.append("")
+            lines.append(error.traceback_str.rstrip("\n"))
+        return "\n".join(lines)

{processes-3.0.1 → processes-3.1.0}/src/processes/email_config.py

@@ -37,13 +37,7 @@ class SMTPConfig:
     fromaddr: str
     toaddrs: list[str]
     credentials: tuple[str, str] | None = None
-    secure: (
-        tuple[()]
-        | tuple[str]
-        | tuple[str, str]
-        | tuple[str, str, ssl.SSLContext]
-        | None
-    ) = None
+    secure: tuple[()] | tuple[str] | tuple[str, str] | tuple[str, str, ssl.SSLContext] | None = None
     timeout: int = 5
 
 
@@ -79,9 +73,7 @@ class HTMLEmailStyle:
 
     def __post_init__(self) -> None:
         if self.style not in _VALID_STYLES:
-            raise ValueError(
-                f"style must be one of {sorted(_VALID_STYLES)}, got {self.style!r}"
-            )
+            raise ValueError(f"style must be one of {sorted(_VALID_STYLES)}, got {self.style!r}")
         if self.palette not in _VALID_PALETTES:
             raise ValueError(
                 f"palette must be one of {sorted(_VALID_PALETTES)}, got {self.palette!r}"

{processes-3.0.1 → processes-3.1.0}/src/processes/task.py

@@ -10,6 +10,7 @@ if TYPE_CHECKING:
 import logging
 
 from ._email_internals import _build_task_email_handler
+from ._log_formatting import _TaskLogFormatter
 from ._tb_utils import _build_traced_vars_html, _build_traced_vars_location, _format_traceback
 from .email_config import HTMLEmailStyle, SMTPConfig
 from .exceptions import CircularDependencyError
@@ -243,17 +244,14 @@ class Task:
                 raise ValueError(f"Duplicate dependency name: {dependency.task_name}")
             depedencies_names.append(dependency.task_name)
             if dependency.task_name == self.name:
-                raise CircularDependencyError(
-                    f"Task '{self.name}' lists itself as a dependency."
-                )
+                raise CircularDependencyError(f"Task '{self.name}' lists itself as a dependency.")
 
         logger = logging.getLogger(f"processes.{self.name}.{id(self)}")
         logger.setLevel(logging.DEBUG)
 
         file_handler = logging.FileHandler(self.log_path)
         file_handler.setLevel(logging.INFO)
-        formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-        file_handler.setFormatter(formatter)
+        file_handler.setFormatter(_TaskLogFormatter())
         logger.addHandler(file_handler)
 
         if smtp_config is not None:
@@ -288,13 +286,9 @@ class Task:
             raise TypeError(f"kwargs must be dict. Got {type(self.kwargs)}")
 
         if smtp_config is not None and not isinstance(smtp_config, SMTPConfig):
-            raise TypeError(
-                f"smtp_config must be of type SMTPConfig. Got {type(smtp_config)}"
-            )
+            raise TypeError(f"smtp_config must be of type SMTPConfig. Got {type(smtp_config)}")
         if email_style is not None and not isinstance(email_style, HTMLEmailStyle):
-            raise TypeError(
-                f"email_style must be of type HTMLEmailStyle. Got {type(email_style)}"
-            )
+            raise TypeError(f"email_style must be of type HTMLEmailStyle. Got {type(email_style)}")
 
         if not isinstance(self.dependencies, list):
             raise TypeError(f"dependencies must be list. Got {type(self.dependencies)}")
@@ -308,20 +302,14 @@ class Task:
         if self.timeout is not None and (
             not isinstance(self.timeout, (int, float)) or self.timeout <= 0
         ):
-            raise TypeError(
-                f"timeout must be a positive number or None, got {self.timeout!r}"
-            )
+            raise TypeError(f"timeout must be a positive number or None, got {self.timeout!r}")
         if not isinstance(self.retries, int) or self.retries < 0:
-            raise TypeError(
-                f"retries must be a non-negative int, got {self.retries!r}"
-            )
+            raise TypeError(f"retries must be a non-negative int, got {self.retries!r}")
         if self.retry_on is not None and (
             not isinstance(self.retry_on, tuple)
             or not all(isinstance(e, type) and issubclass(e, Exception) for e in self.retry_on)
         ):
-            raise TypeError(
-                "retry_on must be None or a tuple of Exception subclasses"
-            )
+            raise TypeError("retry_on must be None or a tuple of Exception subclasses")
 
     def get_dependencies_names(self) -> set[str]:
         """
@@ -352,9 +340,7 @@ class Task:
         finally:
             executor.shutdown(wait=False)
 
-    def _resolve_args(
-        self, executing_process: Process | None
-    ) -> tuple[list[Any], dict[str, Any]]:
+    def _resolve_args(self, executing_process: Process | None) -> tuple[list[Any], dict[str, Any]]:
         """Inject upstream dependency results into args/kwargs."""
         final_args = list(self.args)
         final_kwargs = self.kwargs.copy()
@@ -373,7 +359,8 @@ class Task:
         """Build the structured failure payload passed to every log handler."""
         downstream_names: list[str] = (
             [d.name for d in executing_process.get_dependant_tasks(self.name)]
-            if executing_process is not None else []
+            if executing_process is not None
+            else []
         )
         exc_tb = exc.__traceback__
         return {

{processes-3.0.1 → processes-3.1.0}/tests/manual_tests/manual_themed_tracebacks.py

@@ -156,9 +156,7 @@ def _log_path(logs_dir: str, name: str) -> str:
     return os.path.join(logs_dir, f"{name}.log")
 
 
-def build_tasks(
-    logs_dir: str, smtp: SMTPConfig, style: HTMLEmailStyle
-) -> list[Task]:
+def build_tasks(logs_dir: str, smtp: SMTPConfig, style: HTMLEmailStyle) -> list[Task]:
     dep = TaskDependency
     return [
         Task(

{processes-3.0.1 → processes-3.1.0}/tests/test_complex_dag_failures.py

@@ -152,8 +152,7 @@ class TestComplexDagFailures(BaseTest):
             f"got {result.errored_tasks}"
         )
         assert result.skipped_tasks == skipped_task_names, (
-            f"skipped_tasks should be the three cascade-skipped tasks, "
-            f"got {result.skipped_tasks}"
+            f"skipped_tasks should be the three cascade-skipped tasks, got {result.skipped_tasks}"
         )
         assert result.errored_tasks.isdisjoint(result.skipped_tasks), (
             "errored_tasks and skipped_tasks must be disjoint"
@@ -208,9 +207,7 @@ class TestComplexDagFailures(BaseTest):
             assert ctx["args"] == ()
             assert ctx["kwargs"] == {}
             assert isinstance(ctx["downstream_impact"], list)
-            expected_downstream = {
-                n for n in skipped_task_names if name in _ancestors_of(n, tasks)
-            }
+            expected_downstream = {n for n in skipped_task_names if name in _ancestors_of(n, tasks)}
             assert set(ctx["downstream_impact"]) == expected_downstream
 
             serialized = repr(ctx)

{processes-3.0.1 → processes-3.1.0}/tests/test_email_themes.py

@@ -166,9 +166,7 @@ class TestEmailRendering(BaseTest):
                     formatter = _HTMLEmailFormatter(
                         HTMLEmailStyle(style=style, palette=palette, language=language)
                     )
-                    output = formatter.format(
-                        _make_record(f"task_{language}_{style}_{palette}")
-                    )
+                    output = formatter.format(_make_record(f"task_{language}_{style}_{palette}"))
 
                     for key in _LANG_CONTENT_KEYS:
                         placeholder = "{{" + key + "}}"
@@ -214,14 +212,16 @@ class TestEmailRendering(BaseTest):
         except Exception as exc:
             record = _make_record("filter_user")
             frame_filter = "test_email_themes"
-            record.task_context.update({
-                "exception": str(exc),
-                "traceback_str": _format_traceback(exc),
-                "traced_vars": _build_traced_vars_html(exc.__traceback__, frame_filter),
-                "traced_vars_location": _build_traced_vars_location(
-                    exc.__traceback__, frame_filter
-                ),
-            })
+            record.task_context.update(
+                {
+                    "exception": str(exc),
+                    "traceback_str": _format_traceback(exc),
+                    "traced_vars": _build_traced_vars_html(exc.__traceback__, frame_filter),
+                    "traced_vars_location": _build_traced_vars_location(
+                        exc.__traceback__, frame_filter
+                    ),
+                }
+            )
 
         formatter = _HTMLEmailFormatter(HTMLEmailStyle())
         body = formatter.format(record)
@@ -254,14 +254,16 @@ class TestEmailRendering(BaseTest):
         except Exception as exc:
             record = _make_record("filter_json")
             frame_filter = "json"
-            record.task_context.update({
-                "exception": str(exc),
-                "traceback_str": _format_traceback(exc),
-                "traced_vars": _build_traced_vars_html(exc.__traceback__, frame_filter),
-                "traced_vars_location": _build_traced_vars_location(
-                    exc.__traceback__, frame_filter
-                ),
-            })
+            record.task_context.update(
+                {
+                    "exception": str(exc),
+                    "traceback_str": _format_traceback(exc),
+                    "traced_vars": _build_traced_vars_html(exc.__traceback__, frame_filter),
+                    "traced_vars_location": _build_traced_vars_location(
+                        exc.__traceback__, frame_filter
+                    ),
+                }
+            )
 
         formatter = _HTMLEmailFormatter(HTMLEmailStyle())
         body = formatter.format(record)
@@ -287,12 +289,14 @@ class TestEmailRendering(BaseTest):
             _inner()
         except Exception as exc:
             record = _make_record("traced_task")
-            record.task_context.update({
-                "exception": str(exc),
-                "traceback_str": _format_traceback(exc),
-                "traced_vars": _build_traced_vars_html(exc.__traceback__, None),
-                "traced_vars_location": _build_traced_vars_location(exc.__traceback__, None),
-            })
+            record.task_context.update(
+                {
+                    "exception": str(exc),
+                    "traceback_str": _format_traceback(exc),
+                    "traced_vars": _build_traced_vars_html(exc.__traceback__, None),
+                    "traced_vars_location": _build_traced_vars_location(exc.__traceback__, None),
+                }
+            )
 
         formatter = _HTMLEmailFormatter(
             HTMLEmailStyle(style="modern", palette="neutral", language="en")
@@ -393,9 +397,7 @@ class TestTaskEmailWiring(BaseTest):
         assert "Fallo en el pipeline: wired" in body, (
             "Rendered email body is missing the Spanish 'lang_failure_header'"
         )
-        assert "Función" in body, (
-            "Rendered email body is missing the Spanish 'lang_function_label'"
-        )
+        assert "Función" in body, "Rendered email body is missing the Spanish 'lang_function_label'"
         assert "planned end-to-end failure" in body
 
     def test_task_subject_carries_language_prefix(self) -> None:
@@ -477,18 +479,18 @@ class TestTaskEmailWiring(BaseTest):
         def boom() -> None:
             raise RuntimeError("boom")
 
-        task_a = Task(name="iso_task_a", log_path=self._log("iso_task_a.log"), func=boom,
-                      smtp_config=smtp_cfg)
-        task_b = Task(name="iso_task_b", log_path=self._log("iso_task_b.log"), func=boom,
-                      smtp_config=smtp_cfg)
+        task_a = Task(
+            name="iso_task_a", log_path=self._log("iso_task_a.log"), func=boom, smtp_config=smtp_cfg
+        )
+        task_b = Task(
+            name="iso_task_b", log_path=self._log("iso_task_b.log"), func=boom, smtp_config=smtp_cfg
+        )
         try:
             email_handlers_a = [
-                h for h in task_a.logger.handlers
-                if isinstance(h, logging.handlers.SMTPHandler)
+                h for h in task_a.logger.handlers if isinstance(h, logging.handlers.SMTPHandler)
             ]
             email_handlers_b = [
-                h for h in task_b.logger.handlers
-                if isinstance(h, logging.handlers.SMTPHandler)
+                h for h in task_b.logger.handlers if isinstance(h, logging.handlers.SMTPHandler)
             ]
 
             assert len(email_handlers_a) == 1, "Task A should have exactly one email handler"
@@ -519,8 +521,7 @@ class TestTaskEmailWiring(BaseTest):
         )
         try:
             email_handlers = [
-                h for h in task.logger.handlers
-                if isinstance(h, logging.handlers.SMTPHandler)
+                h for h in task.logger.handlers if isinstance(h, logging.handlers.SMTPHandler)
             ]
             assert len(email_handlers) == 0, (
                 f"No email handler should be attached when smtp_config is None, "

{processes-3.0.1 → processes-3.1.0}/tests/test_normal_run_no_errors.py

@@ -77,15 +77,27 @@ class TestNormalRun(BaseTest):
             Task("task_1", log, task_1),
             Task("task_2", log, task_2),
             Task("task_3", log, task_3, args=(1,)),
-            Task("task_4", log, task_4,
-                 dependencies=[TaskDependency("task_2", use_result_as_additional_args=True)]),
-            Task("task_5", log, task_5,
-                 dependencies=[TaskDependency("task_1", use_result_as_additional_args=True)]),
-            Task("task_6", log, task_6,
-                 dependencies=[
-                     TaskDependency("task_2", use_result_as_additional_args=True),
-                     TaskDependency("task_5", use_result_as_additional_args=True),
-                 ]),
+            Task(
+                "task_4",
+                log,
+                task_4,
+                dependencies=[TaskDependency("task_2", use_result_as_additional_args=True)],
+            ),
+            Task(
+                "task_5",
+                log,
+                task_5,
+                dependencies=[TaskDependency("task_1", use_result_as_additional_args=True)],
+            ),
+            Task(
+                "task_6",
+                log,
+                task_6,
+                dependencies=[
+                    TaskDependency("task_2", use_result_as_additional_args=True),
+                    TaskDependency("task_5", use_result_as_additional_args=True),
+                ],
+            ),
         ]
 
     def test_run_dependent_tasks_sequential(self) -> None:

{processes-3.0.1 → processes-3.1.0}/tests/test_timeout_retry.py

@@ -58,8 +58,9 @@ class TestTimeout(BaseTest):
 
         assert "t_seq" in pr.failed_tasks
         assert "t_seq" in pr.errored_tasks
-        assert isinstance(pr.passed_tasks_results.get("t_seq", None) or
-                          pr.failed_tasks, set)  # task did not pass
+        assert isinstance(
+            pr.passed_tasks_results.get("t_seq", None) or pr.failed_tasks, set
+        )  # task did not pass
 
     def test_timeout_in_parallel_process(self) -> None:
         """Timeout propagates through Process.run(parallel=True)."""
@@ -275,13 +276,13 @@ class TestRetry(BaseTest):
 
     def test_retry_on_string_raises(self) -> None:
         with pytest.raises(TypeError, match="retry_on must be None or a tuple"):
-            Task("t", self._log("t.log"), lambda: None, retries=1,
-                 retry_on="ConnectionError")  # type: ignore[arg-type]
+            Task("t", self._log("t.log"), lambda: None, retries=1, retry_on="ConnectionError")  # type: ignore[arg-type]
 
     def test_retry_on_non_exception_raises(self) -> None:
         with pytest.raises(TypeError, match="retry_on must be None or a tuple"):
-            Task("t", self._log("t.log"), lambda: None, retries=1,
-                 retry_on=(int,))  # int is not an Exception subclass
+            Task(
+                "t", self._log("t.log"), lambda: None, retries=1, retry_on=(int,)
+            )  # int is not an Exception subclass
 
 
 class TestTimeoutWithRetry(BaseTest):