codendium 1.0.0__py3-none-any.whl

copyright_deposit/core/strip/python_strip.py

@@ -0,0 +1,131 @@
+"""Python comment and docstring classification.
+
+``tokenize`` is authoritative for comments: it cannot be fooled by a ``#``
+inside a string literal, which is exactly where regex-based strippers go
+wrong. ``ast`` supplies docstring positions.
+
+One rule deserves emphasis: a docstring that is the *only* statement in a
+function or class is never removed, because deleting it would leave an
+empty suite and turn valid source into a syntax error. The deposit must
+still be the program.
+"""
+
+from __future__ import annotations
+
+import ast
+import io
+import tokenize
+
+from . import KIND_COMMENT, KIND_DOCSTRING, KIND_SHEBANG, Span, line_start_offsets
+
+_DOCSTRING_PARENTS = (ast.Module, ast.ClassDef, ast.FunctionDef, ast.AsyncFunctionDef)
+
+
+def find_spans(text: str) -> tuple[list[Span] | None, list[str]]:
+    """Classify comments and docstrings.
+
+    Returns ``(None, warnings)`` if the file cannot be tokenised, so the
+    caller can fall back to a more forgiving lexer.
+    """
+    warnings: list[str] = []
+    starts = line_start_offsets(text)
+    spans: list[Span] = []
+
+    try:
+        tokens = list(tokenize.generate_tokens(io.StringIO(text).readline))
+    except (tokenize.TokenError, IndentationError, SyntaxError, ValueError) as exc:
+        return None, [f"Python tokenizer failed ({exc.__class__.__name__}); using fallback lexer."]
+
+    for tok in tokens:
+        if tok.type != tokenize.COMMENT:
+            continue
+        start = starts[tok.start[0]] + tok.start[1]
+        end = starts[tok.end[0]] + tok.end[1]
+        kind = KIND_SHEBANG if tok.start[0] == 1 and tok.string.startswith("#!") else KIND_COMMENT
+        spans.append((start, end, kind))
+
+    doc_spans, doc_warnings = _docstring_spans(text, starts)
+    spans.extend(doc_spans)
+    warnings.extend(doc_warnings)
+    return spans, warnings
+
+
+def _docstring_spans(text: str, starts: list[int]) -> tuple[list[Span], list[str]]:
+    try:
+        tree = ast.parse(text)
+    except SyntaxError as exc:
+        return [], [f"Could not parse for docstrings ({exc.msg}); docstrings kept."]
+
+    spans: list[Span] = []
+    for node in ast.walk(tree):
+        if not isinstance(node, _DOCSTRING_PARENTS):
+            continue
+        body = getattr(node, "body", None)
+        if not body:
+            continue
+        first = body[0]
+        if not (
+            isinstance(first, ast.Expr)
+            and isinstance(first.value, ast.Constant)
+            and isinstance(first.value.value, str)
+        ):
+            continue
+        # Removing the sole statement of a suite would break the syntax.
+        if len(body) == 1 and not isinstance(node, ast.Module):
+            continue
+        if first.end_lineno is None or first.end_col_offset is None:
+            continue
+        start = starts[first.lineno] + first.col_offset
+        end = starts[first.end_lineno] + first.end_col_offset
+        spans.append((start, end, KIND_DOCSTRING))
+    return spans, []
+
+
+# ---------------------------------------------------------------------------
+# Verification
+# ---------------------------------------------------------------------------
+
+
+def _strip_all_docstrings(tree: ast.AST) -> ast.AST:
+    for node in ast.walk(tree):
+        if not isinstance(node, _DOCSTRING_PARENTS):
+            continue
+        body = getattr(node, "body", None)
+        if not body:
+            continue
+        first = body[0]
+        if (
+            isinstance(first, ast.Expr)
+            and isinstance(first.value, ast.Constant)
+            and isinstance(first.value.value, str)
+        ):
+            rest = body[1:]
+            # A module may legitimately become empty; a suite may not, so it
+            # gets a Pass. Both sides of the comparison normalise the same
+            # way, which keeps a docstring-only module from looking changed.
+            node.body = rest if isinstance(node, ast.Module) else (rest or [ast.Pass()])
+    return tree
+
+
+def verify_equivalent(original: str, stripped: str, options) -> tuple[bool, str]:
+    """Confirm stripping did not change the program.
+
+    Compares ASTs with all docstrings normalised away, so the check is
+    independent of the docstring policy. If the *original* does not parse
+    there is nothing to verify against and the check passes.
+    """
+    try:
+        original_tree = ast.parse(original)
+    except SyntaxError:
+        return True, "original not parseable; nothing to verify"
+
+    try:
+        stripped_tree = ast.parse(stripped)
+    except SyntaxError as exc:
+        return False, f"stripped source no longer parses: line {exc.lineno}"
+
+    left = ast.dump(_strip_all_docstrings(original_tree), include_attributes=False)
+    right = ast.dump(_strip_all_docstrings(stripped_tree), include_attributes=False)
+    if left != right:
+        return False, "abstract syntax trees differ"
+    return True, "ok"

copyright_deposit/gui/__init__.py

@@ -0,0 +1 @@
+"""PySide6 front end. A thin shell over `core.pipeline`."""

copyright_deposit/gui/app.py

@@ -0,0 +1,34 @@
+"""QApplication bootstrap."""
+
+from __future__ import annotations
+
+import sys
+
+from PySide6.QtWidgets import QApplication
+
+from .. import APP_NAME, DISPLAY_NAME, __version__
+from .branding import app_icon, claim_taskbar_identity
+
+
+def run(argv: list[str] | None = None) -> int:
+    # Must happen before the first window exists, or Windows has already
+    # decided which taskbar group this process belongs to.
+    claim_taskbar_identity()
+
+    app = QApplication(argv if argv is not None else sys.argv)
+    app.setApplicationName(APP_NAME)
+    app.setApplicationDisplayName(DISPLAY_NAME)
+    app.setApplicationVersion(__version__)
+    app.setOrganizationName(APP_NAME)
+    # Applies to every window and dialog, not just the main one.
+    app.setWindowIcon(app_icon())
+
+    from .main_window import MainWindow
+
+    window = MainWindow()
+    window.show()
+    return app.exec()
+
+
+if __name__ == "__main__":
+    raise SystemExit(run())

copyright_deposit/gui/branding.py

@@ -0,0 +1,83 @@
+"""The application icon.
+
+The logo is rasterised at a fixed set of sizes rather than handed to Qt as
+an SVG file, for two reasons: it works when the package is imported from a
+zip or a wheel (where there is no filesystem path to give Qt), and it lets
+the window manager pick a crisp pre-rendered size instead of scaling one
+bitmap for the title bar, the alt-tab switcher and the taskbar alike.
+
+Everything here degrades quietly. A missing or unreadable logo costs the
+window its icon; it must never stop the application from starting.
+"""
+
+from __future__ import annotations
+
+import sys
+
+from PySide6.QtCore import QByteArray, QRectF, Qt
+from PySide6.QtGui import QIcon, QImage, QPainter, QPixmap
+
+from .. import APP_NAME
+
+#: Sizes Windows, macOS and common Linux desktops actually ask for.
+ICON_SIZES = (16, 20, 24, 32, 48, 64, 128, 256)
+
+_cached_icon: QIcon | None = None
+
+
+def logo_bytes() -> bytes | None:
+    """Read the packaged logo, whether installed as files or in a zip."""
+    try:
+        from importlib.resources import files
+
+        return (files("copyright_deposit.assets") / "logo.svg").read_bytes()
+    except Exception:
+        return None
+
+
+def app_icon() -> QIcon:
+    """The Codendium mark as a multi-resolution icon."""
+    global _cached_icon
+    if _cached_icon is not None:
+        return _cached_icon
+
+    icon = QIcon()
+    data = logo_bytes()
+    if data:
+        try:
+            from PySide6.QtSvg import QSvgRenderer
+
+            renderer = QSvgRenderer(QByteArray(data))
+            if renderer.isValid():
+                for size in ICON_SIZES:
+                    image = QImage(size, size, QImage.Format.Format_ARGB32)
+                    image.fill(Qt.GlobalColor.transparent)
+                    painter = QPainter(image)
+                    painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
+                    renderer.render(painter, QRectF(0, 0, size, size))
+                    painter.end()
+                    icon.addPixmap(QPixmap.fromImage(image))
+        except Exception:
+            pass
+
+    _cached_icon = icon
+    return icon
+
+
+def claim_taskbar_identity() -> None:
+    """Let Windows show our icon in the taskbar instead of Python's.
+
+    Without an explicit AppUserModelID, Windows groups the process under
+    the host interpreter and shows python.exe's icon on the taskbar, no
+    matter what window icon is set. Harmless and skipped elsewhere.
+    """
+    if not sys.platform.startswith("win"):
+        return
+    try:
+        import ctypes
+
+        ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(
+            f"{APP_NAME}.desktop.1"
+        )
+    except Exception:
+        pass

copyright_deposit/gui/history.py

@@ -0,0 +1,192 @@
+"""Persistent history and reusable profiles.
+
+Two things are remembered: named *profiles* (a complete settings snapshot
+for one program, so the next version's registration starts where the last
+one finished) and a log of *runs* (what was built, when, and with which
+settings, so a filing can be reproduced or explained later).
+
+Settings are stored as JSON and reloaded tolerantly, so a database written
+by an older version of the tool still opens.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+
+from .. import APP_NAME
+from ..config import BuildSettings
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS profiles (
+    name        TEXT PRIMARY KEY,
+    settings    TEXT NOT NULL,
+    updated_utc TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS runs (
+    id             INTEGER PRIMARY KEY AUTOINCREMENT,
+    started_utc    TEXT NOT NULL,
+    program_name   TEXT NOT NULL DEFAULT '',
+    source_root    TEXT NOT NULL DEFAULT '',
+    settings       TEXT NOT NULL,
+    total_pages    INTEGER NOT NULL DEFAULT 0,
+    deposit_pages  INTEGER NOT NULL DEFAULT 0,
+    deposit_mode   TEXT NOT NULL DEFAULT '',
+    outputs        TEXT NOT NULL DEFAULT '[]',
+    fingerprint    TEXT NOT NULL DEFAULT '',
+    warning_count  INTEGER NOT NULL DEFAULT 0
+);
+CREATE INDEX IF NOT EXISTS runs_started ON runs (started_utc DESC);
+"""
+
+
+@dataclass
+class RunRecord:
+    id: int
+    started_utc: str
+    program_name: str
+    source_root: str
+    total_pages: int
+    deposit_pages: int
+    deposit_mode: str
+    outputs: list[str]
+    fingerprint: str
+    warning_count: int
+    settings_json: str
+
+    def settings(self) -> BuildSettings:
+        return BuildSettings.from_json(self.settings_json)
+
+    def label(self) -> str:
+        stamp = self.started_utc.replace("T", " ")[:16]
+        name = self.program_name or Path(self.source_root).name or "(unnamed)"
+        return f"{stamp}  -  {name}  -  {self.total_pages}p"
+
+
+def data_dir() -> Path:
+    base = os.environ.get("APPDATA") or os.environ.get("XDG_DATA_HOME")
+    root = Path(base) if base else Path.home() / ".local" / "share"
+    path = root / APP_NAME
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+class HistoryStore:
+    def __init__(self, path: str | Path | None = None) -> None:
+        self.path = Path(path) if path else data_dir() / "history.db"
+        self._connection = sqlite3.connect(str(self.path))
+        self._connection.row_factory = sqlite3.Row
+        self._connection.executescript(_SCHEMA)
+        self._connection.commit()
+
+    def close(self) -> None:
+        self._connection.close()
+
+    # -- profiles ---------------------------------------------------------
+
+    def save_profile(self, name: str, settings: BuildSettings) -> None:
+        self._connection.execute(
+            "INSERT INTO profiles (name, settings, updated_utc) VALUES (?, ?, ?) "
+            "ON CONFLICT(name) DO UPDATE SET settings=excluded.settings, "
+            "updated_utc=excluded.updated_utc",
+            (name, settings.to_json(indent=None), _now()),
+        )
+        self._connection.commit()
+
+    def profile_names(self) -> list[str]:
+        rows = self._connection.execute(
+            "SELECT name FROM profiles ORDER BY updated_utc DESC"
+        ).fetchall()
+        return [row["name"] for row in rows]
+
+    def load_profile(self, name: str) -> BuildSettings | None:
+        row = self._connection.execute(
+            "SELECT settings FROM profiles WHERE name = ?", (name,)
+        ).fetchone()
+        if row is None:
+            return None
+        try:
+            return BuildSettings.from_json(row["settings"])
+        except (ValueError, TypeError):
+            return None
+
+    def delete_profile(self, name: str) -> None:
+        self._connection.execute("DELETE FROM profiles WHERE name = ?", (name,))
+        self._connection.commit()
+
+    # -- runs -------------------------------------------------------------
+
+    def record_run(
+        self,
+        settings: BuildSettings,
+        total_pages: int,
+        deposit_pages: int,
+        deposit_mode: str,
+        outputs: list[str],
+        warning_count: int,
+    ) -> int:
+        cursor = self._connection.execute(
+            "INSERT INTO runs (started_utc, program_name, source_root, settings, "
+            "total_pages, deposit_pages, deposit_mode, outputs, fingerprint, warning_count) "
+            "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+            (
+                _now(),
+                settings.header.program_name,
+                settings.source_root,
+                settings.to_json(indent=None),
+                total_pages,
+                deposit_pages,
+                deposit_mode,
+                json.dumps(outputs),
+                settings.content_fingerprint(),
+                warning_count,
+            ),
+        )
+        self._connection.commit()
+        return int(cursor.lastrowid or 0)
+
+    def recent_runs(self, limit: int = 50) -> list[RunRecord]:
+        rows = self._connection.execute(
+            "SELECT * FROM runs ORDER BY id DESC LIMIT ?", (limit,)
+        ).fetchall()
+        return [_to_record(row) for row in rows]
+
+    def delete_run(self, run_id: int) -> None:
+        self._connection.execute("DELETE FROM runs WHERE id = ?", (run_id,))
+        self._connection.commit()
+
+    def recent_folders(self, limit: int = 10) -> list[str]:
+        rows = self._connection.execute(
+            "SELECT source_root, MAX(id) AS latest FROM runs "
+            "WHERE source_root <> '' GROUP BY source_root ORDER BY latest DESC LIMIT ?",
+            (limit,),
+        ).fetchall()
+        return [row["source_root"] for row in rows]
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+def _to_record(row: sqlite3.Row) -> RunRecord:
+    try:
+        outputs = json.loads(row["outputs"])
+    except (ValueError, TypeError):
+        outputs = []
+    return RunRecord(
+        id=row["id"],
+        started_utc=row["started_utc"],
+        program_name=row["program_name"],
+        source_root=row["source_root"],
+        total_pages=row["total_pages"],
+        deposit_pages=row["deposit_pages"],
+        deposit_mode=row["deposit_mode"],
+        outputs=outputs,
+        fingerprint=row["fingerprint"],
+        warning_count=row["warning_count"],
+        settings_json=row["settings"],
+    )