PyTaskWireCheck 0.1.0__py3-none-any.whl

pytaskwirecheck/tui/renderer.py

@@ -0,0 +1,143 @@
+"""Plain-text console reporting.
+
+This renderer provides a useful non-TTY fallback and a CI-friendly mode. It
+never assumes ANSI colour support and keeps concurrent task output labelled.
+It only observes events; it never mutates run state.
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import Dict, Optional, TextIO
+
+from pytaskwirecheck.engine.events import (
+    Event,
+    RunFinished,
+    RunStarted,
+    TaskAttemptFinished,
+    TaskAttemptStarted,
+    TaskOutput,
+    TaskStateChanged,
+)
+from pytaskwirecheck.engine.state import TaskStatus
+
+_STATUS_GLYPH = {
+    TaskStatus.SUCCEEDED: "ok",
+    TaskStatus.FAILED: "fail",
+    TaskStatus.CACHED: "cached",
+    TaskStatus.SKIPPED: "skip",
+    TaskStatus.CANCELLED: "cancel",
+    TaskStatus.TIMED_OUT: "timeout",
+    TaskStatus.BLOCKED: "blocked",
+}
+
+_COLORS = {
+    TaskStatus.SUCCEEDED: "\033[32m",
+    TaskStatus.CACHED: "\033[36m",
+    TaskStatus.FAILED: "\033[31m",
+    TaskStatus.TIMED_OUT: "\033[31m",
+    TaskStatus.BLOCKED: "\033[31m",
+    TaskStatus.CANCELLED: "\033[33m",
+}
+_RESET = "\033[0m"
+
+
+class PlainReporter:
+    """A synchronous, line-oriented event reporter."""
+
+    def __init__(
+        self,
+        stream: Optional[TextIO] = None,
+        *,
+        color: bool = False,
+        quiet: bool = False,
+        show_output: bool = True,
+    ) -> None:
+        self._stream = stream if stream is not None else sys.stdout
+        self._color = color
+        self._quiet = quiet
+        self._show_output = show_output
+        self._buffers: Dict[tuple, str] = {}
+
+    def _write(self, text: str) -> None:
+        try:
+            self._stream.write(text)
+            self._stream.flush()
+        except (BrokenPipeError, ValueError):
+            pass
+
+    def _paint(self, status: TaskStatus, text: str) -> str:
+        if not self._color:
+            return text
+        color = _COLORS.get(status)
+        return "%s%s%s" % (color, text, _RESET) if color else text
+
+    def handle(self, event: Event) -> None:
+        if isinstance(event, RunStarted):
+            if not self._quiet:
+                self._write("Run %s: %d task(s)\n" % (event.run_id, event.total_tasks))
+            return
+
+        if isinstance(event, TaskAttemptStarted):
+            if event.max_attempts > 1 and not self._quiet:
+                self._write(
+                    "  %s: attempt %d/%d\n"
+                    % (event.task_id, event.attempt, event.max_attempts)
+                )
+            return
+
+        if isinstance(event, TaskAttemptFinished):
+            return
+
+        if isinstance(event, TaskStateChanged):
+            self._on_state_changed(event)
+            return
+
+        if isinstance(event, TaskOutput):
+            self._on_output(event)
+            return
+
+        if isinstance(event, RunFinished):
+            self._on_run_finished(event)
+            return
+
+    def _on_state_changed(self, event: TaskStateChanged) -> None:
+        if event.status is TaskStatus.RUNNING:
+            if not self._quiet and not self._show_output:
+                self._write("  %s: running\n" % event.task_id)
+            return
+        if not event.status.is_terminal:
+            return
+        glyph = _STATUS_GLYPH.get(event.status, event.status.value)
+        suffix = ""
+        if event.status is TaskStatus.FAILED and event.message:
+            suffix = " (%s)" % event.message
+        elif event.status in (TaskStatus.TIMED_OUT, TaskStatus.BLOCKED):
+            if event.message:
+                suffix = " (%s)" % event.message
+        label = self._paint(event.status, glyph)
+        self._write("  [%s] %s%s\n" % (label, event.task_id, suffix))
+
+    def _on_output(self, event: TaskOutput) -> None:
+        if not self._show_output or self._quiet:
+            return
+        key = (event.task_id, event.stream)
+        buffer = self._buffers.get(key, "")
+        buffer += event.data.decode("utf-8", errors="replace")
+        while "\n" in buffer:
+            line, buffer = buffer.split("\n", 1)
+            prefix = event.task_id
+            if event.stream == "stderr":
+                prefix += "!stderr"
+            self._write("  %s | %s\n" % (prefix, line))
+        self._buffers[key] = buffer
+
+    def _on_run_finished(self, event: RunFinished) -> None:
+        summary = event.summary or {}
+        counts = summary.get("counts", {})
+        duration = summary.get("duration_seconds", 0.0)
+        status = "succeeded" if event.succeeded else "failed"
+        rendered = ", ".join("%d %s" % (counts[k], k) for k in sorted(counts))
+        self._write(
+            "Run %s %s in %.2fs (%s)\n" % (event.run_id, status, duration, rendered)
+        )

pytaskwirecheck-0.1.0.dist-info/METADATA

@@ -0,0 +1,316 @@
+Metadata-Version: 2.4
+Name: PyTaskWireCheck
+Version: 0.1.0
+Summary: Local-first, dependency-aware task orchestration engine (DAG scheduler + content-addressed cache + CLI).
+Author: Georgi Mullassery
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Mullassery/PyTaskWireCheck
+Project-URL: Repository, https://github.com/Mullassery/PyTaskWireCheck
+Project-URL: Issues, https://github.com/Mullassery/PyTaskWireCheck/issues
+Project-URL: Changelog, https://github.com/Mullassery/PyTaskWireCheck/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://github.com/Mullassery/PyTaskWireCheck#readme
+Keywords: task,tasks,orchestration,dag,workflow,scheduler,pipeline,build,local-first,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tomli>=2.0; python_version < "3.11"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Provides-Extra: release
+Requires-Dist: build>=1.0; extra == "release"
+Requires-Dist: twine>=4.0; extra == "release"
+Dynamic: license-file
+
+<div align="center">
+
+# PyTaskWireCheck
+
+**Local-first, dependency-aware task orchestration for Python.**
+
+Describe your tasks and how they depend on each other. PyTaskWireCheck works out the
+order, runs independent work in parallel, retries the flaky parts, skips work
+that hasn't changed, and tells you exactly why — without a server, a daemon,
+or a single byte leaving your machine.
+
+[![CI](https://github.com/Mullassery/PyTaskWireCheck/actions/workflows/ci.yml/badge.svg)](https://github.com/Mullassery/PyTaskWireCheck/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/PyTaskWireCheck.svg)](https://pypi.org/project/PyTaskWireCheck/)
+[![Python versions](https://img.shields.io/pypi/pyversions/PyTaskWireCheck.svg)](https://pypi.org/project/PyTaskWireCheck/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Typed](https://img.shields.io/badge/typing-py.typed-blue.svg)](src/pytaskwirecheck/py.typed)
+
+</div>
+
+---
+
+## Why PyTaskWireCheck
+
+Most build tools want to own your project. PyTaskWireCheck does one job: it orchestrates
+*other* programs. You already have the scripts, the compilers, the test runners,
+the data jobs — PyTaskWireCheck just knows which ones can run at once, which must wait,
+and which can be skipped because nothing they depend on has changed.
+
+- **Local-first.** No server, no account, no telemetry. State lives in
+  `.pytaskwirecheck/` inside your project.
+- **Dependency-aware.** Tasks declare `depends_on`; PyTaskWireCheck topologically sorts
+  them and runs every independent branch concurrently.
+- **Content-addressed cache.** Tasks declare `inputs` and `outputs`. If the
+  fingerprint is unchanged, the task is skipped and its outputs restored.
+- **Deterministic failure handling.** `fail_fast` or continue-and-block, with a
+  documented state machine — never a half-observed status.
+- **Scriptable and embeddable.** A first-class CLI *and* a small Python API.
+- **Zero runtime dependencies** on Python 3.11+, one tiny backport otherwise.
+
+## Install
+
+```bash
+pip install PyTaskWireCheck
+# or, for the bleeding edge:
+pip install "PyTaskWireCheck @ git+https://github.com/Mullassery/PyTaskWireCheck"
+```
+
+PyTaskWireCheck targets Python **3.9 – 3.13**. The import name and the command are both
+`pytaskwirecheck`.
+
+```bash
+pytaskwirecheck --version
+```
+
+## Quick start
+
+```bash
+pytaskwirecheck init            # write a starter pytaskwirecheck.toml
+pytaskwirecheck validate        # check the config and the graph
+pytaskwirecheck graph           # print the DAG (text, dot, or json)
+pytaskwirecheck plan            # show levels, order, and max parallelism
+pytaskwirecheck run             # run everything, in dependency order
+```
+
+A minimal `pytaskwirecheck.toml`:
+
+```toml
+[project]
+name = "example-workflow"
+version = 1
+
+[execution]
+max_workers = 4
+fail_fast = false
+
+[tasks.fetch]
+command = ["python", "scripts/fetch.py"]
+outputs = ["data/raw.json"]
+
+[tasks.transform]
+command = ["python", "scripts/transform.py"]
+depends_on = ["fetch"]
+inputs = ["data/raw.json"]
+outputs = ["data/clean.parquet"]
+
+[tasks.test]
+command = ["pytest", "-q"]
+depends_on = ["transform"]
+```
+
+Run it:
+
+```console
+$ pytaskwirecheck run
+run 3f9c1a2b4d5e
+  fetch      running
+  transform  pending
+  test       pending
+  fetch      succeeded   0.84s
+  transform  running
+  transform  succeeded   1.20s
+  test       running
+  test       succeeded   3.05s
+ok: 3 succeeded in 5.11s
+```
+
+## Features at a glance
+
+| Area | What you get |
+| --- | --- |
+| **Graph** | `depends_on`, cycle detection, missing-dependency detection, topological levels |
+| **Scheduling** | bounded concurrency, deterministic ordering, `fail_fast` or continue-and-block |
+| **Processes** | streaming output, process groups, timeouts, cooperative cancellation, output budget |
+| **Retries** | bounded attempts, fixed or exponential backoff, retry-on-exit-code |
+| **Cache** | content-addressed, sha256-verified, atomic commits, corrupt-entry recovery |
+| **CLI** | `init` `validate` `graph` `plan` `run` `cache` `explain` `history`, each with `--json` |
+| **TUI** | optional live dashboard when attached to a TTY (`run --tui`) |
+| **Persistence** | local run history (SQLite, WAL) and optional webhook notifications |
+| **Library** | `Workflow.from_file(...).run()` and functional helpers |
+
+## Command-line reference
+
+```
+pytaskwirecheck [-C ROOT] [--config PATH] [--no-color] COMMAND ...
+
+  init [--path DIR] [--force]     create a starter configuration
+  validate [--json]               validate configuration and graph
+  graph [--format text|dot|json]  display the task DAG
+  plan [TASKS...] [--json]        show the execution plan
+  run [TASKS...] [--no-cache] [--max-workers N] [--fail-fast|--no-fail-fast]
+      [--json] [-q] [--no-output] [--tui]
+  cache status [--json]           show cache statistics
+  cache clean [--force] [--json]  remove cached data
+  explain TASK [--json]           explain scheduling and cache status for a task
+  history [--limit N] [--json]    show recent execution summaries
+```
+
+`run` accepts task names and runs only those tasks plus their dependencies. Add
+`--json` for a machine-readable summary, and `-q` to silence progress.
+
+### Exit codes
+
+| Code | Meaning |
+| --- | --- |
+| `0` | success |
+| `1` | one or more tasks failed |
+| `2` | usage or configuration error |
+| `3` | graph error (cycle, missing dependency, unknown target) |
+| `130` | interrupted (`Ctrl-C`) |
+
+## Python API
+
+```python
+from pytaskwirecheck import Workflow
+
+workflow = Workflow.from_file("pytaskwirecheck.toml")
+
+# Inspect before running.
+plan = workflow.plan(["test"])
+print(plan.order, plan.max_parallelism)
+
+# Run and react to events.
+def on_event(event):
+    print(type(event).__name__, event)
+
+result = workflow.run(["test"], on_event=on_event)
+if not result.succeeded:
+    for task_id, record in result.records.items():
+        if not record.status.is_success:
+            print(task_id, record.status.value, record.exit_code)
+
+raise SystemExit(0 if result.succeeded else 1)
+```
+
+Functional helpers are available for one-liners:
+
+```python
+import pytaskwirecheck
+
+plan = pytaskwirecheck.validate(root=".")          # -> ExecutionPlan
+result = pytaskwirecheck.run(["build"], path="ci.toml")
+```
+
+`Workflow.run` supports `use_cache`, `max_workers`, `fail_fast`, `on_event`,
+`cancel_token`, `record_history`, and `notify`. See
+[docs/python-api.md](docs/python-api.md).
+
+## Caching model
+
+The cache is **content-addressed** and conservative by design:
+
+- A task is cache-eligible only if it declares `inputs` **or** `outputs`
+  (otherwise its side effects are unknown, so PyTaskWireCheck never guesses).
+- The fingerprint covers the command, resolved inputs (hashing file contents),
+  declared outputs' expectations, relevant environment variables, the config
+  schema version, and the cache keys of upstream dependencies.
+- A hit restores declared outputs, but only after verifying every stored file's
+  sha256 and size; anything corrupt is discarded rather than trusted.
+- Commits are atomic (staged, then `os.replace`), and protected by a
+  cross-process lock. Restores are confined to the workspace root.
+- Environment values are **hashed, never stored in plaintext**.
+
+Disable it globally (`[cache] enabled = false`), per task (`cache = false`), or
+per run (`pytaskwirecheck run --no-cache`). Inspect decisions with
+`pytaskwirecheck explain TASK`.
+
+## Execution semantics
+
+Every task moves through an explicit state machine:
+
+```
+PENDING → READY → RUNNING → SUCCEEDED | FAILED | TIMED_OUT | CACHED
+                                     ↘ CANCELLED
+dependents of a failure → BLOCKED
+```
+
+- **`fail_fast = true`** stops launching new tasks and cancels in-flight work as
+  soon as a task fails.
+- **`fail_fast = false`** lets unrelated branches finish; only the transitive
+  dependents of the failed task become `BLOCKED`.
+- A cancelled, timed-out, or failed task is **never cached**.
+- Persistence (history, notifications) is best-effort and **never** changes a
+  run's outcome or exit code.
+
+## Architecture
+
+```
+pytaskwirecheck.toml
+     │
+     ▼
+ config ──▶ graph ──▶ planner ──▶ scheduler ──▶ executor ──▶ processes
+ (schema,   (DAG,     (levels,    (bounded      (retries,    (streaming,
+ validation) builder) order)      concurrency)  cache hooks) process groups)
+                                     │
+                                     ▼
+                              events ──▶ CLI / TUI / logs / history
+```
+
+Each layer depends only on the one below it. The scheduler owns state
+transitions; the executor owns retries and cache interaction; the process runner
+owns the subprocess. Rendering and persistence are observers, never participants.
+Read the full design in [docs/architecture.md](docs/architecture.md).
+
+## Documentation
+
+| Document | Contents |
+| --- | --- |
+| [docs/architecture.md](docs/architecture.md) | Layers, data flow, state machine, design rules |
+| [docs/configuration.md](docs/configuration.md) | Every `pytaskwirecheck.toml` field |
+| [docs/execution.md](docs/execution.md) | Scheduling, retries, timeouts, cancellation |
+| [docs/caching.md](docs/caching.md) | Fingerprints, storage, integrity, eviction |
+| [docs/cli.md](docs/cli.md) | Commands, flags, exit codes |
+| [docs/python-api.md](docs/python-api.md) | Embedding PyTaskWireCheck as a library |
+| [docs/security.md](docs/security.md) | Trust model and hardening |
+| [docs/development.md](docs/development.md) | Contributing, tests, tooling |
+| [docs/roadmap.md](docs/roadmap.md) | Where PyTaskWireCheck is going |
+| [docs/implementation-status.md](docs/implementation-status.md) | What is done and verified |
+
+## Status
+
+PyTaskWireCheck is **0.1.0** — a complete, tested horizontal slice: config → graph →
+scheduler → runner → cache → CLI → TUI → history → notifications. See
+[docs/implementation-status.md](docs/implementation-status.md) for the verified
+breakdown. It is pre-1.0, so the configuration schema is versioned (`version = 1`)
+and unsupported versions are rejected rather than guessed at.
+
+## Contributing
+
+Issues and pull requests are welcome. Start with
+[CONTRIBUTING.md](CONTRIBUTING.md) and [docs/development.md](docs/development.md).
+Please follow the [Code of Conduct](CODE_OF_CONDUCT.md) and report
+vulnerabilities via [SECURITY.md](SECURITY.md).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

pytaskwirecheck-0.1.0.dist-info/RECORD

@@ -0,0 +1,45 @@
+pytaskwirecheck/__init__.py,sha256=9icSd3bik9pcpTr9OAkfMYBeuX4hr8h5rqb6Td93H0Q,804
+pytaskwirecheck/api.py,sha256=HTITnLIH2aJJKITPfwoA7JWj-hfULTo3eRXMb7dJvZ8,11073
+pytaskwirecheck/cli.py,sha256=3b6NCrrjgkj1Wjyu8JE5j_OP5oiv5V0gviRuzvLyego,22618
+pytaskwirecheck/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytaskwirecheck/cache/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytaskwirecheck/cache/fingerprint.py,sha256=57-6HLsbtbfi4CG16X_E8OO9W9_pK8F0fICtwwREtyM,5588
+pytaskwirecheck/cache/policy.py,sha256=cj4t3A-uONAEmTreZF1L77REtrJu0WXDRqJUJwpKZOY,1527
+pytaskwirecheck/cache/store.py,sha256=VT_N_V6Xp-wHkfK4HBpmOK8N865ieghCFCmZJAXR6NA,12581
+pytaskwirecheck/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytaskwirecheck/config/loader.py,sha256=cFn05YrmVkcSKUVrj0vBVR-zAK6WFiLpAA4UMKtP7Bs,2569
+pytaskwirecheck/config/schema.py,sha256=POJHgX-_1gt_q5ZaEiE7mYye7F2Y3HQNGB7UhApF2RU,4806
+pytaskwirecheck/config/validation.py,sha256=PG_NX5OjJQVcyL18Sh-I8tsfp3S40qo7DBHI-Hvh7QU,18630
+pytaskwirecheck/diagnostics/__init__.py,sha256=eOYVOYF_FiCi1Au3rclpU0xlImzxv1x4j52kmkxzDLA,643
+pytaskwirecheck/diagnostics/errors.py,sha256=THR3OJmXmuiP4hkFGDIh1vH09KIrCi-haVCWVnKSBew,2519
+pytaskwirecheck/engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytaskwirecheck/engine/cancellation.py,sha256=1tXIWN31p_mNUbn65_RW2iNVoz07o04ijseTlLXuUec,1046
+pytaskwirecheck/engine/events.py,sha256=5-LD2uFEebvF5qhK7Gqx1wsX974P9Ay6OX7Wa8c_eT8,2014
+pytaskwirecheck/engine/executor.py,sha256=fBv89FUUCQg-yvjxOm_4XKhGUS-5RU3q6zobUmhbndM,10590
+pytaskwirecheck/engine/scheduler.py,sha256=T_PkmwbuNtL74E-dQjPcJkPkVr23TImS3NRILhOmouU,11109
+pytaskwirecheck/engine/state.py,sha256=TdKCpegMIjNuFwa4P2YxJjdZejyMClI2258Q4zAsXZw,3226
+pytaskwirecheck/graph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytaskwirecheck/graph/builder.py,sha256=GhlrhjUpyS03B2CuEkK9qBM1OBwKP8yl1lIZ8DEN0rg,1178
+pytaskwirecheck/graph/model.py,sha256=-FXJZclPFUw2XNrJ43g1iMPRKI8II0aCfp2DodumEoI,3334
+pytaskwirecheck/graph/planner.py,sha256=aUbUE72Y2qzKoyszqiWTjptZnlAXBFk8b88N01QUECk,5068
+pytaskwirecheck/graph/validator.py,sha256=PbEfPr3QEboKfgyEpixOfRHrGKla2VZz-jqIDfCDtG8,3054
+pytaskwirecheck/history/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytaskwirecheck/history/store.py,sha256=6heaoKi7E8BulUsUVUejeeT_31bxREptmeGwtrzPhRI,5530
+pytaskwirecheck/logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytaskwirecheck/logging/artifacts.py,sha256=onpRAxO2DAYzhK6s7DepzJ_klbSZxqLKuDdGAou5uS0,2935
+pytaskwirecheck/logging/structured.py,sha256=y20JoU6EVoMbMFSmq-ykyYpCr9F6DxHaD4Lc5ZiWa0Q,2510
+pytaskwirecheck/notifications/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytaskwirecheck/notifications/base.py,sha256=0I-fMlKBcKYRoFuSAk3MjUkx1Foo93xT9DvcpFLiqKI,1262
+pytaskwirecheck/notifications/webhook.py,sha256=dfkIa0H0OSSqLV4Cp4J7ohwaLEP-3lXSny3gHJDtq5o,2544
+pytaskwirecheck/processes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytaskwirecheck/processes/runner.py,sha256=HuhABwnIujW1eB9eDv4fjmCopSCSJSTd6D5QAnY2E4Y,8149
+pytaskwirecheck/processes/signals.py,sha256=o6IeQnxqx2ZEBeZdLYCfxGFmnZTbJNocbb_2eZHnSok,1923
+pytaskwirecheck/tui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytaskwirecheck/tui/app.py,sha256=_EBYVEwh5JiR_xC_AYXCukcglu85tSH01yd9ZSQJbUg,6780
+pytaskwirecheck/tui/renderer.py,sha256=_eSpNJYCePqbadCozlqQjJ5_541ttJDHSpHTvRyH3jw,4652
+pytaskwirecheck-0.1.0.dist-info/licenses/LICENSE,sha256=7AYaQADXpsZdOBzCUVw82nbd6I89xeX0EEp9TrpfZLk,1085
+pytaskwirecheck-0.1.0.dist-info/METADATA,sha256=47U65AHJ3pjspucfuhBUq-yityS0X_ehJ28C3zNQQPA,12237
+pytaskwirecheck-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pytaskwirecheck-0.1.0.dist-info/entry_points.txt,sha256=z3oOm1Vi2rpmbKL9OHBwdsTzte7k18Gtxleuz-PiaLU,61
+pytaskwirecheck-0.1.0.dist-info/top_level.txt,sha256=gR0zDJHu-PA-6EkkhyxtWPHsAZcXs7pDohOkOaX6JAI,16
+pytaskwirecheck-0.1.0.dist-info/RECORD,,

pytaskwirecheck-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pytaskwirecheck-0.1.0.dist-info/entry_points.txt

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

pytaskwirecheck-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PyTaskWireCheck Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pytaskwirecheck-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pytaskwirecheck