ttasks 0.2.0__tar.gz → 0.2.1__tar.gz

{ttasks-0.2.0 → ttasks-0.2.1}/.github/workflows/docs.yml

@@ -5,6 +5,9 @@ on:
     branches: [master]
   workflow_dispatch:
 
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
+
 permissions:
   contents: read
   pages: write

{ttasks-0.2.0 → ttasks-0.2.1}/.github/workflows/publish.yml

@@ -5,6 +5,9 @@ on:
     tags:
       - "v*"
 
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
+
 jobs:
   build:
     runs-on: ubuntu-latest

{ttasks-0.2.0 → ttasks-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ttasks
-Version: 0.2.0
+Version: 0.2.1
 Summary: Add your description here
 Requires-Python: >=3.12
 Requires-Dist: github-copilot-sdk>=0.1.0
@@ -133,8 +133,7 @@ assert task in store.tasks   # id-membership shortcut
 `InMemoryStore`. A single SQLite file holds both tasks and graphs.
 
 ```python
-from ttasks import Task, TaskGraph, TaskExecutor
-from ttasks.storage.sqlite import SQLiteStore
+from ttasks import Task, TaskGraph, TaskExecutor, SQLiteStore
 
 store = SQLiteStore("ttasks.db")
 
@@ -179,8 +178,7 @@ Persistence failures are isolated from execution: they are recorded on
 out of `execute()` and does not transition the task to `FAILED`.
 
 ```python
-from ttasks import TaskExecutor
-from ttasks.storage.sqlite import SQLiteStore
+from ttasks import TaskExecutor, SQLiteStore
 
 store = SQLiteStore("ttasks.db")
 executor = TaskExecutor(store=store)

{ttasks-0.2.0 → ttasks-0.2.1}/README.md

@@ -125,8 +125,7 @@ assert task in store.tasks   # id-membership shortcut
 `InMemoryStore`. A single SQLite file holds both tasks and graphs.
 
 ```python
-from ttasks import Task, TaskGraph, TaskExecutor
-from ttasks.storage.sqlite import SQLiteStore
+from ttasks import Task, TaskGraph, TaskExecutor, SQLiteStore
 
 store = SQLiteStore("ttasks.db")
 
@@ -171,8 +170,7 @@ Persistence failures are isolated from execution: they are recorded on
 out of `execute()` and does not transition the task to `FAILED`.
 
 ```python
-from ttasks import TaskExecutor
-from ttasks.storage.sqlite import SQLiteStore
+from ttasks import TaskExecutor, SQLiteStore
 
 store = SQLiteStore("ttasks.db")
 executor = TaskExecutor(store=store)

{ttasks-0.2.0 → ttasks-0.2.1}/src/ttasks/_executor.py

@@ -167,8 +167,8 @@ class TaskExecutor:
         emits the BLOCKED event so observers and the store see the outcome.
         """
         previous_status = task.status
-        task._set_blocked_by(parent_id)
         task.transition_to(TaskStatus.BLOCKED)
+        task._set_blocked_by(parent_id)
         self._emit(task, TaskEventType.BLOCKED, previous_status)
 
     def _terminalize(
@@ -333,6 +333,9 @@ class TaskExecutor:
         handler = self._handlers.get(task.type)
         if handler is None:
             message = f"No handler registered for task type {task.type.value!r}"
+            previous_status = task.status
+            if not task.can_transition_to(TaskStatus.FAILED):
+                task.transition_to(TaskStatus.RUNNING)
             finished_at = datetime.now()
             failed_result = TaskResult(
                 task_id=task.id,
@@ -347,7 +350,7 @@ class TaskExecutor:
                 task,
                 failed_result,
                 TaskStatus.FAILED,
-                previous=TaskStatus.PENDING,
+                previous=previous_status,
                 event_type=TaskEventType.FAILED,
                 error=message,
             )
@@ -471,6 +474,8 @@ class TaskExecutor:
             args,
             shell=shell,
             text=True,
+            encoding="utf-8",
+            errors="replace",
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
             start_new_session=True,

{ttasks-0.2.0 → ttasks-0.2.1}/src/ttasks/_graph.py

@@ -70,7 +70,11 @@ class TaskGraph:
             raise ValueError("required=False is only valid with finally_=True")
 
         self._tasks[task.id] = task
-        self._deps[task.id] = [d.id for d in after]
+        deps: list[str] = []
+        for dep in after:
+            if dep.id not in deps:
+                deps.append(dep.id)
+        self._deps[task.id] = deps
         if finally_:
             self._finally.add(task.id)
             if required:
@@ -170,6 +174,7 @@ class TaskGraph:
         """True iff every required task succeeded without run errors."""
         return all(
             self._tasks[tid].status == TaskStatus.SUCCEEDED
+            and tid not in self._errors
             for tid in self._deps
             if tid not in self._optional
         )
@@ -288,11 +293,23 @@ class TaskGraph:
                 """Return whether tid is already done or succeeded in this run."""
                 return self._tasks[tid].status == TaskStatus.SUCCEEDED
 
+            def retryable_this_run(tid: str) -> bool:
+                """Return whether a bad-status task can still recover this run."""
+                task = self._tasks[tid]
+                return (
+                    tid not in futures
+                    and task.can_transition_to(TaskStatus.RUNNING)
+                    and (
+                        task.status != TaskStatus.BLOCKED
+                        or tid in entering_blocked
+                    )
+                )
+
             def inactive(tid: str) -> bool:
                 """Return whether tid can no longer change in this run."""
                 task = self._tasks[tid]
                 return (
-                    task.is_terminal
+                    (task.is_terminal and not retryable_this_run(tid))
                     or tid in self._errors
                     or (tid in futures and futures[tid].done())
                 )
@@ -307,12 +324,14 @@ class TaskGraph:
                 """Return the first dep (in declaration order) blocking ``tid``.
 
                 A parent "blocks" when its status is FAILED, CANCELLED, or
-                BLOCKED. Returns ``None`` if every parent is still
-                recoverable. Pre-start handler errors terminalize the parent
-                to FAILED before raising, so status alone is authoritative.
+                BLOCKED and it cannot still be retried during this run.
+                Returns ``None`` if every bad parent is still recoverable.
+                Pre-start handler errors terminalize the parent to FAILED
+                before raising, so status plus retry eligibility is
+                authoritative.
                 """
                 for d in self._deps[tid]:
-                    if self._tasks[d].status.is_bad:
+                    if self._tasks[d].status.is_bad and not retryable_this_run(d):
                         return d
                 return None
 

{ttasks-0.2.0 → ttasks-0.2.1}/src/ttasks/_sqlite.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import sqlite3
+import uuid
 import warnings
 from collections.abc import Iterator, MutableMapping
 from datetime import datetime
@@ -43,7 +44,18 @@ class _Connection:
     ) -> None:
         """Open or create the SQLite database at ``path`` and init the schema."""
         self.path = Path(path)
-        if self.path.parent != Path(""):
+        self._memory_uri: str | None = None
+        self._anchor_connection: sqlite3.Connection | None = None
+        if str(path) == ":memory:":
+            self._memory_uri = (
+                f"file:ttasks-{uuid.uuid4().hex}?mode=memory&cache=shared"
+            )
+            self._anchor_connection = sqlite3.connect(
+                self._memory_uri,
+                uri=True,
+                timeout=_CONNECT_TIMEOUT_SECONDS,
+            )
+        elif self.path.parent != Path(""):
             self.path.parent.mkdir(parents=True, exist_ok=True)
         self._schema_lock = RLock()
         self._allow_destructive = allow_destructive_migration
@@ -51,7 +63,14 @@ class _Connection:
 
     def connect(self) -> sqlite3.Connection:
         """Return a fresh SQLite connection configured for the store."""
-        connection = sqlite3.connect(self.path, timeout=_CONNECT_TIMEOUT_SECONDS)
+        if self._memory_uri is None:
+            connection = sqlite3.connect(self.path, timeout=_CONNECT_TIMEOUT_SECONDS)
+        else:
+            connection = sqlite3.connect(
+                self._memory_uri,
+                uri=True,
+                timeout=_CONNECT_TIMEOUT_SECONDS,
+            )
         connection.row_factory = sqlite3.Row
         connection.execute("PRAGMA foreign_keys = ON")
         return connection

{ttasks-0.2.0 → ttasks-0.2.1}/src/ttasks/_store.py

@@ -103,7 +103,9 @@ class InMemoryTaskCollection(MutableMapping[str, Task]):
     def __contains__(self, key: object) -> bool:
         """Return whether ``key`` (task or task id) is present."""
         if isinstance(key, Task):
-            return key.id in self._tasks
+            key = key.id
+        if not isinstance(key, str):
+            return False
         return key in self._tasks
 
     def __repr__(self) -> str:
@@ -153,7 +155,9 @@ class InMemoryGraphCollection(MutableMapping[str, "TaskGraph"]):
     def __contains__(self, key: object) -> bool:
         """Return whether ``key`` (graph or graph id) is present."""
         if isinstance(key, TaskGraph):
-            return key.id in self._graphs
+            key = key.id
+        if not isinstance(key, str):
+            return False
         return key in self._graphs
 
     def __repr__(self) -> str:

{ttasks-0.2.0 → ttasks-0.2.1}/src/ttasks/_task.py

@@ -232,6 +232,9 @@ class Task:
             )
             raise ValueError(message)
 
+        if status in {TaskStatus.RUNNING, TaskStatus.SUCCEEDED}:
+            error = None
+
         self.error = error
         self._status = status
         if status == TaskStatus.RUNNING:
@@ -244,7 +247,7 @@ class Task:
         Cancellation is intentionally idempotent so duplicate user/API requests
         are harmless, while transition_to(CANCELLED) remains strict.
         """
-        if self.status == TaskStatus.CANCELLED:
+        if self.status in {TaskStatus.SUCCEEDED, TaskStatus.CANCELLED}:
             return
 
         self.transition_to(TaskStatus.CANCELLED, error=self.error)

{ttasks-0.2.0 → ttasks-0.2.1}/src/ttasks/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.2.0'
-__version_tuple__ = version_tuple = (0, 2, 0)
+__version__ = version = '0.2.1'
+__version_tuple__ = version_tuple = (0, 2, 1)
 
 __commit_id__ = commit_id = None

{ttasks-0.2.0 → ttasks-0.2.1}/tests/test_executor.py

@@ -256,6 +256,25 @@ def test_execute_terminalizes_task_without_registered_handler() -> None:
     assert events[0].previous_status == TaskStatus.PENDING
 
 
+def test_execute_without_handler_terminalizes_blocked_retry_cleanly() -> None:
+    """A retryable BLOCKED task without a handler fails with the handler error."""
+    executor = TaskExecutor.empty()
+    task = Task.bash("", title="Example")
+    task.transition_to(TaskStatus.BLOCKED)
+    events: list[TaskEvent] = []
+    executor.events.subscribe(events.append)
+
+    with pytest.raises(ValueError, match="No handler registered"):
+        executor.execute(task)
+
+    assert task.status == TaskStatus.FAILED
+    assert task.result is not None
+    assert task.result.termination_reason == "handler"
+    assert task.result.error == "No handler registered for task type 'bash'"
+    assert [e.type for e in events] == [TaskEventType.FAILED]
+    assert events[0].previous_status == TaskStatus.BLOCKED
+
+
 def test_execute_rejects_cancelled_task_without_calling_handler() -> None:
     """Cancelled tasks are rejected before any handler side effects occur."""
     executor = TaskExecutor()
@@ -575,6 +594,18 @@ def test_powershell_task_executes() -> None:
     assert not executor.is_running(task.id)
 
 
+def test_bash_task_with_non_utf8_output_succeeds_with_replacement_text() -> None:
+    """Successful subprocesses are not failed by undecodable output bytes."""
+    executor = TaskExecutor()
+    task = Task.bash("python -c 'import sys; sys.stdout.buffer.write(bytes([255]))'")
+
+    result = executor.execute(task)
+
+    assert task.status == TaskStatus.SUCCEEDED
+    assert result.output == "�"
+    assert result.returncode == 0
+
+
 def test_bash_task_without_timeout_waits_for_completion() -> None:
     """timeout=None means the subprocess is allowed to run until it exits."""
     executor = TaskExecutor()
@@ -1393,6 +1424,20 @@ class TestTerminationReason:
 # ---- Step 15: public mark_blocked seam --------------------------------------
 
 
+def test_mark_blocked_rejection_does_not_set_blocked_by() -> None:
+    """A failed mark_blocked() call must not leave stale block metadata."""
+    executor = TaskExecutor()
+    task = Task.bash("", title="Example")
+    task.transition_to(TaskStatus.RUNNING)
+    task.transition_to(TaskStatus.SUCCEEDED)
+
+    with pytest.raises(ValueError, match="Cannot transition task"):
+        executor.mark_blocked(task, "parent-id-123")
+
+    assert task.status == TaskStatus.SUCCEEDED
+    assert task.blocked_by is None
+
+
 def test_mark_blocked_transitions_and_emits_blocked_event() -> None:
     """executor.mark_blocked(task, parent_id) is the public scheduler seam."""
     executor = TaskExecutor()

{ttasks-0.2.0 → ttasks-0.2.1}/tests/test_sqlite_store.py

@@ -116,6 +116,16 @@ class TestSQLiteTaskCollection:
         SQLiteStore(store_path).tasks.save(task)
         assert SQLiteStore(store_path).tasks[task.id].title == task.title
 
+    def test_memory_store_reuses_schema_across_operations(self) -> None:
+        """SQLiteStore(':memory:') works across the collection's connections."""
+        store = SQLiteStore(":memory:")
+        task = _bash("Memory", "echo memory")
+
+        store.tasks.save(task)
+
+        assert len(store.tasks) == 1
+        assert store.tasks[task.id].title == "Memory"
+
     def test_delitem_missing_task_raises_key_error(self, store: SQLiteStore) -> None:
         with pytest.raises(KeyError):
             del store.tasks["missing"]

{ttasks-0.2.0 → ttasks-0.2.1}/tests/test_store.py

@@ -51,6 +51,10 @@ class TestInMemoryTaskCollection:
         assert task in tasks
         assert "missing" not in tasks
 
+    def test_contains_returns_false_for_unhashable_non_keys(self) -> None:
+        tasks = InMemoryTaskCollection()
+        assert [] not in tasks
+
     def test_len_reflects_stored_tasks(self) -> None:
         tasks = InMemoryTaskCollection()
         assert len(tasks) == 0
@@ -109,6 +113,10 @@ class TestInMemoryGraphCollection:
         graphs.save(graph)
         assert graph in graphs
 
+    def test_contains_returns_false_for_unhashable_non_keys(self) -> None:
+        graphs = InMemoryGraphCollection()
+        assert [] not in graphs
+
     def test_setitem_rejects_non_graph(self) -> None:
         bogus = _opaque("not a graph")
         with pytest.raises(TypeError):

{ttasks-0.2.0 → ttasks-0.2.1}/tests/test_task.py

@@ -104,6 +104,17 @@ def test_status_changes_through_transition_to() -> None:
     assert task.error is None
 
 
+def test_success_transition_clears_even_explicit_error_text() -> None:
+    """A SUCCEEDED task must not retain error text from a bad caller argument."""
+    task = Task.bash("echo hi", title="Example")
+    task.transition_to(TaskStatus.RUNNING)
+
+    task.transition_to(TaskStatus.SUCCEEDED, error="should be ignored")
+
+    assert task.status == TaskStatus.SUCCEEDED
+    assert task.error is None
+
+
 def test_cancel_changes_status_through_state_machine() -> None:
     """cancel() is a domain helper around the CANCELLED transition."""
     task = Task.bash("echo hi", title="Example")
@@ -123,6 +134,18 @@ def test_cancel_is_idempotent() -> None:
     assert task.status == TaskStatus.CANCELLED
 
 
+def test_cancel_after_success_is_no_op() -> None:
+    """Cancelling an already-succeeded task leaves the success intact."""
+    task = Task.bash("echo hi", title="Example")
+    task.transition_to(TaskStatus.RUNNING)
+    task.transition_to(TaskStatus.SUCCEEDED)
+
+    task.cancel()
+
+    assert task.status == TaskStatus.SUCCEEDED
+    assert task.error is None
+
+
 def test_cancel_preserves_previous_error() -> None:
     """Cancelling a failed task keeps the failure reason for inspection."""
     task = Task.bash("echo hi", title="Example")

{ttasks-0.2.0 → ttasks-0.2.1}/tests/test_workflow.py

@@ -353,6 +353,26 @@ def test_diamond_runs_with_parallelism() -> None:
 # ---- Failure policy ----------------------------------------------------------
 
 
+def test_required_executor_error_makes_graph_not_ok_even_if_status_succeeded() -> None:
+    """A required task future error makes graph.ok false even with success status."""
+
+    class BrokenExecutor(TaskExecutor):
+        def execute(self, task, upstream=None):
+            task.transition_to(TaskStatus.RUNNING)
+            task.transition_to(TaskStatus.SUCCEEDED)
+            raise RuntimeError("executor post-processing failed")
+
+    a = _bash("A", "echo a")
+    graph = TaskGraph()
+    graph[a] = []
+
+    graph.run(BrokenExecutor())
+
+    assert a.status == TaskStatus.SUCCEEDED
+    assert a.id in graph.errors
+    assert not graph.ok
+
+
 def test_graph_records_executor_errors() -> None:
     """Pre-start handler errors terminalize the task as FAILED with the error."""
     a = _bash("A", "echo a")
@@ -875,6 +895,20 @@ def test_add_after_accepts_arbitrary_iterables() -> None:
     assert graph.dependencies(b) == [a]
 
 
+def test_add_deduplicates_repeated_dependencies() -> None:
+    """Repeated upstream tasks are one edge, not a false cycle."""
+    a = _bash("A", "echo a")
+    b = _bash("B", "echo b")
+    graph = TaskGraph()
+    graph.add(a)
+
+    graph.add(b, after=[a, a])
+
+    assert graph.dependencies(b) == [a]
+    graph.run(TaskExecutor())
+    assert graph.ok
+
+
 def test_add_finally_marks_task_as_finally_required_by_default() -> None:
     """finally_=True without required= keeps the task required."""
     a = _bash("A", "echo a")
@@ -960,6 +994,24 @@ def test_add_rejects_non_bool_required() -> None:
 # ---- Step 12: carryover-BLOCKED retry ----------------------------------------
 
 
+def test_failed_parent_added_after_child_retries_before_child_is_blocked() -> None:
+    """A retryable failed parent can recover even when visited after its child."""
+    a = _bash("A", "echo a")
+    b = _bash("B", "echo b")
+    a.transition_to(TaskStatus.RUNNING)
+    a.transition_to(TaskStatus.FAILED, error="previous failure")
+    graph = TaskGraph()
+    graph[b] = [a]
+    graph[a] = []
+
+    graph.run(TaskExecutor())
+
+    assert graph.ok
+    assert graph.blocked == []
+    assert a.status == TaskStatus.SUCCEEDED
+    assert b.status == TaskStatus.SUCCEEDED
+
+
 def test_carryover_blocked_with_succeeded_parent_recovers() -> None:
     """A BLOCKED task entering run() with all parents SUCCEEDED runs and succeeds."""
     a = _bash("A", "echo a")
@@ -1027,6 +1079,32 @@ def test_within_run_blocked_is_not_retried_same_run() -> None:
     assert attempts["B"] == 0
 
 
+def test_finally_waits_for_retryable_failed_dependency_added_later() -> None:
+    """A finally task waits for a retryable failed dependency to rerun first."""
+    parent = _bash("parent", "")
+    parent.transition_to(TaskStatus.RUNNING)
+    parent.transition_to(TaskStatus.FAILED, error="old failure")
+    cleanup = _bash("cleanup", "")
+    seen: list[str] = []
+
+    executor = TaskExecutor.empty()
+
+    def handler(context: Any) -> str:
+        seen.append(context.title)
+        return "ok"
+
+    executor.register(TaskType.BASH, handler)
+    graph = TaskGraph()
+    graph.add(cleanup, after=[parent], finally_=True)
+    graph[parent] = []
+
+    graph.run(executor, max_workers=1)
+
+    assert seen == ["parent", "cleanup"]
+    assert parent.status == TaskStatus.SUCCEEDED
+    assert cleanup.status == TaskStatus.SUCCEEDED
+
+
 def test_finally_runs_after_carryover_blocked_recovers() -> None:
     """A finally task fires after a carryover-BLOCKED task recovers to SUCCEEDED."""
     finally_ran: list[str] = []