codendium 1.0.0__py3-none-any.whl

copyright_deposit/core/manifest.py

@@ -0,0 +1,282 @@
+"""Audit trail for a build.
+
+Writes a machine-readable manifest and a human-readable summary recording
+exactly what went into the deposit: every file, its SHA-256, where it
+landed in the PDF, and every warning raised along the way. The summary also
+contains the sentence to give the Copyright Office describing the deposit.
+
+Secret findings are recorded by masked excerpt only - the manifest must not
+become a second copy of the credential.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+from .. import DISPLAY_NAME, __version__
+from .pipeline import EstimateResult
+
+
+def build_manifest(estimate: EstimateResult, outputs: list[str]) -> dict:
+    settings = estimate.settings
+    layout = estimate.layout
+    selection = estimate.selection
+    ranges = {r.rel_path: r for r in layout.file_ranges}
+    listed = {
+        item.rel_path: item.source for item in estimate.plan.items
+    }
+
+    files = []
+    for order, prepared in enumerate(estimate.prepared, start=1):
+        page_range = ranges.get(prepared.rel_path)
+        files.append(
+            {
+                "order": order,
+                "path": prepared.rel_path,
+                "sha256": prepared.sha256,
+                "language": prepared.language,
+                "encoding": prepared.encoding,
+                "source_lines": len(prepared.lines),
+                "total_lines_in_file": prepared.total_lines,
+                "rendered_lines": page_range.rendered_lines if page_range else 0,
+                "first_page": page_range.first_page if page_range else None,
+                "last_page": page_range.last_page if page_range else None,
+                "strip_method": prepared.strip.method,
+                "lines_removed": prepared.strip.removed_lines,
+                "partial": prepared.selection.partial,
+                "line_ranges": prepared.range_spec,
+                "line_range_label": prepared.selection.label,
+                "lines_omitted_by_range": prepared.selection.omitted_lines,
+                "redacted_chars": prepared.redaction.redacted_chars,
+                "origin": listed.get(prepared.rel_path, "unlisted"),
+                "warnings": prepared.warnings,
+            }
+        )
+
+    return {
+        "tool": {"name": DISPLAY_NAME, "version": __version__},
+        "generated_utc": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+        "settings_fingerprint": settings.fingerprint(),
+        "source_root": estimate.discovery.root,
+        "identification": settings.header.lines(),
+        "page_grid": estimate.geometry_note,
+        "totals": {
+            "files": len(estimate.prepared),
+            "partial_files": sum(1 for p in estimate.prepared if p.selection.partial),
+            "source_lines": layout.source_lines,
+            "rendered_lines": layout.rendered_lines,
+            "wrapped_lines": layout.wrapped_lines,
+            "pages": layout.page_count,
+            "glyph_replacements": layout.glyph_replacements,
+        },
+        "deposit": {
+            "mode": selection.mode,
+            "total_pages": selection.total_pages,
+            "deposited_pages": selection.deposited_pages,
+            "omitted_pages": list(selection.omitted) if selection.omitted else None,
+            "filing_statement": selection.filing_statement(),
+            "files_entirely_omitted": estimate.omitted_files(),
+            "files_partially_shown": estimate.split_files(),
+        },
+        "redaction": {
+            "enabled": settings.redaction.enabled,
+            "redacted_chars": estimate.redaction_report.redacted_chars,
+            "total_chars": estimate.redaction_report.total_chars,
+            "ratio": round(estimate.redaction_report.ratio, 6),
+            "within_721_7_limit": estimate.redaction_report.compliant,
+        },
+        "order": {
+            "entries": settings.order_entries,
+            "unmatched": estimate.plan.unmatched,
+            "ambiguities": [
+                {"entry": a.entry, "candidates": a.candidates, "chosen": a.chosen}
+                for a in estimate.plan.ambiguities
+            ],
+            "excluded": estimate.plan.excluded,
+        },
+        "files": files,
+        "skipped": [
+            {"path": s.rel_path, "reason": s.reason, "size": s.size}
+            for s in estimate.discovery.skipped
+        ],
+        "findings": {
+            "secrets": [
+                {
+                    "id": f.id,
+                    "location": f.location(),
+                    "rule": f.rule,
+                    "detail": f.detail,
+                    "severity": f.severity,
+                    "masked_excerpt": f.excerpt,
+                }
+                for f in estimate.scan.sorted_secrets()
+            ],
+            "third_party": [
+                {
+                    "id": f.id,
+                    "location": f.location(),
+                    "rule": f.rule,
+                    "detail": f.detail,
+                    "severity": f.severity,
+                }
+                for f in estimate.scan.sorted_third_party()
+            ],
+        },
+        "warnings": estimate.warnings,
+        "outputs": outputs,
+        "settings": settings.to_dict(),
+    }
+
+
+def format_summary(manifest: dict) -> str:
+    lines: list[str] = []
+    add = lines.append
+
+    add(f"{manifest['tool']['name'].upper()} - DEPOSIT BUILD SUMMARY")
+    add("=" * 72)
+    add(f"Generated : {manifest['generated_utc']}")
+    add(f"Tool      : {manifest['tool']['name']} {manifest['tool']['version']}")
+    add(f"Source    : {manifest['source_root']}")
+    add(f"Page grid : {manifest['page_grid']}")
+    add("")
+
+    add("IDENTIFICATION BLOCK (first page of the deposit)")
+    add("-" * 72)
+    for line in manifest["identification"]:
+        add(f"  {line}")
+    add("")
+
+    totals = manifest["totals"]
+    deposit = manifest["deposit"]
+    add("DEPOSIT")
+    add("-" * 72)
+    add(f"  Files included    : {totals['files']}")
+    add(f"  Lines rendered    : {totals['rendered_lines']} ({totals['wrapped_lines']} wrapped)")
+    add(f"  Complete program  : {deposit['total_pages']} page(s)")
+    add(f"  Pages deposited   : {deposit['deposited_pages']}")
+    if deposit["omitted_pages"]:
+        first, last = deposit["omitted_pages"]
+        add(f"  Pages omitted     : {first}-{last}")
+    add("")
+    add("  Statement for the application:")
+    for chunk in _wrap(deposit["filing_statement"], 66):
+        add(f"    {chunk}")
+    add("")
+
+    if deposit["files_entirely_omitted"]:
+        add("  Files that fall entirely inside the omitted pages:")
+        for path in deposit["files_entirely_omitted"]:
+            add(f"    - {path}")
+        add("")
+
+    redaction = manifest["redaction"]
+    if redaction["enabled"] and redaction["redacted_chars"]:
+        add("REDACTION (Compendium sec. 721.7)")
+        add("-" * 72)
+        add(
+            f"  Blocked out: {redaction['redacted_chars']} of {redaction['total_chars']} "
+            f"characters ({redaction['ratio'] * 100:.1f}%)"
+        )
+        add(f"  Within the 49% limit: {'yes' if redaction['within_721_7_limit'] else 'NO'}")
+        add("")
+
+    add("FILE ORDER")
+    add("-" * 72)
+    add(f"  {'#':>3}  {'pages':>11}  {'lines':>6}  path")
+    for entry in manifest["files"]:
+        pages = (
+            f"{entry['first_page']}-{entry['last_page']}"
+            if entry["first_page"] is not None
+            else "-"
+        )
+        marker = " " if entry["origin"] != "unlisted" else "*"
+        suffix = "  [PARTIAL]" if entry.get("partial") else ""
+        add(
+            f"  {entry['order']:>3}{marker} {pages:>11}  {entry['rendered_lines']:>6}  "
+            f"{entry['path']}{suffix}"
+        )
+    add("  (* = not named in the order list; appended automatically)")
+    add("")
+
+    partial = [entry for entry in manifest["files"] if entry.get("partial")]
+    if partial:
+        add("PARTIAL FILES (only the listed lines were deposited)")
+        add("-" * 72)
+        for entry in partial:
+            add(f"  {entry['path']}")
+            add(
+                f"      lines {entry['line_range_label']} included; "
+                f"{entry['lines_omitted_by_range']} line(s) omitted"
+            )
+        add("")
+
+    secrets = manifest["findings"]["secrets"]
+    third_party = manifest["findings"]["third_party"]
+    if secrets:
+        add("SECRET / PII FINDINGS")
+        add("-" * 72)
+        for finding in secrets:
+            add(f"  [{finding['severity']:>6}] {finding['location']} - {finding['detail']} ({finding['masked_excerpt']})")
+        add("")
+    if third_party:
+        add("THIRD-PARTY INDICATORS")
+        add("-" * 72)
+        for finding in third_party:
+            add(f"  [{finding['severity']:>6}] {finding['location']} - {finding['detail']}")
+        add("")
+
+    if manifest["skipped"]:
+        add("SKIPPED FILES")
+        add("-" * 72)
+        for entry in manifest["skipped"]:
+            add(f"  {entry['path']} - {entry['reason']}")
+        add("")
+
+    if manifest["warnings"]:
+        add("WARNINGS")
+        add("-" * 72)
+        for warning in manifest["warnings"]:
+            add(f"  - {warning}")
+        add("")
+
+    add("OUTPUTS")
+    add("-" * 72)
+    for path in manifest["outputs"]:
+        add(f"  {path}")
+    add("")
+    return "\n".join(lines)
+
+
+def _wrap(text: str, width: int) -> list[str]:
+    words = text.split()
+    lines: list[str] = []
+    current = ""
+    for word in words:
+        if current and len(current) + 1 + len(word) > width:
+            lines.append(current)
+            current = word
+        else:
+            current = f"{current} {word}".strip()
+    if current:
+        lines.append(current)
+    return lines or [""]
+
+
+def write_manifest(
+    estimate: EstimateResult,
+    out_dir: str | Path,
+    base: str,
+    outputs: list[str],
+) -> tuple[str, str]:
+    out_dir = Path(out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    manifest = build_manifest(estimate, outputs)
+    manifest_path = out_dir / f"{base}_manifest.json"
+    summary_path = out_dir / f"{base}_summary.txt"
+
+    manifest_path.write_text(json.dumps(manifest, indent=2), encoding="utf-8")
+    summary_path.write_text(format_summary(manifest), encoding="utf-8")
+    return str(manifest_path), str(summary_path)

copyright_deposit/core/metrics.py

@@ -0,0 +1,279 @@
+"""Page geometry and font metrics.
+
+The whole design rests on one property: with a monospaced font and a fixed
+number of lines per page, **page count is a pure function of the character
+stream**. Nothing here consults the renderer, so the estimator and the
+renderer cannot disagree.
+
+Font policy: Courier is a PDF base-14 face, so it needs no embedding, is
+guaranteed monospaced, renders identically everywhere and carries no
+redistribution question. A TrueType file may be supplied instead; drop one
+in ``assets/fonts`` or name a path in the settings.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from pathlib import Path
+
+from ..config import LayoutOptions
+
+PAGE_SIZES: dict[str, tuple[float, float]] = {
+    "letter": (612.0, 792.0),  # 8.5 x 11 in
+    "a4": (595.276, 841.890),
+}
+
+BASE14_MONO = {"Courier", "Courier-Bold", "Courier-Oblique", "Courier-BoldOblique"}
+
+HEADER_BAND = 20.0
+FOOTER_BAND = 22.0
+
+_ASSET_DIR = Path(__file__).resolve().parent.parent / "assets" / "fonts"
+
+
+@dataclass(frozen=True)
+class FontSpec:
+    regular: str
+    bold: str
+    size: float
+    char_width: float
+    embedded: bool
+    warnings: tuple[str, ...] = ()
+
+    def supports(self, ch: str) -> bool:
+        return _font_supports(self.regular, ch)
+
+    def sanitize(self, text: str) -> tuple[str, int]:
+        """Replace glyphs the font cannot draw. Returns (text, replacements)."""
+        if text.isascii():
+            return text, 0
+        out: list[str] = []
+        replaced = 0
+        for ch in text:
+            if ch.isascii() or _font_supports(self.regular, ch):
+                out.append(ch)
+            else:
+                out.append("?")
+                replaced += 1
+        return "".join(out), replaced
+
+
+@dataclass(frozen=True)
+class PageGeometry:
+    width: float
+    height: float
+    margin: float
+    lines_per_page: int
+    leading: float
+    text_top: float
+    text_bottom: float
+    total_columns: int
+    gutter_columns: int
+    font: FontSpec
+    running_header: bool
+    page_numbers: bool
+
+    @property
+    def code_columns(self) -> int:
+        return max(8, self.total_columns - self.gutter_columns)
+
+    def baseline(self, row: int) -> float:
+        """Baseline y for the given 0-based row on a page."""
+        return self.text_top - self.leading * row - self.font.size
+
+    @property
+    def text_left(self) -> float:
+        return self.margin
+
+    def column_x(self, column: int) -> float:
+        return self.margin + column * self.font.char_width
+
+
+# ---------------------------------------------------------------------------
+# Font registration
+# ---------------------------------------------------------------------------
+
+_registered: dict[str, bool] = {}
+_coverage_cache: dict[str, set[int] | None] = {}
+
+
+def _register_ttf(path: Path) -> tuple[str, str] | None:
+    """Register a TTF (and a bold sibling if present). Returns font names."""
+    from reportlab.pdfbase import pdfmetrics
+    from reportlab.pdfbase.ttfonts import TTFont
+
+    family = path.stem
+    if _registered.get(family):
+        return family, _registered_bold(family)
+    try:
+        pdfmetrics.registerFont(TTFont(family, str(path)))
+    except Exception:
+        return None
+    _registered[family] = True
+
+    bold_name = family
+    for candidate in (
+        path.with_name(path.stem + "-Bold" + path.suffix),
+        path.with_name(path.stem + "Bd" + path.suffix),
+        path.with_name(path.stem.replace("-Regular", "") + "-Bold" + path.suffix),
+    ):
+        if candidate.is_file():
+            try:
+                pdfmetrics.registerFont(TTFont(family + "-Bold", str(candidate)))
+                bold_name = family + "-Bold"
+                _registered[family + "-Bold"] = True
+                break
+            except Exception:
+                continue
+    return family, bold_name
+
+
+def _registered_bold(family: str) -> str:
+    return family + "-Bold" if _registered.get(family + "-Bold") else family
+
+
+def _bundled_font() -> Path | None:
+    if not _ASSET_DIR.is_dir():
+        return None
+    for path in sorted(_ASSET_DIR.glob("*.ttf")):
+        if "bold" not in path.stem.lower() and "italic" not in path.stem.lower():
+            return path
+    return None
+
+
+def _font_supports(font_name: str, ch: str) -> bool:
+    coverage = _coverage_cache.get(font_name)
+    if coverage is None and font_name not in _coverage_cache:
+        coverage = _load_coverage(font_name)
+        _coverage_cache[font_name] = coverage
+    if coverage is None:
+        # Base-14 fonts use WinAnsi; cp1252 encodability is the real test.
+        try:
+            ch.encode("cp1252")
+            return True
+        except UnicodeEncodeError:
+            return False
+    return ord(ch) in coverage
+
+
+def _load_coverage(font_name: str) -> set[int] | None:
+    from reportlab.pdfbase import pdfmetrics
+
+    try:
+        font = pdfmetrics.getFont(font_name)
+    except Exception:
+        return None
+    face = getattr(font, "face", None)
+    char_to_glyph = getattr(face, "charToGlyph", None)
+    if not char_to_glyph:
+        return None
+    return set(char_to_glyph.keys())
+
+
+def resolve_font(options: LayoutOptions) -> FontSpec:
+    """Pick the deposit font, preferring an explicit TTF, then a bundled one."""
+    warnings: list[str] = []
+    name = (options.font_name or "Courier").strip()
+    regular = "Courier"
+    bold = "Courier-Bold"
+    embedded = False
+
+    candidate: Path | None = None
+    if name.lower().endswith(".ttf"):
+        candidate = Path(name)
+        if not candidate.is_file():
+            warnings.append(f"Font file not found: {name}; using Courier.")
+            candidate = None
+    elif name in BASE14_MONO:
+        candidate = None
+    else:
+        asset = _ASSET_DIR / f"{name}.ttf"
+        candidate = asset if asset.is_file() else None
+        if candidate is None and name not in BASE14_MONO:
+            candidate = _bundled_font()
+
+    if candidate is None and name in ("", "auto"):
+        candidate = _bundled_font()
+
+    if candidate is not None:
+        registered = _register_ttf(candidate)
+        if registered:
+            regular, bold = registered
+            embedded = True
+        else:
+            warnings.append(f"Could not embed {candidate.name}; using Courier.")
+
+    from reportlab.pdfbase import pdfmetrics
+
+    size = float(options.font_size)
+    narrow = pdfmetrics.stringWidth("i", regular, size)
+    wide = pdfmetrics.stringWidth("W", regular, size)
+    if abs(narrow - wide) > 0.01:
+        warnings.append(
+            f"'{regular}' is not monospaced; the Copyright Office requires a "
+            "monospaced face. Falling back to Courier."
+        )
+        regular, bold, embedded = "Courier", "Courier-Bold", False
+        wide = pdfmetrics.stringWidth("W", regular, size)
+
+    return FontSpec(
+        regular=regular,
+        bold=bold,
+        size=size,
+        char_width=wide,
+        embedded=embedded,
+        warnings=tuple(warnings),
+    )
+
+
+# ---------------------------------------------------------------------------
+# Geometry
+# ---------------------------------------------------------------------------
+
+
+def build_geometry(options: LayoutOptions, max_line_number: int = 0) -> PageGeometry:
+    """Derive the fixed page grid from the layout options."""
+    font = resolve_font(options)
+    width, height = PAGE_SIZES.get(options.page_size.lower(), PAGE_SIZES["letter"])
+    margin = float(options.margin)
+
+    header_band = HEADER_BAND if options.running_header else 0.0
+    footer_band = FOOTER_BAND if options.page_numbers else 0.0
+    text_top = height - margin - header_band
+    text_bottom = margin + footer_band
+
+    lines_per_page = max(1, int(options.lines_per_page))
+    leading = (text_top - text_bottom) / lines_per_page
+
+    usable_width = width - 2 * margin
+    total_columns = max(20, int(math.floor(usable_width / font.char_width + 1e-9)))
+
+    gutter = 0
+    if options.show_line_numbers:
+        gutter = max(4, len(str(max(max_line_number, 1)))) + 1
+
+    return PageGeometry(
+        width=width,
+        height=height,
+        margin=margin,
+        lines_per_page=lines_per_page,
+        leading=leading,
+        text_top=text_top,
+        text_bottom=text_bottom,
+        total_columns=total_columns,
+        gutter_columns=gutter,
+        font=font,
+        running_header=options.running_header,
+        page_numbers=options.page_numbers,
+    )
+
+
+def describe(geometry: PageGeometry) -> str:
+    """One-line summary shown in the GUI and written to the manifest."""
+    return (
+        f"{geometry.font.regular} {geometry.font.size:g}pt, "
+        f"{geometry.lines_per_page} lines/page, "
+        f"{geometry.code_columns} columns, "
+        f"leading {geometry.leading:.2f}pt"
+    )