ttasks 0.3.0__tar.gz → 0.4.0__tar.gz

{ttasks-0.3.0 → ttasks-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ttasks
-Version: 0.3.0
+Version: 0.4.0
 Summary: Add your description here
 Requires-Python: >=3.12
 Requires-Dist: github-copilot-sdk>=0.1.0

{ttasks-0.3.0 → ttasks-0.4.0}/docs/quickstart.md

@@ -19,6 +19,26 @@ assert task.result is result
 and Copilot agent tasks. You can override any handler or create an executor with
 no defaults by using `TaskExecutor.empty()`.
 
+## Share a Copilot agent session
+
+The default Copilot agent handler creates a fresh Copilot session for each task.
+Use `CopilotAgentSession` when multiple `Task.agent(...)` tasks should share one
+conversation:
+
+```python
+from ttasks import CopilotAgentSession, Task, TaskExecutor, TaskType
+
+with CopilotAgentSession(working_directory="/path/to/repo") as agent:
+    executor = TaskExecutor()
+    executor.register(TaskType.AGENT, agent.handler())
+
+    executor.execute(Task.agent("Create a first change."))
+    executor.execute(Task.agent("Continue from the previous change."))
+```
+
+Shared sessions preserve conversation state across agent tasks. The handler
+serializes turns through the session, including when used by `TaskGraph`.
+
 ## Run a graph
 
 ```python

{ttasks-0.3.0 → ttasks-0.4.0}/src/ttasks/__init__.py

@@ -20,12 +20,14 @@ from ._store import (
     Store,
 )
 from ._task import Task, TaskResult, TaskStatus, TaskType
+from .copilot import CopilotAgentSession
 
 __all__ = [
     "EventBus",
     "InMemoryStore",
     "SQLiteStore",
     "Store",
+    "CopilotAgentSession",
     "RetryPolicy",
     "Task",
     "TaskCancelled",

{ttasks-0.3.0 → ttasks-0.4.0}/src/ttasks/_executor.py

@@ -11,9 +11,10 @@ import time
 import warnings
 from collections.abc import Callable, Mapping
 from concurrent.futures import Future, ThreadPoolExecutor
+from contextlib import suppress
 from dataclasses import dataclass
 from datetime import datetime
-from threading import RLock, Thread
+from threading import RLock, Thread, current_thread
 from types import MappingProxyType
 from typing import TYPE_CHECKING, Any, TextIO, cast
 
@@ -236,6 +237,8 @@ class TaskExecutor:
         :meth:`Future.cancel` only cancels work that has not started yet; cancel
         running tasks through :meth:`cancel`.
         """
+        self._validate_task(task)
+        policy = self._resolve_retry_policy(retry_policy)
         # Shallow-copy the mapping so caller mutation cannot race the worker;
         # Task refs themselves intentionally remain shared.
         upstream_snapshot = dict(upstream or {})
@@ -244,12 +247,27 @@ class TaskExecutor:
                 raise RuntimeError("executor is shut down")
             if self._pool is None:
                 self._pool = ThreadPoolExecutor(thread_name_prefix="ttasks")
-            return self._pool.submit(
-                self.execute,
+            future = self._pool.submit(
+                self._execute_submitted,
                 task,
                 upstream_snapshot,
-                retry_policy=retry_policy,
+                policy,
             )
+            future.add_done_callback(
+                lambda submitted: self.cancel(task) if submitted.cancelled() else None
+            )
+            return future
+
+    def _execute_submitted(
+        self,
+        task: Task,
+        upstream: Mapping[str, Task],
+        retry_policy: RetryPolicy,
+    ) -> TaskResult:
+        """Execute submitted work, preserving queued cancellation semantics."""
+        if task.status == TaskStatus.CANCELLED:
+            raise TaskCancelled(f"Task {task.id!r} was cancelled")
+        return self.execute(task, upstream, retry_policy=retry_policy)
 
     def shutdown(self) -> None:
         """Shut down async submission, waiting for submitted work to finish.
@@ -265,7 +283,15 @@ class TaskExecutor:
             pool = self._pool
             self._pool = None
         if pool is not None:
-            pool.shutdown(wait=True)
+            current = current_thread()
+            pool_threads = list(getattr(pool, "_threads", ()))
+            if current in pool_threads:
+                pool.shutdown(wait=False)
+                for thread in pool_threads:
+                    if thread is not current:
+                        thread.join()
+            else:
+                pool.shutdown(wait=True)
 
     def close(self) -> None:
         """Alias for :meth:`shutdown` for resource-cleanup contexts."""
@@ -417,10 +443,11 @@ class TaskExecutor:
             self.store.graphs.save(graph)
         except BaseException as error:
             self.graph_persistence_errors.append((graph.id, error))
-            warnings.warn(
-                f"graph persistence failed for graph {graph.id!r}: {error}",
-                stacklevel=2,
-            )
+            with suppress(Warning):
+                warnings.warn(
+                    f"graph persistence failed for graph {graph.id!r}: {error}",
+                    stacklevel=2,
+                )
 
     def cancel(self, task: Task) -> None:
         """Cancel a task and terminate its subprocess if one is active.
@@ -495,7 +522,8 @@ class TaskExecutor:
         ``retry_policy`` retries failed attempts for this single task only.
         Cancellation is never retried.
         """
-        policy = retry_policy or RetryPolicy()
+        self._validate_task(task)
+        policy = self._resolve_retry_policy(retry_policy)
         if policy.max_attempts == 1 or self._handlers.get(task.type) is None:
             return self._execute_once(task, upstream)
 
@@ -513,7 +541,7 @@ class TaskExecutor:
                 if out_of_attempts or task.status != TaskStatus.FAILED:
                     raise
                 if policy.backoff:
-                    time.sleep(policy.backoff)
+                    self._sleep_retry_backoff(task, policy.backoff)
                 if task.status == TaskStatus.CANCELLED:
                     raise TaskCancelled(
                         f"Task {task.id!r} was cancelled",
@@ -521,6 +549,35 @@ class TaskExecutor:
 
         raise AssertionError("unreachable retry loop exit")  # pragma: no cover
 
+    @staticmethod
+    def _validate_task(task: Task) -> None:
+        """Reject malformed task arguments before accessing Task internals."""
+        if not isinstance(task, Task):
+            raise TypeError("task must be a Task")
+
+    @staticmethod
+    def _resolve_retry_policy(retry_policy: RetryPolicy | None) -> RetryPolicy:
+        """Return a concrete RetryPolicy, rejecting malformed public input."""
+        if retry_policy is None:
+            return RetryPolicy()
+        if not isinstance(retry_policy, RetryPolicy):
+            raise TypeError("retry_policy must be a RetryPolicy")
+        return retry_policy
+
+    @staticmethod
+    def _sleep_retry_backoff(task: Task, backoff: float) -> None:
+        """Sleep between retry attempts while periodically observing cancel()."""
+        if backoff <= 0.5:
+            time.sleep(backoff)
+            return
+
+        deadline = time.monotonic() + backoff
+        while task.status != TaskStatus.CANCELLED:
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                return
+            time.sleep(min(remaining, 0.05))
+
     def _execute_once(
         self,
         task: Task,
@@ -714,6 +771,16 @@ class TaskExecutor:
         stderr_thread.start()
         timed_out = False
         timeout_error: subprocess.TimeoutExpired | None = None
+        deadline = (
+            None if context.timeout is None else time.monotonic() + context.timeout
+        )
+
+        def remaining_timeout() -> float | None:
+            """Return remaining wall-clock timeout for process/output draining."""
+            if deadline is None:
+                return None
+            return max(0.0, deadline - time.monotonic())
+
         if context.cancelled:
             self._terminate_process(process)
         try:
@@ -724,14 +791,23 @@ class TaskExecutor:
                 timed_out = True
                 timeout_error = e
         finally:
-            stdout_thread.join()
-            stderr_thread.join()
+            for thread in (stdout_thread, stderr_thread):
+                thread.join(remaining_timeout())
+            if (
+                not timed_out
+                and deadline is not None
+                and (stdout_thread.is_alive() or stderr_thread.is_alive())
+            ):
+                self._terminate_process(process)
+                timed_out = True
+            if timed_out:
+                stdout_thread.join()
+                stderr_thread.join()
             self._running_processes.pop(context.id, None)
 
         stdout = "".join(stdout_chunks)
         stderr = "".join(stderr_chunks)
         if timed_out:
-            assert timeout_error is not None
             message = f"Task timed out after {context.timeout} seconds"
             completed = subprocess.CompletedProcess(
                 args=args,
@@ -739,7 +815,9 @@ class TaskExecutor:
                 stdout=stdout,
                 stderr=stderr,
             )
-            raise TaskTimeoutError(message, completed) from timeout_error
+            if timeout_error is not None:
+                raise TaskTimeoutError(message, completed) from timeout_error
+            raise TaskTimeoutError(message, completed)
 
         result = subprocess.CompletedProcess(
             args=args,

{ttasks-0.3.0 → ttasks-0.4.0}/src/ttasks/_graph.py

@@ -72,6 +72,8 @@ class TaskGraph:
         self._tasks[task.id] = task
         deps: list[str] = []
         for dep in after:
+            if not isinstance(dep, Task):
+                raise TypeError(f"Expected Task dependency, got {type(dep).__name__}")
             if dep.id not in deps:
                 deps.append(dep.id)
         self._deps[task.id] = deps
@@ -349,11 +351,12 @@ class TaskGraph:
 
             def inactive(tid: str) -> bool:
                 """Return whether tid can no longer change in this run."""
+                if tid in futures:
+                    return futures[tid].done()
                 task = self._tasks[tid]
                 return (
                     (task.is_terminal and not retryable_this_run(tid))
                     or tid in self._errors
-                    or (tid in futures and futures[tid].done())
                 )
 
             def ready(tid: str) -> bool:
@@ -373,6 +376,10 @@ class TaskGraph:
                 authoritative.
                 """
                 for d in self._deps[tid]:
+                    if d in futures and not futures[d].done():
+                        continue
+                    if d in self._errors:
+                        return d
                     if self._tasks[d].status.is_bad and not retryable_this_run(d):
                         return d
                 return None

{ttasks-0.3.0 → ttasks-0.4.0}/src/ttasks/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.3.0'
-__version_tuple__ = version_tuple = (0, 3, 0)
+__version__ = version = '0.4.0'
+__version_tuple__ = version_tuple = (0, 4, 0)
 
 __commit_id__ = commit_id = None

ttasks-0.4.0/src/ttasks/copilot.py

@@ -0,0 +1,329 @@
+"""Copilot-backed task handlers and session helpers."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable
+from concurrent.futures import CancelledError as FutureCancelledError
+from concurrent.futures import TimeoutError as FutureTimeoutError
+from threading import Event, Lock, Thread
+from typing import Any, Self
+
+from ._exceptions import TaskCancelled
+from ._executor import DEFAULT_COPILOT_AGENT_MODEL, TaskContext, TaskHandler
+
+
+class CopilotAgentSession:
+    """Long-lived Copilot agent session with a ``TaskExecutor`` handler.
+
+    A shared session preserves Copilot conversation state across multiple
+    ``Task.agent(...)`` executions. Use a fresh ``CopilotAgentSession`` for an
+    independent conversational lane.
+    """
+
+    def __init__(
+        self,
+        *,
+        model: str = DEFAULT_COPILOT_AGENT_MODEL,
+        reasoning_effort: str | None = None,
+        working_directory: str | None = None,
+        timeout: float | None = None,
+        on_event: Callable[[Any], None] | None = None,
+        **session_options: Any,
+    ) -> None:
+        """Configure a reusable Copilot agent session.
+
+        ``session_options`` are passed through to
+        ``CopilotClient.create_session(...)``. Permission requests default to
+        ``PermissionHandler.approve_all`` to match the existing one-shot AGENT
+        handler unless ``on_permission_request`` is supplied.
+        """
+        if not model:
+            raise ValueError("model must not be empty")
+        if timeout is not None and timeout <= 0:
+            raise ValueError("timeout must be greater than 0")
+
+        self.model = model
+        self.reasoning_effort = reasoning_effort
+        self.working_directory = working_directory
+        self.timeout = timeout
+        self._session_options = dict(session_options)
+
+        self._event_handlers: list[Callable[[Any], None]] = []
+        self.event_errors: list[BaseException] = []
+        self._event_lock = Lock()
+        if on_event is not None:
+            self._event_handlers.append(on_event)
+
+        self._client: Any | None = None
+        self._session: Any | None = None
+        self._send_lock: asyncio.Lock | None = None
+        self._active = False
+        self._sync_active = False
+
+        self._loop: asyncio.AbstractEventLoop | None = None
+        self._thread: Thread | None = None
+        self._thread_ready = Event()
+        self._handler_lock = Lock()
+
+    async def __aenter__(self) -> Self:
+        """Open the Copilot client and session in the current event loop."""
+        if self._active:
+            raise RuntimeError("CopilotAgentSession is already active")
+        await self._open_async()
+        self._sync_active = False
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        traceback: object | None,
+    ) -> None:
+        """Close the Copilot session and client."""
+        await self._close_async(exc_type, exc, traceback)
+
+    def __enter__(self) -> Self:
+        """Open the Copilot client and session on a background event loop."""
+        if self._active:
+            raise RuntimeError("CopilotAgentSession is already active")
+        self._start_loop_thread()
+        try:
+            self._run_on_loop(self._open_async())
+        except BaseException:
+            self._stop_loop_thread()
+            raise
+        self._sync_active = True
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        traceback: object | None,
+    ) -> None:
+        """Close the Copilot session/client and stop the background loop."""
+        try:
+            if self._loop is not None:
+                self._run_on_loop(self._close_async(exc_type, exc, traceback))
+        finally:
+            self._sync_active = False
+            self._stop_loop_thread()
+
+    async def send_and_wait(
+        self,
+        prompt: str,
+        *,
+        timeout: float | None = None,
+    ) -> str:
+        """Send ``prompt`` through the shared session and return assistant text."""
+        if not self._active or self._session is None:
+            raise RuntimeError("CopilotAgentSession is not active")
+        if not isinstance(prompt, str):
+            raise TypeError("prompt must be a str")
+        if timeout is not None and timeout <= 0:
+            raise ValueError("timeout must be greater than 0")
+
+        effective_timeout = self.timeout if timeout is None else timeout
+        if self._send_lock is None:
+            self._send_lock = asyncio.Lock()
+        async with self._send_lock:
+            response = await self._session.send_and_wait(
+                prompt,
+                timeout=effective_timeout,
+            )
+        return self._response_text(response)
+
+    def on(self, handler: Callable[[Any], None]) -> Callable[[], None]:
+        """Subscribe to Copilot session events.
+
+        The returned callable unsubscribes ``handler``. Handlers may be called
+        from the session's event-loop thread when using the synchronous context
+        manager.
+        """
+        if not callable(handler):
+            raise TypeError("handler must be callable")
+        with self._event_lock:
+            self._event_handlers.append(handler)
+
+        def unsubscribe() -> None:
+            with self._event_lock:
+                if handler in self._event_handlers:
+                    self._event_handlers.remove(handler)
+
+        return unsubscribe
+
+    def handler(self) -> TaskHandler:
+        """Return a synchronous AGENT task handler backed by this session."""
+
+        def run(context: TaskContext) -> str:
+            context.raise_if_cancelled()
+            if not self._sync_active or self._loop is None:
+                raise RuntimeError(
+                    "CopilotAgentSession.handler() requires an active sync context",
+                )
+            with self._handler_lock:
+                context.raise_if_cancelled()
+                future = asyncio.run_coroutine_threadsafe(
+                    self.send_and_wait(context.payload, timeout=context.timeout),
+                    self._loop,
+                )
+                while True:
+                    try:
+                        result = future.result(timeout=0.05)
+                    except FutureTimeoutError:
+                        if context.cancelled:
+                            future.cancel()
+                            self._abort_active()
+                            raise TaskCancelled(
+                                f"Task {context.id!r} was cancelled",
+                            ) from None
+                        continue
+                    except FutureCancelledError as error:
+                        raise TaskCancelled(
+                            f"Task {context.id!r} was cancelled",
+                        ) from error
+                    context.raise_if_cancelled()
+                    return result
+
+        return run
+
+    async def _open_async(self) -> None:
+        """Create the SDK client/session pair."""
+        from copilot import CopilotClient
+        from copilot.session import PermissionHandler
+
+        session_options = dict(self._session_options)
+        session_options.setdefault(
+            "on_permission_request",
+            PermissionHandler.approve_all,
+        )
+        session_options["model"] = self.model
+        if self.reasoning_effort is not None:
+            session_options["reasoning_effort"] = self.reasoning_effort
+        if self.working_directory is not None:
+            session_options["working_directory"] = self.working_directory
+        session_options["on_event"] = self._dispatch_event
+
+        client = CopilotClient()
+        entered_client = await client.__aenter__()
+        try:
+            session = await entered_client.create_session(**session_options)
+            entered_session = await session.__aenter__()
+        except BaseException:
+            await entered_client.__aexit__(None, None, None)
+            raise
+
+        self._client = entered_client
+        self._session = entered_session
+        self._send_lock = asyncio.Lock()
+        self._active = True
+
+    async def _close_async(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc: BaseException | None = None,
+        traceback: object | None = None,
+    ) -> None:
+        """Close active SDK resources in reverse creation order."""
+        session = self._session
+        client = self._client
+        self._session = None
+        self._client = None
+        self._send_lock = None
+        self._active = False
+
+        close_error: BaseException | None = None
+        if session is not None:
+            try:
+                await session.__aexit__(exc_type, exc, traceback)
+            except BaseException as error:
+                close_error = error
+        if client is not None:
+            try:
+                await client.__aexit__(exc_type, exc, traceback)
+            except BaseException as error:
+                if close_error is None:
+                    close_error = error
+        if close_error is not None:
+            raise close_error
+
+    async def _abort_active_async(self) -> None:
+        """Abort the active Copilot turn if the SDK session supports it."""
+        session = self._session
+        abort = getattr(session, "abort", None)
+        if callable(abort):
+            await abort()
+
+    def _abort_active(self) -> None:
+        """Best-effort abort for a cancelled synchronous handler call."""
+        if self._loop is None:
+            return
+        future = asyncio.run_coroutine_threadsafe(
+            self._abort_active_async(),
+            self._loop,
+        )
+        future.result(timeout=5)
+
+    @staticmethod
+    def _response_text(response: Any) -> str:
+        """Normalize a Copilot SDK response event to assistant text."""
+        from copilot.generated.session_events import AssistantMessageData
+
+        if response is None or not isinstance(response.data, AssistantMessageData):
+            return ""
+        return response.data.content or ""
+
+    def _dispatch_event(self, event: Any) -> None:
+        """Fan out one SDK event to registered session subscribers."""
+        with self._event_lock:
+            handlers = list(self._event_handlers)
+        for handler in handlers:
+            try:
+                handler(event)
+            except BaseException as error:
+                self.event_errors.append(error)
+
+    def _start_loop_thread(self) -> None:
+        """Start the background event loop used by the sync API."""
+        self._thread_ready.clear()
+
+        def run_loop() -> None:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            self._loop = loop
+            self._thread_ready.set()
+            try:
+                loop.run_forever()
+            finally:
+                loop.close()
+                self._loop = None
+
+        self._thread = Thread(
+            target=run_loop,
+            name="ttasks-copilot-agent-session",
+            daemon=True,
+        )
+        self._thread.start()
+        self._thread_ready.wait()
+
+    def _stop_loop_thread(self) -> None:
+        """Stop and join the background event-loop thread."""
+        loop = self._loop
+        thread = self._thread
+        if loop is not None:
+            loop.call_soon_threadsafe(loop.stop)
+        if thread is not None:
+            thread.join(timeout=5)
+        self._thread = None
+        self._thread_ready.clear()
+
+    def _run_on_loop(self, coroutine: Any) -> Any:
+        """Run ``coroutine`` on the sync background loop and return its result."""
+        if self._loop is None:
+            raise RuntimeError("CopilotAgentSession event loop is not running")
+        future = asyncio.run_coroutine_threadsafe(coroutine, self._loop)
+        return future.result()
+
+
+__all__ = ["CopilotAgentSession"]