doc-control 0.0.1.dev0__py3-none-any.whl

doc_control/safety/verify.py

@@ -0,0 +1,357 @@
+"""Write a document through the safety pipeline: back up, write, verify, auto-restore.
+
+A write runs five stages, each a seam for fault injection (``backup``,
+``temp_write``, ``fsync``, ``replace``, ``verify``). The document itself is only
+touched by the atomic replace, so a failure before it leaves the original
+alone; a failure at or after it (including a verification that finds a change
+outside the declared footprint) puts the backup back with the same atomic
+replace. Either way the caller gets ``VERIFY_FAILED_RESTORED`` and the original
+bytes, never a half-written file.
+
+The restore never destroys anyone else's work. Just before the replace the
+document is re-checked (lock file, sha256), and it is put back only if it is
+missing or holds exactly the bytes we wrote: our own replace swaps in a fully
+fsynced temp file atomically, so it can never leave a torn copy, and an empty or
+partial file is another program mid-save. If anything else is on disk (Word or
+a sync client saved in between), that file is left in place, a copy of it is
+saved in the backups folder as
+``foreign-<sha8>-<UTC stamp>.docx`` (a name retention never prunes) and the
+error is ``DOC_CHANGED_ON_DISK``. Reads of the document are retried briefly on
+``PermissionError``, as antivirus scanners on Windows hold files for a moment.
+
+Unavoidable race: between the restore's last read of the document and its
+replace another program can still save, and that save is lost; the window is
+one read and one rename.
+
+Known gap: a process killed between the replace and the verification leaves
+the new file on disk with no marker saying it was never verified; the backup
+taken before it is the way back.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import time
+import xml.etree.ElementTree as ET
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import TypeVar
+
+from doc_control.errors import DocControlError, ErrorCode
+from doc_control.ooxml.splice import scan
+from doc_control.ooxml.zipio import (
+    Package,
+    build_package,
+    commit_bytes,
+    restore_file,
+    sha256_file,
+)
+from doc_control.safety import guard_write
+from doc_control.safety.lock import check_unlocked
+from doc_control.safety.store import store_dir
+
+DOCUMENT_PART = "word/document.xml"
+STAGES = ("backup", "temp_write", "fsync", "replace", "verify")
+_READ_RETRY_DELAYS = (0.05, 0.1, 0.2)
+_T = TypeVar("_T")
+
+
+@dataclass(frozen=True)
+class Footprint:
+    """What a write is allowed to change.
+
+    ``replaced`` are the indices (in the original ``word/document.xml``) of
+    paragraphs that are rewritten or deleted, ``inserted_after`` those after
+    which new paragraphs land (``-1``: at the start of the body), ``inserted_before``
+    those before which new paragraphs land. ``parts`` are
+    the other zip members that may change or be created; every member not
+    listed is checked byte for byte, header fields included.
+    """
+
+    replaced: frozenset[int] = frozenset()
+    inserted_after: frozenset[int] = frozenset()
+    parts: frozenset[str] = frozenset()
+    inserted_before: frozenset[int] = frozenset()
+
+
+@dataclass(frozen=True)
+class WriteResult:
+    before_sha256: str
+    after_sha256: str
+    backup: Path
+
+
+class _FootprintViolation(Exception):
+    def __init__(self, message: str, problems: list[str]) -> None:
+        super().__init__(message)
+        self.problems = problems
+
+
+def verify_footprint(original: Package, result: Package, footprint: Footprint) -> list[str]:
+    """Problems found comparing ``result`` with ``original``; empty means all is as declared."""
+    problems: list[str] = []
+    before, after = original.names, result.names
+    if after[: len(before)] != before:
+        problems.append("zip member names or order changed")
+    added = [n for n in after[len(before) :] if n not in footprint.parts]
+    if added:
+        problems.append(f"members added outside the footprint: {', '.join(added)}")
+    if result.comment != original.comment:
+        problems.append("zip comment changed")
+    for name in before:
+        if name == DOCUMENT_PART or name not in result:
+            continue
+        if name not in footprint.parts and result.fingerprint(name) != original.fingerprint(name):
+            problems.append(f"member changed outside the footprint: {name}")
+    if DOCUMENT_PART in result:
+        problems.extend(_document_problems(original, result, footprint))
+    for name in after:
+        if (
+            name != DOCUMENT_PART
+            and name.endswith((".xml", ".rels"))
+            and _changed(original, result, name)
+        ):
+            try:
+                ET.fromstring(result.read(name))
+            except ET.ParseError as exc:
+                problems.append(f"{name} does not parse: {exc}")
+    return problems
+
+
+def _changed(original: Package, result: Package, name: str) -> bool:
+    return name not in original or original.read(name) != result.read(name)
+
+
+def _document_problems(original: Package, result: Package, footprint: Footprint) -> list[str]:
+    old, new = original.read(DOCUMENT_PART), result.read(DOCUMENT_PART)
+    try:
+        spans = scan(old)
+        scan(new)
+        ET.fromstring(new)
+    except (DocControlError, ET.ParseError) as exc:
+        return [f"{DOCUMENT_PART} does not parse: {exc}"]
+    cuts: list[tuple[int, int]] = []
+    for i in footprint.replaced:
+        if not 0 <= i < len(spans.paragraphs):
+            return [f"footprint names paragraph {i}, but the document has {len(spans.paragraphs)}"]
+        cuts.append((spans.paragraphs[i].start, spans.paragraphs[i].end))
+    for i in footprint.inserted_after:
+        if i == -1 and spans.body_content is not None:
+            cuts.append((spans.body_content, spans.body_content))
+        elif 0 <= i < len(spans.paragraphs):
+            cuts.append((spans.paragraphs[i].end, spans.paragraphs[i].end))
+        else:
+            return [f"footprint inserts after paragraph {i}, which does not exist"]
+    for i in footprint.inserted_before:
+        if not 0 <= i < len(spans.paragraphs):
+            return [f"footprint inserts before paragraph {i}, which does not exist"]
+        cuts.append((spans.paragraphs[i].start, spans.paragraphs[i].start))
+    # Everything between the touched spans must reappear, in order, in the result.
+    gaps: list[bytes] = []
+    pos = 0
+    for start, end in sorted(cuts):
+        if start >= pos:
+            gaps.append(old[pos:start])
+            pos = end
+        else:
+            pos = max(pos, end)  # nested or overlapping spans: one touched region
+    gaps.append(old[pos:])
+    if _gaps_match(gaps, new):
+        return []
+    return [f"{DOCUMENT_PART} changed outside the declared paragraphs"]
+
+
+def _gaps_match(gaps: list[bytes], new: bytes) -> bool:
+    if len(gaps) == 1:
+        return new == gaps[0]
+    first, last = gaps[0], gaps[-1]
+    if not (new.startswith(first) and new.endswith(last)):
+        return False
+    pos, end = len(first), len(new) - len(last)
+    if end < pos:
+        return False
+    for gap in gaps[1:-1]:
+        at = new.find(gap, pos, end)
+        if at < 0:
+            return False
+        pos = at + len(gap)
+    return True
+
+
+def write_verified(
+    doc_path: Path,
+    replacements: Mapping[str, bytes],
+    footprint: Footprint,
+    expect_sha256: str | None = None,
+    *,
+    now: datetime | None = None,
+    env: Mapping[str, str] | None = None,
+    stage: Callable[[str], None] | None = None,
+) -> WriteResult:
+    """Apply ``replacements`` to ``doc_path`` and verify the result against ``footprint``.
+
+    Errors raised by the checks around the backup (``DOC_NOT_FOUND``,
+    ``DOC_LOCKED``, ``DOC_CHANGED_ON_DISK``, ``SCHEMA_INVALID``, ``INTERNAL``)
+    and by the re-check just before the replace pass through unchanged, with
+    the document untouched; so does ``DOC_LOCKED`` when the replace is still
+    denied after its retry. After that any failure, whatever the stage, puts
+    the original back if the document was touched (see the module docstring for
+    when it is not) and raises ``VERIFY_FAILED_RESTORED`` naming the stage. If
+    the restore cannot be confirmed byte for byte the error is ``INTERNAL`` and
+    names the backup; an interrupt is re-raised with that error as its cause.
+    ``stage``, if given, is called with each name in ``STAGES`` just before that
+    step runs: tests raise from it to inject a fault.
+    """
+    for name, data in replacements.items():
+        if not isinstance(data, bytes):
+            raise TypeError(f"replacement for {name} must be bytes")
+    current = "backup"
+    touched = False  # the replace may have happened: the document can differ from the original
+    backup_path: Path | None = None
+    created_backup = False  # this call made the file, so it may delete it
+    original_sha = ""
+    payload = b""
+
+    def mark(name: str) -> None:
+        nonlocal current, touched
+        current = name
+        if stage is not None:
+            stage(name)
+        if name == "replace":
+            check_unlocked(doc_path)
+            _check_unchanged(doc_path, original_sha)
+            touched = True
+
+    try:
+        mark("backup")
+        known = _existing_backups(doc_path, env)
+        backup_path = guard_write(doc_path, expect_sha256, now=now, env=env)
+        created_backup = backup_path not in known
+        pkg = Package(doc_path)
+        if sha256_file(backup_path) != pkg.sha256:
+            if created_backup:
+                backup_path.unlink(missing_ok=True)  # a torn copy is no backup
+            backup_path = None
+            raise DocControlError(
+                ErrorCode.DOC_CHANGED_ON_DISK,
+                f"{doc_path.name} changed on disk while it was backed up",
+                path=str(doc_path),
+            )
+        original_sha = pkg.sha256
+        payload = build_package(pkg, replacements)
+        after_sha = hashlib.sha256(payload).hexdigest()
+        commit_bytes(payload, doc_path, mark)
+        mark("verify")
+        if _retry(sha256_file, doc_path) != after_sha:
+            raise OSError(f"{doc_path.name} does not hold the bytes that were written")
+        problems = verify_footprint(pkg, _retry(Package, doc_path), footprint)
+        if problems:
+            raise _FootprintViolation("; ".join(problems), problems)
+    except BaseException as exc:
+        if touched and backup_path is not None:
+            try:
+                _restore(doc_path, backup_path, original_sha, payload)
+            except DocControlError as restore_error:
+                if isinstance(exc, Exception):
+                    raise restore_error from exc
+                raise exc from restore_error
+        if not isinstance(exc, Exception):
+            raise
+        if isinstance(exc, DocControlError) and current in ("backup", "replace"):
+            raise  # a refusal before anything was written: nothing to restore, nothing to wrap
+        if current == "replace" and isinstance(exc, PermissionError):
+            raise DocControlError(
+                ErrorCode.DOC_LOCKED,
+                f"could not replace {doc_path.name}, it is held open: {exc}",
+                path=str(doc_path),
+            ) from exc
+        raise DocControlError(
+            ErrorCode.VERIFY_FAILED_RESTORED,
+            f"write failed at stage {current}, original kept: {exc}",
+            stage=current,
+            path=str(doc_path),
+            cause=f"{type(exc).__name__}: {exc}",
+            **({"problems": exc.problems} if isinstance(exc, _FootprintViolation) else {}),
+        ) from exc
+    return WriteResult(original_sha, after_sha, backup_path)
+
+
+def _existing_backups(doc_path: Path, env: Mapping[str, str] | None) -> set[Path]:
+    try:
+        return set((store_dir(doc_path, env) / "backups").iterdir())
+    except OSError:
+        return set()
+
+
+def _retry(read: Callable[[Path], _T], path: Path) -> _T:
+    """``read(path)``, retried a few times on ``PermissionError`` (a scanner holding the file)."""
+    for delay in _READ_RETRY_DELAYS:
+        try:
+            return read(path)
+        except PermissionError:
+            time.sleep(delay)
+    return read(path)
+
+
+def _check_unchanged(doc_path: Path, original_sha: str) -> None:
+    actual = _retry(sha256_file, doc_path)
+    if actual != original_sha:
+        raise DocControlError(
+            ErrorCode.DOC_CHANGED_ON_DISK,
+            f"{doc_path.name} changed on disk while the write was prepared",
+            path=str(doc_path),
+            expected_sha256=original_sha,
+            actual_sha256=actual,
+        )
+
+
+def _restore(doc_path: Path, backup_path: Path, original_sha: str, written: bytes) -> None:
+    """Put the backup back if the document is missing or exactly what we wrote.
+
+    Anything else (an empty or partial file included) was saved by someone else
+    since our replace: leave it, keep a copy of it in the backups folder and raise
+    ``DOC_CHANGED_ON_DISK``.
+    """
+
+    def internal(why: str) -> DocControlError:
+        return DocControlError(
+            ErrorCode.INTERNAL,
+            f"{why} {doc_path.name}; the original is at {backup_path}",
+            path=str(doc_path),
+            backup=str(backup_path),
+        )
+
+    try:
+        current: bytes | None = _retry(Path.read_bytes, doc_path)
+    except FileNotFoundError:
+        current = None
+    except OSError as exc:
+        raise internal("could not inspect") from exc
+    if current is not None:
+        digest = hashlib.sha256(current).hexdigest()
+        if digest == original_sha:
+            return
+        if digest != hashlib.sha256(written).hexdigest():
+            stamp = datetime.now(UTC).strftime("%Y%m%dT%H%M%SZ")
+            copy = backup_path.parent / f"foreign-{digest[:8]}-{stamp}.docx"
+            try:
+                commit_bytes(current, copy, None)
+            except OSError as exc:
+                raise internal("could not save a copy of the newer") from exc
+            raise DocControlError(
+                ErrorCode.DOC_CHANGED_ON_DISK,
+                f"{doc_path.name} was saved by another program during the write; "
+                "it was left as it is and a copy was kept",
+                path=str(doc_path),
+                saved_copy=str(copy),
+                actual_sha256=digest,
+            )
+    try:
+        restore_file(backup_path, doc_path)
+        restored = _retry(sha256_file, doc_path) == original_sha
+    except OSError as exc:
+        raise internal("could not restore") from exc
+    if not restored:
+        raise internal("could not restore")

doc_control/schema.py

@@ -0,0 +1,143 @@
+"""A small JSON Schema subset validator (stdlib only).
+
+Supported keywords: type, properties, required, additionalProperties (bool),
+enum, items, minimum, maximum, minLength, description, default.
+`check_schema` verifies a schema uses only that subset, correctly; `validate`
+checks a value against a schema that passed it.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+from doc_control.errors import DocControlError, ErrorCode
+
+_TYPES: dict[str, tuple[type, ...]] = {
+    "object": (dict,),
+    "array": (list,),
+    "string": (str,),
+    "integer": (int,),
+    "number": (int, float),
+    "boolean": (bool,),
+    "null": (type(None),),
+}
+
+_KEYWORDS = frozenset(
+    {
+        "type",
+        "properties",
+        "required",
+        "additionalProperties",
+        "enum",
+        "items",
+        "minimum",
+        "maximum",
+        "minLength",
+        "description",
+        "default",
+    }
+)
+
+
+def check_schema(schema: Any, path: str = "$") -> list[str]:
+    """Return every way `schema` strays from the supported subset; [] means well formed."""
+    if not isinstance(schema, dict):
+        return [f"{path} must be a schema object"]
+    problems = [f"{path}.{k} is not a supported keyword" for k in schema if k not in _KEYWORDS]
+    if "type" in schema:
+        t = schema["type"]
+        names = t if isinstance(t, list) else [t]
+        if not names or not all(isinstance(n, str) and n in _TYPES for n in names):
+            problems.append(f"{path}.type must name known types: {sorted(_TYPES)}")
+    props = schema.get("properties", {})
+    if not isinstance(props, dict):
+        problems.append(f"{path}.properties must be an object")
+        props = {}
+    for key, sub in props.items():
+        problems += check_schema(sub, f"{path}.properties.{key}")
+    if "required" in schema:
+        req = schema["required"]
+        if not isinstance(req, list) or not all(isinstance(r, str) for r in req):
+            problems.append(f"{path}.required must be a list of property names")
+        else:
+            problems += [f"{path}.required names undeclared {r!r}" for r in req if r not in props]
+    if "additionalProperties" in schema and not isinstance(schema["additionalProperties"], bool):
+        problems.append(f"{path}.additionalProperties must be true or false")
+    if "enum" in schema and not (isinstance(schema["enum"], list) and schema["enum"]):
+        problems.append(f"{path}.enum must be a non-empty list")
+    if "items" in schema:
+        problems += check_schema(schema["items"], f"{path}.items")
+    for bound in ("minimum", "maximum"):
+        if bound in schema and not _is_finite_number(schema[bound]):
+            problems.append(f"{path}.{bound} must be a finite number")
+    if "minLength" in schema:
+        n = schema["minLength"]
+        if not isinstance(n, int) or isinstance(n, bool) or n < 0:
+            problems.append(f"{path}.minLength must be a non-negative integer")
+    if "description" in schema and not isinstance(schema["description"], str):
+        problems.append(f"{path}.description must be a string")
+    return problems
+
+
+def validate(value: Any, schema: dict[str, Any], path: str = "$") -> None:
+    """Raise SCHEMA_INVALID with the JSON path of the first violation."""
+    expected = schema.get("type")
+    names: list[str] = []
+    if expected is not None:
+        names = expected if isinstance(expected, list) else [expected]
+        ok = any(
+            isinstance(value, _TYPES[n])
+            and not (n in ("integer", "number") and isinstance(value, bool))
+            for n in names
+        )
+        if not ok:
+            _fail(path, f"expected {'/'.join(names)}")
+    numeric = bool({"integer", "number"} & set(names)) or "minimum" in schema or "maximum" in schema
+    if numeric and isinstance(value, float) and not math.isfinite(value):
+        _fail(path, "must be a finite number")
+    if "enum" in schema and not any(_json_equal(value, v) for v in schema["enum"]):
+        _fail(path, f"must be one of {schema['enum']}")
+    if isinstance(value, str) and len(value) < schema.get("minLength", 0):
+        _fail(path, f"shorter than {schema['minLength']}")
+    if isinstance(value, (int, float)) and not isinstance(value, bool):
+        if "minimum" in schema and value < schema["minimum"]:
+            _fail(path, f"below minimum {schema['minimum']}")
+        if "maximum" in schema and value > schema["maximum"]:
+            _fail(path, f"above maximum {schema['maximum']}")
+    if isinstance(value, dict):
+        props: dict[str, Any] = schema.get("properties", {})
+        for key in schema.get("required", []):
+            if key not in value:
+                _fail(f"{path}.{key}", "is required")
+        if schema.get("additionalProperties", True) is False:
+            for key in value:
+                if key not in props:
+                    _fail(f"{path}.{key}", "is not allowed")
+        for key, sub in props.items():
+            if key in value:
+                validate(value[key], sub, f"{path}.{key}")
+    if isinstance(value, list) and "items" in schema:
+        for i, item in enumerate(value):
+            validate(item, schema["items"], f"{path}[{i}]")
+
+
+def _json_equal(a: Any, b: Any) -> bool:
+    """JSON equality: booleans never equal numbers (Python's True == 1 does not apply)."""
+    if isinstance(a, bool) or isinstance(b, bool):
+        return isinstance(a, bool) and isinstance(b, bool) and a is b
+    if isinstance(a, list) and isinstance(b, list):
+        return len(a) == len(b) and all(_json_equal(x, y) for x, y in zip(a, b, strict=True))
+    if isinstance(a, dict) and isinstance(b, dict):
+        return a.keys() == b.keys() and all(_json_equal(a[k], b[k]) for k in a)
+    if isinstance(a, (list, dict)) or isinstance(b, (list, dict)):
+        return False
+    return bool(a == b)
+
+
+def _is_finite_number(x: Any) -> bool:
+    return isinstance(x, (int, float)) and not isinstance(x, bool) and math.isfinite(x)
+
+
+def _fail(path: str, why: str) -> None:
+    raise DocControlError(ErrorCode.SCHEMA_INVALID, f"{path} {why}", path=path)

doc_control-0.0.1.dev0.dist-info/METADATA

@@ -0,0 +1,62 @@
+Metadata-Version: 2.5
+Name: doc-control
+Version: 0.0.1.dev0
+Summary: Deterministic, LLM-first control of Word documents: addresses, anchors, tracked-change batches and a safety layer.
+License-Expression: Apache-2.0
+License-File: LICENSE
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# doc-control
+
+<p align="center">
+  <img src="docs/social-preview.png" width="100%" alt="doc-control: let AI agents edit Word documents safely. Deterministic .docx edits, every change a tracked change the writer can reject.">
+</p>
+
+> Status: **spec and plan approved** — implementation starting. See `status/specification.md` and `status/plan.md`.
+
+A deterministic tool that lets AI agents work on Word documents quickly,
+precisely and safely, ideally live in the Word window the writer has open.
+Every content change is a tracked change the writer can accept or reject.
+
+For anyone — writers and editors first — who wants an AI agent's help inside a
+Word document without a single silent change. Nothing to install yet; watch the
+repo for the first release.
+
+## Planned shape
+
+- **One core, two engines, one API**
+  - *File engine*: edits a closed `.docx` with the Python standard library only,
+    rewriting only the parts it touches.
+  - *Live engine*: controls the open Word (Windows/COM first, Mac later).
+- **Two front doors**: a CLI with JSON in/out, and an MCP server for Claude
+  Desktop / Cowork.
+- **Safety first**: lock-file and on-disk change detection, backup before every
+  write, verification, automatic restore, operation log with undo, and
+  `unintended_changes == 0` as a gate.
+- **No AI inside.** Judgment belongs to the agent; approval belongs to the writer.
+
+It will replace `docx-fixer`, whose rules become packs built on this tool, and
+serve `literary-critic` as its first downstream consumer.
+
+## Documents
+
+- [Initial research: tooling and risks](docs/research/01-tooling-and-risks.md)
+
+## Development
+
+This repo uses [claude-arsenal](https://github.com/nuncaeslupus/claude-arsenal)
+(spec-driven workflow, gated tasks in `arsenal/tasks/`). See `CLAUDE.md`.
+
+## Related projects
+
+Same author:
+
+- [claude-arsenal](https://github.com/nuncaeslupus/claude-arsenal) — a Claude Code skill and plugin marketplace: specs before code, failing tests first, gates with numbers.
+- [literary-critic](https://github.com/nuncaeslupus/literary-critic) — lets an LLM index, analyse and advise on a full novel manuscript the way a professional editor would; doc-control's first planned consumer.
+- [drawspec](https://github.com/nuncaeslupus/drawspec) — declarative diagram spec → clean, themeable SVG; JSON with no coordinates, so an LLM can write it.
+- [integral-job-search](https://github.com/nuncaeslupus/integral-job-search) — a candidate-centred job search run as a conversation in Claude Code.
+
+## License
+
+[Apache-2.0](LICENSE)

doc_control-0.0.1.dev0.dist-info/RECORD

@@ -0,0 +1,68 @@
+doc_control/__init__.py,sha256=qeouMpK38JthTURrrfta8tXSsJ9yqSSCE-SMaiZ_EG4,114
+doc_control/__main__.py,sha256=gUqz6_59npJrYQyKH7Mu4RFb3vatmSZcTeYKmXOaLBg,59
+doc_control/cli.py,sha256=y_u3sviedqmfMU3KFLGbEE6HgaQaXMqYV58CbnAHtsg,3027
+doc_control/envelope.py,sha256=Ycjy7a77cvR6e3tnUmzAYNjrTEwQFDurmyagAkC3roU,1089
+doc_control/errors.py,sha256=YTcvZknc03_7-NBbNK_1PZN586Ny0nSjBG2jLBoQ5To,3269
+doc_control/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+doc_control/registry.py,sha256=58p3zx7gk8OsjVst7pIFFdCq4FK9UdwE_IrQCBOwprQ,2051
+doc_control/schema.py,sha256=RGEx1evr-gtqCH44eqHMunJt7ewdmA4o4ZZJBc_Eebc,6083
+doc_control/model/__init__.py,sha256=g7XQUZZrGbpQAC_ZhtrljkAWqKnS-5Qz77CzEvTfhpY,65
+doc_control/model/address.py,sha256=nxB3RyWTShhUM7SSRHH_zBgsG0eQNE-1jTVSSNqscdQ,4129
+doc_control/model/align.py,sha256=Tt4BUhm0aOai3a2yTl2Pz0e2iwlsZ7tObSWrIhPS6Ug,23188
+doc_control/model/anchor.py,sha256=cDn3PugCyvga7Gc7y2G6J2sxQf_9bqRGISZOlDHR3_k,23691
+doc_control/model/annotations.py,sha256=0moNYUgn2-p_AgXotaH3Z-OLXSYMYxQm1o4SjQ2Dzfo,10315
+doc_control/model/document.py,sha256=i_9qCxylVjzCTGlUsLEvBjYo2MyAgkxfjPjpqeAZ490,4250
+doc_control/model/format.py,sha256=A-0KAHe7cm-ME8UIEN4GoS2GOlL0QY9JnqEvrm4-rh4,3632
+doc_control/model/index.py,sha256=g7vd47OMToy_Td0GEOON1F4BjY5W6zqa1be7mBn3e4o,14036
+doc_control/model/layout.py,sha256=E8X4OytzVfUXY-dPGpzZQuyoU_2CIWrvcijN1E_ptcQ,5623
+doc_control/model/normalized.py,sha256=1-19iKRFTPlvMECt-_XQNWJPHx1JzmQO6ZkxrO0Z8gE,6860
+doc_control/model/pages.py,sha256=MEUJU_uNve8XGj5MPR9hncjCj6zZMtxl-SxJe9x4V88,17225
+doc_control/model/parts.py,sha256=FXD9QJ3hijR7qcUSHaD2bdPm1ctsbl85vIQuRogcSW4,1843
+doc_control/model/search.py,sha256=m423tzX_N68clnQY23Xa6nAasIu4o1ayYw0sekvY7mI,16038
+doc_control/model/segment.py,sha256=kFFexKltyU5Qwy79HmTvNJEdYWji87Xr6Y_Ewx9pRIU,16601
+doc_control/model/structure.py,sha256=5HRtcFe_fXdkhXKUD0HGSfhyPybNn1a619GNHtgu50I,16065
+doc_control/model/styles.py,sha256=0fFi5QM30mw3Vfhxz7U_NzyPyH30AwAv_JL-jgitQAo,4934
+doc_control/ooxml/__init__.py,sha256=KsdBbl4PsKpGZrCErVJtvped_m9nFFJzD2OumuTnwrI,54
+doc_control/ooxml/commentparts.py,sha256=KoMcUrIUtjX-5WMmg-CTA4wk3ORe9drR0Hy5rPAx3Wc,27982
+doc_control/ooxml/formatting.py,sha256=TIl_Q7CUhUcjRQUylDcAsC7QN1-O5ylN6Tp9-YAO-48,6894
+doc_control/ooxml/resolve.py,sha256=Q2Tq5be6gd6uRbWiWeEkvspoA7J_RqVvqx2QFAgcFdU,9304
+doc_control/ooxml/revisions.py,sha256=eubBESd8fbqDzwFnPEjR2EcTR_DnnpFtu1xFQAzXTZA,41537
+doc_control/ooxml/splice.py,sha256=dtr24rIFgPROeLGCSMtBGVkIrmYCF2p46UNmKV0wFMk,38371
+doc_control/ooxml/styledef.py,sha256=k616LAfWS-zYkuQ8iBjMJ2KjS3kMqvLWlRsBnd1u78s,16334
+doc_control/ooxml/zipio.py,sha256=n_gYTPfnQeNZIyeO0rUiRetLIYzwi2xFd5Big_FaAho,15468
+doc_control/ops/__init__.py,sha256=NpPTBYBKUlCswx_bL0HOc2iSXMjX3jDWkUmoT2K2egI,66
+doc_control/ops/anchor.py,sha256=KFORs-Q9JE3avevinSQEMUrP2P6UL-Fcn9A-4mLqAZw,5087
+doc_control/ops/batch.py,sha256=vqzJdQIVOI_ETpL2C3Kx3RmEnZJjEoHSzlMEVlIm-pc,7607
+doc_control/ops/comments.py,sha256=RHaoLhbOrJ0WFx6neuFPyMxuIVRZmWVKjFLDjg4mS98,16197
+doc_control/ops/compare.py,sha256=r_Ef8VVgaDHprvlpRXnsGLFxbPxJDI2LUJ51nuOAxJc,23975
+doc_control/ops/diff.py,sha256=b74kw1nq7PEVRzZop8tQ9cQCU6C--hyRvQ9s5NGKDX8,7003
+doc_control/ops/dotx.py,sha256=izZ_je3rBu7lmYsEAEfqDIMLXXdVXeinBZqzlgzABMw,8518
+doc_control/ops/find.py,sha256=7KJ973Ib6DJZprlLJXyuQ4N-kFg0SKoTta36_jg9H6Q,7369
+doc_control/ops/history.py,sha256=6RkobVru-EiPtXLppeIxMFHhZcvNaG4RizT2sL1W3v4,18039
+doc_control/ops/layout.py,sha256=uQo0pXtBj6IpTA_n4ioiMUUbH5JZxnbQI3sS8TTqivo,1397
+doc_control/ops/locate.py,sha256=2nojJ6exFby6ibambgNtfuHhpHff_Jn1hWAYVjASk34,16172
+doc_control/ops/meta.py,sha256=VneIJjPh53Y_9ar1c65cKFBFamUGcuQXhf3aChwleo8,1618
+doc_control/ops/page.py,sha256=TTaN2gEh22aCk2o-MX9LZOWFn5Waq6v2g0WE4ZfIpQI,3613
+doc_control/ops/paging.py,sha256=qVwAG7kF0wNpJWjojzBiXqtCSkGspAXrzodxbQcp2_g,4364
+doc_control/ops/read.py,sha256=0So4DlIO1uMNWT_4IjPRPEz3CG4gaL9G0VS_qB1UeS0,18359
+doc_control/ops/recipe.py,sha256=CdcpDwepD7tgT9WirJL9vYfrAR_hK0DXOsowB9EqbRw,3836
+doc_control/ops/rename.py,sha256=IQoRrO4GC-_zVJybbhMd4ZSna42x10-vA5oIXle3a2I,14275
+doc_control/ops/revision.py,sha256=fsw2gTuJaRGbk8betOqaOhyzc75UkVWG3EWZD6rkjxY,23265
+doc_control/ops/segment.py,sha256=AAQ1Nxo2R3Wm84NLrgv4h9beZfcNC4R07YY1Qk5wegM,10106
+doc_control/ops/styleset.py,sha256=hXOOgCtw8WYkfj8nlUSzGPuuoIhIoB1wC2q2kLf72Q4,10272
+doc_control/ops/stylewrite.py,sha256=yfFWu1R0N4i0MudBNFwQ7sXllEK8IEmWdq20Yk2umpQ,21996
+doc_control/ops/text.py,sha256=YUGcIzWj5sqnCiJ5oTv9CKmmT2xcQSqbOIm8V0853mA,8380
+doc_control/ops/tracked.py,sha256=H95fW1PfEF7xPHMHydws5_mAGJ1BYPX1dFwhxBHxu7o,57032
+doc_control/recipes/engine.py,sha256=2dmAeipkBsvEXEk2SMb5H7yYRmf48n35-_rnviJJyq4,8100
+doc_control/recipes/schema.py,sha256=unwhGaTS3W2VBbfiadj-mnuTtvbzQybRJVh147yuG-4,5715
+doc_control/recipes/store.py,sha256=YmBGkCDRoGEa87H-bfeWuaTT5C1VZ3CqIRhOVELX6Ls,3492
+doc_control/safety/__init__.py,sha256=uAUFcCESkj6jYhkbEl4WLkTUgbBrJAkniSEQUpGCf_8,1415
+doc_control/safety/history.py,sha256=ZST9xDoWCla2cZIG3hj1Se2JDmQqxAHppgqj7JtmTF4,17793
+doc_control/safety/lock.py,sha256=cg-qXq-LNZkvz68rp5S24AtsQpM_f4zI6iad17v4tKY,2556
+doc_control/safety/store.py,sha256=9Cmf8Hi7Ftqo4GzMyIA-8v3BjD_xPnylSglHu9glrsc,15591
+doc_control/safety/verify.py,sha256=9Z_YGh6tzcHsXRjN8tCdmCu4qkdL7HEKQJMs33BsDC4,14553
+doc_control-0.0.1.dev0.dist-info/METADATA,sha256=6fwf6VQk5MoGgM4A5AvbtTTPox3sR4W0uUgAP1d2iDM,2860
+doc_control-0.0.1.dev0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+doc_control-0.0.1.dev0.dist-info/entry_points.txt,sha256=2nrW4FYVZaIl1WoBhFUDY1me8YE-XKF1yZamI0jQtgA,53
+doc_control-0.0.1.dev0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+doc_control-0.0.1.dev0.dist-info/RECORD,,

doc_control-0.0.1.dev0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

doc_control-0.0.1.dev0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+doc-control = doc_control.cli:main