texpkg 0.1.0__py3-none-any.whl

texpkg/document.py

@@ -0,0 +1,225 @@
+"""`Document[T]`: a kind's tree and the directory it lives in (P27, P28)."""
+
+import dataclasses
+import datetime
+import enum
+import json
+import pathlib
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any
+
+from texmodel import drift
+from texmodel.components import Command, Environment
+
+from . import provenance
+from ._internal import directory, handedits, state
+from .contracts import Pair
+from .declaration import Kind
+from .errors import HandEditError, NotADocumentError
+
+if TYPE_CHECKING:
+    from ._internal.release import Release
+
+
+@enum.unique
+class FileState(enum.StrEnum):
+    UNCHANGED = "unchanged"
+    CHANGED = "changed"
+    MISSING = "missing"
+    EXTRA = "extra"  # in a place the payload writes to, and not written by it: a retired `.sty` (A4)
+
+
+@enum.unique
+class HandEditKind(enum.StrEnum):
+    ADDED = "added"  # in the file, not in the plan
+    REMOVED = "removed"  # in the plan, not in the file
+    CHANGED = "changed"
+
+
+@dataclasses.dataclass(frozen=True)
+class HandEdit:
+    """One line of a `.tex` that is not what `save` wrote (D8). `path` is the node's data path (`/content/1/content/0`),
+    or the plan's own for a line no node wrote; `value` is the typed value when texmodel can read the edit back (D9),
+    else `None`: it is never guessed."""
+
+    file: pathlib.Path
+    path: str
+    expected: str
+    found: str
+    kind: HandEditKind
+    value: object = None
+
+
+@dataclasses.dataclass(frozen=True)
+class TemplateChange:
+    """One thing a new release changes for a saved document (D4): a setting a `.tex` is written with
+    (`setting deck.tex FactGap`), a default (`default Fact.accent`) or a `.sty` (`sty acme-brand.sty`, by hash).
+    `old` and `new` are the recorded and the current value; `None` is absent."""
+
+    setting: str
+    old: object
+    new: object
+
+
+@dataclasses.dataclass(frozen=True)
+class Check:
+    """What a `save` would change, and nothing changed to find out (P29, A4). A file that is `EXTRA` is reported, but a
+    save removes nothing, so it does not make the document not current."""
+
+    files: Mapping[pathlib.Path, FileState]
+    edits: tuple[HandEdit, ...] = ()
+
+    @property
+    def current(self) -> bool:
+        return not self.edits and all(s in (FileState.UNCHANGED, FileState.EXTRA) for s in self.files.values())
+
+
+@dataclasses.dataclass(frozen=True)
+class StackEntry:
+    package: str
+    release: str
+    output: Pair  # what the package rendered with, `current:revision` (V18)
+
+
+@dataclasses.dataclass(frozen=True)
+class Stack:
+    """The packages a document was rendered through, the top one first: its lockfile (V18)."""
+
+    entries: tuple[StackEntry, ...]
+
+
+class Document[T: Command | Environment]:
+    """A texmodel tree of a kind's classes (`doc.tree`) with texpkg's interface as methods (P28). Made by a kind's
+    `load` and `create`, never by hand; a tree is frozen, so `replace` gives another document."""
+
+    def __init__(self, tree: T, path: pathlib.Path, release: "Release", kind: Kind) -> None:
+        self.tree = tree
+        self.path = path
+        self._release, self._kind = release, kind
+
+    @property
+    def kind(self) -> str:
+        return self._kind.name
+
+    @property
+    def defaults(self) -> tuple[str, ...]:
+        """The data paths of the values that are still the package's defaults (V21)."""
+        return state.default_paths(self.tree)
+
+    @property
+    def stack(self) -> Stack:
+        """The packages the document was last saved through; the release's own when nothing is saved yet."""
+        saved = directory.read(self.path, directory.TEMPLATE)
+        template = json.loads(saved) if saved else self._release.template(self._kind)
+        return Stack(tuple(StackEntry(e["package"], e["release"], Pair(*e["output"])) for e in template["stack"]))
+
+    def render(self, variant: str | None = None) -> str:
+        """The `.tex` of the document, complete: pure, nothing is written. Raises an `ExceptionGroup` of texmodel
+        `ValidationError` when the tree breaks a rule."""
+        return self._release.plan(self._kind, self.tree, variant).text
+
+    def replace(self, tree: T) -> "Document[T]":
+        """The same document, in the same directory, with another tree."""
+        return Document(tree, self.path, self._release, self._kind)
+
+    def _expected(self, stamp: str, time: str) -> dict[str, str | bytes]:
+        """Every file a save writes, by path in the directory."""
+        files = provenance.files(self._release, stamp, time)
+        payload = self._release.payload(self._kind, files)
+        return (
+            payload.expected()
+            | self._release.rendered(self._kind, self.tree)
+            | self._release.states(self._kind, self.tree)
+        )
+
+    def _data_path(self, plan_path: str) -> str:
+        """A profile's tree is expanded before it is written, so a plan path names a node of the base's tree and not a
+        path in this document's data: it is given as it is."""
+        return plan_path if self._kind.expand else handedits.data_path(plan_path)
+
+    def hand_edits(self) -> tuple[HandEdit, ...]:
+        """The lines of the `.tex` files that differ from the plan `save` kept of them (D8)."""
+        return tuple(
+            HandEdit(
+                self.path / name,
+                self._data_path(edit.path),
+                edit.expected,
+                edit.found,
+                HandEditKind(edit.kind.value),
+            )
+            for name, edit in handedits.edits(self.path, self._kind.documents())
+        )
+
+    def save(self, *, now: datetime.datetime | None = None, stamp: str | None = None, force: bool = False) -> None:
+        """Write the states, the `.tex` of every variant with its plan, and the payload of the kind: only what changed,
+        and a history entry only when the states did (P29). Raises `HandEditError`, writing nothing, when a `.tex` was
+        edited by hand, unless `force`. Nothing is written if the tree or the payload is not whole.
+
+        The provenance files carry `stamp` (default: the release's version, V4) and the time of `now` (default: the
+        clock, N4). Their time is kept while the stamp and the rest of the payload are as they were."""
+        rendered = self._release.rendered(self._kind, self.tree)
+        states = self._release.states(self._kind, self.tree)
+        wanted = provenance.stamp_of(stamp, self._release)
+        bare = self._release.payload(self._kind)
+        bare.complete()
+        saved = provenance.saved(self.path, self._release)
+        unchanged = saved is not None and saved.stamp == wanted and not bare.pending(self.path)
+        time = saved.time if unchanged and saved else provenance.time_of(now)
+        payload = self._release.payload(self._kind, provenance.files(self._release, wanted, time))
+        if not force and (edits := self.hand_edits()):
+            files = ", ".join(sorted({e.file.name for e in edits}))
+            raise HandEditError(
+                f"{len(edits)} hand-edited line(s) in {files}: not overwritten",
+                edits=edits,
+                hint="doc.hand_edits() lists them; save(force=True) overwrites them",
+            )
+        payload.write(self.path)
+        directory.write(self.path, directory.differing(self.path, rendered))
+        if changed := directory.differing(self.path, states):
+            directory.rotate_history(self.path)
+            directory.write(self.path, changed)
+
+    def check(self, *, stamp: str | None = None) -> Check:
+        """What a save would change; writes nothing. A hand-edited `.tex` is reported as changed and in `edits`. The
+        provenance files are compared by stamp (A4): `stamp` is the one the document was saved with (default: the
+        release's version), and the time they hold is not a difference."""
+        wanted = provenance.stamp_of(stamp, self._release)
+        saved = provenance.saved(self.path, self._release)
+        expected = self._expected(wanted, saved.time if saved else provenance.time_of(None))
+        report = drift.check_drift(expected, self.path, self._release.dist.layout.owned())
+        files: dict[pathlib.Path, FileState] = {}
+        for rel in expected:
+            files[self.path / rel] = (
+                FileState.MISSING
+                if rel in report.missing
+                else FileState.CHANGED
+                if rel in report.stale
+                else FileState.UNCHANGED
+            )
+        files |= {self.path / rel: FileState.EXTRA for rel in report.orphaned}
+        return Check(files, self.hand_edits())
+
+    def template_changes(self) -> tuple[TemplateChange, ...]:
+        """What the installed release changes for this document against the template state it was saved with (D4)."""
+        saved = directory.read(self.path, directory.TEMPLATE)
+        if saved is None:
+            raise NotADocumentError(
+                f"{self.path}: no {directory.TEMPLATE}", code="TP-D001", path=str(self.path), hint="save the document"
+            )
+        old, new = _flat(json.loads(saved)), _flat(self._release.template(self._kind))
+        return tuple(
+            TemplateChange(key, old.get(key), new.get(key)) for key in sorted(old | new) if old.get(key) != new.get(key)
+        )
+
+
+def _flat(template: dict[str, Any]) -> dict[str, object]:
+    """The parts of a template state a release can change for a document, one entry each."""
+    return (
+        {
+            f"setting {file} {value}": line
+            for file, lines in template["settings"].items()
+            for value, line in lines.items()
+        }
+        | {f"default {name}": value for name, value in template["defaults"].items()}
+        | {f"sty {name}": digest for name, digest in template["sty"].items()}
+    )

texpkg/errors.py

@@ -0,0 +1,66 @@
+"""The errors of a package: a built-in base and a stable `.code` each (B11).
+
+No class is shared between packages (each wheel embeds its own copy of this module), so a consumer catches the built-in
+base (`ValueError`, `FileNotFoundError`) and reads `.code`, which is `TP-<area><nnn>` and never reused.
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .document import HandEdit
+    from .migration import Unresolved
+
+
+class TexpkgError(Exception):
+    """What every texpkg error carries: a stable code, where it happened and the fix."""
+
+    def __init__(self, message: str, *, code: str, path: str = "", hint: str = "") -> None:
+        super().__init__(message)
+        self.code = code
+        self.path = path
+        self.hint = hint
+
+
+class DeclarationError(TexpkgError, ValueError):
+    """A declaration (an asset, a layout, a kind, a distribution) is invalid."""
+
+
+class PayloadError(TexpkgError, FileNotFoundError):
+    """A payload that cannot be written whole: a source file is absent (A3)."""
+
+
+class NotADocumentError(TexpkgError, FileNotFoundError):
+    """The directory holds no readable document state (P27)."""
+
+
+class DocumentExistsError(TexpkgError, FileExistsError):
+    """`create` into a directory that already holds a document."""
+
+
+class KindMismatchError(TexpkgError, ValueError):
+    """A kind's `load` of a directory that holds another kind's document, or another package's (K3)."""
+
+    def __init__(self, message: str, *, found: str, expected: str, path: str = "", hint: str = "") -> None:
+        super().__init__(message, code="TP-D003", path=path, hint=hint)
+        self.found = found
+        self.expected = expected
+
+
+class NewerDataError(TexpkgError, ValueError):
+    """Data written for a newer `data` version than this release reads (V14)."""
+
+
+class MigrationError(TexpkgError, ValueError):
+    """Adopting a release failed; nothing was returned or written (V31). `unresolved` lists what no migration placed."""
+
+    def __init__(self, message: str, *, code: str, unresolved: "tuple[Unresolved, ...]" = (), hint: str = "") -> None:
+        super().__init__(message, code=code, hint=hint)
+        self.unresolved = unresolved
+
+
+class HandEditError(TexpkgError, ValueError):
+    """`save` found a `.tex` that differs from the plan of what was last written (D8). `edits` lists them."""
+
+    def __init__(self, message: str, *, edits: "tuple[HandEdit, ...]", hint: str = "") -> None:
+        super().__init__(message, code="TP-D005", hint=hint)
+        self.edits = edits

texpkg/layout.py

@@ -0,0 +1,48 @@
+"""The layout (A2): where a payload file goes under a document directory, and the preamble lines that find it (A5).
+
+Policy over `texmodel.bundle`, which decides nothing about placement. There is one layout, `LAYOUT`, for every
+distribution: a package built on another writes into the same directory, which the one set of preamble lines finds.
+"""
+
+import dataclasses
+import pathlib
+
+from texmodel.package import PreambleSlots
+from texmodel.preamble import GraphicsPath, InputPath
+
+from .assets import Role
+from .errors import DeclarationError
+
+
+@dataclasses.dataclass(frozen=True)
+class Project:
+    """`.sty`, graphics and notes in `dir`; fonts at the root, since luaotfload reads no document-side search path;
+    `BY_PATH` at its own path."""
+
+    dir: pathlib.PurePosixPath
+
+    def __post_init__(self) -> None:
+        if not self.dir.parts or self.dir.is_absolute() or ".." in self.dir.parts or "." in self.dir.parts:
+            raise DeclarationError(
+                f"layout directory {str(self.dir)!r}: not a relative directory inside the document",
+                code="TP-A003",
+                hint="e.g. Project(PurePosixPath('res/acme'))",
+            )
+
+    def place(self, role: Role, path: pathlib.PurePosixPath) -> pathlib.PurePosixPath:
+        match role:
+            case Role.BY_PATH:
+                return path
+            case Role.FONT:
+                return pathlib.PurePosixPath(path.name)
+            case Role.PACKAGE | Role.GRAPHIC | Role.NOTE:
+                return self.dir / path.name
+
+    def preamble(self) -> PreambleSlots:
+        return PreambleSlots(before_package=(InputPath(f"{self.dir}/"),), after_package=(GraphicsPath(f"{self.dir}/"),))
+
+    def owned(self) -> tuple[str, ...]:
+        return (f"{self.dir}/**/*",)
+
+
+LAYOUT = Project(pathlib.PurePosixPath("res/texpkg"))

texpkg/migration.py

@@ -0,0 +1,73 @@
+"""Migrations: one API whoever writes them (V32): the build derives some, a kind lists some, a consumer passes some.
+
+A migration is a function over plain data, from the stored state of `data` version `to - 1` to `to` (V28); what it
+cannot place it leaves unresolved, never guessed (V15).
+"""
+
+import dataclasses
+import enum
+from collections.abc import Callable, Sequence
+from typing import Any
+
+from .errors import DeclarationError
+
+
+@enum.unique
+class DefaultChange(enum.StrEnum):
+    """What a consumer does when a release changes a default that a stored document still marks as default (V23). A
+    `StrEnum`, so one package's value equals another's (B11)."""
+
+    FOLLOW = "follow"  # the marked value moves to the new default
+    FREEZE = "freeze"  # it keeps the old value, which stops being marked
+    ASK = "ask"  # adoption aborts with each changed default as an unresolved item
+
+
+@dataclasses.dataclass(frozen=True)
+class Unresolved:
+    """What no migration placed: the data path, why, and the old value. texpkg fills `schema` (the new schema at that
+    path) and `boundary` (`"4 -> 5"`) when it reports."""
+
+    path: str
+    reason: str
+    value: object = None
+    schema: dict[str, Any] = dataclasses.field(default_factory=dict[str, Any])
+    boundary: str = ""
+
+
+@dataclasses.dataclass(frozen=True)
+class Migrated:
+    """A migration's result: the state, and what it left unresolved."""
+
+    state: dict[str, Any]
+    unresolved: Sequence[Unresolved] = ()
+
+
+type MigrationFunction = Callable[[dict[str, Any]], Migrated]
+
+
+@dataclasses.dataclass(frozen=True)
+class Migration:
+    """A function from `data` version `to - 1` to `to`; make one with `@migration(to=N)`."""
+
+    to: int
+    function: MigrationFunction
+
+    def __post_init__(self) -> None:
+        if self.to < 2:
+            raise DeclarationError(
+                f"migration(to={self.to}): `data` version 1 is the first, so a migration goes to 2 or later",
+                code="TP-M001",
+                hint="@migration(to=N) migrates from `data` version N - 1 to N",
+            )
+
+    def __call__(self, state: dict[str, Any]) -> Migrated:
+        return self.function(state)
+
+
+def migration(*, to: int) -> Callable[[MigrationFunction], Migration]:
+    """`@migration(to=5)`: from `data` version 4 to 5."""
+
+    def wrap(function: MigrationFunction) -> Migration:
+        return Migration(to, function)
+
+    return wrap

texpkg/protocol.py

@@ -0,0 +1,61 @@
+"""The fixed surface of a built package (P6), as protocols: the build generates a module to satisfy them and checks it
+does, and a consumer's type checker reads the generated module's own types."""
+
+import datetime
+import pathlib
+from collections.abc import Mapping, Sequence
+from typing import Any, Literal, Protocol, runtime_checkable
+
+from .contracts import Changes, Contracts
+from .document import Document
+from .migration import DefaultChange, Migration
+
+
+@runtime_checkable
+class KindModule(Protocol):
+    """`acme_tex.kinds.expert`: besides these, the kind's own classes (P24)."""
+
+    @property
+    def NAME(self) -> str: ...  # noqa: N802
+    def load(
+        self,
+        path: pathlib.Path | str,
+        *,
+        migrations: Sequence[Migration] = (),
+        default_changes: DefaultChange | Mapping[str, DefaultChange] = DefaultChange.FOLLOW,
+    ) -> Document[Any]: ...
+    def create(self, path: pathlib.Path | str, tree: Any) -> Document[Any]: ...  # noqa: ANN401  # the kind's root class
+    def schema(self, mode: Literal["validation", "serialization"] = "validation") -> dict[str, Any]: ...
+    def example(self) -> Any: ...  # noqa: ANN401  # the kind's root class
+    def variants(self) -> tuple[str, ...]: ...
+    def changes(self, old: int, new: int) -> Changes: ...
+
+
+@runtime_checkable
+class KindsModule(Protocol):
+    """`acme_tex.kinds`."""
+
+    def names(self) -> tuple[str, ...]: ...
+    def modules(self) -> Mapping[str, KindModule]: ...
+
+
+@runtime_checkable
+class PackageModule(Protocol):
+    """`acme_tex`."""
+
+    @property
+    def __version__(self) -> str: ...
+    @property
+    def CONTRACTS(self) -> Contracts: ...  # noqa: N802
+    @property
+    def kinds(self) -> KindsModule: ...
+    def export(
+        self, dest: pathlib.Path | str, *, now: datetime.datetime | None = None, stamp: str | None = None
+    ) -> tuple[pathlib.Path, ...]: ...
+    def load(
+        self,
+        path: pathlib.Path | str,
+        *,
+        migrations: Sequence[Migration] = (),
+        default_changes: DefaultChange | Mapping[str, DefaultChange] = DefaultChange.FOLLOW,
+    ) -> Document[Any]: ...

texpkg/provenance.py

@@ -0,0 +1,61 @@
+"""The provenance file: what a document directory was materialised from and when (V2, V34).
+
+`save` writes `<package>-provenance.sty` for every package of the stack, the only payload file that holds a time. A
+document can print what it was built from with `\\<prefix>ProvenanceInfo`, and the PDF carries the same text.
+"""
+
+import dataclasses
+import datetime
+import pathlib
+from typing import TYPE_CHECKING
+
+from ._internal import directory, provenance_tex
+from .errors import DeclarationError
+
+if TYPE_CHECKING:
+    from ._internal.release import Release
+
+
+@dataclasses.dataclass(frozen=True)
+class Provenance:
+    stamp: str
+    time: str
+
+
+def stamp_of(stamp: str | None, release: "Release") -> str:
+    """The stamp a save or a check uses: the consumer's (V4, e.g. `1.2.0-3f9c2ab-dirty`), else the release's version."""
+    chosen = release.version if stamp is None else stamp
+    if not provenance_tex.STAMP.fullmatch(chosen):
+        raise DeclarationError(
+            f"stamp {chosen!r}: letters, digits and . + : / @ - and space only",
+            code="TP-D006",
+            hint="it is printed on the page and written into the PDF's metadata, so it has to be the same text in both",
+        )
+    return chosen
+
+
+def time_of(now: datetime.datetime | None) -> str:
+    """`now` in UTC, or the clock's. This is the one place texpkg reads the clock (N4): a caller that wants the
+    time pinned passes `now`."""
+    moment = now or datetime.datetime.now(datetime.UTC)
+    if moment.tzinfo is not None:
+        moment = moment.astimezone(datetime.UTC)
+    return moment.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def files(release: "Release", stamp: str, time: str) -> dict[str, str]:
+    """The provenance file of every package in the stack, by file name."""
+    return {
+        provenance_tex.file_name(r.dist.package.name): provenance_tex.companion(
+            r.dist.package.prefix, r.dist.package.name, r.version, stamp, time
+        )
+        for r in release.releases()
+    }
+
+
+def saved(root: pathlib.Path, release: "Release") -> Provenance | None:
+    """The stamp and time of the top package's provenance file in `root`; `None` if it is not there."""
+    text = directory.read(root, release.layout_path(provenance_tex.file_name(release.dist.package.name)))
+    if text is None:
+        return None
+    return Provenance(*provenance_tex.read(text, release.dist.package.prefix))

texpkg-0.1.0.dist-info/METADATA

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: texpkg
+Version: 0.1.0
+Summary: LaTeX package management.
+Author-Email: Ilja Orlovs <ilja@release.art>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Typing :: Typed
+Project-URL: Homepage, https://github.com/release-art/texpkg
+Project-URL: Repository, https://github.com/release-art/texpkg
+Requires-Python: <3.16,>=3.15
+Requires-Dist: texmodel>=0.4.0
+Requires-Dist: pydantic>=2.14.1
+Provides-Extra: build
+Requires-Dist: typer>=0.27.3; extra == "build"
+Requires-Dist: pdm-backend>=2.4; extra == "build"
+Description-Content-Type: text/markdown
+
+# texpkg
+
+LaTeX package management.
+
+```zsh
+pdm install
+git config core.hooksPath .githooks   # pre-commit runs ruff and pyright
+bin/autoformat.sh
+bin/test.sh                           # pytest, 100% coverage gate
+```

texpkg-0.1.0.dist-info/RECORD

@@ -0,0 +1,41 @@
+texpkg-0.1.0.dist-info/METADATA,sha256=acTlQL8FfOd65nsz51ps3DQfndOYpkKIIMrXuJ97HuM,894
+texpkg-0.1.0.dist-info/WHEEL,sha256=IuIk3wbaEnFH1cx75iM2R1CmliRI3dFLXTbRakgvgFQ,90
+texpkg-0.1.0.dist-info/entry_points.txt,sha256=oUqhd04qxoHQRBgbkHgEIQj5UnlKkvyrTbsBMpS-s-8,70
+texpkg-0.1.0.dist-info/licenses/LICENSE,sha256=URgqTzVBt4gXkRH2QdXRAmSR42oS1Vziq6C60LxzAoc,1068
+texpkg/__init__.py,sha256=ERXQOzGTJDCMgjbB-2arlapJhxkN5xv7A7HCk2SsNZM,434
+texpkg/_internal/__init__.py,sha256=wuskjiFnpPCgptbkhCFXj0_z2Dl6TWm8mhNLbuFoWMw,60
+texpkg/_internal/adopt.py,sha256=En46yS0EDSW8Br4pgA_7g-o5ATeSp8x7qcEX_HQDVrM,5378
+texpkg/_internal/classify.py,sha256=Uxs-2D4C0KiKGuYofEEs1QltopSi80TZcAqqBQwrCQU,9147
+texpkg/_internal/directory.py,sha256=ewOgbesT2Dt6Ery_AvKj8gfDS2EP3xPYnJuFgpfQT_0,2015
+texpkg/_internal/envelope.py,sha256=SLj0leS-RGuDgl7KmD7xpTfvT6xf6Ux25sqRpwzucBQ,1243
+texpkg/_internal/export.py,sha256=chzZYnM9Pn1eUemaN883AGAczvd5YU8c5yLXFjlJ3sw,2313
+texpkg/_internal/handedits.py,sha256=YALsA0bdUhjE56_zI3Jh2YZy4owoKtHVvfAEIn8tJwo,1413
+texpkg/_internal/history.py,sha256=gsxIOcC83wcV-Wea11EAz02rFcQU6ITSt1E7or-a8xs,3829
+texpkg/_internal/payload.py,sha256=rjjp-uT62ElSTyvmAJ_uvIw6SaE7Vaf-_qknaIJu5sY,5114
+texpkg/_internal/provenance_tex.py,sha256=bWidYrA7XrVL8ozYqz08p1rPfuhlmpWUkxHjAghpAx8,3007
+texpkg/_internal/release.py,sha256=NFDnXXG922HEqa4pSlvI3dIR5gwDbm1inIhdlTaGevY,11960
+texpkg/_internal/snapshots.py,sha256=p0LYdyRcDm-mwhqqsGRczk36UKajwoowzPpGvq6EX0A,2580
+texpkg/_internal/state.py,sha256=37vchgRcVF2KyLx1ds4btiF692sGdSroTTSKRp_W5_Y,4942
+texpkg/_internal/versions.py,sha256=r3F6B76IdtQpGOUFm56i-lJJA2nIXEAsIA93tWpC34Y,2970
+texpkg/assets.py,sha256=Qsv1P5cuBeT7CWdDfNCR9qv99pLIO-6MxZBh1ckqNFg,2105
+texpkg/contracts.py,sha256=3owxcK7FP2G7AZxx-ZozpeaEAnnWNzJrfhng4sG6D9g,1578
+texpkg/declaration.py,sha256=M0ihNSPhNqnYQDArEyFdrzy8PXFOhE8sp5HJZTFRxWU,17475
+texpkg/document.py,sha256=VK5_5R7o5OLLyOQb3f6undOOXtDVQNU9Ihpk7t7y45s,9718
+texpkg/errors.py,sha256=MZWkM8MeNo8-hPlOO4yeagPhpafWMQkTnI4lkO_l-hg,2523
+texpkg/layout.py,sha256=-7nymRjX9kUvcbWSRdwn1-83zkHcOGHnvMy_j5RTZic,1822
+texpkg/migration.py,sha256=m3OY6DYFtY9smB5G03iZxZ9uPCGznCSDjIHrNRm6s84,2406
+texpkg/protocol.py,sha256=1zJiMPvTjxk9C_PhgdYrUYueX4PV1OFWUOl5LIb9Bfw,2124
+texpkg/provenance.py,sha256=9uAIcSQA124HuihuD0iuMJX-aGfvcxctZQoq-gGvCK4,2386
+texpkg/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+texpkg_build/__init__.py,sha256=XUHwnmcgvNpiN9bcsaTgnxieq0SJ-APAReLLU_1KYpA,69
+texpkg_build/_internal/__init__.py,sha256=EOIj7Sj8W9wJiKcplrtfUeyM-olcY6ctjvZzXwQlwbg,57
+texpkg_build/_internal/checks.py,sha256=1fHGHJZiRgYTrp-h-6gn9QaQpt7AZvZoMl9gyPGvDaU,7000
+texpkg_build/_internal/embed.py,sha256=AFholRjHQQDX4ivERetaR3Y1uFWFxBXPyCwdqy8ZbbI,12161
+texpkg_build/_internal/generate.py,sha256=Vm87ZITxCV3gjIvKYKgeOnVwtHIUCOU-n-GRyWXtyoQ,10000
+texpkg_build/_internal/isolate.py,sha256=BLxYvUbZ3UzACCEkPDo6oilxV-mbUug158ri7zajNK8,3659
+texpkg_build/_internal/snapshot.py,sha256=sy0e6e48jT5HV3onjvZcCs-vehY0cCokznqHgPlQAsk,14085
+texpkg_build/cli.py,sha256=C_vW1kZTrpQWSY-ihUYdW5GXFICrQVKczW1tGPbUL-Q,3917
+texpkg_build/hook.py,sha256=M4Pj1Jsln4WyugyOiJ0miWqXXgR0qPn0FXZCOD0_Tyw,3415
+texpkg_build/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+texpkg_build/testing.py,sha256=R4yZdB31nrNMo7jFDSPr34hdZQupt6ay_62WsgazNtY,8563
+texpkg-0.1.0.dist-info/RECORD,,

texpkg-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: pdm-backend (2.5.0)
+Root-Is-Purelib: true
+Tag: py3-none-any

texpkg-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+texpkg-build = texpkg_build.cli:app
+
+[gui_scripts]
+

texpkg-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ilja Orlovs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

texpkg_build/__init__.py

@@ -0,0 +1 @@
+"""The build of a texpkg package (never embedded in a wheel, B8)."""

texpkg_build/_internal/__init__.py

@@ -0,0 +1 @@
+"""The internal modules of the build: not public API."""