modelwright 0.1.0a1__py3-none-any.whl

modelwright/validation.py

@@ -0,0 +1,475 @@
+"""Validation report records.
+
+These objects describe validation results; they do not run workbook or generated
+model comparisons themselves.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Literal
+
+
+JsonValue = str | int | float | bool | None | list[Any] | dict[str, Any]
+OutputKind = Literal["number", "text", "boolean", "blank", "error"]
+ReportStatus = Literal["pass", "fail"]
+DiagnosticSeverity = Literal["info", "warning", "error"]
+TextComparisonMode = Literal["exact"]
+BooleanComparisonMode = Literal["exact"]
+
+
+class _MissingValue:
+    pass
+
+
+MISSING_VALUE = _MissingValue()
+
+
+@dataclass(frozen=True)
+class OracleConfig:
+    """Oracle backend configuration from a validation scenario."""
+
+    backend: str
+    options: dict[str, JsonValue] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "OracleConfig":
+        backend = data["backend"]
+        options = {key: value for key, value in data.items() if key != "backend"}
+        return cls(backend=backend, options=options)
+
+    def to_dict(self) -> dict[str, JsonValue]:
+        return {"backend": self.backend, **self.options}
+
+
+@dataclass(frozen=True)
+class ScenarioInput:
+    """Input override declared by a validation scenario."""
+
+    cell_ref: str
+    value: JsonValue
+    kind: OutputKind
+    source: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "ScenarioInput":
+        return cls(
+            cell_ref=data["cell_ref"],
+            value=data.get("value"),
+            kind=data["kind"],
+            source=data.get("source"),
+        )
+
+    def to_dict(self) -> dict[str, JsonValue]:
+        payload: dict[str, JsonValue] = {
+            "cell_ref": self.cell_ref,
+            "value": self.value,
+            "kind": self.kind,
+        }
+        if self.source is not None:
+            payload["source"] = self.source
+        return payload
+
+
+@dataclass(frozen=True)
+class ScenarioOutput:
+    """Output expectation declared by a validation scenario."""
+
+    cell_ref: str
+    kind: OutputKind
+    tolerance: float | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "ScenarioOutput":
+        return cls(
+            cell_ref=data["cell_ref"],
+            kind=data["kind"],
+            tolerance=data.get("tolerance"),
+        )
+
+    def to_dict(self) -> dict[str, JsonValue]:
+        payload: dict[str, JsonValue] = {
+            "cell_ref": self.cell_ref,
+            "kind": self.kind,
+        }
+        if self.tolerance is not None:
+            payload["tolerance"] = self.tolerance
+        return payload
+
+
+@dataclass(frozen=True)
+class ComparisonRules:
+    """Default comparison rules declared by a validation scenario."""
+
+    default_numeric_tolerance: float = 1e-9
+    text: TextComparisonMode = "exact"
+    boolean: BooleanComparisonMode = "exact"
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "ComparisonRules":
+        return cls(
+            default_numeric_tolerance=data.get("default_numeric_tolerance", 1e-9),
+            text=data.get("text", "exact"),
+            boolean=data.get("boolean", "exact"),
+        )
+
+    def to_dict(self) -> dict[str, JsonValue]:
+        return {
+            "default_numeric_tolerance": self.default_numeric_tolerance,
+            "text": self.text,
+            "boolean": self.boolean,
+        }
+
+
+@dataclass(frozen=True)
+class ValidationScenario:
+    """Validation scenario loaded from a JSON boundary."""
+
+    scenario_id: str
+    description: str
+    source_workbook: str
+    generated_model: str
+    oracle: OracleConfig
+    inputs: tuple[ScenarioInput, ...]
+    outputs: tuple[ScenarioOutput, ...]
+    comparison: ComparisonRules
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "ValidationScenario":
+        return cls(
+            scenario_id=data["scenario_id"],
+            description=data.get("description", ""),
+            source_workbook=data["source_workbook"],
+            generated_model=data["generated_model"],
+            oracle=OracleConfig.from_dict(data["oracle"]),
+            inputs=tuple(ScenarioInput.from_dict(input_data) for input_data in data.get("inputs", [])),
+            outputs=tuple(ScenarioOutput.from_dict(output_data) for output_data in data["outputs"]),
+            comparison=ComparisonRules.from_dict(data.get("comparison", {})),
+        )
+
+    def to_dict(self) -> dict[str, JsonValue]:
+        return {
+            "scenario_id": self.scenario_id,
+            "description": self.description,
+            "source_workbook": self.source_workbook,
+            "generated_model": self.generated_model,
+            "oracle": self.oracle.to_dict(),
+            "inputs": [scenario_input.to_dict() for scenario_input in self.inputs],
+            "outputs": [output.to_dict() for output in self.outputs],
+            "comparison": self.comparison.to_dict(),
+        }
+
+
+def load_validation_scenario(path: str | Path) -> ValidationScenario:
+    """Load a validation scenario JSON file from disk."""
+
+    scenario_path = Path(path)
+    data = json.loads(scenario_path.read_text(encoding="utf-8"))
+    return ValidationScenario.from_dict(data)
+
+
+@dataclass(frozen=True)
+class Diagnostic:
+    """Run-level diagnostic not tied to one output comparison."""
+
+    diagnostic_code: str
+    message: str
+    severity: DiagnosticSeverity = "warning"
+    location: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Diagnostic":
+        return cls(
+            diagnostic_code=data["diagnostic_code"],
+            message=data["message"],
+            severity=data.get("severity", "warning"),
+            location=data.get("location"),
+        )
+
+    def to_dict(self) -> dict[str, JsonValue]:
+        return {
+            "diagnostic_code": self.diagnostic_code,
+            "message": self.message,
+            "severity": self.severity,
+            "location": self.location,
+        }
+
+
+@dataclass(frozen=True)
+class ComparisonResult:
+    """Comparison result for one declared workbook output."""
+
+    scenario_id: str
+    cell_ref: str
+    kind: OutputKind
+    generated: JsonValue
+    oracle: JsonValue
+    matches: bool
+    tolerance: float | None
+    difference: float | None
+    diagnostic_code: str | None
+    message: str
+    oracle_backend: str
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "ComparisonResult":
+        return cls(
+            scenario_id=data["scenario_id"],
+            cell_ref=data["cell_ref"],
+            kind=data["kind"],
+            generated=data.get("generated"),
+            oracle=data.get("oracle"),
+            matches=data["matches"],
+            tolerance=data.get("tolerance"),
+            difference=data.get("difference"),
+            diagnostic_code=data.get("diagnostic_code"),
+            message=data["message"],
+            oracle_backend=data["oracle_backend"],
+        )
+
+    def to_dict(self) -> dict[str, JsonValue]:
+        return {
+            "scenario_id": self.scenario_id,
+            "cell_ref": self.cell_ref,
+            "kind": self.kind,
+            "generated": self.generated,
+            "oracle": self.oracle,
+            "matches": self.matches,
+            "tolerance": self.tolerance,
+            "difference": self.difference,
+            "diagnostic_code": self.diagnostic_code,
+            "message": self.message,
+            "oracle_backend": self.oracle_backend,
+        }
+
+
+def compare_scalar_output(
+    *,
+    scenario_id: str,
+    output: ScenarioOutput,
+    generated: JsonValue | _MissingValue,
+    oracle: JsonValue | _MissingValue,
+    oracle_backend: str,
+    default_numeric_tolerance: float = 1e-9,
+) -> ComparisonResult:
+    """Compare one observed generated value against one oracle value."""
+
+    if generated is MISSING_VALUE and oracle is MISSING_VALUE:
+        return ComparisonResult(
+            scenario_id=scenario_id,
+            cell_ref=output.cell_ref,
+            kind=output.kind,
+            generated=None,
+            oracle=None,
+            matches=False,
+            tolerance=_tolerance_for(output, default_numeric_tolerance),
+            difference=None,
+            diagnostic_code="missing_generated_and_oracle_output",
+            message="generated and oracle outputs are missing",
+            oracle_backend=oracle_backend,
+        )
+    if generated is MISSING_VALUE:
+        return ComparisonResult(
+            scenario_id=scenario_id,
+            cell_ref=output.cell_ref,
+            kind=output.kind,
+            generated=None,
+            oracle=oracle,
+            matches=False,
+            tolerance=_tolerance_for(output, default_numeric_tolerance),
+            difference=None,
+            diagnostic_code="missing_generated_output",
+            message="generated output is missing",
+            oracle_backend=oracle_backend,
+        )
+    if oracle is MISSING_VALUE:
+        return ComparisonResult(
+            scenario_id=scenario_id,
+            cell_ref=output.cell_ref,
+            kind=output.kind,
+            generated=generated,
+            oracle=None,
+            matches=False,
+            tolerance=_tolerance_for(output, default_numeric_tolerance),
+            difference=None,
+            diagnostic_code="missing_oracle_output",
+            message="oracle output is missing",
+            oracle_backend=oracle_backend,
+        )
+
+    if output.kind == "number":
+        return _compare_number(
+            scenario_id=scenario_id,
+            output=output,
+            generated=generated,
+            oracle=oracle,
+            oracle_backend=oracle_backend,
+            default_numeric_tolerance=default_numeric_tolerance,
+        )
+    if output.kind == "text":
+        return _compare_text(
+            scenario_id=scenario_id,
+            output=output,
+            generated=generated,
+            oracle=oracle,
+            oracle_backend=oracle_backend,
+        )
+
+    return ComparisonResult(
+        scenario_id=scenario_id,
+        cell_ref=output.cell_ref,
+        kind=output.kind,
+        generated=generated,
+        oracle=oracle,
+        matches=False,
+        tolerance=_tolerance_for(output, default_numeric_tolerance),
+        difference=None,
+        diagnostic_code="unsupported_output_kind",
+        message=f"unsupported output kind: {output.kind}",
+        oracle_backend=oracle_backend,
+    )
+
+
+def _tolerance_for(output: ScenarioOutput, default_numeric_tolerance: float) -> float | None:
+    if output.kind != "number":
+        return None
+    return output.tolerance if output.tolerance is not None else default_numeric_tolerance
+
+
+def _compare_number(
+    *,
+    scenario_id: str,
+    output: ScenarioOutput,
+    generated: JsonValue,
+    oracle: JsonValue,
+    oracle_backend: str,
+    default_numeric_tolerance: float,
+) -> ComparisonResult:
+    tolerance = _tolerance_for(output, default_numeric_tolerance)
+    if not _is_number(generated) or not _is_number(oracle):
+        return ComparisonResult(
+            scenario_id=scenario_id,
+            cell_ref=output.cell_ref,
+            kind=output.kind,
+            generated=generated,
+            oracle=oracle,
+            matches=False,
+            tolerance=tolerance,
+            difference=None,
+            diagnostic_code="numeric_type_mismatch",
+            message="generated and oracle values must both be numeric",
+            oracle_backend=oracle_backend,
+        )
+
+    difference = abs(float(generated) - float(oracle))
+    matches = difference <= float(tolerance)
+    return ComparisonResult(
+        scenario_id=scenario_id,
+        cell_ref=output.cell_ref,
+        kind=output.kind,
+        generated=generated,
+        oracle=oracle,
+        matches=matches,
+        tolerance=tolerance,
+        difference=difference,
+        diagnostic_code=None if matches else "numeric_mismatch",
+        message="values match" if matches else "generated value differs from oracle value",
+        oracle_backend=oracle_backend,
+    )
+
+
+def _compare_text(
+    *,
+    scenario_id: str,
+    output: ScenarioOutput,
+    generated: JsonValue,
+    oracle: JsonValue,
+    oracle_backend: str,
+) -> ComparisonResult:
+    matches = isinstance(generated, str) and isinstance(oracle, str) and generated == oracle
+    return ComparisonResult(
+        scenario_id=scenario_id,
+        cell_ref=output.cell_ref,
+        kind=output.kind,
+        generated=generated,
+        oracle=oracle,
+        matches=matches,
+        tolerance=None,
+        difference=None,
+        diagnostic_code=None if matches else "text_mismatch",
+        message="values match" if matches else "generated text differs from oracle text",
+        oracle_backend=oracle_backend,
+    )
+
+
+def _is_number(value: JsonValue) -> bool:
+    return isinstance(value, int | float) and not isinstance(value, bool)
+
+
+@dataclass(frozen=True)
+class ValidationReport:
+    """Validation report for one scenario."""
+
+    scenario_id: str
+    oracle_backend: str
+    comparisons: tuple[ComparisonResult, ...] = field(default_factory=tuple)
+    diagnostics: tuple[Diagnostic, ...] = field(default_factory=tuple)
+
+    @property
+    def mismatches(self) -> tuple[ComparisonResult, ...]:
+        return tuple(comparison for comparison in self.comparisons if not comparison.matches)
+
+    @property
+    def status(self) -> ReportStatus:
+        if self.mismatches or any(diagnostic.severity == "error" for diagnostic in self.diagnostics):
+            return "fail"
+        return "pass"
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "ValidationReport":
+        return cls(
+            scenario_id=data["scenario_id"],
+            oracle_backend=data["oracle_backend"],
+            comparisons=tuple(ComparisonResult.from_dict(item) for item in data.get("comparisons", [])),
+            diagnostics=tuple(Diagnostic.from_dict(item) for item in data.get("diagnostics", [])),
+        )
+
+    def to_dict(self) -> dict[str, JsonValue]:
+        return {
+            "scenario_id": self.scenario_id,
+            "oracle_backend": self.oracle_backend,
+            "status": self.status,
+            "comparisons": [comparison.to_dict() for comparison in self.comparisons],
+            "mismatches": [comparison.to_dict() for comparison in self.mismatches],
+            "diagnostics": [diagnostic.to_dict() for diagnostic in self.diagnostics],
+        }
+
+
+def build_validation_report(
+    *,
+    scenario: ValidationScenario,
+    generated_values: Mapping[str, JsonValue],
+    oracle_values: Mapping[str, JsonValue],
+) -> ValidationReport:
+    """Build a report from scenario outputs and already-observed values."""
+
+    comparisons = tuple(
+        compare_scalar_output(
+            scenario_id=scenario.scenario_id,
+            output=output,
+            generated=generated_values.get(output.cell_ref, MISSING_VALUE),
+            oracle=oracle_values.get(output.cell_ref, MISSING_VALUE),
+            oracle_backend=scenario.oracle.backend,
+            default_numeric_tolerance=scenario.comparison.default_numeric_tolerance,
+        )
+        for output in scenario.outputs
+    )
+
+    return ValidationReport(
+        scenario_id=scenario.scenario_id,
+        oracle_backend=scenario.oracle.backend,
+        comparisons=comparisons,
+    )

modelwright-0.1.0a1.dist-info/METADATA

@@ -0,0 +1,160 @@
+Metadata-Version: 2.4
+Name: modelwright
+Version: 0.1.0a1
+Summary: Tools for converting spreadsheet workbooks into transparent Python models.
+Author: UBC FRESH Lab
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/UBC-FRESH/modelwright
+Project-URL: Documentation, https://ubc-fresh.github.io/modelwright/
+Project-URL: Repository, https://github.com/UBC-FRESH/modelwright
+Project-URL: Issues, https://github.com/UBC-FRESH/modelwright/issues
+Project-URL: Changelog, https://github.com/UBC-FRESH/modelwright/blob/main/CHANGE_LOG.md
+Keywords: spreadsheets,excel,model-conversion,reproducible-models,validation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: rich>=13
+Requires-Dist: typer>=0.9
+Provides-Extra: docs
+Requires-Dist: sphinx>=7; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=2; extra == "docs"
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: formulas; extra == "dev"
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: ruff>=0.8; extra == "dev"
+Requires-Dist: sphinx>=7; extra == "dev"
+Requires-Dist: sphinx-rtd-theme>=2; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Provides-Extra: oracle
+Requires-Dist: formulas; extra == "oracle"
+Provides-Extra: quality
+Requires-Dist: ruff>=0.8; extra == "quality"
+Provides-Extra: release
+Requires-Dist: build>=1.2; extra == "release"
+Requires-Dist: twine>=5; extra == "release"
+Provides-Extra: test
+Requires-Dist: formulas; extra == "test"
+Requires-Dist: pytest>=8; extra == "test"
+Dynamic: license-file
+
+# Modelwright
+
+`modelwright` is an early-stage project for turning spreadsheet workbooks into transparent, version-controlled, standalone Python models.
+
+The intended direction is a generic workflow that can inspect workbook structure, extract formulas and dependencies, generate maintainable Python source, and validate the generated model against the original workbook outputs.
+
+This repository is currently an early implementation skeleton. It defines minimal Python package and test scaffolding plus initial validation, extraction, graph, generation, oracle records, and thin JSON command-line wrappers, but does not yet provide a release stability guarantee, catalog schema, or full workbook conversion.
+
+## Current Focus
+
+- Build the first package-backed validation/report, workbook extraction, generation, and CLI cores.
+- Keep extraction, code generation, validation, diagnostics, and reporting responsibilities separate.
+- Avoid committing private notes, source workbooks, generated clones, or large artifacts while the project shape is still being established.
+
+## Python API Boundary
+
+The durable API is organized by module responsibility:
+
+- `modelwright.extraction`: workbook extraction records and `extract_workbook`.
+- `modelwright.graph`: dependency graph records and `build_dependency_graph`.
+- `modelwright.formulas`: formula expression records, translation helpers, and reference-index helpers.
+- `modelwright.generation`: generated-module records and `generate_python_module`.
+- `modelwright.validation`: validation scenarios, scalar comparisons, and report records.
+- `modelwright.oracles`, `modelwright.formulas_oracle`, and `modelwright.oracle_validation`: oracle request/result records, optional `formulas` oracle execution, and oracle-backed report assembly.
+
+The package root `modelwright` exposes a curated convenience facade for those records and functions. Module-level imports remain preferred for implementation work because this project is still pre-release.
+
+## Command-Line Interface
+
+Bootstrap the repo-local virtual environment before using the console script:
+
+```bash
+scripts/bootstrap_dev_env.sh
+```
+
+The current CLI prints JSON to stdout and stays close to the Python APIs:
+
+```bash
+modelwright workbook extract path/to/workbook.xlsx > tmp/extraction.json
+modelwright workbook graph path/to/workbook.xlsx > tmp/dependency-graph.json
+modelwright conversion plan path/to/workbook.xlsx > tmp/conversion-plan.json
+modelwright model generate --contract tmp/contract.json --expressions tmp/expressions.json --constants tmp/constants.json --out tmp/generated_model.py > tmp/generation-result.json
+modelwright validation report --scenario tests/fixtures/synthetic_model/baseline_scenario.json --generated-values tmp/generated-values.json --oracle-values tmp/oracle-values.json > tmp/validation-report.json
+```
+
+These commands do not provide a one-step workbook converter. `conversion plan` reports extraction, graphing, formula-translation, and residual-blocker status; `model generate` expects explicit generated-module and formula-expression JSON inputs; and `validation report` compares already-observed generated/oracle values. See `planning/cli-json-workflows.md` for JSON examples and workflow boundaries.
+
+## Local Development
+
+Bootstrap a repo-local virtual environment:
+
+```bash
+scripts/bootstrap_dev_env.sh
+```
+
+This installs Modelwright with the `dev` extra:
+
+```bash
+.venv/bin/python -m pip install -e '.[dev]'
+```
+
+Run lint checks:
+
+```bash
+.venv/bin/python -m ruff check .
+```
+
+Run tests:
+
+```bash
+.venv/bin/python -m pytest
+```
+
+Build docs locally:
+
+```bash
+.venv/bin/sphinx-build -b html docs _build/html -W
+.venv/bin/python scripts/verify_docs_theme.py _build/html
+```
+
+Restore the public external FABLE benchmark workbooks into ignored local paths:
+
+```bash
+scripts/bootstrap_dev_env.sh --benchmarks
+```
+
+`modelwright` is pre-release. The first planned alpha line is `0.1.0a1`; alpha releases must not be described as full-workbook conversion guarantees.
+
+Check release artifacts locally:
+
+```bash
+scripts/check_release_artifacts.sh
+```
+
+Release checks write build outputs under ignored `tmp/release-checks/`.
+
+See `docs/guides/release-deployment.rst` for the release and deployment runbook.
+
+## Repository Conventions
+
+- `AGENTS.md` is the working contract for AI coding agents.
+- `CONTRIBUTING.md` is the contributor onboarding and development workflow guide.
+- `ROADMAP.md` is the current plan and next-step tracker.
+- `CHANGE_LOG.md` is the append-only project narrative.
+- `planning/` contains focused design notes and research records that are too detailed for the roadmap.
+- `benchmarks/` contains tracked metadata for official external benchmarks; large workbook binaries remain untracked and are restored locally under `tmp/`.
+- `src/modelwright/` contains the importable Python package.
+- `tests/` contains package-backed tests and tracked synthetic fixture helpers.
+- `tmp/` is ignored local working space for private notes, source workbooks, experiments, and generated scratch outputs.

modelwright-0.1.0a1.dist-info/RECORD

@@ -0,0 +1,20 @@
+modelwright/__init__.py,sha256=niukW7pkRKSkkC77iOEqt1gzT9rYaXXh8UfSXUvyibc,3573
+modelwright/cli.py,sha256=MFyn0iRm6NGIRZevuV2gpQ7g7V1iU0nGelctzFlWgAE,13891
+modelwright/conversion.py,sha256=dbVLrDSnJp9Ffi0HwwVr7IK14xcF0OAFfVNYm7855_0,35788
+modelwright/evaluation.py,sha256=awwePtzODiA4dyjbh2-bS3LMY3qclxt9G7L2CIjOw4Y,6476
+modelwright/execution.py,sha256=JnoFGoGdLiEw4BlZdwzqc4GNbs-oFB3C6gdmB8ZsYhA,8087
+modelwright/extraction.py,sha256=3_EI4dlgoRRP-TtjbNHtfyEF01UNFAaSpxyHiEb9p9o,22576
+modelwright/formulas.py,sha256=rGuZCsdT0qCjG_dnYpqB4DHwAc-cCSgBk2JmyvjGidw,21259
+modelwright/formulas_oracle.py,sha256=2GAk_oQDLFzmhDqmv2soTOcORUwgahm5XulUDbxAn_U,5167
+modelwright/generation.py,sha256=7DMB5MVnX6gg78iWRMR90Z7o3F1_-tRknNSiKxydOB4,28979
+modelwright/graph.py,sha256=BX6IyI5A52RBjm4uTSBW9hfFZmJIqzwU-dn9qDTlrFg,20112
+modelwright/oracle_validation.py,sha256=drvFik9x7J2PtJBLekccsFMEIkQisdgoRc05Kz57qkA,1738
+modelwright/oracles.py,sha256=WjiVFK0Kg5VpILEIoC2lQlqJzN-5MZGUB967qWW34K4,4478
+modelwright/references.py,sha256=ur2n_jeQ5H6Tyz31vwEYSmWaQXA57C6uD2YOhhf7aG8,6593
+modelwright/validation.py,sha256=_Oo2cAHTUGPdEAdw60Jec7b4xW88AY1iev0coIIcnRw,15320
+modelwright-0.1.0a1.dist-info/licenses/LICENSE,sha256=-wxpwq3CXqCZyuDvzOEdo6nxxy1Rz1Mcudjnq6uBQ3E,1070
+modelwright-0.1.0a1.dist-info/METADATA,sha256=hMQewpYCLTjaHdBjx3aAK85rYkywO58BeNfqFtj7YA8,7117
+modelwright-0.1.0a1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+modelwright-0.1.0a1.dist-info/entry_points.txt,sha256=SM5N6V17pwDqPMaRL4kY6zOdfkIDxoTl5OH3nFtu2SI,52
+modelwright-0.1.0a1.dist-info/top_level.txt,sha256=NZNmVeA6iHFviNzQD-6DaW6tGDUcgXBoPTW4CcjM43k,12
+modelwright-0.1.0a1.dist-info/RECORD,,

modelwright-0.1.0a1.dist-info/WHEEL

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

modelwright-0.1.0a1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+modelwright = modelwright.cli:app

modelwright-0.1.0a1.dist-info/licenses/LICENSE

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

modelwright-0.1.0a1.dist-info/top_level.txt

@@ -0,0 +1 @@
+modelwright