loremfile 0.3.0__tar.gz → 0.3.1__tar.gz

{loremfile-0.3.0 → loremfile-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loremfile
-Version: 0.3.0
+Version: 0.3.1
 Summary: Download CC0 sample files from loremfile.dev and verify every byte
 Author: the loremfile.dev contributors
 License-Expression: MIT
@@ -46,7 +46,9 @@ correctly by default: every file is verified, and a file that fails is not writt
 
 Every command takes `--json` for scripts, `--quiet`, and `--catalog-version X.Y.Z` to
 refuse to run if loremfile.dev has moved on. `get` also takes `--force` (overwrite) and
-`--dry-run` (what it would fetch, and how many bytes).
+`--dry-run` (what it would fetch, and how many bytes). `get`, `list` and `verify` leave out the
+`sample.{format}` aliases, which repeat another file's bytes, unless you pass `--include-aliases`;
+a path you name is always fetched.
 
 Exit codes: `0` fine, `1` a file failed verification or is missing, `2` the request was
 wrong, `3` loremfile.dev could not be read.

{loremfile-0.3.0 → loremfile-0.3.1}/README.md

@@ -26,7 +26,9 @@ correctly by default: every file is verified, and a file that fails is not writt
 
 Every command takes `--json` for scripts, `--quiet`, and `--catalog-version X.Y.Z` to
 refuse to run if loremfile.dev has moved on. `get` also takes `--force` (overwrite) and
-`--dry-run` (what it would fetch, and how many bytes).
+`--dry-run` (what it would fetch, and how many bytes). `get`, `list` and `verify` leave out the
+`sample.{format}` aliases, which repeat another file's bytes, unless you pass `--include-aliases`;
+a path you name is always fetched.
 
 Exit codes: `0` fine, `1` a file failed verification or is missing, `2` the request was
 wrong, `3` loremfile.dev could not be read.

{loremfile-0.3.0 → loremfile-0.3.1}/pyproject.toml

@@ -11,7 +11,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "loremfile"
-version = "0.3.0"
+version = "0.3.1"
 description = "Download CC0 sample files from loremfile.dev and verify every byte"
 readme = "README.md"
 # A range, and a policy: the floor is the oldest CPython still receiving security fixes

{loremfile-0.3.0 → loremfile-0.3.1}/src/loremfile.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: loremfile
-Version: 0.3.0
+Version: 0.3.1
 Summary: Download CC0 sample files from loremfile.dev and verify every byte
 Author: the loremfile.dev contributors
 License-Expression: MIT
@@ -46,7 +46,9 @@ correctly by default: every file is verified, and a file that fails is not writt
 
 Every command takes `--json` for scripts, `--quiet`, and `--catalog-version X.Y.Z` to
 refuse to run if loremfile.dev has moved on. `get` also takes `--force` (overwrite) and
-`--dry-run` (what it would fetch, and how many bytes).
+`--dry-run` (what it would fetch, and how many bytes). `get`, `list` and `verify` leave out the
+`sample.{format}` aliases, which repeat another file's bytes, unless you pass `--include-aliases`;
+a path you name is always fetched.
 
 Exit codes: `0` fine, `1` a file failed verification or is missing, `2` the request was
 wrong, `3` loremfile.dev could not be read.

{loremfile-0.3.0 → loremfile-0.3.1}/src/loremfile_client/__init__.py

@@ -1,3 +1,3 @@
 """A small client for loremfile.dev: download CC0 sample files and verify every byte."""
 
-__version__ = "0.3.0"
+__version__ = "0.3.1"

{loremfile-0.3.0 → loremfile-0.3.1}/src/loremfile_client/api.py

@@ -153,13 +153,28 @@ def active(document: dict[str, Any]) -> list[dict[str, Any]]:
     return [e for e in document.get("fixtures", []) if e.get("status", "active") == "active"]
 
 
+#: A `sample.{format}` alias is a second URL for bytes that already have one. Its manifest entry is
+#: the only place that says so, and the field that does is `generator`; its original is
+#: `generator_params.of`. (`aliasOf`, which 1.15.0 carried until 1.15.1, matches nothing.)
+ALIAS_GENERATOR = "alias.copy"
+
+
+def is_alias(entry: dict[str, Any]) -> bool:
+    return entry.get("generator") == ALIAS_GENERATOR
+
+
 def select(
     entries: list[dict[str, Any]],
     *,
     paths: list[str] | None = None,
     formats: list[str] | None = None,
+    include_aliases: bool = False,
 ) -> list[dict[str, Any]]:
-    """The entries a request names, or `Refused` naming what does not exist."""
+    """The entries a request names, or `Refused` naming what does not exist.
+
+    A format selects its files, not the aliases that repeat them, unless `include_aliases`; a
+    path that is named is always honoured, alias or not.
+    """
     wanted_paths, wanted_formats = set(paths or []), set(formats or [])
     if not wanted_paths and not wanted_formats:
         raise Refused("name at least one path or format")
@@ -172,7 +187,10 @@ def select(
     if unknown_formats:
         raise Refused(f"no such format: {', '.join(unknown_formats)}")
     chosen = {
-        e["path"]: e for e in entries if e["path"] in wanted_paths or e["format"] in wanted_formats
+        e["path"]: e
+        for e in entries
+        if e["path"] in wanted_paths
+        or (e["format"] in wanted_formats and (include_aliases or not is_alias(e)))
     }
     return [chosen[path] for path in sorted(chosen)]
 

{loremfile-0.3.0 → loremfile-0.3.1}/src/loremfile_client/cli.py

@@ -29,6 +29,13 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--version", action="version", version=f"loremfile {__version__}")
     subcommands = parser.add_subparsers(dest="command", required=True)
 
+    def aliases(sub: argparse.ArgumentParser) -> None:
+        sub.add_argument(
+            "--include-aliases",
+            action="store_true",
+            help="Also the sample.{format} copies, which repeat another file's bytes.",
+        )
+
     def shared(sub: argparse.ArgumentParser) -> None:
         sub.add_argument("--json", action="store_true", help="Print one JSON object.")
         sub.add_argument("--quiet", action="store_true", help="Print nothing but failures.")
@@ -50,18 +57,21 @@ def build_parser() -> argparse.ArgumentParser:
     get.add_argument("--dest", default=DEFAULT_DEST, type=Path, help=f"Default: {DEFAULT_DEST}")
     get.add_argument("--force", action="store_true", help="Overwrite files already there.")
     get.add_argument("--dry-run", action="store_true", help="List what would be fetched.")
+    aliases(get)
     shared(get)
 
     listing = subcommands.add_parser("list", help="What is published, without downloading.")
     listing.add_argument("--format", action="append", default=[], metavar="FMT")
     listing.add_argument("--tag", action="append", default=[], metavar="TAG")
     listing.add_argument("--max-bytes", type=int, metavar="N")
+    aliases(listing)
     shared(listing)
 
     check = subcommands.add_parser("verify", help="Check files on disk against the manifest.")
     check.add_argument("paths", nargs="*", metavar="PATH")
     check.add_argument("--format", action="append", default=[], metavar="FMT")
     check.add_argument("--dest", default=DEFAULT_DEST, type=Path, help=f"Default: {DEFAULT_DEST}")
+    aliases(check)
     shared(check)
 
     subcommands.add_parser(
@@ -88,6 +98,7 @@ def run_get(args: argparse.Namespace) -> int:
         api.active(api.manifest(catalog_version=args.catalog_version)),
         paths=args.paths,
         formats=args.format,
+        include_aliases=args.include_aliases,
     )
     if args.dry_run:
         total = sum(e["bytes"] for e in entries)
@@ -108,6 +119,8 @@ def run_get(args: argparse.Namespace) -> int:
 
 def run_list(args: argparse.Namespace) -> int:
     entries = api.active(api.manifest(catalog_version=args.catalog_version))
+    if not args.include_aliases:
+        entries = [e for e in entries if not api.is_alias(e)]
     if args.format:
         entries = [e for e in entries if e["format"] in set(args.format)]
     if args.tag:
@@ -124,9 +137,12 @@ def run_list(args: argparse.Namespace) -> int:
 def run_verify(args: argparse.Namespace) -> int:
     entries = api.active(api.manifest(catalog_version=args.catalog_version))
     if args.paths or args.format:
-        entries = api.select(entries, paths=args.paths, formats=args.format)
+        entries = api.select(
+            entries, paths=args.paths, formats=args.format, include_aliases=args.include_aliases
+        )
     else:
-        # Everything the destination actually holds, so `verify` alone checks a directory.
+        # Everything the destination actually holds, so `verify` alone checks a directory,
+        # aliases included: a copy that is on disk was put there on purpose.
         entries = [e for e in entries if (args.dest / Path(e["path"])).is_file()]
     results = [api.verify(entry, args.dest) for entry in entries]
     failing = [r for r in results if not r.ok]

{loremfile-0.3.0 → loremfile-0.3.1}/src/loremfile_client/mcp.py

@@ -148,12 +148,15 @@ def list_fixtures(document: dict[str, Any], args: Any) -> dict[str, Any]:  # noq
         args.get("limit", MISSING), "limit", low=1, high=MAX_LIMIT, fallback=DEFAULT_LIMIT
     )
     offset = _integer(args.get("offset", MISSING), "offset", low=0, high=None, fallback=0)
-    # The same filters as `loremfile list`: any of the formats, any of the tags, all three.
+    # The same filters as `loremfile list`: any of the formats, any of the tags, all three. The
+    # sample.{format} aliases repeat another file's bytes and stay out; describe_fixture and
+    # verify_file still take one by path.
     matches = sorted(
         (
             e
             for e in api.active(document)
-            if (not formats or e["format"] in formats)
+            if not api.is_alias(e)
+            and (not formats or e["format"] in formats)
             and (not tags or set(tags) & set(e.get("tags") or []))
             and (max_bytes is None or e["bytes"] <= max_bytes)
         ),

{loremfile-0.3.0 → loremfile-0.3.1}/tests/test_commands.py

@@ -10,7 +10,7 @@ from pathlib import Path
 import pytest
 from loremfile_client import api, cli
 
-from conftest import BODIES, Handler
+from conftest import ALIASES, BODIES, MANIFEST, Handler
 
 
 def run(*argv: str) -> int:
@@ -28,6 +28,80 @@ def test_get_by_format_takes_every_file_of_it(server: str, dest: Path) -> None:
     assert sorted(p.name for p in (dest / "pdf").iterdir()) == ["other.pdf", "small.pdf"]
 
 
+def test_the_fake_manifest_carries_an_alias_the_way_the_real_one_does() -> None:
+    """Control for the tests below: they mean nothing if the alias is not really there."""
+    aliases = [e for e in MANIFEST["fixtures"] if e.get("generator") == "alias.copy"]
+    assert [e["path"] for e in aliases] == list(ALIASES) == ["pdf/sample.pdf"]
+    assert aliases[0]["generator_params"] == {"of": "pdf/small.pdf"}
+    assert "aliasOf" not in aliases[0], "docs/04 §1.4: there is no such field"
+    assert aliases[0]["sha256"] == next(
+        e["sha256"] for e in MANIFEST["fixtures"] if e["path"] == "pdf/small.pdf"
+    )
+
+
+def test_get_by_format_leaves_the_aliases_out_unless_asked(server: str, dest: Path) -> None:
+    assert run("get", "--format", "pdf", "--dest", str(dest)) == cli.OK
+    assert not (dest / "pdf" / "sample.pdf").exists()
+    assert run("get", "--format", "pdf", "--include-aliases", "--dest", str(dest)) == cli.OK
+    assert (dest / "pdf" / "sample.pdf").read_bytes() == BODIES["pdf/small.pdf"]
+
+
+def test_a_dry_run_counts_the_bytes_it_would_fetch_without_the_duplicate(
+    server: str, capsys: pytest.CaptureFixture
+) -> None:
+    run("get", "--format", "pdf", "--dry-run", "--json")
+    without = json.loads(capsys.readouterr().out)["summary"]
+    run("get", "--format", "pdf", "--include-aliases", "--dry-run", "--json")
+    with_aliases = json.loads(capsys.readouterr().out)["summary"]
+    assert (without["files"], with_aliases["files"]) == (2, 3)
+    assert with_aliases["bytes"] - without["bytes"] == len(BODIES["pdf/small.pdf"])
+
+
+def test_a_path_named_outright_is_fetched_even_when_it_is_an_alias(server: str, dest: Path) -> None:
+    assert run("get", "pdf/sample.pdf", "--dest", str(dest)) == cli.OK
+    assert (dest / "pdf" / "sample.pdf").read_bytes() == BODIES["pdf/small.pdf"]
+
+
+def test_filtering_on_the_field_the_manifest_does_not_have_would_match_nothing() -> None:
+    """The mistake the 1.15.1 brief warns about, made on purpose: `aliasOf` finds no alias."""
+    entries = api.active(MANIFEST)
+    assert [e["path"] for e in entries if "aliasOf" in e] == []
+    assert [e["path"] for e in entries if api.is_alias(e)] == ["pdf/sample.pdf"]
+
+
+def test_list_leaves_the_aliases_out_unless_asked(
+    server: str, capsys: pytest.CaptureFixture
+) -> None:
+    def listed(*argv: str) -> set[str]:
+        run("list", *argv, "--json")
+        return {item["path"] for item in json.loads(capsys.readouterr().out)["items"]}
+
+    assert "pdf/sample.pdf" not in listed()
+    assert "pdf/sample.pdf" not in listed("--format", "pdf")
+    assert "pdf/sample.pdf" in listed("--format", "pdf", "--include-aliases")
+    assert listed("--include-aliases") == listed() | set(ALIASES)
+
+
+def test_verify_checks_an_alias_that_is_on_disk_and_by_format_only_with_the_flag(
+    server: str, dest: Path
+) -> None:
+    assert run("get", "pdf/sample.pdf", "--dest", str(dest)) == cli.OK
+    assert run("verify", "--dest", str(dest)) == cli.OK
+    (dest / "pdf" / "sample.pdf").write_bytes(b"not what was published")
+    assert run("verify", "--dest", str(dest)) == cli.FAILED, "a held alias is checked"
+    assert run("verify", "--format", "pdf", "--dest", str(dest)) == cli.FAILED, (
+        "small.pdf and other.pdf are missing"
+    )
+    (dest / "pdf" / "small.pdf").write_bytes(BODIES["pdf/small.pdf"])
+    (dest / "pdf" / "other.pdf").write_bytes(BODIES["pdf/other.pdf"])
+    assert run("verify", "--format", "pdf", "--dest", str(dest)) == cli.OK, (
+        "the bad alias is skipped"
+    )
+    assert (
+        run("verify", "--format", "pdf", "--include-aliases", "--dest", str(dest)) == cli.FAILED
+    ), "and asked for, it is checked"
+
+
 def test_a_withdrawn_entry_is_not_offered(server: str, dest: Path) -> None:
     assert run("get", "pdf/withdrawn.pdf", "--dest", str(dest)) == cli.REFUSED
 

{loremfile-0.3.0 → loremfile-0.3.1}/tests/test_mcp.py

@@ -232,6 +232,16 @@ def test_list_fixtures_pages_and_says_where_it_is(child: Client, server: str) ->
     assert (last["count"], last["next_offset"]) == (1, None)
 
 
+def test_list_fixtures_leaves_the_sample_aliases_out_and_describe_still_finds_one(
+    child: Client,
+) -> None:
+    listed = child.call("list_fixtures", {"format": ["pdf"]})["structuredContent"]
+    assert [f["path"] for f in listed["fixtures"]] == ["pdf/other.pdf", "pdf/small.pdf"]
+    assert listed["total"] == 2
+    described = child.call("describe_fixture", {"path": "pdf/sample.pdf"})["structuredContent"]
+    assert described["path"] == "pdf/sample.pdf", "control: the alias exists and can be asked for"
+
+
 def test_list_fixtures_filters_as_loremfile_list_does(child: Client) -> None:
     def paths(arguments: dict[str, Any]) -> list[str]:
         result = child.call("list_fixtures", arguments)["structuredContent"]