taskforge-sdk 0.1.0__py3-none-any.whl

taskforge/__init__.py

@@ -0,0 +1,63 @@
+"""TaskForge Python SDK.
+
+Client for the TaskForge HTTP API and task registry for worker handlers.
+
+Quickstart:
+    from taskforge import TaskForgeClient
+
+    async with TaskForgeClient(api_key="...") as client:
+        job = await client.enqueue(
+            task_name="send_welcome_email",
+            queue="emails",
+            payload={"recipient": "user@example.com"},
+        )
+        final = await client.wait_for(job.id)
+        print(final.status)
+"""
+
+from taskforge.client import TaskForgeClient
+from taskforge.exceptions import (
+    APIError,
+    ConflictError,
+    NotFoundError,
+    TaskForgeConnectionError,
+    TaskForgeError,
+    UnauthorizedError,
+    ValidationError,
+)
+from taskforge.registry import TaskRegistry
+from taskforge.types import (
+    Attempt,
+    Job,
+    JobDetail,
+    JobStatus,
+    Page,
+    Priority,
+    Queue,
+    RetryPolicy,
+    SubmitResponse,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "__version__",
+    "TaskForgeClient",
+    "TaskRegistry",
+    "Attempt",
+    "Job",
+    "JobDetail",
+    "JobStatus",
+    "Page",
+    "Priority",
+    "Queue",
+    "RetryPolicy",
+    "SubmitResponse",
+    "TaskForgeError",
+    "TaskForgeConnectionError",
+    "APIError",
+    "NotFoundError",
+    "ConflictError",
+    "ValidationError",
+    "UnauthorizedError",
+]

taskforge/client.py

@@ -0,0 +1,276 @@
+"""Async client for the TaskForge HTTP API.
+
+    from taskforge import TaskForgeClient
+
+    async with TaskForgeClient(api_key="...") as client:
+        job = await client.enqueue(
+            task_name="send_welcome_email",
+            queue="emails",
+            payload={"recipient": "user@example.com"},
+        )
+        print(job.id)
+"""
+
+import os
+from datetime import datetime
+from typing import Any, AsyncIterator
+
+import httpx
+
+from taskforge.exceptions import (
+    APIError,
+    ConflictError,
+    NotFoundError,
+    TaskForgeConnectionError,
+    UnauthorizedError,
+    ValidationError,
+)
+from taskforge.types import (
+    Job,
+    JobDetail,
+    JobStatus,
+    Page,
+    Priority,
+    Queue,
+    RetryPolicy,
+    SubmitResponse,
+)
+
+DEFAULT_BASE_URL = "http://localhost:8000"
+DEFAULT_TIMEOUT = 30.0
+
+_STATUS_TO_ERROR = {
+    401: UnauthorizedError,
+    404: NotFoundError,
+    409: ConflictError,
+    422: ValidationError,
+}
+
+
+def _error_message(body: dict[str, Any]) -> str:
+    """Extract a readable message from a FastAPI error body."""
+    detail = body.get("detail") or body.get("message")
+    if isinstance(detail, list):
+        parts = []
+        for item in detail:
+            if isinstance(item, dict):
+                parts.append(str(item.get("msg") or item))
+            else:
+                parts.append(str(item))
+        return "; ".join(parts) if parts else "unknown validation error"
+    return str(detail) if detail else f"unknown error"
+
+
+class TaskForgeClient:
+    def __init__(
+        self,
+        base_url: str = DEFAULT_BASE_URL,
+        api_key: str | None = None,
+        timeout: float = DEFAULT_TIMEOUT,
+        *,
+        transport: httpx.AsyncBaseTransport | None = None,
+    ) -> None:
+        api_key = api_key or os.environ.get("TASKFORGE_API_KEY")
+        if not api_key:
+            raise ValueError(
+                "api_key is required - pass api_key=... or set TASKFORGE_API_KEY"
+            )
+
+        self._client = httpx.AsyncClient(
+            base_url=base_url.rstrip("/") + "/api/v1",
+            headers={"X-API-Key": api_key, "Content-Type": "application/json"},
+            timeout=timeout,
+            transport=transport,
+        )
+
+    @classmethod
+    def from_env(cls) -> "TaskForgeClient":
+        """Construct from TASKFORGE_URL and TASKFORGE_API_KEY env vars."""
+        return cls(
+            base_url=os.environ.get("TASKFORGE_URL", DEFAULT_BASE_URL),
+            api_key=os.environ.get("TASKFORGE_API_KEY", ""),
+        )
+
+    async def __aenter__(self) -> "TaskForgeClient":
+        return self
+
+    async def __aexit__(self, *_exc: Any) -> None:
+        await self.aclose()
+
+    async def aclose(self) -> None:
+        await self._client.aclose()
+
+    # -- HTTP helper --------------------------------------------------
+
+    async def _request(self, method: str, path: str, **kwargs: Any) -> Any:
+        try:
+            resp = await self._client.request(method, path, **kwargs)
+        except httpx.HTTPError as exc:
+            raise TaskForgeConnectionError(str(exc)) from exc
+
+        if resp.is_success:
+            if resp.status_code == 204 or not resp.content:
+                return None
+            return resp.json()
+
+        try:
+            body = resp.json()
+        except Exception:
+            body = {"detail": resp.text or f"HTTP {resp.status_code}"}
+
+        error_cls = _STATUS_TO_ERROR.get(resp.status_code, APIError)
+        raise error_cls(
+            status_code=resp.status_code,
+            code=body.get("code"),
+            message=_error_message(body),
+            request_id=body.get("request_id") or resp.headers.get("X-Request-ID"),
+        )
+
+    # -- Jobs ---------------------------------------------------------
+
+    async def enqueue(
+        self,
+        task_name: str,
+        payload: dict[str, Any],
+        *,
+        queue: str = "default",
+        priority: Priority = "normal",
+        scheduled_at: datetime | str | None = None,
+        retry_policy: RetryPolicy | None = None,
+        max_attempts: int | None = None,
+        initial_delay_seconds: int | None = None,
+        max_delay_seconds: int | None = None,
+        timeout_seconds: int | None = None,
+        idempotency_key: str | None = None,
+    ) -> SubmitResponse:
+        """Submit a job. Returns the server's 202 Accepted response."""
+        if retry_policy is None:
+            overrides: dict[str, Any] = {}
+            if max_attempts is not None:
+                overrides["max_attempts"] = max_attempts
+            if initial_delay_seconds is not None:
+                overrides["initial_delay_seconds"] = initial_delay_seconds
+            if max_delay_seconds is not None:
+                overrides["max_delay_seconds"] = max_delay_seconds
+            if overrides:
+                retry_policy = RetryPolicy(**overrides)
+
+        body: dict[str, Any] = {
+            "queue": queue,
+            "task_name": task_name,
+            "payload": payload,
+            "priority": priority,
+        }
+        if scheduled_at is not None:
+            body["scheduled_at"] = (
+                scheduled_at.isoformat()
+                if hasattr(scheduled_at, "isoformat")
+                else scheduled_at
+            )
+        if retry_policy is not None:
+            body["retry_policy"] = retry_policy.model_dump()
+        if timeout_seconds is not None:
+            body["timeout_seconds"] = timeout_seconds
+        if idempotency_key is not None:
+            body["idempotency_key"] = idempotency_key
+
+        data = await self._request("POST", "/jobs", json=body)
+        return SubmitResponse.model_validate(data)
+
+    async def get(self, job_id: str) -> JobDetail:
+        """Fetch the full job record including payload, result, and attempts."""
+        data = await self._request("GET", f"/jobs/{job_id}")
+        return JobDetail.model_validate(data)
+
+    async def list_jobs(
+        self,
+        *,
+        status: JobStatus | list[JobStatus] | None = None,
+        queue: str | None = None,
+        task_name: str | None = None,
+        priority: int | None = None,
+        limit: int = 25,
+        cursor: str | None = None,
+    ) -> Page[Job]:
+        """List jobs with filters. Returns one page."""
+        params: list[tuple[str, str]] = [("limit", str(limit))]
+        if status is not None:
+            statuses = [status] if isinstance(status, str) else status
+            params.extend(("status", s) for s in statuses)
+        if queue:
+            params.append(("queue", queue))
+        if task_name:
+            params.append(("task_name", task_name))
+        if priority is not None:
+            params.append(("priority", str(priority)))
+        if cursor:
+            params.append(("cursor", cursor))
+
+        data = await self._request("GET", "/jobs", params=params)
+        return Page[Job](
+            items=[Job.model_validate(item) for item in data["items"]],
+            next_cursor=data.get("next_cursor"),
+        )
+
+    async def iter_jobs(self, **filters: Any) -> AsyncIterator[Job]:
+        """Iterate over all pages of matching jobs."""
+        cursor: str | None = None
+        while True:
+            page = await self.list_jobs(cursor=cursor, **filters)
+            for item in page.items:
+                yield item
+            if not page.next_cursor:
+                break
+            cursor = page.next_cursor
+
+    async def cancel(self, job_id: str) -> JobDetail:
+        """Cancel a queued/scheduled/retry_scheduled job."""
+        data = await self._request("POST", f"/jobs/{job_id}/cancel")
+        return JobDetail.model_validate(data)
+
+    async def wait_for(
+        self,
+        job_id: str,
+        *,
+        poll_interval: float = 1.0,
+        timeout: float = 300.0,
+    ) -> JobDetail:
+        """Poll until the job reaches a terminal state."""
+        import asyncio
+
+        terminal = {"succeeded", "failed", "dead_lettered", "cancelled"}
+        elapsed = 0.0
+        while elapsed < timeout:
+            job = await self.get(job_id)
+            if job.status in terminal:
+                return job
+            await asyncio.sleep(poll_interval)
+            elapsed += poll_interval
+        raise TimeoutError(
+            f"job {job_id} did not reach terminal state within {timeout}s"
+        )
+
+    # -- Queues -------------------------------------------------------
+
+    async def queues(self) -> list[Queue]:
+        """List all queues configured for the tenant."""
+        data = await self._request("GET", "/queues")
+        return [Queue.model_validate(item) for item in data["items"]]
+
+    # -- Health -------------------------------------------------------
+
+    async def health_live(self) -> bool:
+        """True if the API process responds."""
+        try:
+            data = await self._request("GET", "/health/live")
+            return bool(data and data.get("status") == "ok")
+        except TaskForgeConnectionError:
+            return False
+
+    async def health_ready(self) -> bool:
+        """True if the API and its dependencies are ready."""
+        try:
+            data = await self._request("GET", "/health/ready")
+            return bool(data and data.get("status") == "ok")
+        except TaskForgeConnectionError:
+            return False

taskforge/exceptions.py

@@ -0,0 +1,42 @@
+"""Typed exceptions raised by TaskForgeClient."""
+
+
+class TaskForgeError(Exception):
+    """Base class for all SDK errors."""
+
+
+class TaskForgeConnectionError(TaskForgeError):
+    """Network layer failed - the API was unreachable."""
+
+
+class APIError(TaskForgeError):
+    """Server returned a non-2xx response."""
+
+    def __init__(
+        self,
+        status_code: int,
+        code: str | None,
+        message: str,
+        request_id: str | None = None,
+    ) -> None:
+        self.status_code = status_code
+        self.code = code
+        self.message = message
+        self.request_id = request_id
+        super().__init__(f"[{status_code}] {code or 'error'}: {message}")
+
+
+class NotFoundError(APIError):
+    """404 - resource does not exist."""
+
+
+class ConflictError(APIError):
+    """409 - state conflict (idempotency mismatch, invalid transition, ...)."""
+
+
+class ValidationError(APIError):
+    """422 - request payload failed validation."""
+
+
+class UnauthorizedError(APIError):
+    """401 - missing or invalid API key."""

taskforge/registry.py

@@ -0,0 +1,55 @@
+"""Explicit task registry for worker handlers.
+
+Framework-agnostic: holds a dict of name -> coroutine function.
+
+Supports three decorator forms:
+    @registry.task                      # bare — uses fn.__name__
+    @registry.task()                    # empty parens — same
+    @registry.task(name="custom.name")  # explicit name
+"""
+
+from collections.abc import Awaitable, Callable
+from typing import Any, Union
+
+HandlerFn = Callable[[dict[str, Any]], Awaitable[dict[str, Any] | None]]
+
+
+class TaskRegistry:
+    def __init__(self) -> None:
+        self._handlers: dict[str, HandlerFn] = {}
+
+    def task(self, name: Union[str, HandlerFn, None] = None):
+        """Decorator. Accepts bare, empty-paren, or named usage.
+
+        Bare usage detection: if `name` is callable, `@registry.task` was
+        used without parens — the function itself arrives as `name`.
+        """
+        # Bare usage: @registry.task  → 'name' is the function itself
+        if callable(name):
+            fn = name
+            self._register(fn.__name__, fn)
+            return fn
+
+        # Paren usage: @registry.task() or @registry.task(name="...")
+        def decorator(fn: HandlerFn) -> HandlerFn:
+            self._register(name or fn.__name__, fn)
+            return fn
+
+        return decorator
+
+    def _register(self, task_name: str, fn: HandlerFn) -> None:
+        if task_name in self._handlers:
+            raise ValueError(f"task {task_name!r} is already registered")
+        self._handlers[task_name] = fn
+
+    def get(self, name: str) -> HandlerFn | None:
+        return self._handlers.get(name)
+
+    def names(self) -> list[str]:
+        return sorted(self._handlers.keys())
+
+    def __contains__(self, name: object) -> bool:
+        return isinstance(name, str) and name in self._handlers
+
+    def __len__(self) -> int:
+        return len(self._handlers)

taskforge/types.py

@@ -0,0 +1,114 @@
+"""Typed models mirroring the TaskForge HTTP API."""
+
+from datetime import datetime
+from typing import Any, Generic, Literal, TypeVar
+from uuid import UUID
+
+from pydantic import BaseModel, ConfigDict, Field
+
+Priority = Literal["low", "normal", "high"]
+
+JobStatus = Literal[
+    "scheduled",
+    "queued",
+    "running",
+    "retry_scheduled",
+    "succeeded",
+    "failed",
+    "dead_lettered",
+    "cancelled",
+]
+
+
+class RetryPolicy(BaseModel):
+    """Per-job retry policy. Defaults match the server."""
+
+    max_attempts: int = Field(default=5, ge=1, le=50)
+    initial_delay_seconds: int = Field(default=2, ge=1, le=3600)
+    max_delay_seconds: int = Field(default=300, ge=1, le=86400)
+    backoff_multiplier: float = Field(default=2.0, ge=1.0, le=10.0)
+    jitter: bool = True
+
+
+class SubmitResponse(BaseModel):
+    """Response from POST /jobs (202 Accepted)."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    job_id: UUID
+    status: JobStatus
+    queue: str
+    task_name: str
+    created_at: datetime
+
+    @property
+    def id(self) -> UUID:
+        """Alias for job_id, for ergonomic access."""
+        return self.job_id
+
+
+class Job(BaseModel):
+    """Job summary as returned by GET /jobs."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    id: UUID
+    queue: str
+    task_name: str
+    status: JobStatus
+    priority: int
+    attempts: int
+    max_attempts: int
+    scheduled_at: datetime
+    started_at: datetime | None = None
+    completed_at: datetime | None = None
+    created_at: datetime
+    updated_at: datetime
+
+
+class Attempt(BaseModel):
+    """One execution attempt of a job."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    id: UUID
+    attempt_number: int
+    status: str
+    started_at: datetime
+    finished_at: datetime | None = None
+    duration_ms: int | None = None
+    error_type: str | None = None
+    error_message: str | None = None
+    error_traceback: str | None = None
+
+
+class JobDetail(Job):
+    """Full job record with payload, result, and attempt history."""
+
+    payload: dict[str, Any]
+    result: dict[str, Any] | None = None
+    last_error: str | None = None
+    timeout_seconds: int
+    attempt_records: list[Attempt] = Field(default_factory=list)
+
+
+class Queue(BaseModel):
+    """Queue configuration."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    id: UUID
+    name: str
+    max_concurrency: int
+    is_active: bool
+    created_at: datetime
+
+
+T = TypeVar("T")
+
+
+class Page(BaseModel, Generic[T]):
+    """Cursor-paginated list of items."""
+
+    items: list[T]
+    next_cursor: str | None = None

taskforge_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,218 @@
+Metadata-Version: 2.5
+Name: taskforge-sdk
+Version: 0.1.0
+Summary: Python client for the TaskForge distributed job engine
+Project-URL: Homepage, https://github.com/Olufemooshegs/taskforge
+License: MIT
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.7
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+
+# TaskForge SDK
+
+Python client for the TaskForge distributed job engine.
+
+Typed async HTTP client plus a task registry for worker handlers.
+
+## Install
+
+From a local checkout (the package isn't published to PyPI):
+
+```bash
+cd sdk
+pip install -e ".[dev]"
+```
+
+Requires Python 3.10+ (the SDK is pure Python — no compiled dependencies).
+
+## Quickstart
+
+```python
+import asyncio
+from taskforge import TaskForgeClient
+
+
+async def main():
+    async with TaskForgeClient(
+        base_url="http://localhost:8000",
+        api_key="dev-api-key-change-me",
+    ) as client:
+        # Submit a job
+        job = await client.enqueue(
+            task_name="send_welcome_email",
+            queue="emails",
+            payload={"recipient": "user@example.com"},
+            priority="high",
+            max_attempts=5,
+        )
+        print(f"submitted: {job.id} ({job.status})")
+
+        # Poll until terminal
+        final = await client.wait_for(job.id, timeout=60)
+        print(f"final status: {final.status}")
+        if final.result:
+            print(f"result: {final.result}")
+
+
+asyncio.run(main())
+```
+
+Expected output:
+
+```
+submitted: <uuid> (queued)
+final status: succeeded
+result: {'echoed': {...}}
+```
+
+## Task registry
+
+Register handlers on the worker side with the decorator. Three forms:
+
+```python
+from taskforge import TaskRegistry
+
+registry = TaskRegistry()
+
+
+# Form 1: bare decorator, uses fn.__name__
+@registry.task
+async def send_welcome_email(payload: dict) -> dict:
+    recipient = payload["recipient"]
+    return {"recipient": recipient, "sent": True}
+
+
+# Form 2: empty parens, same behavior
+@registry.task()
+async def noop(payload: dict) -> dict:
+    return {}
+
+
+# Form 3: explicit name
+@registry.task(name="custom.name")
+async def any_function(payload: dict) -> dict:
+    return {"ok": True}
+```
+
+The registry is framework-agnostic — it holds a dict of name → coroutine function. Feeding it into a worker loop lives in the TaskForge backend's worker process, not in this SDK.
+
+## Error hierarchy
+
+All exceptions inherit from `TaskForgeError`:
+
+| Class | When |
+|---|---|
+| `TaskForgeConnectionError` | Network unreachable (httpx raised) |
+| `APIError` | Any 4xx/5xx from the server |
+| `NotFoundError` | 404 (job/queue/dead-letter missing) |
+| `ConflictError` | 409 (idempotency mismatch, invalid transition) |
+| `ValidationError` | 422 (payload validation) |
+| `UnauthorizedError` | 401 (bad API key) |
+
+`APIError` carries `.status_code`, `.code`, `.message`, `.request_id`. FastAPI validation errors (`422`) are flattened — the `.message` joins all per-field `msg` strings with `; `.
+
+## Client methods
+
+| Method | Purpose |
+|---|---|
+| `enqueue(task_name, payload, *, queue, priority, retry_policy, max_attempts, ...)` | Submit a job |
+| `get(job_id)` | Full job detail with attempt history |
+| `list_jobs(*, status, queue, task_name, priority, limit, cursor)` | Filtered list, one page |
+| `iter_jobs(**filters)` | Async iterator over all pages |
+| `cancel(job_id)` | Cancel queued/scheduled/retry_scheduled |
+| `wait_for(job_id, *, poll_interval, timeout)` | Poll until terminal state |
+| `queues()` | List queues |
+| `health_live()`, `health_ready()` | Liveness / readiness booleans |
+
+### `enqueue` — retry policy
+
+Three ways to specify, from most to least explicit:
+
+```python
+# 1. Full RetryPolicy object
+from taskforge import RetryPolicy
+await client.enqueue(
+    task_name="x", payload={},
+    retry_policy=RetryPolicy(max_attempts=3, initial_delay_seconds=5),
+)
+
+# 2. Shorthand kwargs (unset fields use server defaults)
+await client.enqueue(task_name="x", payload={}, max_attempts=3)
+
+# 3. Omit entirely (server default: 5 attempts, 2s initial delay, jitter)
+await client.enqueue(task_name="x", payload={})
+```
+
+### `wait_for` — polling helper
+
+```python
+final = await client.wait_for(job_id, poll_interval=1.0, timeout=300)
+```
+
+Poll interval in seconds, timeout in seconds. Returns the `JobDetail` once `status` is one of `succeeded`, `failed`, `dead_lettered`, or `cancelled`. Raises `TimeoutError` if the job doesn't reach a terminal state in time.
+
+### `iter_jobs` — pagination
+
+```python
+async for job in client.iter_jobs(status="dead_lettered", limit=25):
+    print(job.id, job.task_name)
+```
+
+Yields across all cursor pages. `limit` controls page size, not total.
+
+## Configuration
+
+Two environment variables are picked up automatically by `TaskForgeClient.from_env()`:
+
+| Variable | Default | Purpose |
+|---|---|---|
+| `TASKFORGE_URL` | `http://localhost:8000` | API base URL |
+| `TASKFORGE_API_KEY` | (none — required) | API key for auth |
+
+```python
+from taskforge import TaskForgeClient
+client = TaskForgeClient.from_env()
+```
+
+Or pass explicitly:
+
+```python
+client = TaskForgeClient(base_url="http://prod:8000", api_key="tf_...")
+```
+
+## Testing
+
+```bash
+cd sdk
+pytest -q
+```
+
+20 tests, no live backend required:
+- 16 client tests via `httpx.MockTransport` — verify request bodies, query params, error mapping, `wait_for` polling, connection errors
+- 4 registry tests — bare decorator, named decorator, empty parens, duplicate detection
+
+## What's not here yet
+
+Deliberate scope limits for v0.1.0:
+
+- **Sync client** — async only. Wrap in `asyncio.run()` for scripts.
+- **Batch enqueue** — one HTTP call per job. Batch endpoint would need a server-side change first.
+- **Client-side retries** — the SDK does not retry on transient 5xx. The *server* retries the *job*; the *request* is caller's responsibility.
+- **Dead-letter replay** — server endpoint (`POST /dead-letters/{id}/replay`) doesn't exist yet. Once added, a `client.replay(...)` method follows.
+- **`POST /jobs/{id}/retry`** — server endpoint doesn't exist yet.
+- **CLI** — no `taskforge submit ...` binary. Would be a thin wrapper around the async client using `typer` or `click`.
+- **PyPI publication** — `pip install taskforge-sdk` doesn't work. Install from a checkout with `pip install -e ./sdk`.
+
+See the main repo's README for the full roadmap.
+
+## Links
+
+- Main project: https://github.com/Olufemooshegs/taskforge
+- API docs: http://localhost:8000/docs (when running locally)
+- Architecture: [`../docs/architecture.md`](../docs/architecture.md)
+- Reliability: [`../docs/reliability.md`](../docs/reliability.md)

taskforge_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+taskforge/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+taskforge/__init__.py,sha256=Ke_2u1ADIcv7dYcJpFCzf0mRRKWsvFuUOKrB_NAGAIA,1294
+taskforge/client.py,sha256=cXewty5Vx2FzDs-taGzlawy0SJVrgjZXBnBglZ_trbg,9228
+taskforge/exceptions.py,sha256=58c0YQN1i9Eo8516fzAebbUWSPBJhuhE3jetu2dpJgY,1035
+taskforge/registry.py,sha256=9HYBvRRz-RSbR6mVArh_9xS_OXS5Te6kvdirv3cprVQ,1859
+taskforge/types.py,sha256=M70eGAY0zWMi3AONc1j-jHIBp6CDbBxCx94zN-9MDSU,2562
+taskforge_sdk-0.1.0.dist-info/METADATA,sha256=zTekEsDodsuZkpIsrn3DqABCdvjys_fLWCfP0xY9kwk,6697
+taskforge_sdk-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+taskforge_sdk-0.1.0.dist-info/RECORD,,

taskforge_sdk-0.1.0.dist-info/WHEEL

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