taskferry 0.2.0__py3-none-any.whl

taskferry/specs.py

@@ -0,0 +1,353 @@
+"""What to execute — the portable request objects.
+
+```mermaid
+flowchart TD
+    ES["ExecutionSpec<br/>(shared: name · queue · profile · retry · timeout · metadata)"]
+    IS["InlineSpec<br/>a callable, right now"]
+    TS["TaskSpec<br/>a named function, on a task engine"]
+    JS["JobSpec<br/>a container/process, on a batch runtime"]
+
+    ES --> IS
+    ES --> TS
+    ES --> JS
+```
+
+Two rules shape every field here.
+
+**Only genuinely portable things get a field.** ``queue``, ``priority``,
+``retry``, ``timeout``, ``image``, ``resources`` mean something on every engine
+that has the corresponding capability. ``procrastinate_lock``,
+``celery_acks_late``, ``cloud_tasks_dispatch_deadline`` and
+``kubernetes_node_selector`` do not, and are therefore *not* fields — they go
+into :class:`~taskferry.core.config.ProviderOptions`, namespaced by backend:
+
+    TaskSpec(
+        task="myapp.tasks.refresh_metadata",
+        queue="metadata",
+        backend_options=BackendOptions({"procrastinate": {"lock": "meta-42"}}),
+    )
+
+An adapter reads only its own namespace and ignores the rest, so one spec travels
+unchanged from Procrastinate to Cloud Tasks and only the ignored extras differ.
+
+**Every spec declares what it needs.** ``required_capabilities()`` turns the
+fields that were actually set into the capabilities a backend must advertise. The
+base backend classes check that before submitting, so asking a thread pool for a
+GPU fails loudly at submit time rather than quietly producing a CPU run.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass, field, replace
+from datetime import datetime, timedelta
+from types import MappingProxyType
+from typing import Any
+
+from taskferry.core.config import ProviderOptions
+from taskferry.core.correlation import Correlation
+from taskferry.core.serialization import ensure_json_serializable
+from taskferry.core.typing import JSONObject, JSONValue
+
+from .capabilities import Capability
+from .execution import ExecutionKind
+from .functions import FunctionRef
+from .retry import NO_RETRY, NO_TIMEOUT, RetryPolicy, TimeoutPolicy
+
+BackendOptions = ProviderOptions
+"""Backend-specific escape hatch, namespaced by backend name.
+
+Aliased from :class:`taskferry.core.config.ProviderOptions` — same object, a name
+that reads correctly next to :class:`TaskSpec`."""
+
+
+@dataclass(frozen=True, slots=True)
+class Resources:
+    """Compute a job asks for.
+
+    ``cpu`` and ``memory`` use Kubernetes quantity syntax (``"1000m"``,
+    ``"512Mi"``) because every batch runtime can translate from it and it is
+    unambiguous about units. ``gpu`` is a count; ``gpu_type`` is the accelerator
+    name when the runtime needs one (``"nvidia-tesla-t4"``).
+    """
+
+    cpu: str | None = None
+    memory: str | None = None
+    gpu: int = 0
+    gpu_type: str | None = None
+
+    def __post_init__(self) -> None:
+        if self.gpu < 0:
+            raise ValueError("gpu count must be >= 0")
+        if self.gpu_type and not self.gpu:
+            raise ValueError("gpu_type was set but gpu count is 0")
+
+    @property
+    def is_empty(self) -> bool:
+        return not (self.cpu or self.memory or self.gpu)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class ExecutionSpec:
+    """Fields common to every kind of execution.
+
+    Attributes:
+        name: Human-readable label. Defaults to something sensible per subclass.
+        queue: Logical queue/lane. The primary routing key for tasks.
+        profile: Logical resource profile (``"heavy"``, ``"gpu"``). The primary
+            routing key for jobs. Never a provider name — that is the router's
+            job to decide.
+        retry: Portable retry intent. See :mod:`taskferry.retry`.
+        timeout: Portable wall-clock timeout intent.
+        idempotency_key: Caller-supplied deduplication key. Backends advertising
+            ``DEDUPLICATION`` collapse duplicate submissions carrying the same
+            key. Taskferry makes **no** exactly-once promise; this is a tool for
+            building idempotency, not a guarantee. See ADR-0010.
+        correlation: Correlation to propagate. Defaults to the ambient one at
+            submit time when left unset.
+        labels: Arbitrary metadata forwarded to the engine where supported.
+        backend_options: Per-backend escape hatch. See the module docstring.
+    """
+
+    name: str = ""
+    queue: str = "default"
+    profile: str = "default"
+    retry: RetryPolicy = NO_RETRY
+    timeout: TimeoutPolicy = NO_TIMEOUT
+    idempotency_key: str | None = None
+    correlation: Correlation | None = None
+    labels: Mapping[str, str] = field(default_factory=dict)
+    backend_options: BackendOptions = field(default_factory=BackendOptions)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "labels", MappingProxyType(dict(self.labels)))
+
+    @property
+    def kind(self) -> ExecutionKind:  # pragma: no cover - overridden everywhere
+        raise NotImplementedError
+
+    def required_capabilities(self) -> frozenset[Capability]:
+        """Capabilities a backend must advertise to honour this spec faithfully."""
+        required: set[Capability] = {Capability.SUBMIT}
+        if self.retry.enabled and self.retry.owner.value == "backend":
+            required.add(Capability.RETRY)
+        if self.timeout.enabled:
+            required.add(Capability.TIMEOUT)
+        if self.idempotency_key is not None:
+            required.add(Capability.DEDUPLICATION)
+        return frozenset(required)
+
+    def evolve(self, **changes: Any) -> Any:
+        """Return a modified copy. Specs are immutable; this is how you adjust one."""
+        return replace(self, **changes)
+
+    def options_for(self, backend: str) -> JSONObject:
+        """Read this spec's options for one backend (empty when none were set)."""
+        return self.backend_options.for_provider(backend)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class InlineSpec(ExecutionSpec):
+    """Run a callable right now, in this process.
+
+    The one spec that carries a live Python object: there is no process boundary
+    to cross, so there is nothing to serialize and no reason to demand an
+    importable name. That is exactly why inline works in a notebook, in a test,
+    or on a lambda.
+
+    Attributes:
+        func: The callable to run. Sync or ``async def``.
+        args: Positional arguments.
+        kwargs: Keyword arguments.
+    """
+
+    func: Callable[..., Any]
+    args: tuple[Any, ...] = ()
+    kwargs: Mapping[str, Any] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        # Explicit base call: @dataclass(slots=True) rebuilds the class, which
+        # invalidates the zero-argument super() cell in these methods.
+        ExecutionSpec.__post_init__(self)
+        object.__setattr__(self, "args", tuple(self.args))
+        object.__setattr__(self, "kwargs", MappingProxyType(dict(self.kwargs)))
+        if not callable(self.func):
+            raise TypeError(f"InlineSpec.func must be callable, got {type(self.func).__name__}")
+        if not self.name:
+            object.__setattr__(self, "name", getattr(self.func, "__qualname__", repr(self.func)))
+
+    @property
+    def kind(self) -> ExecutionKind:
+        return ExecutionKind.INLINE
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class TaskSpec(ExecutionSpec):
+    """Run a named function on a task engine.
+
+    Attributes:
+        task: Portable function reference, ``"package.module:function"``.
+        args: Positional arguments. Must be JSON-shaped — they cross a process
+            boundary.
+        kwargs: Keyword arguments. Must be JSON-shaped.
+        priority: Engine priority. Higher runs sooner where supported; the
+            absolute scale is engine-specific, only the ordering is portable.
+        delay: Wait this long before the task becomes eligible.
+        run_at: Absolute time before which the task must not run. Mutually
+            exclusive with :attr:`delay`.
+
+    Arguments are validated as JSON-serializable at construction, so a bad
+    payload fails in the caller's stack trace rather than on a worker an hour
+    later.
+    """
+
+    task: str
+    args: tuple[JSONValue, ...] = ()
+    kwargs: Mapping[str, JSONValue] = field(default_factory=dict)
+    priority: int = 0
+    delay: timedelta | None = None
+    run_at: datetime | None = None
+
+    def __post_init__(self) -> None:
+        # Explicit base call: @dataclass(slots=True) rebuilds the class, which
+        # invalidates the zero-argument super() cell in these methods.
+        ExecutionSpec.__post_init__(self)
+        object.__setattr__(self, "args", tuple(self.args))
+        object.__setattr__(self, "kwargs", MappingProxyType(dict(self.kwargs)))
+        if not self.task:
+            raise ValueError("TaskSpec.task is required")
+        # Validate the reference eagerly: a malformed path is a programming
+        # error, and finding it now beats finding it on a worker.
+        FunctionRef.parse(self.task)
+        # Same reasoning for the payload — a non-JSON argument must fail in the
+        # caller's stack trace, not an hour later inside a worker.
+        ensure_json_serializable(list(self.args))
+        ensure_json_serializable(dict(self.kwargs))
+        if self.delay is not None and self.run_at is not None:
+            raise ValueError("set either TaskSpec.delay or TaskSpec.run_at, not both")
+        if self.delay is not None and self.delay.total_seconds() < 0:
+            raise ValueError("TaskSpec.delay must not be negative")
+        if not self.name:
+            object.__setattr__(self, "name", self.task)
+
+    @property
+    def kind(self) -> ExecutionKind:
+        return ExecutionKind.TASK
+
+    @property
+    def function(self) -> FunctionRef:
+        """The parsed function reference."""
+        return FunctionRef.parse(self.task)
+
+    @property
+    def is_deferred(self) -> bool:
+        return self.delay is not None or self.run_at is not None
+
+    def scheduled_for(self, *, now: datetime | None = None) -> datetime | None:
+        """Absolute time this task becomes eligible, or ``None`` if immediate.
+
+        ``now`` is injectable so scheduling logic stays testable without
+        freezing the clock globally.
+        """
+        if self.run_at is not None:
+            return self.run_at
+        if self.delay is None:
+            return None
+        from datetime import UTC
+
+        base = now if now is not None else datetime.now(UTC)
+        return base + self.delay
+
+    def required_capabilities(self) -> frozenset[Capability]:
+        required = set(ExecutionSpec.required_capabilities(self))
+        if self.is_deferred:
+            required.add(Capability.DELAY)
+        if self.priority:
+            required.add(Capability.PRIORITY)
+        return frozenset(required)
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class JobSpec(ExecutionSpec):
+    """Run an isolated workload — a container or a process — to completion.
+
+    A Job is not a long Task. It has its own image, its own resource envelope and
+    its own lifecycle, it does not share a worker with anything else, and it
+    returns an exit code rather than a Python value. Collapsing the two would
+    force every task engine to grow container semantics it does not have.
+
+    Attributes:
+        job: Job name. Also identifies the pre-declared provider resource for
+            runtimes such as Cloud Run Jobs that run an existing Job definition.
+        image: Container image. Required by container runtimes, ignored by the
+            local subprocess backend.
+        command: Full argv. The entrypoint for the local backend; the container
+            entrypoint/args override for container runtimes.
+        args: Extra arguments appended to :attr:`command`. Kept separate because
+            several runtimes model entrypoint and args separately.
+        env: Environment variables to inject.
+        resources: CPU/memory/GPU request.
+        parallelism: Number of task instances per submission (array jobs).
+        working_dir: Working directory inside the container/process.
+    """
+
+    job: str
+    image: str | None = None
+    command: Sequence[str] = ()
+    args: Sequence[str] = ()
+    env: Mapping[str, str] = field(default_factory=dict)
+    resources: Resources = field(default_factory=Resources)
+    parallelism: int = 1
+    working_dir: str | None = None
+
+    def __post_init__(self) -> None:
+        # Explicit base call: @dataclass(slots=True) rebuilds the class, which
+        # invalidates the zero-argument super() cell in these methods.
+        ExecutionSpec.__post_init__(self)
+        object.__setattr__(self, "command", tuple(self.command))
+        object.__setattr__(self, "args", tuple(self.args))
+        object.__setattr__(self, "env", MappingProxyType(dict(self.env)))
+        if not self.job:
+            raise ValueError("JobSpec.job is required")
+        if self.parallelism < 1:
+            raise ValueError("JobSpec.parallelism must be >= 1")
+        if not self.name:
+            object.__setattr__(self, "name", self.job)
+
+    @property
+    def kind(self) -> ExecutionKind:
+        return ExecutionKind.JOB
+
+    @property
+    def argv(self) -> tuple[str, ...]:
+        """Full argv: :attr:`command` followed by :attr:`args`."""
+        return (*self.command, *self.args)
+
+    def required_capabilities(self) -> frozenset[Capability]:
+        required = set(ExecutionSpec.required_capabilities(self))
+        if self.parallelism > 1:
+            required.add(Capability.PARALLELISM)
+        if self.resources.cpu is not None:
+            required.add(Capability.CPU)
+        if self.resources.memory is not None:
+            required.add(Capability.MEMORY)
+        if self.resources.gpu > 0:
+            required.add(Capability.GPU)
+        if self.env:
+            required.add(Capability.ENVIRONMENT)
+        return frozenset(required)
+
+
+AnySpec = InlineSpec | TaskSpec | JobSpec
+"""Union of every spec kind — what :meth:`taskferry.Taskferry.submit` accepts."""
+
+
+__all__ = [
+    "AnySpec",
+    "BackendOptions",
+    "ExecutionSpec",
+    "InlineSpec",
+    "JobSpec",
+    "Resources",
+    "TaskSpec",
+]

taskferry/tracking.py

@@ -0,0 +1,129 @@
+"""Pairing Taskferry ids with engine ids — the bookkeeping every adapter needs.
+
+A Taskferry id is Taskferry's. Procrastinate mints an integer, Cloud Run mints a
+resource path, AWS Batch mints a UUID, and none of them will ever store ours. So
+an adapter that wants ``get(execution_id)`` to work has to remember the pairing:
+
+```mermaid
+flowchart LR
+    SUB["submit()"]
+    IDX["ExternalIdIndex<br/>task_9f2c... ↔ 4711"]
+    GET["get(task_9f2c...)"]
+    ENG["engine.lookup(4711)"]
+
+    SUB -->|"remember"| IDX
+    GET -->|"resolve"| IDX --> ENG
+```
+
+Five adapters were about to grow the same ``OrderedDict`` plus lock plus eviction
+loop, so it lives here once, with the two properties that matter:
+
+**Bounded.** A producer that runs for a month must not accumulate a map for a
+month. Oldest entries are evicted, and an evicted lookup fails loudly.
+
+**Honest about its scope.** The index is per-process and in-memory. It cannot
+survive a restart and it is invisible to another replica — which is a real
+limitation of looking an execution up by Taskferry id, not something to paper
+over. Adapters accept the engine's own id as a fallback so an operator holding a
+job id from a dashboard can always look it up, from anywhere.
+"""
+
+from __future__ import annotations
+
+import threading
+from collections import OrderedDict
+from collections.abc import Callable
+
+DEFAULT_CAPACITY = 10_000
+"""Entries kept before the oldest is evicted. Roughly 1 MB at typical id sizes."""
+
+
+class ExternalIdIndex:
+    """A bounded, thread-safe, bidirectional map of Taskferry id ↔ engine id.
+
+    Args:
+        capacity: Maximum entries. Zero disables tracking entirely, which is a
+            legitimate choice for a fire-and-forget backend that could not look
+            an execution up anyway.
+        recognises: Predicate deciding whether a string is already an engine id.
+            It lets ``resolve`` accept ``"projects/p/locations/eu/executions/x"``
+            or ``"4711"`` directly, so an id copied from a console works without
+            this process ever having submitted it.
+    """
+
+    __slots__ = ("_by_execution", "_capacity", "_lock", "_recognises")
+
+    def __init__(
+        self,
+        *,
+        capacity: int = DEFAULT_CAPACITY,
+        recognises: Callable[[str], bool] | None = None,
+    ) -> None:
+        if capacity < 0:
+            raise ValueError("capacity must be >= 0")
+        self._capacity = capacity
+        self._recognises = recognises
+        self._by_execution: OrderedDict[str, str] = OrderedDict()
+        self._lock = threading.Lock()
+
+    def __len__(self) -> int:
+        with self._lock:
+            return len(self._by_execution)
+
+    def __contains__(self, execution_id: object) -> bool:
+        with self._lock:
+            return str(execution_id) in self._by_execution
+
+    def __repr__(self) -> str:
+        return f"ExternalIdIndex(entries={len(self)}, capacity={self._capacity})"
+
+    def remember(self, execution_id: str, external_id: str | None) -> None:
+        """Record the pairing produced by a submission. ``None`` is ignored."""
+        if external_id is None or self._capacity == 0:
+            return
+        with self._lock:
+            self._by_execution[execution_id] = external_id
+            self._by_execution.move_to_end(execution_id)
+            while len(self._by_execution) > self._capacity:
+                self._by_execution.popitem(last=False)
+
+    def resolve(self, execution_id: str) -> str | None:
+        """The engine id for ``execution_id``, or ``None`` when it is unknown.
+
+        A remembered pairing wins. Failing that, ``execution_id`` is returned
+        unchanged if ``recognises`` says it already *is* an engine id.
+        """
+        with self._lock:
+            known = self._by_execution.get(execution_id)
+            if known is not None:
+                self._by_execution.move_to_end(execution_id)
+                return known
+        if self._recognises is not None and self._recognises(execution_id):
+            return execution_id
+        return None
+
+    def forget(self, execution_id: str) -> None:
+        """Drop one pairing. Silent when it was not tracked."""
+        with self._lock:
+            self._by_execution.pop(execution_id, None)
+
+    def clear(self) -> None:
+        with self._lock:
+            self._by_execution.clear()
+
+
+def is_digits(value: str) -> bool:
+    """``recognises`` predicate for engines with numeric ids (Procrastinate)."""
+    return value.isdigit()
+
+
+def has_prefix(prefix: str) -> Callable[[str], bool]:
+    """``recognises`` predicate for engines with path-shaped ids (Cloud Run, GCP)."""
+
+    def _check(value: str) -> bool:
+        return value.startswith(prefix)
+
+    return _check
+
+
+__all__ = ["DEFAULT_CAPACITY", "ExternalIdIndex", "has_prefix", "is_digits"]

taskferry-0.2.0.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.5
+Name: taskferry
+Version: 0.2.0
+Summary: A portable execution layer for Python — inline, tasks and jobs on the engines you already run.
+Project-URL: Homepage, https://github.com/xiidigital/taskferry
+Project-URL: Documentation, https://taskferry.dev
+Project-URL: Source, https://github.com/xiidigital/taskferry
+Project-URL: Changelog, https://github.com/xiidigital/taskferry/blob/main/packages/taskferry/CHANGELOG.md
+Author: Taskferry authors
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: capabilities,execution,jobs,portability,ports-and-adapters,taskferry,tasks
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Distributed Computing
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# taskferry
+
+**A portable execution layer for Python.**
+
+Taskferry models units of work, chooses the right *kind* of execution, and routes
+them to engines that already exist. It is not a task queue, not a worker system,
+not a scheduler and not a workflow engine.
+
+```bash
+pip install taskferry
+```
+
+That installs **nothing else**. No Django, no PostgreSQL driver, no Redis client,
+no cloud SDK. The distribution declares zero dependencies and CI proves it in a
+bare virtualenv on every commit.
+
+```python
+from taskferry import Taskferry
+
+runtime = Taskferry.local()
+
+
+def add(a: int, b: int) -> int:
+    return a + b
+
+
+execution = runtime.inline.submit(add, 20, 22)
+assert execution.result().value == 42
+```
+
+## Three primitives
+
+```python
+runtime.inline.submit(add, 20, 22)  # now, in this process
+runtime.tasks.submit("myapp.tasks:send_email", 42)  # later, on an engine
+runtime.jobs.submit("build-cog", image="gdal:latest")  # a container, to completion
+```
+
+A Job is not "a Task that takes longer": it has its own image, its own resource
+envelope and its own lifecycle, and it returns an exit code rather than a Python
+value.
+
+## Built-in backends
+
+| Backend | Kind | Use |
+| --- | --- | --- |
+| `inline` | inline | tests, notebooks, CLIs, small tools |
+| `thread` | task | development, single-process applications |
+| `process` | task | rehearsing what a real worker does to your code |
+| `subprocess` | job | local batch workloads |
+
+None of them is a queue. They are not durable, not visible across processes, and
+they lose pending work on restart — which is stated plainly in their docstrings
+and in their capability sets. For production, route at a real engine; that is a
+configuration change.
+
+## Adapters
+
+Install the engine you use. Each registers itself through the `taskferry.backends`
+entry-point group, so naming it in configuration is all it takes.
+
+```bash
+pip install taskferry-procrastinate    # PostgreSQL-backed tasks
+pip install taskferry-cloudtasks       # push-based serverless tasks
+pip install taskferry-cloudrun         # serverless container jobs
+pip install taskferry-jobs             # AWS Batch, Kubernetes, Azure Container Apps
+pip install taskferry-django           # django.tasks integration
+```
+
+## CLI
+
+```bash
+taskferry backends
+taskferry capabilities pg
+taskferry route --kind job --profile gpu
+taskferry doctor
+```
+
+## Documentation
+
+Full documentation, ADRs and the migration guide live in the
+[repository](https://github.com/xiidigital/taskferry).
+
+## License
+
+Apache-2.0.

taskferry-0.2.0.dist-info/RECORD

@@ -0,0 +1,48 @@
+taskferry/__init__.py,sha256=jlXhwsG9uYObCO9uNw_UBVjLFnbXU7jbmxIBoNEdL4E,5828
+taskferry/aio.py,sha256=K9vqsLg2FQhnT4UOI90HHi8rA6VK-g2YlspFVt7rOg4,16970
+taskferry/capabilities.py,sha256=kDbbbxTBazYKlH9otRn7Qi_63zwN9r7YawqM24cDo88,3140
+taskferry/cli.py,sha256=UDkhgHwqUcqc4Z_0m5FNtnWEhvxGKBv3JEklQKn3IeM,16294
+taskferry/config.py,sha256=4b_y_GzHVRK2Ze7c40D5kpPGEqZZKJeWIKL2s1djARw,14564
+taskferry/envelope.py,sha256=UQdkGJ9lT-UmcX5rZB3xwCGpWGYUht3j0d2dJeyTcT4,7169
+taskferry/errors.py,sha256=r3YrjBGoTmWEB0-vHMZLjEvbmjk3mrnQAmnB-5p6_4Q,4700
+taskferry/execution.py,sha256=rmtg11DjIlE39YlOrDEi6GDU2NR-1m-8SqLyQKupR5U,8466
+taskferry/functions.py,sha256=JC0jAWUALiR7BjtG2FKMbuOuOHr30XvBQqbbj5YkKHk,11774
+taskferry/handle.py,sha256=cBv7oK3WWPYSajN91pxs9Emyptu-VLwwM-0m-hoPsCw,6656
+taskferry/hooks.py,sha256=pKUDyD5pvQF8QlQoK0AlyFZ6jNSmKvZkZEHMmISkYWI,9047
+taskferry/plugins.py,sha256=MNGhZOBju_GmixZGYj0PLEBAXmN5y4ZE_tJ3CSeWVNw,6374
+taskferry/ports.py,sha256=lPO3U3BippQzVZn-AvVgkiG0k4o6qRNHO0F6xARhG_c,13741
+taskferry/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+taskferry/retry.py,sha256=qqv2Dl-87WvqIHDoYnwZ8d8wr9AM2UPXO6MDoFV0G7U,6920
+taskferry/router.py,sha256=TP93M0ly3RvALZKBWWWnsJsOlv0arop-NAlaKsSJafc,6252
+taskferry/runtime.py,sha256=LfqDIeYy1XAGriNqnObQrFwV5uc4PlZdGZgVYXBZ8j8,22729
+taskferry/specs.py,sha256=Z1O2FBs7wuASC-1N97Ri-x-egQnHFnmsBh8hl6EYQNM,14169
+taskferry/tracking.py,sha256=kcGMPt2pccWwXMyPgcst4h5tt8BpF9iAhbpM8q6i2QQ,4793
+taskferry/backends/__init__.py,sha256=9odsHuv_OFMRIGn9SvCslBcXaWW-pkFkwyOI2COBUWI,1394
+taskferry/backends/inline.py,sha256=Kxdou00scP_ebXPUbPyyksITk6rnK1jaXgSb_iMJg0g,8215
+taskferry/backends/process.py,sha256=UiJ_Yr-BvmP1m3Eqxd_EaoCcA-CM1g4AWIeYLkEBsqY,10482
+taskferry/backends/subprocess.py,sha256=_f8bg-MEb90cZzdGZs_J15JBltWHPR0jvqIPFmlWhB4,14192
+taskferry/backends/thread.py,sha256=lo9ehxUQWf4JJQTkQdxJmiHeQ3fMV7fw6bl4X2XG9b8,12864
+taskferry/contract/__init__.py,sha256=TJr1qq8IQTjh4moga-8vHQssg4gPOnGv1DkQaC_hZgk,1742
+taskferry/contract/base.py,sha256=NJqGZTmt4lEHJdivx4Pl9EBaqtnRLy5jWOHGRYjnusk,7927
+taskferry/contract/inline.py,sha256=cOaUsBh5IEUky0XSmbCki7VKt8bNYG9T818i-FRSNp8,3143
+taskferry/contract/job.py,sha256=F85ekBdrFS1-67YyAbTFui_7LIVB1E53DV9pZjO06p4,3451
+taskferry/contract/task.py,sha256=6I6Z3q_vkWmO9I-hd0NpjNDVzU0WecVnMFJK01Eif1Y,3352
+taskferry/core/__init__.py,sha256=_xTuiMvnsRRf3yakVRZheHUr-g2-b4uZpovMUHCa1hI,3237
+taskferry/core/capabilities.py,sha256=9Sazy_jVplY_C-T3bHCSPKRjRTbffyIJmJBCUviPYN4,3243
+taskferry/core/config.py,sha256=do2C-mc6ThSkTed_ZF_ktRMEnVsOgHE_WejqH24_FX8,5498
+taskferry/core/correlation.py,sha256=CUsMWhQj_QY9pcEYq5iQ1vDCbypwNj8jdx8Zh-4_jRo,4210
+taskferry/core/delivery.py,sha256=xNBwawpBR7D5lzH5ON94zsaf_gxfJpdADfstLb-D7i8,1073
+taskferry/core/errors.py,sha256=yS48DNSgf-PFobj65OfZdMuLfjsdWOoZrUM1YfiIrOs,1831
+taskferry/core/ids.py,sha256=69bD2Um1FU4eeFWx_HRBA3r2PgflxGjKO9jBQ2MV6QE,1303
+taskferry/core/observability.py,sha256=unXRWzWEsEKKrj1q2ajK0l9fuqzsMJgDDyLDONTb8_w,3881
+taskferry/core/otel.py,sha256=-lZzp8GdwAPmMYJfGoCTcYOR1UVsiaR_YfQoo2a1VCI,2798
+taskferry/core/provider.py,sha256=6aqk468rMnVKl9lEbUAV2MGHhm5eEvFeUU0Q4Kpu_w0,1968
+taskferry/core/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+taskferry/core/registry.py,sha256=9pTIXb4HUnRaZWTp_Uh-nlMTDsh7n1vTlFGUsi3kwdM,3425
+taskferry/core/serialization.py,sha256=ROh3w8E2A8c0O1I7SVbkA7HGbOjmv-fZBHG7h-wrtxI,2529
+taskferry/core/typing.py,sha256=IHbJbt5i1ClEDfqiMcAtLMar3t-n8QaRHnCA3tgri6U,649
+taskferry-0.2.0.dist-info/METADATA,sha256=fIBdxHV3m7BRTimEIYeTPzfaQe8NBnggUWJGCETDXHQ,3575
+taskferry-0.2.0.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
+taskferry-0.2.0.dist-info/entry_points.txt,sha256=bx6DKenzSZRUXdqcoChvz07P3TeLpIteyNl1LWl9f_E,49
+taskferry-0.2.0.dist-info/licenses/LICENSE,sha256=de-gfE0q-xTYImzwC3dj3S7BxVhanf6RmIGjo_7y3aw,11357
+taskferry-0.2.0.dist-info/RECORD,,

taskferry-0.2.0.dist-info/WHEEL

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

taskferry-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+taskferry = taskferry.cli:main