pi-durable-python 1.3.0__py3-none-any.whl

pi_durable_python-1.3.0.dist-info/METADATA

@@ -0,0 +1,276 @@
+Metadata-Version: 2.5
+Name: pi-durable-python
+Version: 1.3.0
+Summary: Python port of @earendil-works/pi-durable v1.3.0
+Project-URL: Repository, https://github.com/arpesenti/pi-durable-python
+Project-URL: Upstream, https://github.com/earendil-works/pi/tree/main/packages/durable
+Author: Armando Pesenti Gritti
+License: MIT
+License-File: LICENSE
+Keywords: agents,conversations,durable-execution,pi,port,tasks
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Provides-Extra: all
+Requires-Dist: anthropic>=0.46; extra == 'all'
+Requires-Dist: jsonschema>=4.20; extra == 'all'
+Requires-Dist: openai>=1.70; extra == 'all'
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.46; extra == 'anthropic'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: openai
+Requires-Dist: openai>=1.70; extra == 'openai'
+Provides-Extra: schema
+Requires-Dist: jsonschema>=4.20; extra == 'schema'
+Description-Content-Type: text/markdown
+
+# pi-durable-python
+
+A Python port of [`@earendil-works/pi-durable`](https://github.com/earendil-works/pi/tree/v1.3.0/packages/durable)
+**v1.3.0**: durable conversations, tasks, and documents for agents, on `asyncio`.
+
+The process can die at any point. A run, a tool round, a compaction, or an inbox placement only
+happens after the state it depends on is committed, so a restart resumes from what storage holds
+rather than from what memory held.
+
+- **Durable by construction.** Every effect is sandwiched between committed state: tasks re-enter
+  their checkpoint, submissions survive a crash, documents version as they change.
+- **Small core.** The base install has no runtime dependencies, and the memory, SQLite, and JSONL
+  storage backends all ship in it. Model adapters and JSON Schema validation are separate extras.
+- **Composable.** A `Session` is the kernel; the `Harness` adds conversations, submissions,
+  scheduling, compaction, extensions, and hooks on top of it.
+- **Parity, not resemblance.** This is a mechanical translation of the v1.3.0 source held to its
+  semantics and persisted record shapes. [`PARITY.md`](./PARITY.md) is the contract.
+
+## Requirements
+
+- **Python.** CPython 3.11 or newer. The verified set is 3.11, 3.12, 3.13, 3.14, and 3.15 on Linux
+  and macOS, plus the 3.14t and 3.15t free-threaded builds; the classifiers list the plain CPython
+  versions 3.11 through 3.15.
+- **Free-threaded parity.** The suite passes on builds with the GIL disabled, so the code does not
+  depend on it. Nothing claims thread safety: do not share one `Session` or `Storage` between
+  threads. Concurrent `asyncio` tasks are the supported concurrency.
+- **Dependencies.** The core package has no runtime dependencies. The `openai` and `anthropic`
+  extras carry their SDKs, and `schema` carries `jsonschema`.
+
+## Install
+
+```console
+pip install pi-durable-python
+```
+
+Extras are independent; install only the ones you use:
+
+| Extra | Adds | Install |
+| --- | --- | --- |
+| `openai` | OpenAI Chat Completions adapter (`AsyncOpenAI`) | `pip install "pi-durable-python[openai]"` |
+| `anthropic` | Anthropic Messages adapter (`AsyncAnthropic`) | `pip install "pi-durable-python[anthropic]"` |
+| `schema` | JSON Schema validation for structured output and tool arguments | `pip install "pi-durable-python[schema]"` |
+| `all` | Everything in `openai`, `anthropic`, and `schema` | `pip install "pi-durable-python[all]"` |
+| `dev` | pytest, pytest-asyncio, ruff, and mypy | `pip install "pi-durable-python[dev]"` |
+
+From a checkout, `uv sync --extra dev` or
+`python -m pip install -e ".[dev,openai,anthropic,schema]"` matches CI.
+
+## Quick start
+
+### A durable session and a document
+
+A `Session` is the only writer: every change goes through `commit`, and readers see committed
+state. Documents are typed JSON records, defined once and used as tokens.
+
+<!-- example -->
+```python
+import asyncio
+
+from pi_durable import MemoryStorage, create_session, define_doc
+from pi_durable.context import BACKGROUND_CONTEXT
+
+# Define once: the kind, version, scope, and initial value migrate and materialize the document.
+CounterDoc = define_doc(
+    {"kind": "demo.counter", "version": 1, "scope": "session", "initial": lambda: {"count": 0}}
+)
+
+
+async def main() -> None:
+    session = create_session(MemoryStorage())
+
+    async def bump(tx):
+        counter = await tx.doc(CounterDoc)  # a draft, materialized only if the commit lands
+        counter.count += 1
+
+    await session.commit(bump, BACKGROUND_CONTEXT)
+
+    async def bump_again(tx):
+        (await tx.doc(CounterDoc)).count += 1
+
+    await session.commit(bump_again, BACKGROUND_CONTEXT)
+
+    snapshot = await session.snapshot(CounterDoc, BACKGROUND_CONTEXT)
+    print(snapshot)  # {'count': 2}
+
+    await session.close(BACKGROUND_CONTEXT)
+
+
+asyncio.run(main())
+```
+
+Snapshots, document states, and watches are disposable reads: `snapshot()` copies the committed
+value, `document_state()` subscribes to later commits, and `watch_doc()` delivers every committed
+frame. `MemoryStorage` is the reference backend; SQLite and JSONL live in
+`pi_durable.storage.sqlite` and `pi_durable.storage.jsonl`.
+
+### A conversation
+
+The `Harness` adds conversations on top of a `Session`. A submission is the only entry point: it is
+admitted to the inbox, placed as an entry, and settled once a run answers it. Passive writes (such
+as seeding a transcript) need no model at all.
+
+<!-- example -->
+```python
+import asyncio
+
+from pi_durable import Harness, MemoryStorage, UserEntry, create_registry
+from pi_durable.context import BACKGROUND_CONTEXT
+
+
+async def main() -> None:
+    harness = await Harness.open(
+        MemoryStorage(), {"models": {}, "registry": create_registry()}, BACKGROUND_CONTEXT
+    )
+    try:
+        conversation = await harness.root(BACKGROUND_CONTEXT)
+        await conversation.submit(
+            {
+                "type": "write",
+                "entry": {
+                    "kind": UserEntry.kind,
+                    "model": [{"role": "user", "content": "hello", "timestamp": 0}],
+                },
+            },
+            BACKGROUND_CONTEXT,
+        )
+
+        view = await conversation.context(BACKGROUND_CONTEXT)
+        print([message["role"] for message in view["messages"]])  # ['user']
+
+        state = await conversation.view_state(BACKGROUND_CONTEXT)
+        print([entry["kind"] for entry in state.value["entries"]])  # ['pi.user']
+        state.dispose()
+    finally:
+        await harness.close(BACKGROUND_CONTEXT)
+
+
+asyncio.run(main())
+```
+
+### Answering with a model
+
+The provider adapters implement the `Models` protocol, so the core never imports an SDK. A model
+reference in an agent change uses the persisted camelCase spelling. Opening a `Harness` starts it
+paused, and admitting a submission resumes scheduling, so a host can restore state before work
+begins.
+
+```python
+import asyncio
+
+from pi_durable import Harness, MemoryStorage, Model, create_registry
+from pi_durable.context import BACKGROUND_CONTEXT
+from pi_durable.providers.openai import OpenAIModels
+
+
+async def main() -> None:
+    model = Model(provider="openai", model_id="gpt-4.1", context_window=1_000_000, max_tokens=32_768)
+    models = OpenAIModels([model])  # reads OPENAI_API_KEY, or pass api_key=...
+    harness = await Harness.open(
+        MemoryStorage(), {"models": models, "registry": create_registry()}, BACKGROUND_CONTEXT
+    )
+    try:
+        conversation = await harness.root(
+            BACKGROUND_CONTEXT,
+            {"agent": {"model": {"provider": "openai", "modelId": "gpt-4.1"}}},
+        )
+        submission = await conversation.submit(
+            {"type": "input", "content": "Explain durable execution in one sentence."},
+            BACKGROUND_CONTEXT,
+        )
+        settled = await submission.wait(BACKGROUND_CONTEXT)
+        print(settled["status"])  # 'done' or 'unanswered'
+    finally:
+        await harness.close(BACKGROUND_CONTEXT)
+
+
+asyncio.run(main())
+```
+
+The answer is an entry, not a return value: `settled["answer"]` names the assistant entry, which the
+conversation view and the entry scan both expose. This snippet needs credentials, so the test suite
+does not run it; README examples that run offline carry an `<!-- example -->` marker and are
+executed by `tests/test_release_docs.py`.
+
+## API at a glance
+
+| Module | Holds |
+| --- | --- |
+| `pi_durable` | Root export: `Session`/`create_session`, `Harness`, entry tokens, document and task definitions, errors, provider protocol, `MemoryStorage`, and the built-in task types. |
+| `pi_durable.env` | The `ExecutionEnv` contract, the POSIX backend, output truncation, and line scanning. |
+| `pi_durable.harness` | Conversations, submissions and the inbox, the scheduler, agents and the registry, extensions and hooks, tools, generation, compaction, usage, the conversation view, the agent event stream, and the task graph. |
+| `pi_durable.providers` | The `Model` catalog entry, the `Models` protocol, transcript and request helpers, retry and overflow classifiers, and the OpenAI/Anthropic adapters (`pi_durable.providers.openai`, `pi_durable.providers.anthropic`). |
+| `pi_durable.session` | The Session kernel, the transaction API, document drafts, forks, and observation. |
+| `pi_durable.storage` | The reference memory backend (`pi_durable.storage.memory`), SQLite (`pi_durable.storage.sqlite`), and JSONL (`pi_durable.storage.jsonl`). |
+| `pi_durable.testing` | Storage and environment conformance suites, plus assertions for writing your own backend. |
+| `pi_durable.tool_search` | BM25 deferred-tool discovery for large tool sets. |
+| `pi_durable.tools` | The built-in coding tools: `read`, `write`, `edit`, and `bash`. |
+
+The [usage guide](./docs/usage.md) walks through documents, tasks, the Harness, providers, storage
+backends, and extensions with runnable examples. The normative details are in the
+[vendored 1.3.0 specification](./docs/upstream/spec-1.3.0.md); the parity matrix is
+[`PARITY.md`](./PARITY.md), and the [audit report](./docs/parity-report.md) lists the translated
+suites and the remaining explicit deviations.
+
+## Stability and versioning
+
+- **Lockstep.** The package version tracks the upstream release it translates: 1.3.0 here is
+  `@earendil-works/pi-durable` v1.3.0 (tag `v1.3.0`, commit
+  `71023aec1546d6d677a65669c5665c0927ce0dd0`). Adopting a later upstream release is a version bump,
+  not a routine sync.
+- **Parity is semantics and persisted shapes.** Python names follow PEP 8 while classes stay
+  PascalCase and persisted JSON keeps camelCase, so a stored record round-trips as the specification
+  describes. Cross-language storage interoperability is incidental, not a contract; see
+  [ADR 0001](./docs/adr/0001-parity-baseline-and-boundary.md).
+- **Stable surface.** The modules in the table above, the names exported from them, and the
+  specification sections they implement. `AgentEventStream` is experimental, as upstream says.
+- **Excluded.** Code Mode, the image implementation (the `ImageProcessor` protocol remains),
+  Cloudflare adapters, PowerShell, Windows support, and the benchmark helpers. [`PARITY.md`](./PARITY.md)
+  marks every exclusion.
+
+## Development
+
+```console
+uv sync --extra dev,openai,anthropic,schema
+uv run ruff check src tests
+uv run mypy
+uv run pytest
+```
+
+CI runs the suite on Linux and macOS for Python 3.11–3.15 and the two free-threaded builds, builds
+and installs the sdist and wheel in fresh environments, then installs each extra from the wheel to
+prove the extras resolve and stay independent. [`docs/release.md`](./docs/release.md) records the
+full release steps: verify, build, tag, publish.
+
+## License
+
+MIT. The vendored v1.3.0 specification is MIT, copyright (c) 2025 Mario Zechner; see
+[`docs/upstream/LICENSE`](./docs/upstream/LICENSE).

pi_durable_python-1.3.0.dist-info/RECORD

@@ -0,0 +1,90 @@
+pi_durable/__init__.py,sha256=mkkC_RQFE0dopGWCo6jPAoUTNLwOePkxOzrfn2X4ZB0,7648
+pi_durable/context.py,sha256=1vGEdRsE_6_hgQTmDQGgf9BpWs6425ZU40x0cG4-kTo,9747
+pi_durable/delta.py,sha256=SAh27NvqkZZTKnCkGkDiTIqQNMQqhjykV7BuU_VwLe0,9136
+pi_durable/documents.py,sha256=EH3v8gyC482hHpazA9m8VqSJgK6wKChHNep-Rux0ijY,12933
+pi_durable/entries.py,sha256=sw10JTd849TtQMX1c_YqbmV37te2Q9o2QsDb4RKTT34,2414
+pi_durable/errors.py,sha256=tsrMKUQTZCTyh4kU7ACXN-pOYcHpKodv7eXT64rR5Rk,2848
+pi_durable/ids.py,sha256=DV6xBL_OxjfCb3pAO00uiT7s5cX5vBGJ1bgMrAP1GQs,1969
+pi_durable/json.py,sha256=NV7D6ZyI4lownPLwWgS6ygHvAUb6V-02hNIhLmWFkKE,6120
+pi_durable/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pi_durable/search.py,sha256=vAkwzMKp871AvJBY7WGO_525QC1FDyFEVujhM920DtA,3550
+pi_durable/tasks.py,sha256=6VPlXQOdIvx4rC0dxmKi2qWeC1HGiSJwh6TOgABt6Is,2759
+pi_durable/truncate.py,sha256=49DT7g9tWRZQgxyZar-zZ5s6faN2zUQXT6zG0vM9mHw,5461
+pi_durable/types.py,sha256=Jq_P-lJm31vXNVmabv-IdS3l4vcs4-bQK_erMPNuMns,36687
+pi_durable/env/__init__.py,sha256=h4VEbhjodYkqgJjQ_XGYACNVhYcmG_aE5LS1wAmcfGQ,10946
+pi_durable/env/decode.py,sha256=18F-hHNjWqjxfWRsrr14HR2FUni_QwD0pFru7P9OR_c,1663
+pi_durable/env/line_scan.py,sha256=e9vivHY4LUb3A8HkcFbA_6M3k8CIBcOtZd6bixkXgXc,6733
+pi_durable/env/posix.py,sha256=z5bwb7wVGAb7zJdOZFrZ22QtgNwwffYFWBkfiD389h8,56850
+pi_durable/harness/__init__.py,sha256=O3dclZ8or9XqZNPazD82sFdwZmH2mpd1rJMDmPz4UVQ,29
+pi_durable/harness/agent.py,sha256=q2v7Xvp2-fPcFLtmMGs8YJIAr-3kw_Yk5k0w_1gDrgs,11833
+pi_durable/harness/compaction.py,sha256=REdvYBGvmKJoTMuy8e0iR6XUajcAW6leWzp8EIfTTyk,24717
+pi_durable/harness/context.py,sha256=CRiIiT70qTpUB8fhQGNVdsVbamEp1o5Wfky-EdZJOLI,17585
+pi_durable/harness/define.py,sha256=LcYmVI654sPGzFUPV6ZOR9kl1dEiCD_RZPFD5sy323o,3561
+pi_durable/harness/events.py,sha256=K6dUGkOFRdB1IetO_H_K8yFuJiA5enJ4XB3WClkBwyE,28141
+pi_durable/harness/generation.py,sha256=RFAxj-7jR6JTmwwY0hAcD1GwL3DHv6YID5eN1wTWV2E,39576
+pi_durable/harness/harness.py,sha256=E5_X1u5nVBSPsu8X9MS1u6iDNerF-zkWoZUMVlveS_k,22479
+pi_durable/harness/inbox.py,sha256=ptowY8M2m-oZnTHWWKamMZzxqaAHWrst1IwtDW54Glk,8380
+pi_durable/harness/live.py,sha256=LYEIvIiezgnVEaNrwNl3rjo4nVwj1AQKkCpVd4NWJpo,11462
+pi_durable/harness/output.py,sha256=8N8jNAav2g040sxc6UNgWFtDqloXCb3i2C30XPZSPCU,16467
+pi_durable/harness/prompt.py,sha256=0NdX9acYyOMfRXKWiziieADjzW_uMVxyRzUZp6aVchQ,9801
+pi_durable/harness/provider.py,sha256=GqcJYOnhhQ9tIJB9jxh5tEWZC4vpQ_gZxnmxXtBFbcY,2412
+pi_durable/harness/registry.py,sha256=vXErM_5viI2gus4hC08zgOR3bm5v2EJ7XNR-mRIEmcM,4610
+pi_durable/harness/scheduler.py,sha256=A13ACVx7Xxdcab06kN4gzRKZ3CPXsK3Ad4t5sS2sLDE,80296
+pi_durable/harness/submissions.py,sha256=cQN41fRfD875DyHPkNPFyI6VPXQH5PKhHC2U_3hEcm4,12752
+pi_durable/harness/task_graph.py,sha256=_eH9tIKZTrXtf8CcR7GvTi7liOTI9EyWmpRjTQ9Akfo,10891
+pi_durable/harness/tool.py,sha256=-_cattqt1xb2KcqZy0fWMw_6-XOdklY-072QGFiJYVc,51344
+pi_durable/harness/types.py,sha256=3Eie8ly5TEF97BTM82xYGb_2MFazMLM3Seaeitl1Bm4,22556
+pi_durable/harness/usage.py,sha256=wiQ0At1lhErXXj1eEae4MpdsRnbijITRBQz3vc-jmgM,3183
+pi_durable/harness/util.py,sha256=r1xWxlyJst99tuGRpde8-R-ZsiNYCAjztLRY1B6QhGg,6742
+pi_durable/harness/validation.py,sha256=kdD8-wR2bloltVww3ZGP2zgqidnGI80nf5EvCh2ygwU,18903
+pi_durable/harness/view.py,sha256=DTgcljzYvNs9UuPcBopb4fdEMAFV91qquUmuJRZ5jMI,11608
+pi_durable/providers/__init__.py,sha256=QV-VBDbQCqo6_aAQ6zyNp9DGqbGetxBDZRzGlQOgut0,12304
+pi_durable/providers/anthropic.py,sha256=vz366Ts0i_-NWu0sclFi47szUKYWDdLu7F00ors45rU,24736
+pi_durable/providers/base.py,sha256=2Ejvms2GPARMWkpnLI2tjaC6FNmwZlFhcWWygcJN7Hs,3072
+pi_durable/providers/json_parse.py,sha256=Mbr46kojsbm0PQkobNwZFSnkX3w0h_CKJ3xB51nV8E8,3660
+pi_durable/providers/openai.py,sha256=ztJLf_7yapADlPTPVUnnr3yTw2zV0WsJQmj5xuDtJDs,21876
+pi_durable/providers/request.py,sha256=0ozS6WQIMnjE_8vUctJzqsmzx3ZcsgT-_TCdlu5trlc,1091
+pi_durable/providers/retry.py,sha256=wOqXVHZLf7CWlCgWU-FJ6xCWSp-_1B4DzYuxdLxxJ94,4161
+pi_durable/providers/stream.py,sha256=OGvhgrf__ixhU_QfBsV1OHDcO_c723henZpWOH7MCRA,6558
+pi_durable/providers/transcript.py,sha256=h0S4xv6H0Vyi6l6byl6CetcUi7Lzu8gHRvVvuVWNN9g,8505
+pi_durable/providers/usage.py,sha256=Rsqg8rQbwYskRwQhq5zMzTqxynn3JWAODalDS4f6a6A,1972
+pi_durable/session/__init__.py,sha256=pPI6XLnp12vWdD2NzH3_GB-N6LLehWdAwIZ8GU56Ixs,157
+pi_durable/session/drafts.py,sha256=9LQzsihdwLO0-7vpSDiGAqL9tvcnSsRqjYd0K4jNlRU,25621
+pi_durable/session/forks.py,sha256=XIPfd9RMbmnhOI5KyCXZMmU78Hnxma320bqGYhUvn5w,3492
+pi_durable/session/observation.py,sha256=ImcNNE7aOixh3lEk6koIFZ9EAkauq_CU1Q3MXTfvKns,12752
+pi_durable/session/session.py,sha256=0UnxPkMRvjOTc9mDFkdSccK1Ii6JtJo49sWeCJe-Mj0,44868
+pi_durable/session/transaction.py,sha256=t1x-a45jocEi3237YcaCk_tnk7Y3nT_AFNCI49za43k,43289
+pi_durable/storage/__init__.py,sha256=J-2_1Q1xim1xTub9QSYAJocwgc7MOlZ5rv3fDZaPopk,134
+pi_durable/storage/memory.py,sha256=8be-R20ypBi17nrrtT2LS1_UWLA5nmjfwtGH2bYehCg,37616
+pi_durable/storage/scan.py,sha256=FPLPt7r8Fj500FlADk1b-NyVJYdyOhxjW6Df6OOU03U,1952
+pi_durable/storage/jsonl/__init__.py,sha256=Zl-sPADIbaQ-7N4W5KYdVZJWJOCMWttXtH9Hd7eGoOI,278
+pi_durable/storage/jsonl/storage.py,sha256=JdxHB6a512i-69K0EzdtXqOhkn5XbYu3JsnJAXdkMuQ,37965
+pi_durable/storage/sqlite/__init__.py,sha256=cZlC-55GCFTw0kmVdNW1xU44Skrnd0tapawsiHZm9Nw,714
+pi_durable/storage/sqlite/database.py,sha256=POVqSb4zQKc6U1MTySuhIcLYHdieb87rpNPU4Uy3h-E,2888
+pi_durable/storage/sqlite/migrations.py,sha256=XqnGszUs7f9HiYT3Li_CNuql8Fe8fOq3TO36j4_PyS0,8407
+pi_durable/storage/sqlite/posix.py,sha256=Cs_WdgnL4YSLXINWcK5aoPL3LhES8_Xjm4wBAOH1nBY,10826
+pi_durable/storage/sqlite/schema.py,sha256=9WpOEBPeIRjJs5ybDD1jlYDqaY0FF_rWJW4GRQZP-FA,3306
+pi_durable/storage/sqlite/storage.py,sha256=1fHhQWFpPLTMtE0F0OUOyZZ9QJmyvUqhuoASKwMIDJE,44786
+pi_durable/testing/__init__.py,sha256=HEFSZe8chLqsla94jBz_SxWK_YnOtGPTSxcuDGJQtYc,1319
+pi_durable/testing/assertions.py,sha256=GguUZRZnDvApXK8bcwCLF8a5l5ZJazBWluE8_v9QUSQ,1611
+pi_durable/testing/env_conformance.py,sha256=pAqqd8PDTl9w2bNOJP27p6pD_y6R1GBcVuPrlqBDMTA,34343
+pi_durable/testing/runner.py,sha256=WM-cr5pq2SPvwh8uwmnBCOwSspYdwJOJuVoVHQelq_Y,1777
+pi_durable/testing/storage_conformance.py,sha256=XUbSOQvf4XiGew_q6yjSRZ5YSBTOhT43fepaIrk1ca4,81478
+pi_durable/testing/types.py,sha256=ZKN_N2Z7ZolUAieRZmHXx00tHC6f0OXrkftImEdBumI,3008
+pi_durable/tool_search/__init__.py,sha256=iPLeu10cfRmg51qBRRszekry9IWGjBSwNSuttMLpIIE,5760
+pi_durable/tools/__init__.py,sha256=iq4x7uQeOEXODesNs0dM5pqHdwQ512FTojiL16_lFtM,2093
+pi_durable/tools/_values.py,sha256=kDFm03Zk6-6FVD_gqc3uHo1-bVQyhk2XIZ2r2VYY9BE,1299
+pi_durable/tools/bash.py,sha256=_KJqHcQvGBEkMS2p3BeUjZwwaXZKDOM7Y09RdvSXuCE,8563
+pi_durable/tools/edit.py,sha256=otmVeayyWtfTCWWcKu4HSVAZWGH7wGJPwGZFxojjhEk,7777
+pi_durable/tools/edit_diff.py,sha256=4Q4MxkXT7cHFV5ndnweFxYKAwVNjEEue1nm7pxHcjRs,16958
+pi_durable/tools/env.py,sha256=7f54EL-l8YsbC0u_J4MuA4pYKI5WLzf5EDqrqFcjqSY,462
+pi_durable/tools/file_mutation_queue.py,sha256=YKTbP2XCW0h4URmFUwMaqcy04VKpHMHOj1fvqDyGzEA,2340
+pi_durable/tools/image.py,sha256=rbdcIkeaDYr_nSyX1N0i3gIRgi6C-D_i-hGJeWXww-E,8481
+pi_durable/tools/image_processor.py,sha256=ESQViVL6BC7RF_qk3R3e4EiLpdS9h0JfwwjFOKEkA8Q,2070
+pi_durable/tools/path_utils.py,sha256=8BbCUW9xnSJvXxYOBYdz3waOmnDhxM9_eXpCeRth0_g,4000
+pi_durable/tools/read.py,sha256=a1rdYwWajU-PUIowko1bpdT07yocAsPS-V48-WrNPHE,18895
+pi_durable/tools/write.py,sha256=XmmRqne2Y8R1jh9ZB0tBh5IPFZw87QsWx7UWjkkPJPw,2357
+pi_durable_python-1.3.0.dist-info/METADATA,sha256=e9qad4McIb-bszu5pDSZRj9kDWeZxX-yaLrpgJKOwn0,12324
+pi_durable_python-1.3.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+pi_durable_python-1.3.0.dist-info/licenses/LICENSE,sha256=v4jh9TtVqmIw9d9G92RUgEsx0Ekb5hPuPVqAZOE2Tek,1079
+pi_durable_python-1.3.0.dist-info/RECORD,,

pi_durable_python-1.3.0.dist-info/WHEEL

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

pi_durable_python-1.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Armando Pesenti Gritti
+
+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.