ecosemantic-databases 0.1.8__tar.gz

ecosemantic_databases-0.1.8/.gitignore

@@ -0,0 +1,24 @@
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+*.egg-info/
+dist/
+build/
+node_modules/
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.coverage
+coverage.json
+htmlcov/
+
+.env
+.env.*
+!.env.example
+
+.DS_Store
+graphify-out
+knowledge/
+.okf-cache.json
+**/ecosemantic/view/static/

ecosemantic_databases-0.1.8/LICENSE

@@ -0,0 +1,73 @@
+# PolyForm Noncommercial License 1.0.0
+
+<https://polyformproject.org/licenses/noncommercial/1.0.0>
+
+## Acceptance
+
+In order to get any license under these terms, you must agree to them as both strict obligations and conditions to all your licenses.
+
+## Copyright License
+
+The licensor grants you a copyright license for the software to do everything you might do with the software that would otherwise infringe the licensor's copyright in it for any permitted purpose.  However, you may only distribute the software according to [Distribution License](#distribution-license) and make changes or new works based on the software according to [Changes and New Works License](#changes-and-new-works-license).
+
+## Distribution License
+
+The licensor grants you an additional copyright license to distribute copies of the software.  Your license to distribute covers distributing the software with changes and new works permitted by [Changes and New Works License](#changes-and-new-works-license).
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you also gets a copy of these terms or the URL for them above, as well as copies of any plain-text lines beginning with `Required Notice:` that the licensor provided with the software.  For example:
+
+> Required Notice: Copyright Yoyodyne, Inc. (http://example.com)
+
+## Changes and New Works License
+
+The licensor grants you an additional copyright license to make changes and new works based on the software for any permitted purpose.
+
+## Patent License
+
+The licensor grants you a patent license for the software that covers patent claims the licensor can license, or becomes able to license, that you would infringe by using the software.
+
+## Noncommercial Purposes
+
+Any noncommercial purpose is a permitted purpose.
+
+## Personal Uses
+
+Personal use for research, experiment, and testing for the benefit of public knowledge, personal study, private entertainment, hobby projects, amateur pursuits, or religious observance, without any anticipated commercial application, is use for a permitted purpose.
+
+## Noncommercial Organizations
+
+Use by any charitable organization, educational institution, public research organization, public safety or health organization, environmental protection organization, or government institution is use for a permitted purpose regardless of the source of funding or obligations resulting from the funding.
+
+## Fair Use
+
+You may have "fair use" rights for the software under the law. These terms do not limit them.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of your licenses to anyone else, or prevent the licensor from granting licenses to anyone else.  These terms do not imply any other licenses.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or contributes to infringement of any patent, your patent license for the software granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company.
+
+## Violations
+
+The first time you are notified in writing that you have violated any of these terms, or done anything with the software not covered by your licenses, your licenses can nonetheless continue if you come into full compliance with these terms, and take practical steps to correct past violations, within 32 days of receiving notice.  Otherwise, all your licenses end immediately.
+
+## No Liability
+
+***As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will not be liable to you for any damages arising out of these terms or the use or nature of the software, under any kind of legal claim.***
+
+## Definitions
+
+The **licensor** is the individual or entity offering these terms, and the **software** is the software the licensor makes available under these terms.
+
+**You** refers to the individual or entity agreeing to these terms.
+
+**Your company** is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all organizations that have control over, are under the control of, or are under common control with that organization.  **Control** means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise.  Control can be direct or indirect.
+
+**Your licenses** are all the licenses granted to you for the software under these terms.
+
+**Use** means anything you do with the software requiring one of your licenses.

ecosemantic_databases-0.1.8/NOTICE

@@ -0,0 +1,13 @@
+EcoSemantic
+Required Notice: Copyright 2026 Carlos Gaete-Morales (https://github.com/cdgaete/ecosemantic)
+
+EcoSemantic is licensed under the PolyForm Noncommercial License 1.0.0, in LICENSE
+and at https://polyformproject.org/licenses/noncommercial/1.0.0. Any noncommercial
+purpose is permitted. Commercial use needs a separate licence from Carlos
+Gaete-Morales: cdgaete@gmail.com.
+
+The page that ecosemantic-view carries bundles third-party software under its
+own licences; their notices are in ecosemantic/view/static/THIRD_PARTY_NOTICES.txt
+inside that distribution. Components of the page adapt shadcn/ui, Copyright (c)
+2023 shadcn, under the MIT licence, as page/PROVENANCE.md in the source
+repository records.

ecosemantic_databases-0.1.8/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.5
+Name: ecosemantic-databases
+Version: 0.1.8
+Summary: Native EcoSemantic bundles built from a source database's own files.
+Project-URL: Homepage, https://github.com/cdgaete/ecosemantic
+Project-URL: Repository, https://github.com/cdgaete/ecosemantic
+Project-URL: Issues, https://github.com/cdgaete/ecosemantic/issues
+Project-URL: Changelog, https://github.com/cdgaete/ecosemantic/blob/main/CHANGELOG.md
+Author-email: Carlos Gaete-Morales <cdgaete@gmail.com>
+License-Expression: PolyForm-Noncommercial-1.0.0
+License-File: LICENSE
+License-File: NOTICE
+Keywords: EcoSpold2,LCA,ecoinvent,life cycle assessment,openLCA
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: ecosemantic-core==0.1.8
+Requires-Dist: ecosemantic-engine==0.1.8
+Requires-Dist: lca-data-interface~=0.1
+Requires-Dist: numpy>=2.5
+Requires-Dist: olca-schema==2.4.0
+Requires-Dist: pydantic<3,>=2.7
+Requires-Dist: pyyaml<7,>=6.0.1
+Requires-Dist: scipy>=1.16
+Provides-Extra: ecoinvent
+Requires-Dist: ecoinvent-interface==3.1; extra == 'ecoinvent'
+Requires-Dist: python-calamine<1,>=0.3; extra == 'ecoinvent'
+Description-Content-Type: text/markdown
+
+# ecosemantic-databases
+
+The sources a background database installs from, each read from its own release files and written as an openLCA JSON-LD bundle the core installs: the ecoinvent builder with its release profiles, the USLCI source, the BAFU source, and the reader for an openLCA `.zolca` database.
+
+## Names it publishes
+
+- `ecosemantic.databases.ecoinvent` — the builder: a release's EcoSpold2 datasets, its MasterData and its LCIA implementation, read and nothing else; no Brightway, no bw2io. It downloads the release, probes what it holds against what a build reads, writes one openLCA JSON-LD bundle, and validates the bundle against ecoinvent's published results. `releases/` beside it holds one profile per validated release: file hashes, workbook layouts, the decisions the probe asked for, and the measured validation numbers.
+- `ecosemantic.databases.uslci` — the USLCI source: the release the profile pins, downloaded from the Federal LCA Commons through `lca-data-interface`, with its profile, its two lists and its notices.
+- `ecosemantic.databases.bafu` — the BAFU source: the release the profile pins, read through an openLCA Nexus session, with its profile and the terms an install accepts.
+- `ecosemantic.databases.zolca` — the reader for an openLCA `.zolca` database.
+- `ecosemantic.databases.profiles`, `lists`, `checks` and `scores` — the profiles a source pins, the lists a release is filed under, the checks a bundle passes and the scores it is validated against.
+- The `ecosemantic-databases` command, over the `bafu`, `ecoinvent` and `uslci` groups.
+
+## The command
+
+`ecosemantic-databases` runs one step of an ecoinvent build on its own, for a person who wants the files; `setup ecoinvent` runs the same steps and installs what they build.
+
+```bash
+ecosemantic-databases ecoinvent download 3.12 --system-model cutoff
+ecosemantic-databases ecoinvent probe 3.12 --system-model cutoff
+ecosemantic-databases ecoinvent build 3.12 --system-model cutoff --out builds
+ecosemantic-databases ecoinvent validate 3.12 --system-model cutoff --bundle builds/ecoinvent-3.12-cutoff.zip
+```
+
+`download` fetches the release's five files and prints each path with the SHA-256 of every file a build reads; `probe` lists what the release holds against what a build reads and the gaps between them; `build` writes `<dir>/ecoinvent-<version>-<model>.zip`; `validate` compiles the bundle for the engine and compares its scores with the matrix export and the cumulative LCIA workbook. `build` and `validate` read `releases/<version>-<model>.yaml` when the release has one, and take the default layout with `--no-profile`. `uslci` and `bafu` take the same four steps over their own releases.
+
+## What it depends on
+
+`ecosemantic-engine` and `ecosemantic-core` at the same version; `lca-data-interface` for the openLCA Nexus and Federal LCA Commons clients; and pydantic, olca-schema, pyyaml, numpy and scipy. The `ecoinvent` extra adds `ecoinvent_interface` and `python-calamine`.
+
+## Credentials
+
+`ecoinvent_interface` reads `EI_USERNAME` and `EI_PASSWORD` from the environment, and a download refuses with `Unavailable` when either is absent. The BAFU source reads `NEXUS_USERNAME` and `NEXUS_PASSWORD`, and `NEXUS_TOKEN` for an account with a second factor.
+
+## Where the files live
+
+Downloaded releases stay in `ecoinvent_interface`'s cache, `~/.local/share/EcoinventInterface/cache`, and built bundles go to the directory `build` takes. Neither is tracked. `releases/<version>-<model>.yaml` holds one profile per validated release, and no release data enters this distribution.
+
+## Installing it
+
+`pip install ecosemantic` installs this distribution with the other five, its `ecoinvent` extra included, and the `ecosemantic` command. `pip install "ecosemantic-databases[ecoinvent]"` installs the builder alone, with the dependencies an ecoinvent build needs.
+
+## Licence
+
+PolyForm Noncommercial License 1.0.0, copyright Carlos Gaete-Morales: `LICENSE` and `NOTICE` in this distribution. Any noncommercial purpose is permitted, by individuals and by charities, schools, public research and government bodies; commercial use needs a separate licence from him (cdgaete@gmail.com). EcoSemantic is his trademark, and the licence grants no right to use that name (`TRADEMARK.md` in the repository). This distribution handles licensed data and credentials and carries no release data. The code is published from https://github.com/cdgaete/ecosemantic.

ecosemantic_databases-0.1.8/README.md

@@ -0,0 +1,45 @@
+# ecosemantic-databases
+
+The sources a background database installs from, each read from its own release files and written as an openLCA JSON-LD bundle the core installs: the ecoinvent builder with its release profiles, the USLCI source, the BAFU source, and the reader for an openLCA `.zolca` database.
+
+## Names it publishes
+
+- `ecosemantic.databases.ecoinvent` — the builder: a release's EcoSpold2 datasets, its MasterData and its LCIA implementation, read and nothing else; no Brightway, no bw2io. It downloads the release, probes what it holds against what a build reads, writes one openLCA JSON-LD bundle, and validates the bundle against ecoinvent's published results. `releases/` beside it holds one profile per validated release: file hashes, workbook layouts, the decisions the probe asked for, and the measured validation numbers.
+- `ecosemantic.databases.uslci` — the USLCI source: the release the profile pins, downloaded from the Federal LCA Commons through `lca-data-interface`, with its profile, its two lists and its notices.
+- `ecosemantic.databases.bafu` — the BAFU source: the release the profile pins, read through an openLCA Nexus session, with its profile and the terms an install accepts.
+- `ecosemantic.databases.zolca` — the reader for an openLCA `.zolca` database.
+- `ecosemantic.databases.profiles`, `lists`, `checks` and `scores` — the profiles a source pins, the lists a release is filed under, the checks a bundle passes and the scores it is validated against.
+- The `ecosemantic-databases` command, over the `bafu`, `ecoinvent` and `uslci` groups.
+
+## The command
+
+`ecosemantic-databases` runs one step of an ecoinvent build on its own, for a person who wants the files; `setup ecoinvent` runs the same steps and installs what they build.
+
+```bash
+ecosemantic-databases ecoinvent download 3.12 --system-model cutoff
+ecosemantic-databases ecoinvent probe 3.12 --system-model cutoff
+ecosemantic-databases ecoinvent build 3.12 --system-model cutoff --out builds
+ecosemantic-databases ecoinvent validate 3.12 --system-model cutoff --bundle builds/ecoinvent-3.12-cutoff.zip
+```
+
+`download` fetches the release's five files and prints each path with the SHA-256 of every file a build reads; `probe` lists what the release holds against what a build reads and the gaps between them; `build` writes `<dir>/ecoinvent-<version>-<model>.zip`; `validate` compiles the bundle for the engine and compares its scores with the matrix export and the cumulative LCIA workbook. `build` and `validate` read `releases/<version>-<model>.yaml` when the release has one, and take the default layout with `--no-profile`. `uslci` and `bafu` take the same four steps over their own releases.
+
+## What it depends on
+
+`ecosemantic-engine` and `ecosemantic-core` at the same version; `lca-data-interface` for the openLCA Nexus and Federal LCA Commons clients; and pydantic, olca-schema, pyyaml, numpy and scipy. The `ecoinvent` extra adds `ecoinvent_interface` and `python-calamine`.
+
+## Credentials
+
+`ecoinvent_interface` reads `EI_USERNAME` and `EI_PASSWORD` from the environment, and a download refuses with `Unavailable` when either is absent. The BAFU source reads `NEXUS_USERNAME` and `NEXUS_PASSWORD`, and `NEXUS_TOKEN` for an account with a second factor.
+
+## Where the files live
+
+Downloaded releases stay in `ecoinvent_interface`'s cache, `~/.local/share/EcoinventInterface/cache`, and built bundles go to the directory `build` takes. Neither is tracked. `releases/<version>-<model>.yaml` holds one profile per validated release, and no release data enters this distribution.
+
+## Installing it
+
+`pip install ecosemantic` installs this distribution with the other five, its `ecoinvent` extra included, and the `ecosemantic` command. `pip install "ecosemantic-databases[ecoinvent]"` installs the builder alone, with the dependencies an ecoinvent build needs.
+
+## Licence
+
+PolyForm Noncommercial License 1.0.0, copyright Carlos Gaete-Morales: `LICENSE` and `NOTICE` in this distribution. Any noncommercial purpose is permitted, by individuals and by charities, schools, public research and government bodies; commercial use needs a separate licence from him (cdgaete@gmail.com). EcoSemantic is his trademark, and the licence grants no right to use that name (`TRADEMARK.md` in the repository). This distribution handles licensed data and credentials and carries no release data. The code is published from https://github.com/cdgaete/ecosemantic.

ecosemantic_databases-0.1.8/ecosemantic/databases/__init__.py

@@ -0,0 +1 @@
+"""Native EcoSemantic bundles built from a source database's own files."""

ecosemantic_databases-0.1.8/ecosemantic/databases/bafu/__init__.py

@@ -0,0 +1 @@
+"""Build a native EcoSemantic bundle from BAFU's own files."""

ecosemantic_databases-0.1.8/ecosemantic/databases/bafu/build.py

@@ -0,0 +1,44 @@
+"""Build a BAFU zolca into one openLCA JSON-LD bundle, read back by the core's importer."""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+from ecosemantic.databases.zolca.export.write import NotCarried, export
+from ecosemantic.errors import Conflict
+from ecosemantic.package.background import read_background
+
+
+@dataclass(frozen=True)
+class Built:
+    """What a build wrote: the bundle, the records it holds by folder, and the rows its package does
+    not carry."""
+
+    bundle: Path
+    records: dict[str, int]
+    not_carried: tuple[NotCarried, ...]
+
+
+def build(zolca: Path, *, version: str, out_dir: Path) -> Built:
+    """Write a zolca as `<out_dir>/bafu-<version>.zip` and import it under `bafu-<version>`. The
+    package is exported to a staging file beside the destination and moved into place only once the
+    core reads it, so a bundle the core refuses leaves nothing under the final name; a destination
+    that exists is `Conflict`."""
+    destination = out_dir / f"bafu-{version}.zip"
+    staging = out_dir / f".bafu-{version}.staging.zip"
+    if destination.exists():
+        raise Conflict(f"{destination.name} exists; name another destination")
+    out_dir.mkdir(parents=True, exist_ok=True)
+    written = export(zolca, staging)
+    try:
+        read_background(written.bundle, f"bafu-{version}", foreground=frozenset())
+        os.replace(staging, destination)
+    finally:
+        staging.unlink(missing_ok=True)
+    return Built(
+        bundle=destination,
+        records=written.records,
+        not_carried=written.not_carried,
+    )

ecosemantic_databases-0.1.8/ecosemantic/databases/bafu/cli.py

@@ -0,0 +1,124 @@
+"""The command line: the subcommands a BAFU source answers."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import cast
+
+from lca_data_interface import NexusSession
+
+from ecosemantic.databases import command
+from ecosemantic.databases.bafu.build import Built, build
+from ecosemantic.databases.bafu.download import Downloads, Terms, download, translating
+from ecosemantic.databases.bafu.probe import Probe, probe
+from ecosemantic.databases.bafu.profile import RELEASES, read_profile, recorded
+from ecosemantic.databases.bafu.validate import Counted, record, validate
+from ecosemantic.databases.command import Command
+
+
+def _download(args: argparse.Namespace) -> dict[str, object] | Terms:
+    """Fetch a release's packs through Nexus and answer each file's path and the hash the profile
+    pins; while the terms are not accepted, answer the licence file and the citation instead."""
+    profile = read_profile(args.version)
+    with translating(), NexusSession.from_environment(base=profile.server) as session:
+        fetched = download(profile, session, accept_terms=args.accept_terms, results=args.results)
+    if isinstance(fetched, Terms):
+        return fetched
+    return {
+        "inventory": {"path": str(fetched.inventory), "sha256": profile.inventory.sha256},
+        "results": (
+            None
+            if fetched.results is None
+            else {"path": str(fetched.results), "sha256": profile.results.sha256}
+        ),
+        "licence": str(fetched.licence),
+        "citation": fetched.citation,
+    }
+
+
+def _probe(args: argparse.Namespace) -> Probe:
+    """Read a zolca and answer what it holds and what the core would not take of it."""
+    return probe(Path(args.zolca))
+
+
+def _fetched(version: str) -> Path:
+    """The zolca a release's profile pins, fetched through Nexus with the pack's terms accepted, so
+    the answer is always the downloaded file."""
+    profile = read_profile(version)
+    with translating(), NexusSession.from_environment(base=profile.server) as session:
+        fetched = cast(Downloads, download(profile, session, accept_terms=True, results=False))
+    return fetched.inventory
+
+
+def _build(args: argparse.Namespace) -> Built:
+    """Build the zolca given, or the one the release's profile pins, into one bundle under
+    `--out`."""
+    zolca = Path(args.zolca) if args.zolca is not None else _fetched(args.version)
+    return build(zolca, version=args.version, out_dir=Path(args.out))
+
+
+def _validate(args: argparse.Namespace) -> Counted:
+    """Compare a bundle with its release's workbook and the release's two lists, record the run
+    when asked, and answer the differences counted by column."""
+    profile = read_profile(args.version)
+    validation = validate(
+        Path(args.bundle),
+        results=Path(args.results),
+        profile=profile,
+        unlinked=recorded(profile.unlinked),
+        differences=recorded(profile.differences),
+        compiled=Path(args.compiled) if args.compiled is not None else None,
+    )
+    if args.record:
+        record(profile, validation, directory=RELEASES)
+    return validation.counted()
+
+
+def _code(answer: object) -> int:
+    """2 for the answer that asks for the pack's terms to be accepted, 1 for a validation that
+    found a mismatch, and 0 for an answer that stands."""
+    if isinstance(answer, Terms):
+        return 2
+    return 1 if isinstance(answer, Counted) and bool(answer.mismatches) else 0
+
+
+COMMANDS: dict[str, Command] = {
+    "download": Command("Fetch a release's pinned packs from Nexus.", _download),
+    "probe": Command("Read a zolca and list what it holds.", _probe),
+    "build": Command("Write a release's bundle and import it.", _build),
+    "validate": Command("Compare a bundle with its release's workbook.", _validate),
+}
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="ecosemantic-databases bafu",
+        description="Build a native EcoSemantic bundle from a BAFU release.",
+    )
+    subcommands = parser.add_subparsers(dest="command", required=True)
+    for name, each in COMMANDS.items():
+        sub = subcommands.add_parser(name, help=each.help)
+        if name == "download":
+            sub.add_argument("version")
+            sub.add_argument("--accept-terms", action="store_true")
+            sub.add_argument("--results", action="store_true")
+        elif name == "probe":
+            sub.add_argument("zolca")
+        elif name == "build":
+            sub.add_argument("version")
+            sub.add_argument("--out", required=True)
+            sub.add_argument("--zolca")
+        elif name == "validate":
+            sub.add_argument("version")
+            sub.add_argument("--bundle", required=True)
+            sub.add_argument("--results", required=True)
+            sub.add_argument("--compiled")
+            sub.add_argument("--record", action="store_true")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Run one command; 0 on success, 1 on a typed error or a validation that found a mismatch,
+    and 2 when the terms are not accepted."""
+    return command.main(_parser(), COMMANDS, argv, code=_code)

ecosemantic_databases-0.1.8/ecosemantic/databases/bafu/differences.py

@@ -0,0 +1,52 @@
+"""The (process, column) pairs a BAFU validation knows differ beyond its tolerance, keyed by the
+process's id and the workbook column's header so neither BAFU's names nor its values are written
+into the package."""
+
+from __future__ import annotations
+
+import csv
+from collections.abc import Iterable
+from dataclasses import dataclass
+from pathlib import Path
+
+from ecosemantic.errors import Invalid
+
+COLUMNS = ("process_id", "column")
+
+
+@dataclass(frozen=True)
+class Difference:
+    """One pair whose two scores differ beyond the tolerance."""
+
+    process_id: str
+    column: str
+
+
+def _order(row: Difference) -> tuple[str, str]:
+    """A row's sort position: its process, then its column."""
+    return (row.process_id, row.column)
+
+
+def read_differences(path: Path) -> tuple[Difference, ...]:
+    """The pairs a list holds, in process and column order; a pair the list holds twice is
+    `Invalid`."""
+    with path.open(newline="", encoding="utf-8") as read:
+        rows = [
+            Difference(process_id=record["process_id"], column=record["column"])
+            for record in csv.DictReader(read)
+        ]
+    seen: set[tuple[str, str]] = set()
+    for row in rows:
+        if _order(row) in seen:
+            raise Invalid(f"{path} holds {row.process_id} under {row.column!r} twice")
+        seen.add(_order(row))
+    return tuple(sorted(rows, key=_order))
+
+
+def write_differences(path: Path, rows: Iterable[Difference]) -> None:
+    """Write the pairs as CSV, in process and column order."""
+    with path.open("w", newline="", encoding="utf-8") as written:
+        writer = csv.writer(written, lineterminator="\n")
+        writer.writerow(COLUMNS)
+        for row in sorted(rows, key=_order):
+            writer.writerow((row.process_id, row.column))

ecosemantic_databases-0.1.8/ecosemantic/databases/bafu/download.py

@@ -0,0 +1,142 @@
+"""Fetch BAFU's openLCA pack and its LCIA results pack from Nexus, refusing a file whose hash is not
+the one its profile pins."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from contextlib import contextmanager
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Final, Protocol
+
+from lca_data_interface import Downloaded
+from lca_data_interface import Pack as NexusPack
+from lca_data_interface.errors import (
+    CredentialsMissing,
+    LcaDataInterfaceError,
+    LicenceNotAccepted,
+    LoginRefused,
+    MissingField,
+    NotInCatalog,
+    NotOnServer,
+    ServiceError,
+    ShortDownload,
+    TokenRequired,
+)
+
+from ecosemantic.databases.bafu.profile import Pack, Profile
+from ecosemantic.errors import Conflict, EcoSemanticError, Invalid, NotFound, Unavailable
+
+_TRANSLATIONS: Final[dict[type[LcaDataInterfaceError], type[EcoSemanticError]]] = {
+    CredentialsMissing: Unavailable,
+    LoginRefused: Unavailable,
+    TokenRequired: Unavailable,
+    ShortDownload: Unavailable,
+    ServiceError: Unavailable,
+    NotInCatalog: NotFound,
+    NotOnServer: NotFound,
+    MissingField: Invalid,
+    LicenceNotAccepted: Invalid,
+}
+
+
+class Nexus(Protocol):
+    """The three calls a download makes on a Nexus session; `NexusSession` satisfies it and a test
+    doubles it."""
+
+    def pack(self, uuid: str) -> NexusPack: ...
+
+    def licence(self, pack: NexusPack) -> Path: ...
+
+    def download(
+        self,
+        pack: NexusPack,
+        *,
+        version: int,
+        file_format: str,
+        accept_licence: bool,
+    ) -> Downloaded: ...
+
+
+@dataclass(frozen=True)
+class Terms:
+    """What a download answers while a pack's terms are not accepted: the licence file to read and
+    the citation to carry."""
+
+    licence: Path
+    citation: str
+
+
+@dataclass(frozen=True)
+class Downloads:
+    """The files a download fetched, the pack's licence file, and the release's citation."""
+
+    inventory: Path
+    results: Path | None
+    licence: Path
+    citation: str
+
+
+@contextmanager
+def translating() -> Iterator[None]:
+    """A client call whose errors leave as the core's, of the kind and with the names the spec's
+    *Errors* table gives them."""
+    try:
+        yield
+    except LcaDataInterfaceError as error:
+        raise _translated(error) from error
+
+
+def download(
+    profile: Profile, session: Nexus, *, accept_terms: bool, results: bool
+) -> Downloads | Terms:
+    """Fetch a release's packs through Nexus, each file's SHA-256 compared with the profile's.
+
+    Without `accept_terms` the pack's licence file is fetched and nothing is downloaded: the answer
+    is the file a person reads to accept the terms. `results` also fetches the LCIA results pack,
+    which only a validation reads.
+    """
+    with translating():
+        inventory_pack = session.pack(profile.inventory.pack)
+        licence = session.licence(inventory_pack)
+        if not accept_terms:
+            return Terms(licence=licence, citation=profile.citation)
+        inventory = session.download(
+            inventory_pack,
+            version=profile.inventory.version,
+            file_format=profile.inventory.format,
+            accept_licence=True,
+        )
+        results_file = _fetched(profile.results, session) if results else None
+    return Downloads(
+        inventory=_checked(profile.inventory, inventory),
+        results=None if results_file is None else _checked(profile.results, results_file),
+        licence=licence,
+        citation=profile.citation,
+    )
+
+
+def _fetched(pinned: Pack, session: Nexus) -> Downloaded:
+    """One pack's file at the version and the format the profile pins, its terms accepted."""
+    return session.download(
+        session.pack(pinned.pack),
+        version=pinned.version,
+        file_format=pinned.format,
+        accept_licence=True,
+    )
+
+
+def _checked(pinned: Pack, downloaded: Downloaded) -> Path:
+    """The path of a file whose SHA-256 is the one the profile pins; a different hash is a conflict
+    naming the file and both hashes."""
+    if downloaded.sha256 != pinned.sha256:
+        raise Conflict(
+            f"{downloaded.path.name} hashes to {downloaded.sha256}, the profile pins "
+            f"{pinned.sha256}"
+        )
+    return downloaded.path
+
+
+def _translated(error: LcaDataInterfaceError) -> EcoSemanticError:
+    """The core's error for one the client raised."""
+    return _TRANSLATIONS[type(error)](str(error))