functualize-tasks 0.1.0__py3-none-any.whl

functualize_tasks/__init__.py

@@ -0,0 +1,41 @@
+"""functualize-tasks — Tasks Domain SDK.
+
+Provides the Tasks capability class, TaskProvider protocol, shared types,
+errors, event constants, and testing doubles for task management.
+"""
+
+from functualize_tasks._errors import TaskNotFoundError
+from functualize_tasks._events import (
+    TASKS_COMPLETED,
+    TASKS_CREATED,
+    TASKS_DELETED,
+    TASKS_UPDATED,
+)
+from functualize_tasks._metadata import domain_metadata
+from functualize_tasks._protocols import TaskProvider
+from functualize_tasks._tasks import Tasks
+from functualize_tasks._types import TaskItem, TaskLink, TaskStatus
+from functualize_tasks.testing._mock_tasks import MockTaskOperation, MockTasks
+
+__all__ = [
+    # Capability Class
+    "Tasks",
+    # Protocols
+    "TaskProvider",
+    # Types
+    "TaskItem",
+    "TaskLink",
+    "TaskStatus",
+    # Errors
+    "TaskNotFoundError",
+    # Event Constants
+    "TASKS_CREATED",
+    "TASKS_UPDATED",
+    "TASKS_COMPLETED",
+    "TASKS_DELETED",
+    # Testing Doubles
+    "MockTaskOperation",
+    "MockTasks",
+    # Metadata
+    "domain_metadata",
+]

functualize_tasks/_errors.py

@@ -0,0 +1,7 @@
+"""Error classes for the Tasks Domain SDK."""
+
+
+class TaskNotFoundError(Exception):
+    """Raised when a task operation targets a task_id that does not exist."""
+
+    pass

functualize_tasks/_events.py

@@ -0,0 +1,9 @@
+"""Event name constants for the Tasks Domain SDK.
+
+Events follow the {domain}.{resource}.{action} grammar.
+"""
+
+TASKS_CREATED: str = "tasks.task.created"
+TASKS_UPDATED: str = "tasks.task.updated"
+TASKS_COMPLETED: str = "tasks.task.completed"
+TASKS_DELETED: str = "tasks.task.deleted"

functualize_tasks/_metadata.py

@@ -0,0 +1,37 @@
+"""Domain metadata for the Tasks SDK."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class DomainMetadata:
+    """Self-describing metadata for a domain SDK."""
+
+    name: str
+    display_name: str
+    description: str
+    capability_class: str
+    provider_protocol: str
+    config_section: str
+    entry_point_group: str
+    events_prefix: str
+    scaffold_template: str | None = None
+    documentation_url: str | None = None
+    mock_factory: str | None = None
+
+
+domain_metadata = DomainMetadata(
+    name="tasks",
+    display_name="Tasks",
+    description="Task management and planning scratchpad",
+    capability_class="functualize_tasks.Tasks",
+    provider_protocol="functualize_tasks.TaskProvider",
+    config_section="tasks",
+    entry_point_group="functualize.tasks_providers",
+    events_prefix="tasks.",
+    scaffold_template=None,
+    documentation_url=None,
+    mock_factory="functualize_tasks.testing:MockTasks",
+)

functualize_tasks/_protocols.py

@@ -0,0 +1,89 @@
+"""Tasks domain protocol — TaskProvider.
+
+Defines the protocol interface that task implementation plugins must satisfy.
+The Tasks capability delegates all storage and retrieval operations to a
+TaskProvider implementation.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Protocol, runtime_checkable
+
+if TYPE_CHECKING:
+    from functualize_tasks._types import TaskItem, TaskLink, TaskStatus
+
+
+@runtime_checkable
+class TaskProvider(Protocol):
+    """Protocol for task storage implementation plugins.
+
+    Implementation plugins (e.g., local state-backed, remote service) must
+    satisfy this protocol. The Tasks capability delegates all CRUD operations
+    to the active TaskProvider.
+    """
+
+    def add(self, title: str, linked_to: TaskLink | None = None) -> str:
+        """Create a new task and return its generated unique ID.
+
+        Args:
+            title: Human-readable title for the task.
+            linked_to: Optional link associating the task with a job,
+                       workflow step, or job phase.
+
+        Returns:
+            The unique identifier of the newly created task.
+        """
+        ...
+
+    def list(
+        self, status: TaskStatus | None = None, filter: str | None = None
+    ) -> list[TaskItem]:
+        """List tasks, optionally filtered by status or title substring.
+
+        Args:
+            status: If provided, return only tasks matching this status.
+            filter: If provided, return only tasks whose title contains
+                    this substring.
+
+        Returns:
+            A list of matching TaskItem instances.
+        """
+        ...
+
+    def update(
+        self, task_id: str, status: TaskStatus | None = None, notes: str | None = None
+    ) -> None:
+        """Update a task's status and/or notes.
+
+        Args:
+            task_id: The unique identifier of the task to update.
+            status: If provided, the new status to set.
+            notes: If provided, the new notes to set.
+
+        Raises:
+            TaskNotFoundError: If the task_id does not exist.
+        """
+        ...
+
+    def delete(self, task_id: str) -> None:
+        """Delete a task by its ID.
+
+        Args:
+            task_id: The unique identifier of the task to delete.
+
+        Raises:
+            TaskNotFoundError: If the task_id does not exist.
+        """
+        ...
+
+    def link(self, task_id: str, linked_to: TaskLink) -> None:
+        """Associate a task with a job, workflow step, or job phase.
+
+        Args:
+            task_id: The unique identifier of the task to link.
+            linked_to: The link specifying the kind and target.
+
+        Raises:
+            TaskNotFoundError: If the task_id does not exist.
+        """
+        ...

functualize_tasks/_tasks.py

@@ -0,0 +1,250 @@
+"""Tasks capability class — mutable planning scratchpad.
+
+The Tasks class provides methods to add, list, update, delete, and link
+tasks. It delegates all storage operations to a TaskProvider and emits
+structured events via a duck-typed EventBus on every mutation.
+"""
+
+from __future__ import annotations
+
+import uuid
+from typing import TYPE_CHECKING, Any, Protocol
+
+from functualize_tasks._errors import TaskNotFoundError
+from functualize_tasks._events import (
+    TASKS_COMPLETED,
+    TASKS_CREATED,
+    TASKS_DELETED,
+    TASKS_UPDATED,
+)
+from functualize_tasks._types import TaskItem, TaskLink, TaskStatus
+
+if TYPE_CHECKING:
+    from functualize_tasks._protocols import TaskProvider
+
+
+class _EventBus(Protocol):
+    """Duck-typed EventBus — only requires an emit method."""
+
+    def emit(self, event_name: str, **payload: Any) -> None: ...
+
+
+class _InMemoryTaskProvider:
+    """Simple in-memory TaskProvider used when no external provider is configured.
+
+    Stores tasks in a dict keyed by task ID. Suitable for ephemeral use
+    when no persistent TaskProvider plugin is installed.
+    """
+
+    def __init__(self) -> None:
+        self._tasks: dict[str, TaskItem] = {}
+
+    def add(self, title: str, linked_to: TaskLink | None = None) -> str:
+        task_id = uuid.uuid4().hex
+        task = TaskItem(
+            id=task_id,
+            title=title,
+            status=TaskStatus.PENDING,
+            linked_to=linked_to,
+        )
+        self._tasks[task_id] = task
+        return task_id
+
+    def list(
+        self, status: TaskStatus | None = None, filter: str | None = None
+    ) -> list[TaskItem]:
+        results = list(self._tasks.values())
+        if status is not None:
+            results = [t for t in results if t.status == status]
+        if filter is not None:
+            results = [t for t in results if filter in t.title]
+        return results
+
+    def get(self, task_id: str) -> TaskItem | None:
+        return self._tasks.get(task_id)
+
+    def update(
+        self, task_id: str, status: TaskStatus | None = None, notes: str | None = None
+    ) -> None:
+        task = self._tasks.get(task_id)
+        if task is None:
+            raise TaskNotFoundError(f"Task '{task_id}' not found.")
+        # Build updated task (frozen dataclass — must reconstruct)
+        updates: dict[str, Any] = {}
+        if status is not None:
+            updates["status"] = status
+        if notes is not None:
+            updates["notes"] = notes
+        if updates:
+            from dataclasses import asdict
+
+            data = asdict(task)
+            data.update(updates)
+            self._tasks[task_id] = TaskItem(**data)
+
+    def delete(self, task_id: str) -> None:
+        if task_id not in self._tasks:
+            raise TaskNotFoundError(f"Task '{task_id}' not found.")
+        del self._tasks[task_id]
+
+    def link(self, task_id: str, linked_to: TaskLink) -> None:
+        task = self._tasks.get(task_id)
+        if task is None:
+            raise TaskNotFoundError(f"Task '{task_id}' not found.")
+        from dataclasses import asdict
+
+        data = asdict(task)
+        data["linked_to"] = linked_to
+        self._tasks[task_id] = TaskItem(**data)
+
+
+class Tasks:
+    """Task management capability — mutable planning scratchpad.
+
+    Provides methods to create, list, update, delete, and link tasks.
+    Delegates all storage to a TaskProvider implementation and emits
+    structured events on every mutation via a duck-typed EventBus.
+
+    Args:
+        _provider: The TaskProvider implementation for persistence.
+                   If None, an in-memory provider is used.
+        _event_bus: Optional duck-typed EventBus with an emit(event_name, **payload)
+                    method. If None, events are silently discarded.
+    """
+
+    def __init__(
+        self,
+        *,
+        _provider: TaskProvider | None = None,
+        _event_bus: _EventBus | None = None,
+    ) -> None:
+        self._provider: TaskProvider = (
+            _provider if _provider is not None else _InMemoryTaskProvider()
+        )  # type: ignore[assignment]
+        self._event_bus = _event_bus
+
+    def _emit(self, event_name: str, **payload: Any) -> None:
+        """Emit an event if an event bus is available."""
+        if self._event_bus is not None:
+            self._event_bus.emit(event_name, **payload)
+
+    def add(self, title: str, *, linked_to: TaskLink | None = None) -> str:
+        """Create a new task and return its generated unique ID.
+
+        Emits a ``tasks.task.created`` event with payload containing the
+        task id, title, and linked_to.
+
+        Args:
+            title: Human-readable title for the task.
+            linked_to: Optional link associating the task with a job,
+                       workflow step, or job phase.
+
+        Returns:
+            The unique identifier of the newly created task.
+        """
+        task_id = self._provider.add(title, linked_to)
+        self._emit(
+            TASKS_CREATED,
+            task_id=task_id,
+            title=title,
+            linked_to=linked_to,
+        )
+        return task_id
+
+    def list(
+        self,
+        *,
+        status: TaskStatus | None = None,
+        filter: str | None = None,
+    ) -> list[TaskItem]:
+        """List tasks, optionally filtered by status or title substring.
+
+        Args:
+            status: If provided, return only tasks matching this status.
+            filter: If provided, return only tasks whose title contains
+                    this substring.
+
+        Returns:
+            A list of matching TaskItem instances.
+        """
+        return self._provider.list(status, filter)
+
+    def update(
+        self,
+        task_id: str,
+        *,
+        status: TaskStatus | None = None,
+        notes: str | None = None,
+    ) -> None:
+        """Update a task's status and/or notes.
+
+        Emits ``tasks.task.updated`` when the status changes, and
+        ``tasks.task.completed`` when the new status is DONE.
+
+        Args:
+            task_id: The unique identifier of the task to update.
+            status: If provided, the new status to set.
+            notes: If provided, the new notes to set.
+
+        Raises:
+            TaskNotFoundError: If the task_id does not exist.
+        """
+        # Retrieve old status before updating (for event payload)
+        old_tasks = self._provider.list()
+        old_task = next((t for t in old_tasks if t.id == task_id), None)
+        if old_task is None:
+            raise TaskNotFoundError(f"Task '{task_id}' not found.")
+
+        old_status = old_task.status
+
+        self._provider.update(task_id, status, notes)
+
+        # Emit updated event when status changes
+        if status is not None and status != old_status:
+            self._emit(
+                TASKS_UPDATED,
+                task_id=task_id,
+                old_status=old_status.value,
+                new_status=status.value,
+            )
+            # Emit completed event when transitioning to DONE
+            if status == TaskStatus.DONE:
+                self._emit(TASKS_COMPLETED, task_id=task_id)
+
+    def delete(self, task_id: str) -> None:
+        """Delete a task by its ID.
+
+        Emits a ``tasks.task.deleted`` event with the task id.
+
+        Args:
+            task_id: The unique identifier of the task to delete.
+
+        Raises:
+            TaskNotFoundError: If the task_id does not exist.
+        """
+        # Verify existence before delegating (requirement: raise immediately)
+        old_tasks = self._provider.list()
+        old_task = next((t for t in old_tasks if t.id == task_id), None)
+        if old_task is None:
+            raise TaskNotFoundError(f"Task '{task_id}' not found.")
+
+        self._provider.delete(task_id)
+        self._emit(TASKS_DELETED, task_id=task_id)
+
+    def link(self, task_id: str, linked_to: TaskLink) -> None:
+        """Associate a task with a job, workflow step, or job phase.
+
+        Args:
+            task_id: The unique identifier of the task to link.
+            linked_to: The link specifying the kind and target.
+
+        Raises:
+            TaskNotFoundError: If the task_id does not exist.
+        """
+        # Verify existence before delegating
+        old_tasks = self._provider.list()
+        old_task = next((t for t in old_tasks if t.id == task_id), None)
+        if old_task is None:
+            raise TaskNotFoundError(f"Task '{task_id}' not found.")
+
+        self._provider.link(task_id, linked_to)

functualize_tasks/_types.py

@@ -0,0 +1,52 @@
+"""Shared types for the Tasks Domain SDK."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum
+
+
+class TaskStatus(StrEnum):
+    """Status of a task item."""
+
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    DONE = "done"
+    SKIPPED = "skipped"
+    BLOCKED = "blocked"
+
+
+@dataclass(frozen=True)
+class TaskLink:
+    """Specifies what a task is optionally linked to.
+
+    Attributes:
+        kind: The type of link — "job", "workflow_step", or "job_phase".
+        target: The identifier of the linked entity.
+    """
+
+    kind: str  # "job" | "workflow_step" | "job_phase"
+    target: str
+
+
+@dataclass(frozen=True)
+class TaskItem:
+    """A single task with id, title, status, and optional metadata.
+
+    Attributes:
+        id: Unique identifier of the task.
+        title: Human-readable title of the task.
+        status: Current status of the task.
+        linked_to: Optional link to a job, workflow step, or job phase.
+        notes: Optional free-form notes.
+        creator: Optional identifier of who created the task.
+        created_at: Optional UNIX timestamp of creation time.
+    """
+
+    id: str
+    title: str
+    status: TaskStatus
+    linked_to: TaskLink | None = None
+    notes: str | None = None
+    creator: str | None = None
+    created_at: float | None = None

functualize_tasks/testing/__init__.py

@@ -0,0 +1,13 @@
+"""Tasks testing doubles — MockTasks.
+
+Provides a deterministic, operation-capturing testing double for the Tasks
+capability, suitable for unit and integration testing of jobs that use
+task management features.
+"""
+
+from functualize_tasks.testing._mock_tasks import MockTaskOperation, MockTasks
+
+__all__ = [
+    "MockTaskOperation",
+    "MockTasks",
+]

functualize_tasks/testing/_mock_tasks.py

@@ -0,0 +1,168 @@
+"""MockTasks — operation-capturing testing double.
+
+Provides a Tasks implementation for testing that captures all operations
+(add, list, update, delete, link) for assertion. Backed by an in-memory
+TaskProvider so operations actually execute, and all calls are recorded
+in a queryable log.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+from functualize_tasks._tasks import Tasks, _InMemoryTaskProvider
+
+if TYPE_CHECKING:
+    from functualize_tasks._types import TaskItem, TaskLink, TaskStatus
+
+
+@dataclass(frozen=True)
+class MockTaskOperation:
+    """A recorded operation on the MockTasks instance.
+
+    Attributes:
+        method: The method name that was called (e.g., "add", "list").
+        args: Positional arguments as a tuple.
+        kwargs: Keyword arguments as a dict.
+        result: The return value of the operation (None for void methods).
+    """
+
+    method: str
+    args: tuple[Any, ...] = ()
+    kwargs: dict[str, Any] = field(default_factory=dict)
+    result: Any = None
+
+
+class MockTasks(Tasks):
+    """Testing double for Tasks that captures all operations for assertion.
+
+    Extends the Tasks capability with a real in-memory provider so that
+    operations actually execute (add creates tasks, list returns them, etc.),
+    while also recording every call in an operations log that tests can
+    query and assert against.
+
+    Example:
+        >>> tasks = MockTasks()
+        >>> task_id = tasks.add("Write tests")
+        >>> tasks.update(task_id, status=TaskStatus.IN_PROGRESS)
+        >>> assert len(tasks.operations) == 2
+        >>> assert tasks.operations[0].method == "add"
+        >>> assert tasks.operations[1].method == "update"
+        >>> assert tasks.adds == [tasks.operations[0]]
+
+    Args:
+        None — uses an internal in-memory provider automatically.
+    """
+
+    def __init__(self) -> None:
+        provider = _InMemoryTaskProvider()
+        super().__init__(_provider=provider)
+        self._operations: list[MockTaskOperation] = []
+
+    @property
+    def operations(self) -> list[MockTaskOperation]:
+        """All recorded operations in call order."""
+        return list(self._operations)
+
+    @property
+    def adds(self) -> list[MockTaskOperation]:
+        """All recorded 'add' operations."""
+        return [op for op in self._operations if op.method == "add"]
+
+    @property
+    def lists(self) -> list[MockTaskOperation]:
+        """All recorded 'list' operations."""
+        return [op for op in self._operations if op.method == "list"]
+
+    @property
+    def updates(self) -> list[MockTaskOperation]:
+        """All recorded 'update' operations."""
+        return [op for op in self._operations if op.method == "update"]
+
+    @property
+    def deletes(self) -> list[MockTaskOperation]:
+        """All recorded 'delete' operations."""
+        return [op for op in self._operations if op.method == "delete"]
+
+    @property
+    def links(self) -> list[MockTaskOperation]:
+        """All recorded 'link' operations."""
+        return [op for op in self._operations if op.method == "link"]
+
+    def reset(self) -> None:
+        """Clear all recorded operations."""
+        self._operations.clear()
+
+    def add(self, title: str, *, linked_to: TaskLink | None = None) -> str:
+        """Create a task and record the operation."""
+        result = super().add(title, linked_to=linked_to)
+        self._operations.append(
+            MockTaskOperation(
+                method="add",
+                args=(title,),
+                kwargs={"linked_to": linked_to},
+                result=result,
+            )
+        )
+        return result
+
+    def list(
+        self,
+        *,
+        status: TaskStatus | None = None,
+        filter: str | None = None,
+    ) -> list[TaskItem]:
+        """List tasks and record the operation."""
+        result = super().list(status=status, filter=filter)
+        self._operations.append(
+            MockTaskOperation(
+                method="list",
+                args=(),
+                kwargs={"status": status, "filter": filter},
+                result=result,
+            )
+        )
+        return result
+
+    def update(
+        self,
+        task_id: str,
+        *,
+        status: TaskStatus | None = None,
+        notes: str | None = None,
+    ) -> None:
+        """Update a task and record the operation."""
+        super().update(task_id, status=status, notes=notes)
+        self._operations.append(
+            MockTaskOperation(
+                method="update",
+                args=(task_id,),
+                kwargs={"status": status, "notes": notes},
+                result=None,
+            )
+        )
+
+    def delete(self, task_id: str) -> None:
+        """Delete a task and record the operation."""
+        super().delete(task_id)
+        self._operations.append(
+            MockTaskOperation(
+                method="delete",
+                args=(task_id,),
+                kwargs={},
+                result=None,
+            )
+        )
+
+    def link(self, task_id: str, linked_to: TaskLink) -> None:
+        """Link a task and record the operation."""
+        super().link(task_id, linked_to=linked_to)
+        self._operations.append(
+            MockTaskOperation(
+                method="link",
+                args=(task_id,),
+                kwargs={"linked_to": linked_to},
+                result=None,
+            )
+        )

functualize_tasks-0.1.0.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: functualize-tasks
+Version: 0.1.0
+Summary: Tasks Domain SDK for functualize — task management capabilities
+Author-email: Mohammad Hakim Adiprasetya <viltohmyst@gmail.com>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
+Requires-Dist: pytest>=7.4.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# functualize-tasks
+
+> **Status: Published** — Independently installable from PyPI.
+
+Tasks Domain SDK for the functualize framework. Provides a task management capability
+that acts as a mutable planning scratchpad within job execution — create, list, update,
+delete, and link tasks with structured event emission on every mutation. Storage is
+delegated to pluggable `TaskProvider` implementations, making the capability
+backend-agnostic.
+
+## Installation
+
+```bash
+pip install functualize-tasks
+```
+
+## Quick Start
+
+```python
+from functualize_tasks import Tasks, TaskStatus, TaskLink
+
+tasks = Tasks()
+
+# Create tasks
+task_id = tasks.add("Run database migration")
+tasks.add("Deploy service", linked_to=TaskLink(kind="job", target="deploy"))
+
+# Update status
+tasks.update(task_id, status=TaskStatus.IN_PROGRESS)
+tasks.update(task_id, status=TaskStatus.DONE, notes="Migration complete")
+
+# List and filter
+pending = tasks.list(status=TaskStatus.PENDING)
+all_tasks = tasks.list(filter="service")
+```
+
+## Features
+
+- **CRUD task management** — add, list, update, delete, and link tasks with a clean method-call API
+- **Event-driven mutations** — every state change emits structured events (`tasks.task.created`, `tasks.task.updated`, `tasks.task.completed`, `tasks.task.deleted`) via a duck-typed EventBus
+- **Pluggable storage** — implement the `TaskProvider` protocol to back tasks with any persistence layer (in-memory, SQLite, remote service)
+- **Rich data model** — `TaskItem` with status enum (`PENDING`, `IN_PROGRESS`, `DONE`, `SKIPPED`, `BLOCKED`), optional `TaskLink` to associate tasks with jobs or workflow steps
+- **Testing double included** — `MockTasks` captures all operations for assertion while executing against a real in-memory provider
+- **Type-safe** — fully typed with PEP 561 `py.typed` marker for mypy/pyright support
+
+## API Reference
+
+Public classes, types, and constants exported by this plugin:
+
+### Capability
+
+- `Tasks` — Main capability class providing `add()`, `list()`, `update()`, `delete()`, and `link()` methods
+
+### Protocols
+
+- `TaskProvider` — Runtime-checkable protocol that storage backends must implement
+
+### Types
+
+- `TaskItem` — Frozen dataclass representing a task (id, title, status, linked_to, notes, creator, created_at)
+- `TaskLink` — Frozen dataclass specifying a link kind and target
+- `TaskStatus` — String enum with values: `PENDING`, `IN_PROGRESS`, `DONE`, `SKIPPED`, `BLOCKED`
+
+### Errors
+
+- `TaskNotFound` — Raised when an operation targets a non-existent task ID
+
+### Event Constants
+
+- `TASKS_CREATED` — `"tasks.task.created"`
+- `TASKS_UPDATED` — `"tasks.task.updated"`
+- `TASKS_COMPLETED` — `"tasks.task.completed"`
+- `TASKS_DELETED` — `"tasks.task.deleted"`
+
+### Testing
+
+- `MockTasks` — Operation-capturing testing double with `operations`, `adds`, `updates`, `deletes`, `links` properties
+- `MockTaskOperation` — Frozen dataclass recording a single captured method call (method, args, kwargs, result)
+
+### Metadata
+
+- `domain_metadata` — `DomainMetadata` instance describing the tasks domain SDK
+
+## Development
+
+Run plugin tests:
+
+```bash
+uv run pytest plugins/functualize-tasks/tests/ -v
+```

functualize_tasks-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+functualize_tasks/__init__.py,sha256=eM-ngF-vtVP16O9fiZbLXTnTCRrzL-97LZTH88cby7A,1062
+functualize_tasks/_errors.py,sha256=HesVnN5wyNSallDcEeGQt2hVNdpmMzkfLr3FUVnKTrk,172
+functualize_tasks/_events.py,sha256=LJqbnfwCBUmiCfUa5yC2ieEP479t3zDfhGgYUOscgf0,284
+functualize_tasks/_metadata.py,sha256=_lGrQZ2zr5Qj_lygmaRYdNDXflSSxHmCZ-JA1YZVRPI,982
+functualize_tasks/_protocols.py,sha256=-odBf9i2g5EEJQo9RIYQ3h8c4bEAn0SVcAFPxWlXnqo,2734
+functualize_tasks/_tasks.py,sha256=XzZTIwBCDM3imb6fds0i29eB3_dqbV2d2NKkJfOJAmQ,8446
+functualize_tasks/_types.py,sha256=U8KF1_tlk2-GzThRy9HpF5hxaA5xYP4JOvtP2HtGo1M,1340
+functualize_tasks/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+functualize_tasks/testing/__init__.py,sha256=74ZpwLS0x3Ka9If8n6Say2QvVKCFy8rb0GKlZ2dVhPI,354
+functualize_tasks/testing/_mock_tasks.py,sha256=sjq_R4b9mx7114RB9wPcg_FIMOzXOkyzM09Dp5iAW2U,5426
+functualize_tasks-0.1.0.dist-info/METADATA,sha256=gFQV4xcOQwb6lUUAyzl-EFFV3mC50OGSBCv41AkK9LA,3900
+functualize_tasks-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+functualize_tasks-0.1.0.dist-info/entry_points.txt,sha256=cbWHKEshIClHGASgLoLdtL64Etibr2-_QcUjqCXuZwc,74
+functualize_tasks-0.1.0.dist-info/RECORD,,

functualize_tasks-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

functualize_tasks-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[functualize.domains]
+tasks = functualize_tasks._metadata:domain_metadata