open-refinery 0.1.0__tar.gz

open_refinery-0.1.0/.claude/rules/simplicity.md

@@ -0,0 +1,6 @@
+# Simplicity
+
+- The minimum code that solves the problem. No speculative abstractions.
+- Keep the core dependency-free while the standard library suffices.
+- No configurability, flexibility, or error handling that wasn't asked for.
+- Prefer `typing.Protocol` seams over class hierarchies.

open_refinery-0.1.0/.claude/rules/tests-tdd.md

@@ -0,0 +1,7 @@
+# Tests
+
+- Non-trivial logic lands with a test.
+- Prove a bug with a failing test before fixing it.
+- The production loop's ordering (authorize before run; record/log only after
+  success) is behavior — keep it covered.
+- Run `uv run pytest`; all green before a commit or PR.

open_refinery-0.1.0/.gitignore

@@ -0,0 +1,14 @@
+# python
+__pycache__/
+*.pyc
+.venv/
+.pytest_cache/
+*.egg-info/
+dist/
+build/
+# audit trails / runtime state — regenerated, not versioned
+*.jsonl
+# env
+.env
+# personal Claude Code permissions (not shared)
+.claude/settings.local.json

open_refinery-0.1.0/CLAUDE.md

@@ -0,0 +1,45 @@
+# CLAUDE.md — open-refinery
+
+*Manage complexity ruthlessly. The minimum code that solves the problem.*
+
+## What this is
+
+A factory that produces artifacts under governance. The production loop is:
+**authorize → run recipe → record provenance + ownership → audit → log**.
+Core pillars: observability, auditability, authorization, ownership,
+provenance, logging — and, on the roadmap, **governance via policies**.
+
+## Layout
+
+- `src/open_refinery/` — src layout, `hatchling` build, `uv` for env/deps.
+  - `factory.py` — recipe registry + production loop
+  - `provenance.py` — immutable `Record` + I/O digests
+  - `authz.py` — `Authorizer` protocol (`AllowAll`, `AllowList`)
+  - `audit.py` — `AuditSink` protocol (`MemorySink`, `JsonlSink`)
+  - `cli.py` — demo entry point (`open-refinery`)
+- `tests/` — pytest
+- `docs/ARCHITECTURE.md` — the loop, modules, roadmap
+
+## Working rules
+
+- **Keep the core dependency-free** while the stdlib suffices. A new dependency
+  needs a reason.
+- **Protocols over inheritance** for the seams (`Authorizer`, `AuditSink`).
+- **Immutable records, append-only audit.** Never mutate a `Record`.
+- **Test non-trivial logic.** Prove a bug with a failing test first.
+- **Surgical changes.** Touch only what the task needs; match existing style.
+- Order in `produce` is load-bearing: authorize before running; record/log only
+  after a successful run.
+
+## Commands
+
+```bash
+uv sync --extra dev
+uv run pytest
+uv run open-refinery --actor ian --text hello
+```
+
+## Roadmap (don't build ahead of need)
+
+Governance policy layer, observability read-model, pluggable sinks, async
+recipes. See `docs/ARCHITECTURE.md`.

open_refinery-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,38 @@
+# Contributing to open-refinery
+
+Thanks for your interest. This is an early-stage project; the core is small on
+purpose.
+
+## Setup
+
+```bash
+uv sync --extra dev
+uv run pytest
+```
+
+## Principles
+
+- **Manage complexity ruthlessly.** The minimum code that solves the problem.
+  No speculative abstractions, no configurability that wasn't asked for.
+- **Test non-trivial logic.** New behavior lands with a test. Prove a bug with
+  a failing test before fixing it.
+- **Surgical changes.** Touch only what the change requires; match existing
+  style.
+- **Keep the core dependency-free** where the standard library suffices.
+
+## Workflow
+
+1. Branch from `main`.
+2. Make the change with tests.
+3. `uv run pytest` — all green.
+4. Open a PR against `main` with a clear description of the *why*.
+
+## Commit style
+
+Conventional Commits (`feat:`, `fix:`, `docs:`, `refactor:`, `test:`). Subject
+in the imperative, ≤50 chars; body only when the *why* isn't obvious.
+
+## Scope
+
+Discuss larger changes (new pillars, dependencies, policy engine) in an issue
+first — see the roadmap in [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md).

open_refinery-0.1.0/LICENSE

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

open_refinery-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: open-refinery
+Version: 0.1.0
+Summary: A factory for producing artifacts under governance — provenance, ownership, authorization, and an append-only audit trail on every output.
+Project-URL: Homepage, https://github.com/tacoda/open-refinery
+Project-URL: Repository, https://github.com/tacoda/open-refinery
+Author-email: Ian Johnson <ian@tacoda.dev>
+License: MIT
+License-File: LICENSE
+Keywords: audit,factory,governance,observability,provenance
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# open-refinery
+
+A factory for producing artifacts under governance. Every output carries its
+**provenance**, an **owner**, and an **audit trail**; every production is
+**authorized** before it runs and **logged** as it happens.
+
+> Status: **0.1.0 — proof of concept.** The core loop (authorize → produce →
+> record → audit) is real and tested. Policy-based governance, richer
+> observability, and pluggable sinks are on the roadmap.
+
+## Install
+
+```bash
+uv add open-refinery       # or: pip install open-refinery
+```
+
+## Use
+
+```python
+from open_refinery import Factory
+
+factory = Factory()
+
+@factory.recipe("upper")
+def upper(text: str) -> str:
+    return text.upper()
+
+artifact, record = factory.produce("upper", actor="ian", text="hello")
+# artifact -> "HELLO"
+# record   -> Record(recipe="upper", actor="ian", owner="ian",
+#                    artifact_id=..., input_digest=..., output_digest=..., created_at=...)
+```
+
+Try the demo CLI:
+
+```bash
+uv run open-refinery --actor ian --text hello
+```
+
+## Pillars
+
+| Pillar          | Where it lives                                              |
+|-----------------|-------------------------------------------------------------|
+| Authorization   | `Authorizer` (`AllowAll`, `AllowList`) — checked before produce |
+| Provenance      | `Record` — recipe, actor, timestamp, input/output digests   |
+| Ownership       | `owner` on every record (defaults to the actor)             |
+| Auditability    | `AuditSink` (`MemorySink`, `JsonlSink`) — append-only trail  |
+| Logging         | stdlib `logging`, logger name `open_refinery`               |
+| Observability   | *(roadmap)* read-model / metrics over the audit trail       |
+| Governance      | *(roadmap)* policy layer that constrains what may be produced |
+
+## Durable audit trail
+
+```python
+from open_refinery import Factory, JsonlSink
+
+factory = Factory(audit=JsonlSink("audit.jsonl"))
+```
+
+Each production appends one JSON line — a replayable record of who produced
+what, from which inputs, and when.
+
+## Development
+
+```bash
+uv sync --extra dev
+uv run pytest
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) and [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md).
+
+## License
+
+[MIT](LICENSE) © Ian Johnson

open_refinery-0.1.0/README.md

@@ -0,0 +1,74 @@
+# open-refinery
+
+A factory for producing artifacts under governance. Every output carries its
+**provenance**, an **owner**, and an **audit trail**; every production is
+**authorized** before it runs and **logged** as it happens.
+
+> Status: **0.1.0 — proof of concept.** The core loop (authorize → produce →
+> record → audit) is real and tested. Policy-based governance, richer
+> observability, and pluggable sinks are on the roadmap.
+
+## Install
+
+```bash
+uv add open-refinery       # or: pip install open-refinery
+```
+
+## Use
+
+```python
+from open_refinery import Factory
+
+factory = Factory()
+
+@factory.recipe("upper")
+def upper(text: str) -> str:
+    return text.upper()
+
+artifact, record = factory.produce("upper", actor="ian", text="hello")
+# artifact -> "HELLO"
+# record   -> Record(recipe="upper", actor="ian", owner="ian",
+#                    artifact_id=..., input_digest=..., output_digest=..., created_at=...)
+```
+
+Try the demo CLI:
+
+```bash
+uv run open-refinery --actor ian --text hello
+```
+
+## Pillars
+
+| Pillar          | Where it lives                                              |
+|-----------------|-------------------------------------------------------------|
+| Authorization   | `Authorizer` (`AllowAll`, `AllowList`) — checked before produce |
+| Provenance      | `Record` — recipe, actor, timestamp, input/output digests   |
+| Ownership       | `owner` on every record (defaults to the actor)             |
+| Auditability    | `AuditSink` (`MemorySink`, `JsonlSink`) — append-only trail  |
+| Logging         | stdlib `logging`, logger name `open_refinery`               |
+| Observability   | *(roadmap)* read-model / metrics over the audit trail       |
+| Governance      | *(roadmap)* policy layer that constrains what may be produced |
+
+## Durable audit trail
+
+```python
+from open_refinery import Factory, JsonlSink
+
+factory = Factory(audit=JsonlSink("audit.jsonl"))
+```
+
+Each production appends one JSON line — a replayable record of who produced
+what, from which inputs, and when.
+
+## Development
+
+```bash
+uv sync --extra dev
+uv run pytest
+```
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) and [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md).
+
+## License
+
+[MIT](LICENSE) © Ian Johnson

open_refinery-0.1.0/docs/ARCHITECTURE.md

@@ -0,0 +1,54 @@
+# Architecture
+
+open-refinery is a **factory under governance**. The unit of work is a
+*production*: an actor asks the factory to run a named *recipe*; the factory
+gates, runs, and records it.
+
+## The production loop
+
+```
+produce(name, actor, owner?, **inputs)
+   │
+   ├─ 1. resolve recipe        (UnknownRecipe if absent)
+   ├─ 2. authorize             (Unauthorized if denied)   ← authz.py
+   ├─ 3. run recipe(**inputs)  → artifact
+   ├─ 4. build Record          (provenance + ownership)   ← provenance.py
+   ├─ 5. append to audit sink                             ← audit.py
+   ├─ 6. log the event                                    ← stdlib logging
+   └─ return (artifact, record)
+```
+
+Order matters: nothing is recorded or logged unless authorization passed and
+the recipe ran. An unauthorized call leaves no artifact and no audit record.
+
+## Modules
+
+| Module          | Responsibility                                            |
+|-----------------|-----------------------------------------------------------|
+| `factory.py`    | Recipe registry + the production loop                     |
+| `provenance.py` | `Record` (immutable) + stable SHA-256 digests of I/O      |
+| `authz.py`      | `Authorizer` protocol; `AllowAll`, `AllowList`            |
+| `audit.py`      | `AuditSink` protocol; `MemorySink`, `JsonlSink`           |
+
+`Authorizer` and `AuditSink` are `typing.Protocol`s — swap implementations
+without touching the factory.
+
+## Design choices
+
+- **Dependency-free core.** Everything above is stdlib. Dependencies join only
+  when a pillar genuinely needs one.
+- **Immutable records.** A `Record` is a frozen dataclass; the audit trail is
+  append-only. Provenance you can't rewrite is provenance you can trust.
+- **Digests, not payloads.** Records store SHA-256 of inputs/outputs, keeping
+  the trail small and non-sensitive while still verifiable.
+
+## Roadmap
+
+- **Governance via policies** — a policy layer that constrains *what may be
+  produced* (and by whom, from which inputs), evaluated in the production loop
+  alongside authorization. Policies as data/code, cascading (org ▸ repo ▸
+  local, outer wins).
+- **Observability** — a read-model / metrics view built by replaying the audit
+  trail (counts, actors, ownership, failure clusters).
+- **Pluggable sinks** — SQLite, cloud logging, event stream.
+- **Async recipes** and batching.

open_refinery-0.1.0/pyproject.toml

@@ -0,0 +1,37 @@
+[project]
+name = "open-refinery"
+version = "0.1.0"
+description = "A factory for producing artifacts under governance — provenance, ownership, authorization, and an append-only audit trail on every output."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "Ian Johnson", email = "ian@tacoda.dev" }]
+keywords = ["provenance", "audit", "governance", "factory", "observability"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0"]
+
+[project.urls]
+Homepage = "https://github.com/tacoda/open-refinery"
+Repository = "https://github.com/tacoda/open-refinery"
+
+[project.scripts]
+open-refinery = "open_refinery.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/open_refinery"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

open_refinery-0.1.0/src/open_refinery/__init__.py

@@ -0,0 +1,22 @@
+"""open-refinery — a factory for producing artifacts under governance."""
+
+from .audit import AuditSink, JsonlSink, MemorySink
+from .authz import AllowAll, AllowList, Authorizer, Unauthorized
+from .factory import Factory, UnknownRecipe
+from .provenance import Record
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Factory",
+    "UnknownRecipe",
+    "Record",
+    "Authorizer",
+    "AllowAll",
+    "AllowList",
+    "Unauthorized",
+    "AuditSink",
+    "MemorySink",
+    "JsonlSink",
+    "__version__",
+]

open_refinery-0.1.0/src/open_refinery/audit.py

@@ -0,0 +1,35 @@
+"""Audit sink — append-only trail of production events."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Protocol
+
+from .provenance import Record
+
+
+class AuditSink(Protocol):
+    def write(self, record: Record) -> None: ...
+
+
+class MemorySink:
+    """In-memory trail. Default; useful for tests and ephemeral runs."""
+
+    def __init__(self) -> None:
+        self.records: list[Record] = []
+
+    def write(self, record: Record) -> None:
+        self.records.append(record)
+
+
+class JsonlSink:
+    """Append each record as one JSON line. The durable audit trail."""
+
+    def __init__(self, path: str | Path) -> None:
+        self.path = Path(path)
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+
+    def write(self, record: Record) -> None:
+        with self.path.open("a", encoding="utf-8") as fh:
+            fh.write(json.dumps(record.to_dict(), sort_keys=True) + "\n")

open_refinery-0.1.0/src/open_refinery/authz.py

@@ -0,0 +1,30 @@
+"""Authorization — the gate checked before a recipe runs."""
+
+from __future__ import annotations
+
+from typing import Protocol
+
+
+class Unauthorized(Exception):
+    """Raised when an actor may not run a recipe."""
+
+
+class Authorizer(Protocol):
+    def allows(self, actor: str, recipe: str) -> bool: ...
+
+
+class AllowAll:
+    """Default authorizer — permits every actor. Replace in production."""
+
+    def allows(self, actor: str, recipe: str) -> bool:
+        return True
+
+
+class AllowList:
+    """Permit only (actor, recipe) pairs present in the grant set."""
+
+    def __init__(self, grants: set[tuple[str, str]]) -> None:
+        self._grants = grants
+
+    def allows(self, actor: str, recipe: str) -> bool:
+        return (actor, recipe) in self._grants

open_refinery-0.1.0/src/open_refinery/cli.py

@@ -0,0 +1,33 @@
+"""Demo CLI — produces one artifact and prints its provenance record."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+
+from .factory import Factory
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="open-refinery")
+    parser.add_argument("--actor", default="demo-user")
+    parser.add_argument("--text", default="hello", help="text to refine")
+    args = parser.parse_args(argv)
+
+    logging.basicConfig(level=logging.INFO, format="%(message)s")
+
+    factory = Factory()
+
+    @factory.recipe("upper")
+    def upper(text: str) -> str:
+        return text.upper()
+
+    artifact, record = factory.produce("upper", actor=args.actor, text=args.text)
+    print(f"artifact: {artifact!r}")
+    print(json.dumps(record.to_dict(), indent=2, sort_keys=True))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

open_refinery-0.1.0/src/open_refinery/factory.py

@@ -0,0 +1,73 @@
+"""Factory — produces artifacts, wrapping each output in governance."""
+
+from __future__ import annotations
+
+import logging
+from typing import Callable
+
+from .audit import AuditSink, MemorySink
+from .authz import AllowAll, Authorizer, Unauthorized
+from .provenance import Record
+
+log = logging.getLogger("open_refinery")
+
+Recipe = Callable[..., object]
+
+
+class UnknownRecipe(KeyError):
+    """Raised when producing from an unregistered recipe."""
+
+
+class Factory:
+    """Registers recipes and produces artifacts under governance.
+
+    Every ``produce`` call is authorized, run, recorded with provenance and
+    ownership, and appended to the audit trail — in that order.
+    """
+
+    def __init__(
+        self,
+        authorizer: Authorizer | None = None,
+        audit: AuditSink | None = None,
+    ) -> None:
+        self._recipes: dict[str, Recipe] = {}
+        self._authorizer = authorizer or AllowAll()
+        self._audit = audit or MemorySink()
+
+    def register(self, name: str, recipe: Recipe) -> None:
+        self._recipes[name] = recipe
+
+    def recipe(self, name: str) -> Callable[[Recipe], Recipe]:
+        """Decorator form of :meth:`register`."""
+
+        def decorate(fn: Recipe) -> Recipe:
+            self.register(name, fn)
+            return fn
+
+        return decorate
+
+    def produce(
+        self,
+        name: str,
+        *,
+        actor: str,
+        owner: str | None = None,
+        **inputs: object,
+    ) -> tuple[object, Record]:
+        if name not in self._recipes:
+            raise UnknownRecipe(name)
+        if not self._authorizer.allows(actor, name):
+            raise Unauthorized(f"{actor} may not run {name}")
+
+        owner = owner or actor
+        artifact = self._recipes[name](**inputs)
+        record = Record.of(name, actor, owner, inputs, artifact)
+        self._audit.write(record)
+        log.info(
+            "produced recipe=%s artifact=%s actor=%s owner=%s",
+            name,
+            record.artifact_id,
+            actor,
+            owner,
+        )
+        return artifact, record

open_refinery-0.1.0/src/open_refinery/provenance.py

@@ -0,0 +1,44 @@
+"""Provenance record — the governance metadata attached to every produced artifact."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import uuid
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timezone
+
+
+def _digest(value: object) -> str:
+    """Stable SHA-256 of any JSON-serializable value; repr fallback for the rest."""
+    try:
+        payload = json.dumps(value, sort_keys=True, default=repr)
+    except TypeError:
+        payload = repr(value)
+    return hashlib.sha256(payload.encode()).hexdigest()
+
+
+@dataclass(frozen=True)
+class Record:
+    """Immutable provenance for a single production event."""
+
+    recipe: str
+    actor: str
+    owner: str
+    input_digest: str
+    output_digest: str
+    artifact_id: str = field(default_factory=lambda: uuid.uuid4().hex)
+    created_at: str = field(default_factory=lambda: datetime.now(timezone.utc).isoformat())
+
+    @classmethod
+    def of(cls, recipe: str, actor: str, owner: str, inputs: dict, output: object) -> Record:
+        return cls(
+            recipe=recipe,
+            actor=actor,
+            owner=owner,
+            input_digest=_digest(inputs),
+            output_digest=_digest(output),
+        )
+
+    def to_dict(self) -> dict:
+        return asdict(self)

open_refinery-0.1.0/tests/test_factory.py

@@ -0,0 +1,57 @@
+import pytest
+
+from open_refinery import AllowList, Factory, MemorySink, Unauthorized
+from open_refinery.factory import UnknownRecipe
+
+
+def make_factory(**kw):
+    f = Factory(**kw)
+    f.register("upper", lambda text: text.upper())
+    return f
+
+
+def test_produce_returns_artifact_and_record():
+    f = make_factory()
+    artifact, record = f.produce("upper", actor="ian", text="hi")
+    assert artifact == "HI"
+    assert record.recipe == "upper"
+    assert record.actor == "ian"
+    assert record.owner == "ian"  # defaults to actor
+    assert record.artifact_id
+    assert record.input_digest and record.output_digest
+
+
+def test_owner_override():
+    f = make_factory()
+    _, record = f.produce("upper", actor="ian", owner="team", text="hi")
+    assert record.owner == "team"
+
+
+def test_audit_trail_records_every_production():
+    sink = MemorySink()
+    f = make_factory(audit=sink)
+    f.produce("upper", actor="ian", text="a")
+    f.produce("upper", actor="ian", text="b")
+    assert len(sink.records) == 2
+    assert {r.output_digest for r in sink.records}  # distinct digests captured
+
+
+def test_unknown_recipe():
+    f = make_factory()
+    with pytest.raises(UnknownRecipe):
+        f.produce("missing", actor="ian")
+
+
+def test_authorization_blocks_disallowed_actor():
+    f = make_factory(authorizer=AllowList({("ian", "upper")}))
+    f.produce("upper", actor="ian", text="ok")  # allowed
+    with pytest.raises(Unauthorized):
+        f.produce("upper", actor="mallory", text="no")
+
+
+def test_unauthorized_leaves_no_audit_record():
+    sink = MemorySink()
+    f = make_factory(authorizer=AllowList(set()), audit=sink)
+    with pytest.raises(Unauthorized):
+        f.produce("upper", actor="ian", text="no")
+    assert sink.records == []

open_refinery-0.1.0/uv.lock

@@ -0,0 +1,78 @@
+version = 1
+revision = 3
+requires-python = ">=3.11"
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "open-refinery"
+version = "0.1.0"
+source = { editable = "." }
+
+[package.optional-dependencies]
+dev = [
+    { name = "pytest" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "pytest", marker = "extra == 'dev'", specifier = ">=8.0" }]
+provides-extras = ["dev"]
+
+[[package]]
+name = "packaging"
+version = "26.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/f1/e7a6dd94a8d4a5626c03e4e99c87f241ba9e350cd9e6d75123f992427270/packaging-26.2.tar.gz", hash = "sha256:ff452ff5a3e828ce110190feff1178bb1f2ea2281fa2075aadb987c2fb221661", size = 228134, upload-time = "2026-04-24T20:15:23.917Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },
+]