claims-cli 0.6.0__py3-none-any.whl

claims/why.py

@@ -0,0 +1,398 @@
+"""For one claim: what the record establishes, and what it does not.
+
+`repro verify` answers for every assertion and `repro stale` for every file. This puts the two
+answers for one claim side by side, with the commands and files upstream of what it reads, and
+then lists what nothing in the record covers: a file no command is recorded for, a command with
+no re-run that reproduced, an assertion that was not checked.
+
+Under each assertion it also puts what `claims.checks` recorded of it: what it declared and how
+it came out at each `repro verify --record` that found it changed.
+
+Nothing is evaluated here that those two do not evaluate. Each assertion goes through
+`claims.verify.check_evidence`, each state comes from `claims.stale.stale`, and the chain is the
+part of that report's graph `repro.regenerate.upstream` reaches from the files the claim reads.
+Executes nothing and writes nothing.
+"""
+
+from __future__ import annotations
+
+import collections
+import difflib
+import pathlib
+
+from claims.adapters.reads import reading_once
+from claims.checks import Records, address, checked
+from claims.exceptions import ReproError
+from claims.models import (
+    AggregateEvidence,
+    AssertionAccount,
+    ChainNode,
+    Claim,
+    ClaimAccount,
+    Conversion,
+    CorrespondenceEvidence,
+    Decision,
+    Evidence,
+    FileRead,
+    Freshness,
+    Manifest,
+    NotEstablished,
+    NotEstablishedKind,
+    Outcome,
+    QuoteEvidence,
+    StaleCause,
+    TableCellEvidence,
+    Validity,
+)
+from claims.reruns import upstream
+from claims.resolve import stored
+from claims.stale import stale
+from claims.verify import DEFAULT_BACKENDS, Backend, artifact_states, check_evidence
+
+#: Ids named in an error. A manifest can declare thousands.
+MAX_LISTED = 10
+
+#: What the design does not check. An account ends on each that applies to it: the first where
+#: a command is recorded, the second where an assertion has an address, the third where there
+#: is an assertion.
+UNDECLARED_INPUTS = (
+    "the inputs each command declares are the author's list; a file a command reads and does "
+    "not declare is invisible"
+)
+ADDRESS_IS_CHOSEN = (
+    "the address is the author's choice; nothing checks that it holds the quantity the "
+    "sentence means"
+)
+COMPARISON_ONLY = (
+    "a verified assertion says the declared value or passage is in the file, not that the "
+    "analysis is right"
+)
+
+#: What is said of a file no command is recorded for, by what its pin found.
+_TAKEN_AS_GIVEN = {
+    Validity.AUTHORITATIVE: "its bytes are pinned and taken as given",
+    Validity.UNPINNED_ARTIFACT: "its bytes are not pinned and are taken as given",
+    Validity.BROKEN_PIN: "its bytes are not the pinned ones and are taken as given",
+}
+
+_NOT_CHECKED = {
+    Outcome.UNCHECKED: NotEstablishedKind.UNCHECKED,
+    Outcome.NOT_FOUND: NotEstablishedKind.NOT_FOUND,
+    Outcome.ERROR: NotEstablishedKind.ERROR,
+}
+
+
+class UnknownClaimError(ReproError):
+    """A claim was named that the manifest does not declare."""
+
+    def __init__(self, unknown: str, declared: tuple[str, ...]) -> None:
+        self.unknown = unknown
+        self.declared = declared
+        near = tuple(difflib.get_close_matches(unknown, declared, n=MAX_LISTED))
+        listed = near or declared[:MAX_LISTED]
+        more = len(declared) - len(listed)
+        super().__init__(
+            f"the manifest declares no claim {unknown!r}; "
+            + ("nearest: " if near else "declared: ")
+            + (", ".join(listed) or "none")
+            + (f", and {more} more" if more > 0 and not near else "")
+        )
+
+
+#: One file an assertion reads: the artifact, the side it is, the address, the value stored
+#: there, and the conversion declared for it with the value under it.
+Held = tuple[str, str, str, str | None, Conversion | None, str | None]
+
+
+def _held(evidence: Evidence, decision: Decision, paths: dict[str, pathlib.Path]) -> list[Held]:
+    """Each file an assertion reads, and what was found at the address in it."""
+    if isinstance(evidence, QuoteEvidence):
+        return [(evidence.artifact, "", "", None, None, None)]
+    if isinstance(evidence, CorrespondenceEvidence):
+        read = {side.name: side for side in decision.sides}
+        return [
+            (
+                side.artifact,
+                side.name,
+                address(side.locator),
+                read[side.name].extracted if side.name in read else None,
+                side.conversion,
+                read[side.name].converted if side.name in read else None,
+            )
+            for side in evidence.sides
+        ]
+    if isinstance(evidence, AggregateEvidence):
+        # No member was read where a file is absent or undeclared: the engine stops before
+        # the backend, and the decision lists none.
+        read = [(m.extracted, m.converted) for m in decision.members]
+        return [
+            (member.artifact, "", address(member.locator), stored, evidence.conversion, converted)
+            for member, (stored, converted) in zip(
+                evidence.members, read or [(None, None)] * evidence.count, strict=True
+            )
+        ]
+    if isinstance(evidence, TableCellEvidence) and not evidence.addresses_one_row:
+        # Neither `row` nor `where`, or both: there is no one address to show.
+        return [(evidence.artifact, "", "", None, None, None)]
+    path = paths.get(evidence.artifact)
+    return [
+        (
+            evidence.artifact,
+            "",
+            address(evidence.locator),
+            stored(evidence, path) if path is not None else None,
+            evidence.conversion,
+            decision.converted,
+        )
+    ]
+
+
+def _not_established(
+    claim: Claim, assertions: tuple[AssertionAccount, ...], chain: tuple[ChainNode, ...]
+) -> tuple[NotEstablished, ...]:
+    """What the record does not cover for this claim, then what the design does not check."""
+    lines = []
+    for node in chain:
+        if node.regeneration is None and node.validity in _TAKEN_AS_GIVEN:
+            lines.append(
+                NotEstablished(
+                    kind=NotEstablishedKind.NO_PRODUCER,
+                    subject=node.path or node.artifact,
+                    said=f"no command is recorded for it; {_TAKEN_AS_GIVEN[node.validity]}",
+                )
+            )
+    for node in chain:
+        if node.validity is Validity.ARTIFACT_ABSENT:
+            lines.append(
+                NotEstablished(
+                    kind=NotEstablishedKind.ABSENT,
+                    subject=node.path or node.artifact,
+                    said="nothing at the declared path",
+                )
+            )
+        elif node.regeneration is not None and node.validity is Validity.BROKEN_PIN:
+            lines.append(
+                NotEstablished(
+                    kind=NotEstablishedKind.BROKEN_PIN,
+                    subject=node.path or node.artifact,
+                    said="its bytes are not the pinned ones",
+                )
+            )
+    for node in chain:
+        record = node.regeneration
+        if record is None:
+            continue
+        # A record on a cycle is compared with no re-run, whether or not one is recorded.
+        if StaleCause.CYCLE in record.causes:
+            lines.append(
+                NotEstablished(
+                    kind=NotEstablishedKind.CYCLE,
+                    subject=record.id,
+                    said="on a cycle of commands, so it is compared with no re-run",
+                )
+            )
+        elif record.rerun_at is None:
+            lines.append(
+                NotEstablished(
+                    kind=NotEstablishedKind.NEVER_RERUN,
+                    subject=record.id,
+                    said="no re-run that reproduced is recorded; nothing in the record shows "
+                    f"the command produces {node.path or node.artifact}",
+                )
+            )
+    if not claim.evidence:
+        lines.append(
+            NotEstablished(
+                kind=NotEstablishedKind.NO_EVIDENCE,
+                subject=claim.id,
+                said="the claim offers no evidence, so nothing was checked",
+            )
+        )
+    for assertion in assertions:
+        if assertion.outcome in _NOT_CHECKED:
+            reason = assertion.reason.value.replace("_", " ")
+            lines.append(
+                NotEstablished(
+                    kind=_NOT_CHECKED[assertion.outcome],
+                    subject=f"{assertion.kind} {assertion.name}".strip(),
+                    said=f"{assertion.outcome.value.replace('_', ' ')}: {reason}"
+                    + (f": {assertion.detail}" if assertion.detail else ""),
+                )
+            )
+    if any(node.regeneration is not None for node in chain):
+        lines.append(
+            NotEstablished(kind=NotEstablishedKind.UNDECLARED_INPUTS, said=UNDECLARED_INPUTS)
+        )
+    if any(read.address for assertion in assertions for read in assertion.reads):
+        lines.append(NotEstablished(kind=NotEstablishedKind.ADDRESS, said=ADDRESS_IS_CHOSEN))
+    if assertions:
+        lines.append(NotEstablished(kind=NotEstablishedKind.COMPARISON, said=COMPARISON_ONLY))
+    return tuple(lines)
+
+
+def why(
+    manifest: Manifest, claim_id: str, backends: tuple[Backend, ...] = DEFAULT_BACKENDS
+) -> ClaimAccount:
+    """Evaluate one claim's assertions and say what each file it rests on is, against the
+    record of re-runs.
+
+    Executes nothing and writes nothing.
+    """
+    claim = next((c for c in manifest.claims if c.id == claim_id), None)
+    if claim is None:
+        raise UnknownClaimError(claim_id, tuple(c.id for c in manifest.claims))
+
+    report = stale(manifest)
+    states, paths = artifact_states(manifest)
+    registry: dict[str, Backend] = {b.kind: b for b in backends}
+    with reading_once():
+        decisions = [
+            check_evidence(claim, evidence, manifest, paths, states, registry)
+            for evidence in claim.evidence
+        ]
+        held = [
+            _held(evidence, decision, paths)
+            for evidence, decision in zip(claim.evidence, decisions, strict=True)
+        ]
+
+    def read(
+        artifact_id: str,
+        side: str,
+        where: str,
+        value: str | None,
+        conversion: Conversion | None,
+        converted: str | None,
+    ) -> FileRead:
+        declared, state = manifest.artifact(artifact_id), states.get(artifact_id)
+        return FileRead(
+            artifact=artifact_id,
+            path=declared.path.as_posix() if declared else "",
+            side=side,
+            validity=state.validity if state else None,
+            pinned=state.expected if state else None,
+            on_disk=state.actual if state else None,
+            address=where,
+            stored=value,
+            conversion=conversion,
+            converted=converted,
+        )
+
+    # What the record of checks holds for each assertion, and the assertion as it stands where
+    # the record's last entry is something else.
+    root = manifest.path.parent if manifest.path else pathlib.Path.cwd()
+    kept = Records(root)
+    past = kept.history
+    present = checked(claim, tuple(decisions))
+    # The last state of each assertion of a claim that is no longer declared, where it was
+    # not verified and had an address.
+    declared = {each.id for each in manifest.claims}
+    gone = [
+        states[-1]
+        for identity, states in past.items()
+        if identity[0] not in declared
+        and states[-1].outcome is not Outcome.VERIFIED
+        and states[-1].address
+    ]
+
+    freshness = next(node for node in report.claims if node.id == claim.id).assertions
+    assertions = tuple(
+        AssertionAccount(
+            kind=evidence.kind,
+            name=getattr(evidence, "name", ""),
+            printed=evidence.text
+            if isinstance(evidence, QuoteEvidence)
+            else getattr(evidence, "reported", None),
+            reads=tuple(read(*found) for found in files),
+            places=getattr(evidence, "places", None),
+            tie=decision.tie,
+            statistic=evidence.statistic if isinstance(evidence, AggregateEvidence) else None,
+            computed=decision.computed,
+            outcome=decision.outcome,
+            reason=decision.reason,
+            detail=decision.detail,
+            state=node.state,
+            warnings=decision.warnings,
+            history=recorded,
+            now=None if not recorded or now.same_as(recorded[-1]) else now,
+            formerly=tuple(
+                last
+                for last in gone
+                if last.address == now.address and set(last.digests) == set(now.digests)
+            ),
+        )
+        for evidence, decision, files, node, now in zip(
+            claim.evidence, decisions, held, freshness, present, strict=True
+        )
+        for recorded in (past.get(now.identity, ()),)
+    )
+
+    # The records upstream of each file the claim reads, by `upstream`, and so the files: each
+    # record's output at the record's distance and its inputs one step further.
+    records = {record.id: record for record in manifest.regenerations}
+    producers = {record.output.artifact: record for record in manifest.regenerations}
+    steps: dict[str, int] = {}
+    for name in dict.fromkeys(name for evidence in claim.evidence for name in evidence.artifacts):
+        steps[name] = 0
+        producer = producers.get(name)
+        if producer is None:
+            continue
+        for record_id, distance in {**upstream(producer, producers), producer.id: 0}.items():
+            record = records[record_id]
+            for artifact_id, at in (
+                (record.output.artifact, distance),
+                *((wanted.artifact, distance + 1) for wanted in record.inputs),
+            ):
+                steps[artifact_id] = min(at, steps.get(artifact_id, at))
+
+    nodes = {node.artifact: node for node in report.regenerations}
+    chain = tuple(
+        ChainNode(
+            artifact=name,
+            path=declared.path.as_posix() if declared else "",
+            steps=steps[name],
+            validity=states[name].validity if name in states else None,
+            state=nodes[name].state if name in nodes else Freshness.NO_PRODUCER,
+            command=producers[name].command if name in producers else (),
+            volatile=producers[name].volatile if name in producers else (),
+            regeneration=nodes.get(name),
+        )
+        for name in sorted(steps, key=steps.__getitem__)
+        for declared in (manifest.artifact(name),)
+    )
+    on_chain = {node.regeneration.id for node in chain if node.regeneration}
+    by_outcome = collections.Counter(assertion.outcome for assertion in assertions)
+    by_state = collections.Counter(assertion.state for assertion in assertions)
+
+    return ClaimAccount(
+        project=report.project,
+        manifest_digest=report.manifest_digest,
+        claim_id=claim.id,
+        text=claim.text,
+        where=claim.where,
+        assertions=assertions,
+        chain=chain,
+        edges=tuple(
+            edge
+            for edge in report.edges
+            if (edge.kind == "reads" and edge.source == claim.id)
+            or (edge.kind == "produced_by" and edge.target in on_chain)
+            or (edge.kind == "consumes" and edge.source in on_chain)
+        ),
+        findings=tuple(found for found in report.findings if found.regeneration in on_chain),
+        not_established=_not_established(claim, assertions, chain),
+        records=kept.states,
+        set_aside=kept.set_aside,
+        no_local_record=kept.no_local_record,
+        outcomes={outcome: by_outcome[outcome] for outcome in Outcome if by_outcome[outcome]},
+        states={state: by_state[state] for state in Freshness if by_state[state]},
+    )
+
+
+__all__ = [
+    "ADDRESS_IS_CHOSEN",
+    "COMPARISON_ONLY",
+    "UNDECLARED_INPUTS",
+    "UnknownClaimError",
+    "address",
+    "why",
+]

claims_cli-0.6.0.dist-info/METADATA

@@ -0,0 +1,139 @@
+Metadata-Version: 2.5
+Name: claims-cli
+Version: 0.6.0
+Summary: Check what a manuscript states against the files it names: numbers, table cells and quotations
+Project-URL: Changelog, https://github.com/elliottower/reproducible-science/blob/main/CHANGELOG.md
+Project-URL: Homepage, https://github.com/elliottower/reproducible-science
+Project-URL: Issues, https://github.com/elliottower/reproducible-science/issues
+Project-URL: Source, https://github.com/elliottower/reproducible-science/tree/main/packages/claims
+Author-email: Elliot Tower <elliot@elliottower.ai>
+License-Expression: MIT
+Keywords: citations,manuscript,open science,provenance,reproducibility
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+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: Topic :: Scientific/Engineering
+Requires-Python: >=3.11
+Requires-Dist: citations<0.7,>=0.6
+Requires-Dist: provenance-core<0.7,>=0.6
+Requires-Dist: pydantic>=2.9
+Requires-Dist: pyyaml>=6.0.2
+Provides-Extra: arrays
+Requires-Dist: numpy>=2.2.6; extra == 'arrays'
+Provides-Extra: hdf5
+Requires-Dist: h5py>=3.12; extra == 'hdf5'
+Provides-Extra: netcdf
+Requires-Dist: netcdf4>=1.7.2; extra == 'netcdf'
+Provides-Extra: parquet
+Requires-Dist: pyarrow>=18; extra == 'parquet'
+Provides-Extra: rds
+Requires-Dist: rdata>=1; extra == 'rds'
+Provides-Extra: sheets
+Requires-Dist: openpyxl>=3.1; extra == 'sheets'
+Requires-Dist: xlrd>=2.0.1; extra == 'sheets'
+Provides-Extra: stata-spss
+Requires-Dist: pyreadstat>=1.3.6; extra == 'stata-spss'
+Description-Content-Type: text/markdown
+
+# claims-cli
+
+[![pypi](https://img.shields.io/pypi/v/claims-cli)](https://pypi.org/project/claims-cli/)
+[![python](https://img.shields.io/pypi/pyversions/claims-cli)](https://pypi.org/project/claims-cli/)
+[![license](https://img.shields.io/pypi/l/claims-cli)](https://github.com/elliottower/reproducible-science/blob/main/LICENSE)
+[![docs](https://img.shields.io/badge/docs-live-blue)](https://reproducible.science/)
+
+Check what a manuscript states against the files it names.
+
+The part of [reproducible-science](https://github.com/elliottower/reproducible-science) that reads a manifest of claims and checks each one: a number against a results file, a table cell against a table, a quotation against its source. It installs alone, and it runs no command of yours.
+
+## Install
+
+```bash
+pip install claims-cli
+```
+
+This installs `claims` and one dependency of ours, [`citations`](https://pypi.org/project/citations/), which reads the documents a quotation is checked in. The optional readers are extras, each named for what it reads:
+
+```bash
+pip install "claims-cli[parquet,sheets]"
+```
+
+`arrays`, `hdf5`, `netcdf`, `parquet`, `rds`, `sheets` and `stata-spss`. Without the extra a format needs, a check of that format is `unchecked` and names the extra to install.
+
+## What it reads
+
+`repro.yaml`, a manifest that pins a project's files by sha256 and declares what the manuscript claims about them:
+
+```yaml
+artifacts:
+  - id: results
+    path: analysis/results.json
+    digest: {algorithm: sha256, value: 9f635f9a...}
+
+claims:
+  - id: primary
+    text: The treatment reduced the primary outcome
+    evidence:
+      - kind: metric
+        artifact: results
+        name: p_value
+        pointer: /primary/p
+        reported: "0.031"
+```
+
+The file has the same name and the same format whichever command reads it. The [specification](https://reproducible.science/reference/spec/) defines every kind of evidence and every outcome.
+
+## The commands
+
+```bash
+claims manifest init
+```
+
+Writes a starter `repro.yaml` at the top of the project: each file it finds or is given, pinned, with example claims that verify as written. It never overwrites one.
+
+```bash
+claims verify
+```
+
+Checks every declared assertion against the file it names and prints one line per assertion: `ok`, `MISS` where the file holds another value, `GONE` where the address does not resolve, `--` where the check could not run. It exits 1 where the policy fails, and `--format json` and `--format sarif` print the report as a document.
+
+```bash
+claims stale
+```
+
+Says which claims read a file that is no longer what a recorded re-run produced. It reads `.repro/reproductions.jsonl` and runs nothing.
+
+```bash
+claims why primary
+```
+
+For one claim: each assertion as `claims verify` evaluates it now, each file the claim rests on and the command recorded for it, and then what the record does not establish.
+
+```bash
+claims numbers
+```
+
+Counts every number the manuscript's text prints and says which a claim accounts for.
+
+```bash
+claims export record
+```
+
+Writes one record per checked assertion, for another program to read. `sarif` and `ro-crate` write the same records in those formats.
+
+```bash
+claims origins --repo https://github.com/owner/study=../study
+```
+
+For each artifact copied from another repository, which the manifest says with `origin: {repository, commit, path}`, compares the pinned digest with the bytes of that path at that commit: `same`, `differs`, `absent`, `unknown commit` or `not checked`, each with the reason. A clone given with `--repo` is read with `git cat-file`, so committed bytes are compared and never a working tree. With `--fetch`, a GitHub repository no clone is given for is read from `raw.githubusercontent.com`; without it nothing touches the network. `claims verify` never reads an origin.
+
+## With `repro`
+
+[`reproducible-science`](https://pypi.org/project/reproducible-science/) depends on this package and adds the commands that run things: `repro reproduce`, which runs each declared command again and writes the record `claims stale` reads, `repro check` and `repro audit`, which drive `prereg`, `results` and `citations`, and `repro ci`. Under `repro`, every command above has the same name, does the same thing and prints the same output: `repro verify` and `claims verify` are one function. A project that uses `repro` has no reason to install this by itself. It is separate so that checking a manuscript's claims does not require installing something that executes commands a manifest names.
+
+MIT licensed.

claims_cli-0.6.0.dist-info/RECORD

@@ -0,0 +1,51 @@
+claims/__init__.py,sha256=qiTFpxrEffnmtOD3_tEqjih6HFfUW-o640bhaPIT7Bg,3410
+claims/__main__.py,sha256=2G4pjnNFGBK8XPrjiUkGpJHULOk-NzoQrDTdT8xnRcA,115
+claims/checks.py,sha256=MuaPkL3BQvuVb05nQ5CAfGBWMoLbJVfnpWtVzIV50FM,21458
+claims/cli.py,sha256=jnG7jGyfKAXTM84WfPnB9msRtGznCl5VUnhJnulZKn4,49683
+claims/corpus.py,sha256=fjdB-Csd92R-UgMa4RRAHM72JeO3SAXxLA0GaDo_Xls,12538
+claims/exceptions.py,sha256=Hx05bLyk9Xtx9jClieFtrMuG9OSDm5FyFIW0Y_RWz_A,3835
+claims/manifest.py,sha256=QcHVysmvs3jdFfMgDPpPq96jf00dxyW5ym5-a57Fz6w,2310
+claims/models.py,sha256=PSIIIhhiWXDRai5gm9-nmZPx3yXRlZu8j20nDN9W8qs,5840
+claims/numbers.py,sha256=w0yxK_UJoTg8prqv-dNk_wfLZjOUPekDc1o4v350gVE,19295
+claims/origins.py,sha256=eeJBwUz7y27yxPJ13CviQgGL2FOQWM6gGbFFl3Cxfrw,11220
+claims/policy.py,sha256=sWGlpveOA4eCPAGuotaCbw8PadZQ1dvAU4KM1bt6oMA,14540
+claims/provenance.py,sha256=7AXuxhtQaxfAM_Gok-OPruTu0O9jWLOBsn_xf7MIOmk,1590
+claims/record.py,sha256=Z337-37F--HhMVo7YOZ6rJqYsp3QA_Ggv1sZS7EBvwU,43811
+claims/regression.py,sha256=2E0_GnIs_PeacN0UU6zuPtz71i08LDItz5UYKjxGoYg,5945
+claims/reruns.py,sha256=a_1mEux5TLg6T9Gelseb65aoV5gi9CKS9nHXUPsttCc,4563
+claims/resolve.py,sha256=wuGeocIE2NB6Z9FhXnF3DtAGNkjKR-O-9VI-wkGTdBk,4628
+claims/stale.py,sha256=AppPzUyqD6nrx_58DDoWYSFORL50MK0dgViiv5nSD9Y,13142
+claims/starter.py,sha256=8lV9zSG3kfSpa0AGtUtPGPYCcjOYYVnLMdYUYWMLauI,18380
+claims/toolchain.py,sha256=QmzalHL4jHqwXkgQQRTZapfrxuXrkRsl9FWuMlg5V08,4747
+claims/verify.py,sha256=tqvMEg3Fawigp4IN92BJUAwIGDkKjnLIObE_Op6qSRE,59721
+claims/why.py,sha256=YxC8s9yw0eL5FCpTPQ0_CEYIIc4vyBqJxvP9MSyw9ak,15860
+claims/adapters/__init__.py,sha256=Y-oo_AD11xdK4CMEbZbANMWiO_VgHvcnSiHMac5Ywq0,251
+claims/adapters/array.py,sha256=ggeJd3NuNCpWPISiz13QwkMAhN76j5vJ8Fl695zEE9k,9280
+claims/adapters/base.py,sha256=DvoarzVVQwAKFXylczPJqdiqX6HnQj-0Lm9lh_tBgyk,2978
+claims/adapters/cells.py,sha256=XcmOhVsRoRAdMNqKmIvS75Imf5cDKEUNnGvm5ePsE5c,3858
+claims/adapters/columnar.py,sha256=_4PYDb2SQiXP4Lo1I4brvoINorJn5y-VWxs02XkaRsY,8167
+claims/adapters/prose.py,sha256=-XatJ-oz6QatX0_-j_3DqTbzZ4ZWvFqQUR0nk4OUQno,12436
+claims/adapters/reads.py,sha256=b1V9nhRqT7dtmtayw95I_qAgbQZWJS5OUZAwgUUpDXw,1696
+claims/adapters/rows.py,sha256=HhQg2yQHwFYnj8_7u1jRMBYgTvocMmVCIL5IcMz4ZQU,5116
+claims/adapters/sheet.py,sha256=VUEibAXEDvm-t_EZIngaUuQ6UuS47e950ZasKAQOM74,6581
+claims/adapters/sqlite.py,sha256=b7xEYLMxSAIeIOMPEIm7wIaX6gRJfAH0SUjltg6nwTM,2997
+claims/adapters/table.py,sha256=B603jtqpJO_HpPFeKcohbX0wbswDZb4tW9PvOW5W5hQ,5859
+claims/adapters/tree.py,sha256=zRaPi3vY35jYz4WqDfoI8VlIgVnR6KXKwBvi4euu5CM,6247
+claims/core/__init__.py,sha256=C3QIc8B_TH4eDcU8g7VaOJdpGlBmu0wnAh6qJFKiLFA,477
+claims/core/artifacts.py,sha256=SNtxep20cR5vkEUoCF8KAW15akA-LcwbmbTqF-kryNs,4134
+claims/core/checks.py,sha256=cnoRJmv-WB-RbvcbzUM1AX0RgY6UqAdJPgXMyZDzxYs,5418
+claims/core/claims.py,sha256=Ag6aXut6bq4piMcOjVXowlt9Ibs4qPvwJOmrohBn6Rc,3754
+claims/core/evidence.py,sha256=Tp16mtUmO2SrE-D8YKn374RMuDDrCL4MJa-ZhJ9gpqw,27675
+claims/core/manifest.py,sha256=4h5TqeuguFK08s5HCW2dYauSDcxbmJpUpFVjj9dvWzA,14267
+claims/core/numbers.py,sha256=EyMn4Sz8_LUnex_oszxCsy7m6t2WX6EODQT2My1vUPY,6115
+claims/core/outcomes.py,sha256=GwgCCmL31FZbz_W9Ka8mFHUUHpWUZatJPuCTI31GHd8,18024
+claims/core/report.py,sha256=8LFKthC8yfemxLyEd3WTHoCoY7CpSul3zf8rIbUIXHM,18258
+claims/export/__init__.py,sha256=FUJ_4x22azFR_CTLZ4aXT1ezo4znFwUY_Eo7JgqME7A,670
+claims/export/rocrate.py,sha256=RrPePcaf1UyGwwemT_1D97GR2_REygMI2CyJrUnntWE,32953
+claims/export/sarif.py,sha256=EuP8l3YZZm0in2OVvydYLXX6vHO1Lc66ypNnO54kj5s,15628
+claims/renderers/__init__.py,sha256=KMqGyJNw9myWpkEREoKRFuy-bUJvNRq7AhI9lyKRji0,345
+claims/renderers/sarif.py,sha256=yz30yg61O5zt6_xOogXcaXjXmCnQOlAk-Wuy3ijH8xU,12928
+claims_cli-0.6.0.dist-info/METADATA,sha256=fTN3iaV9RQspSTP3ASX-gFVg7sk4yf9n47NpKEwNckA,6372
+claims_cli-0.6.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+claims_cli-0.6.0.dist-info/entry_points.txt,sha256=qPRfNHlVZYCAD9YWmd03hgV6iYh8YfhM2xLJx7qOM5M,43
+claims_cli-0.6.0.dist-info/RECORD,,

claims_cli-0.6.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

claims_cli-0.6.0.dist-info/entry_points.txt

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