primarysource 0.1.0__py3-none-any.whl

primarysource/iana/server.py

@@ -0,0 +1,67 @@
+"""MCP server for the iana collection: `primarysource mcp --collection iana`.
+
+Imported only when served, so `mcp` (the `[mcp]` extra) is needed only then. Tools carry the prefix `iana_`, answer
+in text with the fixed footer, and turn a `LibError` into an MCP tool error naming the remedy. Every tool reads local
+files only; none writes or fetches (importing is `primarysource iana import`).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from mcp.server.mcpserver import MCPServer
+from mcp.types import ToolAnnotations
+
+from primarysource import __version__
+from primarysource.iana import reader
+from primarysource.scaffold import add_tools
+
+READ_ONLY = ToolAnnotations(read_only_hint=True, idempotent_hint=True, destructive_hint=False, open_world_hint=False)
+
+INSTRUCTIONS = (
+    "IANA protocol registries (DNS, DHCP, BGP, STUN, TLS, HTTP, ...) from the user's imported copies of the XML "
+    "at iana.org/assignments, which is CC0. Registry values are authoritative data: use iana_lookup for 'what is "
+    "DHCP option 53' and iana_search to find a registry. Refs: 'dns-parameters' (the file's registries), "
+    "'dns-parameters§dns-parameters-4' (one registry), 'bgp-parameters§bgp-parameters-2#3' (the record with value "
+    "3), '...¶4' (the 4th record). Each row carries its RFC citations (RFC4271§4.3 reads in the rfc collection). "
+    "The cite: footer line is the citation. If a registry is not imported the error says how."
+)
+
+
+def iana_read(ref: str, max_tokens: int = 2000) -> str:
+    """Read an IANA registry by ref, cut at record boundaries within max_tokens. A 'next: <ref>' footer line is the
+    ref that reads the next page: pass it back as ref.
+
+    ref: 'dns-parameters' (list its registries) | 'dns-parameters§dns-parameters-4' (a registry: procedure,
+      notes, then records) | 'bgp-parameters§bgp-parameters-2#3' (records whose value is 3) |
+      'bgp-parameters§bgp-parameters-2¶4' (from the 4th record). 'dns-parameters#dns-parameters-4' also works."""
+    return reader.read(ref, max_tokens=max_tokens)
+
+
+def iana_lookup(registry: str, value: str) -> str:
+    """The record(s) with a value in a registry, e.g. registry 'bootp-dhcp-parameters§message-type-53', value '5'.
+    registry may be just a file name ('dns-parameters') to try every registry in it. A number matches a record whose
+    value is that number or a range containing it (decimal or 0x hex); text matches a value or a column exactly,
+    ignoring case ('A' finds RR type A)."""
+    return reader.lookup(registry, value)
+
+
+def iana_search(text: str, file: str | None = None, limit: int = 20, start: int = 0) -> str:
+    """Find records whose registry title and columns contain every word of text (case-insensitive, literal, at most
+    200 characters). file: restrict to one registry file, e.g. 'stun-parameters'. One line per hit:
+    '<ref>  <registry>: <record>'. A 'next: start=N' footer line means call again with start=N (0-based)."""
+    return reader.search(text, file=file, limit=limit, start=start)
+
+
+def iana_list() -> str:
+    """The catalogue of registries this collection knows, each marked imported or not, with its updated date."""
+    return reader.listing()
+
+
+def _server() -> Any:
+    server = MCPServer("primarysource-iana", version=__version__, instructions=INSTRUCTIONS)
+    add_tools(server, (iana_read, iana_lookup, iana_search, iana_list), annotations=READ_ONLY)
+    return server
+
+
+server = _server()

primarysource/iana/store.py

@@ -0,0 +1,83 @@
+"""Where imported registry files live and how they are read back.
+
+`$PRIMARYSOURCE_HOME/iana/<name>.xml` is the file exactly as IANA served it; `manifest.json` beside them records,
+per file, its URL, sha256, size, the registry's own `updated` date, when it was fetched and the server's
+`Last-Modified`. Reading parses a file once per (path, mtime, size) and checks it against its recorded sha256.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import dataclass
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+from primarysource.errors import LibError
+from primarysource.home import collection_home
+from primarysource.iana import xmlsafe
+from primarysource.iana.catalogue import NAME
+from primarysource.iana.model import RegistryFile, from_tree
+
+MANIFEST = "manifest.json"
+MAX_BYTES = 32_000_000
+"""Ceiling on one registry file. The largest catalogued file (ipfix) is under 0.5 MB; the biggest IANA registries
+(media-types, service-names-port-numbers) are a few MB."""
+
+
+def home() -> Path:
+    return collection_home("iana")
+
+
+def read_manifest(base: Path) -> dict[str, dict[str, Any]]:
+    path = base / MANIFEST
+    if not path.is_file():
+        return {}
+    try:
+        files = json.loads(path.read_text(encoding="utf-8"))["files"]
+    except (ValueError, KeyError, TypeError) as exc:
+        raise LibError(f"{path} is not a readable manifest", "", f"delete {path} and import again") from exc
+    if not isinstance(files, dict):
+        raise LibError(f"{path} is not a readable manifest", "", f"delete {path} and import again")
+    return {str(k): dict(v) for k, v in files.items() if isinstance(v, dict)}
+
+
+def imported(base: Path | None = None) -> tuple[str, ...]:
+    """Names of the registry files present, sorted."""
+    root = base or home()
+    if not root.is_dir():
+        return ()
+    return tuple(sorted(p.stem for p in root.glob("*.xml") if NAME.fullmatch(p.stem)))
+
+
+@dataclass(frozen=True, slots=True)
+class Loaded:
+    file: RegistryFile
+    sha256: str
+    digest_ok: bool | None
+    """True if the manifest's sha256 equals the file's, False if it differs, None if the manifest has no entry."""
+
+
+@lru_cache(maxsize=16)
+def _parse(path: str, mtime_ns: int, size: int, name: str) -> tuple[RegistryFile, str]:
+    raw = Path(path).read_bytes()
+    return from_tree(xmlsafe.parse(raw, MAX_BYTES), name), hashlib.sha256(raw).hexdigest()
+
+
+def load(name: str, base: Path | None = None) -> Loaded:
+    """One imported registry file, parsed. A missing file is an error that names the import command."""
+    if not NAME.fullmatch(name):
+        raise LibError(f"{name!r} is not a registry file name", "e.g. dns-parameters, bgp-parameters")
+    root = base or home()
+    path = root / f"{name}.xml"
+    if not path.is_file():
+        raise LibError(
+            f"registry {name!r} is not imported (looked in {root})",
+            "iana_list shows the catalogue and what is imported",
+            f"primarysource iana import {name}",
+        )
+    stat = path.stat()
+    parsed, digest = _parse(str(path), stat.st_mtime_ns, stat.st_size, name)
+    recorded = read_manifest(root).get(name, {}).get("sha256")
+    return Loaded(parsed, digest, None if recorded is None else recorded == digest)

primarysource/iana/xmlsafe.py

@@ -0,0 +1,47 @@
+"""The iana collection's XML reader: the core's hardened `primarysource.readers.xml` with iana's bounds.
+
+The parser moved to the core (`cl.reader_xml_hardened`). This wrapper keeps the signature the importer, the store
+and their tests use, and the two choices iana makes on top of the core's defaults:
+
+- processing instructions are dropped, not refused, because every IANA registry file opens with an
+  `xml-stylesheet` and an `xml-model` instruction (nothing is ever fetched or executed for them);
+- up to 600,000 elements, because the largest registries are that big.
+
+Everything the core refuses is still refused: declarations, entities, notations, external references, encodings
+other than UTF-8, and input over any bound. Names come out in ElementTree's `{namespace}local` form.
+"""
+
+from __future__ import annotations
+
+import xml.etree.ElementTree as ET  # noqa: S405 - only the Element type; parsing is the core's hardened expat
+
+from primarysource.readers.xml import XmlRefused
+from primarysource.readers.xml import parse as _parse
+
+__all__ = ["HINT", "XmlRefused", "parse"]
+
+HINT = "the file is damaged or not a registry file; fetch it again"
+
+
+def parse(
+    raw: bytes,
+    limit: int,
+    *,
+    max_depth: int = 32,
+    max_elements: int = 600_000,
+    max_attributes: int = 16,
+    max_attribute_length: int = 4096,
+    max_text: int = 1_000_000,
+) -> ET.Element:
+    """Parse `raw` into an Element, or raise `XmlRefused` (a `LibError`). The whole document is passed at once."""
+    return _parse(
+        raw,
+        limit,
+        max_depth=max_depth,
+        max_elements=max_elements,
+        max_attributes=max_attributes,
+        max_attribute_length=max_attribute_length,
+        max_text=max_text,
+        ignore_processing_instructions=True,
+        hint=HINT,
+    )

primarysource/identify.py

@@ -0,0 +1,186 @@
+"""What a supplied document is: which collection knows it, and as which designation (`primarysource identify`).
+
+People keep vendor and standards PDFs under whatever name the download gave them, so an import cannot rely on the
+file name. A `Probe` reads the file name, the PDF's title metadata and the text of its first pages once; each
+collection that declares an `identify` hook (`registry.Collection.identify`, a "module:function" taking a `Probe`
+and returning `Candidate`s) looks for its own designations in it. `score` is the common rule every hook uses,
+so candidates from different collections compare:
+
+- the designation on the first page (the cover): 3;
+- on two or more of the later probed pages (a running header): 2;
+- in the PDF's title metadata: 2;
+- in the file name: 1.
+
+A hook may add evidence of its own (ISO's `Reference number` line on the cover). Nothing here imports anything;
+it says what the document is and the command that imports it.
+"""
+
+from __future__ import annotations
+
+import io
+import re
+from collections.abc import Callable, Iterable, Sequence
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from primarysource.errors import LibError
+
+PROBE_PAGES = 3
+MAX_PROBE_BYTES = 256 * 1024 * 1024
+
+
+@dataclass(frozen=True, slots=True)
+class Probe:
+    """What identification reads: the file's name and path, its title metadata, and its first pages' text."""
+
+    name: str
+    title: str = ""
+    pages: tuple[str, ...] = ()
+    path: Path | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class Candidate:
+    """One answer: `collection` knows this document as `designation`. Higher `score` is surer."""
+
+    collection: str
+    designation: str
+    score: int
+    evidence: tuple[str, ...] = field(default=())
+    command: str = ""
+
+
+def probe_pdf(path: Path, pages: int = PROBE_PAGES) -> Probe:
+    """Read a PDF's title metadata and its first `pages` pages of text. Needs `pypdf` (any PDF extra)."""
+    from primarysource.readers.pdf import _pypdf
+
+    pypdf = _pypdf()
+    try:
+        if path.stat().st_size > MAX_PROBE_BYTES:
+            raise LibError(f"{path.name} is over {MAX_PROBE_BYTES} bytes", "")
+        reader = pypdf.PdfReader(io.BytesIO(path.read_bytes()), strict=False)
+        meta = reader.metadata
+        title = str(meta.title) if meta is not None and meta.title else ""
+        texts = tuple(str(reader.pages[i].extract_text() or "") for i in range(min(pages, len(reader.pages))))
+    except LibError:
+        raise
+    except Exception as exc:  # noqa: BLE001 - pypdf raises many types on hostile input
+        raise LibError(f"could not read {path.name}: {type(exc).__name__}: {exc}", "is it a PDF?") from exc
+    return Probe(path.name, title, texts, path)
+
+
+def score[K](probe: Probe, pattern: re.Pattern[str], key: Callable[[re.Match[str]], K | None]) -> dict[K, list[str]]:
+    """Every designation `pattern` finds in the probe, keyed by `key(match)` (None skips a match), with the
+    evidence for it; `points` turns the evidence into a score."""
+    found: dict[K, list[str]] = {}
+
+    def note(text: str, label: str) -> set[K]:
+        keys: set[K] = set()
+        for match in pattern.finditer(text):
+            value = key(match)
+            if value is not None:
+                keys.add(value)
+        for value in keys:
+            found.setdefault(value, []).append(label)
+        return keys
+
+    if probe.pages:
+        note(probe.pages[0], "cover")
+    later: dict[K, int] = {}
+    for text in probe.pages[1:]:
+        for value in note(text, "page"):
+            later[value] = later.get(value, 0) + 1
+    for value, count in later.items():
+        evidence = [e for e in found[value] if e != "page"]
+        found[value] = [*evidence, *(["running header"] if count >= 2 else ["one later page"])]
+    note(probe.title, "title metadata")
+    note(probe.name, "file name")
+    return found
+
+
+POINTS = {"cover": 3, "running header": 2, "title metadata": 2, "file name": 1, "one later page": 0}
+
+
+def points(evidence: Iterable[str]) -> int:
+    """The score of a designation's evidence under the common rule (unknown evidence counts as the hook says)."""
+    return sum(POINTS.get(e, 0) for e in set(evidence))
+
+
+def identify(probe: Probe, hooks: Sequence[tuple[str, Callable[[Probe], list[Candidate]]]]) -> list[Candidate]:
+    """Every collection's candidates, surest first; a hook that fails is skipped, never fatal."""
+    out: list[Candidate] = []
+    for _name, hook in hooks:
+        try:
+            out.extend(hook(probe))
+        except LibError:
+            continue
+    return sorted((c for c in out if c.score > 0), key=lambda c: (-c.score, c.collection, c.designation))
+
+
+def registered_hooks() -> list[tuple[str, Callable[[Probe], list[Candidate]]]]:
+    """The `identify` hooks of every registered collection that has one and whose code loads."""
+    from primarysource import registry
+
+    hooks: list[tuple[str, Callable[[Probe], list[Candidate]]]] = []
+    for name in registry.available():
+        try:
+            collection = registry.load(name)
+            if collection.identify:
+                hooks.append((name, registry.attribute(collection, collection.identify, "identify hook")))
+        except LibError:
+            continue
+    return hooks
+
+
+def identify_path(path: Path) -> list[Candidate]:
+    """Probe one PDF and ask every registered collection what it is."""
+    return identify(probe_pdf(path), registered_hooks())
+
+
+def describe(path: Path, found: Sequence[Candidate]) -> str:
+    """One report block for `primarysource identify`."""
+    if not found:
+        return f"{path.name}: not recognised as any collection's document"
+    best = found[0]
+    lines = [f"{path.name}: {best.designation} ({best.collection}; {', '.join(best.evidence)})"]
+    if best.command:
+        lines.append(f"  import: {best.command}")
+    lines += [f"  also: {c.designation} ({c.collection}, score {c.score})" for c in found[1:4]]
+    return "\n".join(lines)
+
+
+_PDF = re.compile(r"\.pdf$", re.IGNORECASE)
+
+
+def pdfs(paths: Sequence[Path]) -> list[Path]:
+    """The PDFs named, with directories expanded to the PDFs directly inside them."""
+    out: list[Path] = []
+    for path in paths:
+        if path.is_dir():
+            out.extend(sorted(p for p in path.iterdir() if p.is_file() and _PDF.search(p.name)))
+        else:
+            out.append(path)
+    return out
+
+
+def candidates(
+    probe: Probe,
+    collection: str,
+    pattern: re.Pattern[str],
+    designation: Callable[[re.Match[str]], str | None],
+    command: Callable[[str], str],
+    *,
+    file_pattern: re.Pattern[str] | None = None,
+) -> list[Candidate]:
+    """A hook in one call: every designation `pattern` finds (as `designation(match)` spells it), scored by the
+    common rule, each with the command that imports it. `file_pattern` also reads the file name (a publisher's
+    download name such as `T-REC-X.690-202102`), worth what a file-name match is worth."""
+    found = score(probe, pattern, designation)
+    if file_pattern is not None:
+        for value in {designation(m) for m in file_pattern.finditer(probe.name)} - {None}:
+            if value is not None and "file name" not in found.setdefault(value, []):
+                found[value].append("file name")
+    return [
+        Candidate(collection, value, points(evidence), tuple(dict.fromkeys(evidence)), command(value))
+        for value, evidence in found.items()
+    ]

primarysource/ieee/__init__.py

@@ -0,0 +1,58 @@
+"""IEEE standards: two collections in one subpackage, both installed by `pip install "primarysource[ieee]"`.
+
+- `posix`: IEEE Std 1003.1-2024, which is The Open Group Base Specifications Issue 8 (one text, also published
+  as ISO/IEC/IEEE 9945). The free HTML edition, downloaded by the user and imported from its archive.
+- `ieee802`: IEEE 802 standards a user obtained from the IEEE GET Program, as PDFs.
+
+They are two collections, not one, because licence, placement and pin are per collection and the Open Group's
+terms differ from IEEE's GET terms (PLAN.md §5.8). `docs/ieee.md` is the user-facing description.
+
+Importing this package needs nothing outside the standard library: `pypdf` is imported only by the 802 PDF
+import, so `posix` works without it, and `mcp` only by `server.py` when a collection is served
+(`primarysource mcp --collection posix`). `primarysource posix ...` runs `cli.py`.
+"""
+
+from __future__ import annotations
+
+from primarysource.model import Unit
+from primarysource.refs import RefGrammar
+from primarysource.registry import Collection
+
+POSIX_DOC = r"posix-[0-9]{4}"
+"""An edition of POSIX by year: `posix-2024`."""
+
+POSIX_PAGE = r"[a-z]+(?:/[A-Za-z0-9_\[][A-Za-z0-9_.+\-]*)?"
+"""A page of the HTML edition by its path without `.html`: `functions/open`, `utilities/pax`, `basedefs/stdio.h`,
+`basedefs/V1_chap03`, `xrat/V4_xcu_chap01`. `utilities/[` is the one page whose name starts with `[`."""
+
+IEEE802_DOC = r"802(?:\.[0-9]+[A-Za-z]*)*-[0-9]{4}"
+"""An 802 standard by number and year: `802.1Q-2022`, `802.3-2022`, `802.1AB-2016`, `802.15.4-2020`."""
+
+POSIX = Collection(
+    name="posix",
+    title="IEEE Std 1003.1-2024 / The Open Group Base Specifications Issue 8",
+    prefix="posix_",
+    unit=Unit.BLOCK,
+    grammar=RefGrammar(POSIX_DOC, POSIX_PAGE),
+    server="primarysource.ieee.server:posix_server",
+    cli="primarysource.ieee.cli:posix_main",
+)
+"""Refs: `posix-2024§functions/open#tag_17_372_03¶2`. `§` names the page, `#` an HTML anchor on it. `¶n` counts
+converted blocks (a paragraph, a list item, a code block, a table, a definition term): with an anchor, the blocks
+under that heading, the heading itself excluded and its subsections included; with only a page, every block of
+the page, headings included."""
+
+IEEE802 = Collection(
+    name="ieee802",
+    title="IEEE 802 standards (IEEE GET Program)",
+    prefix="ieee802_",
+    unit=Unit.SENTENCE,
+    grammar=RefGrammar(IEEE802_DOC),
+    server="primarysource.ieee.server:ieee802_server",
+    cli="primarysource.ieee.cli:ieee802_main",
+    identify="primarysource.ieee.identify:identify",
+)
+"""Refs: `802.1Q-2022§5.4¶2`. `§` names a numbered clause or annex (`5.4`, `A.1`); `¶n` is the nth sentence of the
+clause's extracted text, because a PDF gives sentences, not paragraphs."""
+
+__all__ = ["IEEE802", "POSIX"]

primarysource/ieee/_html.py

@@ -0,0 +1,49 @@
+"""The ieee collections' HTML reader: the core's `primarysource.readers.html`, plus the `POSIX` profile.
+
+The converter itself moved to the core (`cl.reader_html`); this module re-exports it so `posix.py` and anything
+else that imported `primarysource.ieee._html` keeps working unchanged. What stays here is ieee's own rule set.
+"""
+
+from __future__ import annotations
+
+from primarysource.readers.html import (
+    GENERIC,
+    MAX_INDENT,
+    MAX_OUTPUT_CHARS,
+    Document,
+    Heading,
+    Link,
+    Profile,
+    convert,
+    fence_language,
+    is_chrome,
+    join_blocks,
+    resolve_href,
+    to_plain,
+)
+
+__all__ = [
+    "GENERIC",
+    "MAX_INDENT",
+    "MAX_OUTPUT_CHARS",
+    "POSIX",
+    "Document",
+    "Heading",
+    "Link",
+    "Profile",
+    "convert",
+    "fence_language",
+    "is_chrome",
+    "join_blocks",
+    "resolve_href",
+    "to_plain",
+]
+
+POSIX = Profile(
+    chrome_classes=frozenset({"navheader", "topofpage"}),
+    inner_anchor=True,
+    small_print_centre=True,
+    plain_blockquote=True,
+    rules=False,
+)
+"""The Open Group's POSIX pages: five rules on top of `GENERIC` (see `Profile` for what each one does)."""

primarysource/ieee/catalogue.json

@@ -0,0 +1,74 @@
+{
+  "schema": 1,
+  "note": "Catalogue metadata and digests only. No document text belongs in this file or anywhere in the repository.",
+  "collections": {
+    "posix": {
+      "licence": "LicenseRef-OpenGroup-IEEE-personal-use",
+      "placement": "volume",
+      "terms_url": "https://pubs.opengroup.org/onlinepubs/terms.htm",
+      "terms_read": "2026-11-12",
+      "terms_summary": "Jointly owned by The Open Group and the IEEE. Reading and downloading for personal use only, after giving a name and email address per publication; no copying, amending, reprinting, sale or re-use without permission of both holders. The hard copy is authoritative.",
+      "editions": [
+        {
+          "id": "posix-2024",
+          "designations": [
+            "IEEE Std 1003.1-2024",
+            "The Open Group Base Specifications Issue 8",
+            "ISO/IEC/IEEE 9945:2026"
+          ],
+          "designation_note": "One text under three covers. IEEE's page for 1003.1-2024 (standards.ieee.org, read 2026-11-13) says it is simultaneously IEEE Std 1003.1-2024 and The Open Group Base Specifications Issue 8, and lists the ISO/IEC/IEEE 9945 International Standard with the same Issue 8 title. ISO/IEC/IEEE 9945:2026 (edition 2, 2026-03, replacing the 2009 first edition) is known only from search-result snippets: iso.org answered HTTP 403 to an automated fetch, so its date and its identity with this HTML are not verified from the primary page. It is sold; this collection neither holds nor imports it.",
+          "title": "IEEE/Open Group Standard for Information Technology--Portable Operating System Interface (POSIX) Base Specifications, Issue 8",
+          "publisher": "IEEE and The Open Group",
+          "edition_date": "2024-06-14",
+          "ieee_page_url": "https://standards.ieee.org/ieee/1003.1/7700/",
+          "ieee_status": "Active Standard (standards.ieee.org, read 2026-11-13)",
+          "archive_updated": "2025-04-01",
+          "page_url": "https://pubs.opengroup.org/onlinepubs/9799919799/",
+          "source_url": "https://pubs.opengroup.org/onlinepubs/9799919799/download/susv5.tgz",
+          "archive": "susv5.tgz",
+          "sha256": "11c7ee3e98febe3d58d03a02885d0fab9a3564d06a9b02742d9d138ae341a957",
+          "size": 4962222,
+          "root": "susv5-html/",
+          "members": 1715,
+          "html_files": 1616,
+          "html_bytes": 24248288
+        }
+      ]
+    },
+    "ieee802": {
+      "licence": "LicenseRef-IEEE-GET-Program",
+      "placement": "volume",
+      "terms_url": "https://ieeexplore.ieee.org/Xplorehelp/overview-of-ieee-xplore/get-program-terms-of-use",
+      "terms_read": "not read: the terms page answered HTTP 418 to an automated fetch on 2026-11-12",
+      "terms_summary": "IEEE GET Program (standards.ieee.org, read 2026-11-12): the Terms and Conditions of Use must be accepted before the PDF is available; the documents are not in the public domain and IEEE remains the sole copyright holder. Copy and automation limits are unverified.",
+      "editions": [
+        {
+          "id": "802.1Q-2022",
+          "designations": ["IEEE Std 802.1Q-2022"],
+          "title": "IEEE Standard for Local and Metropolitan Area Networks--Bridges and Bridged Networks",
+          "publisher": "IEEE",
+          "edition_date": "2022-12-22",
+          "page_url": "https://standards.ieee.org/ieee/802.1Q/10323/",
+          "source_url": null,
+          "archive": null,
+          "sha256": null,
+          "size": null,
+          "get_program": "the standard's page says the PDF is available at no cost through the GET program (read 2026-11-12)"
+        },
+        {
+          "id": "802.3-2022",
+          "designations": ["IEEE Std 802.3-2022"],
+          "title": "IEEE Standard for Ethernet",
+          "publisher": "IEEE",
+          "edition_date": "2022-07-29",
+          "page_url": "https://standards.ieee.org/ieee/802.3/10422/",
+          "source_url": null,
+          "archive": null,
+          "sha256": null,
+          "size": null,
+          "get_program": "the standard's page links the GET program; whether this edition is free there was not stated (read 2026-11-12)"
+        }
+      ]
+    }
+  }
+}