docassert 0.1.0__py3-none-any.whl

docassert/structural.py

@@ -0,0 +1,406 @@
+"""Deterministic structural checks. These are reliable and BLOCKING."""
+from __future__ import annotations
+
+import datetime as dt
+import re
+from collections.abc import Callable
+
+from jsonschema import Draft7Validator, FormatChecker
+
+from .loader import iter_item_lines
+from .models import CheckResult, Document
+
+# ── measurability heuristic ────────────────────────────────────────────────
+# A success criterion is "measurable" if it contains a number AND either a
+# comparator or a unit/symbol/date — enough to make pass/fail unambiguous.
+_NUMBER = re.compile(r"\d")
+_COMPARATOR = re.compile(
+    r"[<>]=?|\b(?:below|under|above|over|at least|at most|no more than|"
+    r"no less than|fewer than|more than|greater than|less than|within|by|"
+    r"reach|reduce|increase|decrease|drop|rise|cut|from|to)\b",
+    re.IGNORECASE,
+)
+_UNIT_OR_SYMBOL = re.compile(
+    r"%|[$€£]|/\s*\d|\d{4}-\d{2}-\d{2}|"
+    r"\b(?:hours?|hrs?|days?|weeks?|months?|minutes?|mins?|seconds?|secs?|"
+    r"USD|EUR|GBP|k|m|bn|pts?|points?|x)\b",
+    re.IGNORECASE,
+)
+
+
+def _is_measurable(text: str) -> bool:
+    if not _NUMBER.search(text):
+        return False
+    return bool(_COMPARATOR.search(text) or _UNIT_OR_SYMBOL.search(text))
+
+
+def _field_value(item: str, field: str) -> str | None:
+    """Return the text after `field:` (up to a sentence/clause break), or None.
+
+    Stops at a semicolon or a period that ends a clause (period + space, or
+    period at end) so dotted handles like ``alex.kim`` are not truncated.
+    """
+    m = re.search(rf"{field}\s*:\s*(.+?)(?:;|\.\s|\.$|$)", item, re.IGNORECASE)
+    if not m:
+        return None
+    val = m.group(1).strip()
+    return val if len(val) >= 2 else None
+
+
+def _jsonify(value):
+    """Convert YAML date/datetime objects to ISO strings so a JSON Schema with
+    `type: string, format: date` validates correctly."""
+    if isinstance(value, dict):
+        return {k: _jsonify(v) for k, v in value.items()}
+    if isinstance(value, list):
+        return [_jsonify(v) for v in value]
+    if isinstance(value, (dt.date, dt.datetime)):
+        return value.isoformat()
+    return value
+
+
+def _as_date(value) -> dt.date | None:
+    if isinstance(value, dt.datetime):
+        return value.date()
+    if isinstance(value, dt.date):
+        return value
+    if isinstance(value, str):
+        try:
+            return dt.date.fromisoformat(value.strip())
+        except ValueError:
+            return None
+    return None
+
+
+# ── individual checks ──────────────────────────────────────────────────────
+def check_frontmatter_schema(doc: Document, ctx: dict) -> tuple[bool, str]:
+    schema = ctx["schema"]
+    validator = Draft7Validator(schema, format_checker=FormatChecker())
+    errors = sorted(validator.iter_errors(_jsonify(doc.frontmatter)), key=str)
+    if not errors:
+        return True, "Frontmatter is valid against the schema."
+    msgs = "; ".join(f"{'/'.join(str(p) for p in e.path) or '(root)'}: {e.message}"
+                     for e in errors)
+    return False, f"Frontmatter schema errors: {msgs}"
+
+
+def check_required_sections(doc: Document, ctx: dict) -> tuple[bool, str]:
+    required = ctx["required_sections"]
+    missing = [s for s in required if s not in doc.sections]
+    empty = [s for s in required if s in doc.sections and doc.sections[s].is_empty]
+    problems = []
+    if missing:
+        problems.append(f"missing: {', '.join(missing)}")
+    if empty:
+        problems.append(f"empty: {', '.join(empty)}")
+    if problems:
+        return False, "Required sections — " + "; ".join(problems)
+    return True, f"All {len(required)} required sections present and non-empty."
+
+
+def check_measurable_success_criteria(doc: Document, ctx: dict) -> tuple[bool, str]:
+    section = doc.section("Success Criteria")
+    if section is None:
+        return False, "No Success Criteria section."
+    items = section.list_items
+    if not items:
+        return False, "Success Criteria has no bulleted criteria."
+    unmeasurable = [it for it in items if not _is_measurable(it)]
+    if unmeasurable:
+        preview = "; ".join(f'“{u[:60]}”' for u in unmeasurable)
+        return False, f"{len(unmeasurable)}/{len(items)} criteria lack a measurable threshold: {preview}"
+    return True, f"All {len(items)} success criteria state a measurable threshold."
+
+
+def check_risks_owner_mitigation(doc: Document, ctx: dict) -> tuple[bool, str]:
+    section = doc.section("Risks")
+    if section is None:
+        return False, "No Risks section."
+    items = section.list_items
+    if not items:
+        return False, "Risks has no bulleted risks."
+    bad = []
+    for it in items:
+        if _field_value(it, "owner") is None or _field_value(it, "mitigation") is None:
+            bad.append(it)
+    if bad:
+        preview = "; ".join(f'“{b[:60]}”' for b in bad)
+        return False, f"{len(bad)}/{len(items)} risks miss an Owner and/or Mitigation: {preview}"
+    return True, f"All {len(items)} risks name an owner and a mitigation."
+
+
+def check_dates_consistent(doc: Document, ctx: dict) -> tuple[bool, str]:
+    dates = doc.frontmatter.get("dates") or {}
+    created = _as_date(dates.get("created"))
+    target = _as_date(dates.get("target"))
+    if created is None or target is None:
+        return False, "dates.created and dates.target must be valid ISO dates."
+    if target < created:
+        return False, f"target ({target}) is before created ({created})."
+    return True, f"Dates consistent (created {created} → target {target})."
+
+
+def check_unique_id(doc: Document, ctx: dict) -> tuple[bool, str]:
+    if not doc.id:
+        return False, "Document has no id."
+    others = [p for p in ctx.get("id_index", {}).get(doc.id, []) if p != doc.path]
+    if others:
+        return False, f"id '{doc.id}' also used by: {', '.join(others)}"
+    return True, f"id '{doc.id}' is unique."
+
+
+def _project_code(doc: Document) -> str:
+    """The project code for a document, e.g. 'AUR' from project: PRJ-001-AUR."""
+    return str(doc.frontmatter.get("project", "")).split("-")[-1]
+
+
+def check_items_well_formed(doc: Document, ctx: dict) -> tuple[bool, str]:
+    """Every bullet in a declared item-section is a valid item
+    ``**<CODE>-<TYPE>-<NNN>**``: the type matches the section, and the project
+    code matches the document's project."""
+    specs = ctx.get("item_sections") or []
+    if not specs:
+        return True, "No item sections for this kind."
+    code = _project_code(doc)
+    problems: list[str] = []
+    total = 0
+    for spec in specs:
+        section = doc.section(spec["section"])
+        if section is None:
+            continue  # a missing section is the required-sections check's job
+        for raw, m in iter_item_lines(section):
+            total += 1
+            if not m:
+                problems.append(f'malformed item in "{spec["section"]}": “{raw[:50]}”')
+                continue
+            if m.group("type") != spec["prefix"]:
+                problems.append(
+                    f'“{m.group("id")}” in "{spec["section"]}" should be type '
+                    f'{spec["prefix"]} ({code}-{spec["prefix"]}-NNN)')
+            if code and m.group("project") != code:
+                problems.append(
+                    f'“{m.group("id")}” uses project {m.group("project")} but the '
+                    f'document belongs to {code}')
+    if problems:
+        return False, "; ".join(problems)
+    return True, f"All {total} item(s) well-formed."
+
+
+_PROJECT_ID_RE = re.compile(r"^PRJ-\d{3,}-(?P<code>[A-Z]{2,6})$")
+
+
+def check_project_id_format(doc: Document, ctx: dict) -> tuple[bool, str]:
+    """A project.md declares a well-formed id (PRJ-NNN-CODE) whose tail matches
+    its `code` field."""
+    pid = str(doc.frontmatter.get("id", ""))
+    code = str(doc.frontmatter.get("code", ""))
+    m = _PROJECT_ID_RE.match(pid)
+    if not m:
+        return False, f"project id {pid!r} must match PRJ-NNN-CODE (e.g. PRJ-001-AUR)."
+    if m.group("code") != code:
+        return False, f"project id tail ({m.group('code')}) must equal code ({code!r})."
+    return True, f"Project id {pid} is well-formed."
+
+
+_RISK_FIELDS = ["Probability", "Impact", "Owner", "Response"]
+_ADR_STATES = {"proposed", "accepted", "superseded", "deprecated", "rejected"}
+
+
+def _items_of_prefix(doc: Document, ctx: dict, prefix: str):
+    """Yield (id, text) for every well-formed item of `prefix` in the doc."""
+    for spec in (ctx.get("item_sections") or []):
+        if spec.get("prefix") != prefix:
+            continue
+        section = doc.section(spec["section"])
+        if section is None:
+            continue
+        for _raw, m in iter_item_lines(section):
+            if m:
+                yield m.group("id"), m.group("text")
+
+
+def check_risk_items_complete(doc: Document, ctx: dict) -> tuple[bool, str]:
+    """Every RISK item names a Probability, Impact, Owner, and Response."""
+    incomplete, total = [], 0
+    for iid, text in _items_of_prefix(doc, ctx, "RISK"):
+        total += 1
+        missing = [f for f in _RISK_FIELDS if _field_value(text, f) is None]
+        if missing:
+            incomplete.append(f'{iid} missing {", ".join(missing)}')
+    if incomplete:
+        return False, "; ".join(incomplete)
+    return True, f"All {total} risk(s) state probability, impact, owner, and response."
+
+
+def check_adr_items_have_status(doc: Document, ctx: dict) -> tuple[bool, str]:
+    """Every ADR item declares a valid Status."""
+    bad, total = [], 0
+    for iid, text in _items_of_prefix(doc, ctx, "ADR"):
+        total += 1
+        status = _field_value(text, "status")
+        if status is None or status.lower() not in _ADR_STATES:
+            bad.append(f"{iid} status {status!r}")
+    if bad:
+        return False, ("; ".join(bad)
+                       + f" (expected one of: {', '.join(sorted(_ADR_STATES))})")
+    return True, f"All {total} decision(s) have a valid status."
+
+
+def check_raci_one_accountable(doc: Document, ctx: dict) -> tuple[bool, str]:
+    """The RACI Matrix table has exactly one Accountable (A) per activity."""
+    section = doc.section("RACI Matrix")
+    if section is None:
+        return False, "No RACI Matrix section."
+    rows = [ln.strip() for ln in section.body.splitlines() if ln.strip().startswith("|")]
+    data = [r for r in rows if "---" not in r][1:]  # drop header + separator
+    if not data:
+        return False, "RACI Matrix has no activity rows."
+    problems = []
+    for row in data:
+        cells = [c.strip() for c in row.strip("|").split("|")]
+        activity = cells[0] if cells else "?"
+        a_count = sum(1 for c in cells[1:] if c.upper() == "A")
+        if a_count != 1:
+            problems.append(f'"{activity}" has {a_count} Accountable (need exactly 1)')
+    if problems:
+        return False, "; ".join(problems)
+    return True, f"All {len(data)} activities have exactly one Accountable role."
+
+
+def check_story_format(doc: Document, ctx: dict) -> tuple[bool, str]:
+    """Every US item follows 'As a … I want … so that …'."""
+    bad, total = [], 0
+    for iid, text in _items_of_prefix(doc, ctx, "US"):
+        total += 1
+        low = text.lower()
+        if not (("as a " in low or "as an " in low) and "i want" in low):
+            bad.append(iid)
+    if bad:
+        return False, "stories not in 'As a … I want …' form: " + ", ".join(bad)
+    return True, f"All {total} user story(ies) follow the standard form."
+
+
+def check_measurable_exit_criteria(doc: Document, ctx: dict) -> tuple[bool, str]:
+    """Every Exit Criteria bullet states a measurable threshold."""
+    section = doc.section("Exit Criteria")
+    if section is None:
+        return False, "No Exit Criteria section."
+    items = section.list_items
+    if not items:
+        return False, "Exit Criteria has no bulleted criteria."
+    unmeasurable = [it for it in items if not _is_measurable(it)]
+    if unmeasurable:
+        preview = "; ".join(f'“{u[:50]}”' for u in unmeasurable)
+        return False, f"{len(unmeasurable)}/{len(items)} exit criteria lack a measurable threshold: {preview}"
+    return True, f"All {len(items)} exit criteria state a measurable threshold."
+
+
+def check_has_mapping_table(doc: Document, ctx: dict) -> tuple[bool, str]:
+    """The Field Mapping section contains a table with at least one row."""
+    section = doc.section("Field Mapping")
+    if section is None:
+        return False, "No Field Mapping section."
+    rows = [ln.strip() for ln in section.body.splitlines() if ln.strip().startswith("|")]
+    data = [r for r in rows if "---" not in r][1:]
+    if not data:
+        return False, "Field Mapping has no mapping table rows."
+    return True, f"Field Mapping table has {len(data)} row(s)."
+
+
+_STEP_RE = re.compile(r"^\s*\d+\.\s")
+
+
+def check_numbered_steps(doc: Document, ctx: dict) -> tuple[bool, str]:
+    """Each section named in `steps_sections` has an ordered (numbered) list of
+    at least two steps."""
+    specs = ctx.get("steps_sections") or []
+    if not specs:
+        return True, "No step sections for this kind."
+    problems, total = [], 0
+    for name in specs:
+        section = doc.section(name)
+        if section is None:
+            continue
+        n = sum(1 for ln in section.body.splitlines() if _STEP_RE.match(ln))
+        total += n
+        if n < 2:
+            problems.append(f'"{name}" needs at least 2 numbered steps (found {n})')
+    if problems:
+        return False, "; ".join(problems)
+    return True, f"Step sections have {total} numbered step(s)."
+
+
+def check_measurable_items(doc: Document, ctx: dict) -> tuple[bool, str]:
+    """Every bullet in each section named in `measurable_sections` states a
+    measurable threshold."""
+    specs = ctx.get("measurable_sections") or []
+    if not specs:
+        return True, "No measurable sections for this kind."
+    problems, total = [], 0
+    for name in specs:
+        section = doc.section(name)
+        if section is None:
+            continue
+        items = section.list_items
+        if not items:
+            problems.append(f'"{name}" has no bulleted items')
+            continue
+        total += len(items)
+        bad = [it for it in items if not _is_measurable(it)]
+        if bad:
+            problems.append(f'{len(bad)}/{len(items)} in "{name}" lack a measurable '
+                            f'threshold: ' + "; ".join(f'“{b[:40]}”' for b in bad))
+    if problems:
+        return False, "; ".join(problems)
+    return True, f"All {total} item(s) in measurable sections state a threshold."
+
+
+_RISK_REF_RE = re.compile(r"\b[A-Z]{2,6}-RISK-\d+\b")
+
+
+def check_references_risk(doc: Document, ctx: dict) -> tuple[bool, str]:
+    """The 'Risks & Issues' section cites at least one <CODE>-RISK-### from the register."""
+    section = doc.section("Risks & Issues")
+    if section is None:
+        return False, "No Risks & Issues section."
+    refs = _RISK_REF_RE.findall(section.body)
+    if not refs:
+        return False, "Risks & Issues cites no <CODE>-RISK-### from the register."
+    return True, f"Cites {len(set(refs))} risk(s) from the register: {', '.join(sorted(set(refs)))}."
+
+
+CHECKS: dict[str, Callable[[Document, dict], tuple[bool, str]]] = {
+    "frontmatter-schema": check_frontmatter_schema,
+    "required-sections": check_required_sections,
+    "measurable-success-criteria": check_measurable_success_criteria,
+    "risks-have-owner-and-mitigation": check_risks_owner_mitigation,
+    "dates-consistent": check_dates_consistent,
+    "unique-id": check_unique_id,
+    "items-well-formed": check_items_well_formed,
+    "risk-items-complete": check_risk_items_complete,
+    "adr-items-have-status": check_adr_items_have_status,
+    "raci-one-accountable": check_raci_one_accountable,
+    "story-format": check_story_format,
+    "measurable-exit-criteria": check_measurable_exit_criteria,
+    "mapping-table": check_has_mapping_table,
+    "numbered-steps": check_numbered_steps,
+    "measurable-items": check_measurable_items,
+    "references-risk": check_references_risk,
+    "project-id-format": check_project_id_format,
+}
+
+
+def run_structural(doc: Document, spec: dict, ctx: dict) -> CheckResult:
+    """Run one structural check described by a criteria `spec` dict."""
+    check_id = spec["id"]
+    fn = CHECKS.get(check_id)
+    blocking = bool(spec.get("blocking", True))
+    if fn is None:
+        return CheckResult(check_id, False, blocking,
+                           f"Unknown structural check '{check_id}'.", kind="structural")
+    try:
+        passed, detail = fn(doc, ctx)
+    except Exception as exc:  # a check crash is a failure, never a silent pass
+        return CheckResult(check_id, False, blocking,
+                           f"Check errored: {exc}", kind="structural")
+    return CheckResult(check_id, passed, blocking, detail, kind="structural")

docassert-0.1.0.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: docassert
+Version: 0.1.0
+Summary: Unit testing for business documents — validate structured Markdown docs against a configurable audit standard.
+Author: C4G Enterprises Inc.
+License: Apache-2.0
+Project-URL: Homepage, https://docassert.com
+Project-URL: Repository, https://github.com/c4g-john/docassert
+Project-URL: Issues, https://github.com/c4g-john/docassert/issues
+Keywords: pmo,documentation,validation,governance,markdown,audit,traceability,ci
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Documentation
+Classifier: Topic :: Text Processing :: Markup :: Markdown
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: python-frontmatter>=1.1
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: jsonschema>=4.0
+Provides-Extra: ai
+Requires-Dist: anthropic>=0.40; extra == "ai"
+Provides-Extra: convert
+Requires-Dist: python-docx>=1.1; extra == "convert"
+Requires-Dist: pypdf>=4.0; extra == "convert"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Dynamic: license-file
+
+# docassert
+
+**Unit testing for business documents.** Validate structured Markdown documents
+(charters, BRDs, PRDs, risk registers, …) against a configurable audit standard:
+deterministic structural checks that gate a merge, plus optional AI-graded
+semantic checks that advise. Requirements trace end to end, and project status is
+derived from the documents rather than self-reported.
+
+docassert is the reference implementation of **[PMO as Code](https://c4g-john.github.io/pmo-as-code/)** —
+a vendor-neutral standard for running a PMO from version-controlled, declarative files.
+
+## Install
+
+```bash
+pip install "docassert @ git+https://github.com/c4g-john/docassert"   # PyPI release coming
+# with the AI advisory extra:
+pip install "docassert[ai] @ git+https://github.com/c4g-john/docassert"
+```
+
+## Quickstart
+
+```bash
+docassert init                        # scaffold criteria/schema/profiles/templates into your repo
+docassert validate documents/**/*.md  # unit-test your documents
+docassert consistency                 # cross-document traceability + profile completeness
+docassert status --index              # derived RAG per project
+docassert pages --out _site           # a portfolio dashboard + a page per project
+```
+
+Config resolves **local override → packaged default**: docassert ships sensible
+defaults, and your repo's own `criteria/` (or `schema/`, `profiles/`,
+`consistency.yaml`) wins when present. `docassert init` copies the defaults in so
+you can customize them.
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `docassert validate <globs>` | Validate documents against their kind's criteria. Exit code = number of blocking failures. |
+| `docassert consistency` | Cross-document checks: referential integrity, coverage, required links, profile completeness. |
+| `docassert rtm [--project ID]` | Requirements traceability matrix (Markdown or CSV). |
+| `docassert status [--project ID] [--index]` | Derived project status (md / json / html). |
+| `docassert pages --out DIR` | Build the portfolio site (index + a page per project). |
+| `docassert projects [--out] [--check]` | Generate / verify the project registry. |
+| `docassert init [DIR]` | Scaffold the default config into a repo. |
+
+## Document kinds
+
+Twenty kinds, each a `templates/<kind>.template.md` + `schema/<kind>.schema.json`
++ `criteria/<kind>.criteria.yaml` trio: `project`, `charter`, `business-case`,
+`brd`, `prd`, `frnfr`, `user-story`, `test-cases`, `adr`, `risk-register`,
+`raci-stakeholder`, `qa-test-plan`, `data-migration-plan`,
+`release-cutover-plan`, `rollback-plan`, `hypercare-plan`, `runbook`,
+`status-report`, `post-implementation-review`, `benefits-realization`. Adding a
+kind is adding a trio — no code for the common cases.
+
+## Two tiers of checks
+
+- **Structural — deterministic, blocking.** Required fields and sections,
+  measurable success criteria, risks with owner + mitigation, resolving
+  references, unique ids. Plain Python, reliable enough to gate a merge.
+- **Semantic — AI-graded, advisory.** Scored via the Anthropic API and posted to
+  the PR — never blocking. Set `ANTHROPIC_API_KEY` to enable; skipped otherwise.
+
+## Development
+
+```bash
+python3 -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+ruff check .
+```
+
+This repo ships example `documents/` (four sample projects) that the test suite
+validates against.
+
+## The reference deployment
+
+[**pmo-as-code-pipeline**](https://github.com/c4g-john/pmo-as-code-pipeline) is a
+living example — sample projects, the gate on every pull request, and a published
+dashboard at
+[c4g-john.github.io/pmo-as-code-pipeline](https://c4g-john.github.io/pmo-as-code-pipeline/).
+The standard's site is [c4g-john.github.io/pmo-as-code](https://c4g-john.github.io/pmo-as-code/).
+
+## License
+
+Apache-2.0 — see [LICENSE](LICENSE) and [NOTICE](NOTICE). © 2026 C4G Enterprises Inc.

docassert-0.1.0.dist-info/RECORD

@@ -0,0 +1,86 @@
+docassert/__init__.py,sha256=r3cAnfv14fB1O1GUSxbmeJO-I6iAqcraldvzs-hCW98,273
+docassert/__main__.py,sha256=4JMK66Wj4uLZTKbF-sT3LAxOsr6buig77PmOkJCRRxw,83
+docassert/cli.py,sha256=3yKxLNx3Z0cvBbOySmc23Il0tG1Ksm4cjKnuQHLiYTA,11452
+docassert/config.py,sha256=kRzBvqKIbC3nsviUf6uo9IMP4DXzrEhB0ebJ_5CjjRM,4299
+docassert/consistency.py,sha256=nRbavINfL3A_ZRZb4SP74s7Ub706mTHaHDDArULVO3g,7531
+docassert/graph.py,sha256=JXQyRmBU3bqAcquFK9T2G49ZOp8i9I9or0oV5qc1FGA,2647
+docassert/loader.py,sha256=04rtye1e95sN6-brPiCNHZzPqZu9c1rntJTP1gLpbhA,4000
+docassert/models.py,sha256=xUz3-Ke-UiSf9oWx3j3MtJsXj6kwTLpEcWd2IUopd5s,3148
+docassert/profiles.py,sha256=Wav3XU4znkLXOOuO674JJgAmaOccPSLCMKpzQJQ6N7c,4477
+docassert/projects.py,sha256=wbN7ZPXUSbiz8uMRQHbj04iLavFzdbvrPuuz84mDA9I,1751
+docassert/report.py,sha256=6klvTyAS2HF-XAXDAH8m48s0jQYZvUAAmHwdGF798nQ,3679
+docassert/rtm.py,sha256=yj_OsON0sdez_qvxEEQT36FTHToopbxWIca60wTkkxk,2474
+docassert/semantic.py,sha256=bPGnT1ascg6sTKBRZqd7pABKZO0rEyUftH1gF9z6swA,4720
+docassert/status.py,sha256=plpo6ofS1QVRp0ol-IZX0Zty0Iq05hEvUXqlqbecs7s,24464
+docassert/structural.py,sha256=ryUy8xFG0BQmEBl731xtDwN8fEuAYfmjkEn7CffUkyY,16979
+docassert/_data/consistency.yaml,sha256=YSe8zaebPVoZLcjfUbLPrPl0JE2gwz1hg2nUQXkz59s,2130
+docassert/_data/criteria/adr.criteria.yaml,sha256=2tTiw4A1EUM2dTTkFKaeIWCSi8RyJYpygDb2APEKo6c,1073
+docassert/_data/criteria/benefits-realization.criteria.yaml,sha256=fwHyKLN6YfHH4DU-20_qcmH_udt6xu96nfmJ4c_PbKs,797
+docassert/_data/criteria/brd.criteria.yaml,sha256=5enPIUR9F7BAOemK1KYHmDu9nmQOshXusz5a77Cw95s,801
+docassert/_data/criteria/business-case.criteria.yaml,sha256=PdxKSELE6L1rfXNVUwbq1SLNlLbGn9YVm4kjUoHCEjY,580
+docassert/_data/criteria/charter.criteria.yaml,sha256=3JpgfHO8qXRiFvSuRZUKwX3SwbgVt_T-kCsTZFp-XdM,2468
+docassert/_data/criteria/data-migration-plan.criteria.yaml,sha256=RyeQUfkR2Tf7DfGxkflDsFbwu9DO3TCf0gayZinFXVw,729
+docassert/_data/criteria/frnfr.criteria.yaml,sha256=w6q8wQmr54fWMfPe48qoG7QvOhYNmawQssb_Kxc5epM,857
+docassert/_data/criteria/hypercare-plan.criteria.yaml,sha256=hYsWDmsw4G2aOAsBElzQMvn_h4dZ6rtmBHbOFtDlxz8,733
+docassert/_data/criteria/post-implementation-review.criteria.yaml,sha256=Kx2vbm4SchJ-xJ50C6XQG9RSx4FqDKrOTH_hwcS5RlM,655
+docassert/_data/criteria/prd.criteria.yaml,sha256=n7wAYWGrlwpO_cvY3ZNYnOjwKQQiJw0D-JMN1elVYjg,838
+docassert/_data/criteria/project.criteria.yaml,sha256=Ix-D1VPbFzPBZZHb2b8fpc7z_0pTNW_qvEnkb-WA2JQ,883
+docassert/_data/criteria/qa-test-plan.criteria.yaml,sha256=mGlbwekp1DBwG0cEy_WxiGm5YhiKVX1KbG9w9jUe2aY,716
+docassert/_data/criteria/raci-stakeholder.criteria.yaml,sha256=TKmB-1ExX2RQvbXNmAVgYL4GBwjqIf8M8XKy1joZpNg,704
+docassert/_data/criteria/release-cutover-plan.criteria.yaml,sha256=tOSCtZG0sH_irYUOQVFqPZhk5NJUkpIioAFq9vYfsrQ,791
+docassert/_data/criteria/risk-register.criteria.yaml,sha256=FQZ5-PnYrSsWCgjuZgEVNEq9t8ueMJ5nEJ7avQ19FJA,839
+docassert/_data/criteria/rollback-plan.criteria.yaml,sha256=UNcYLcS1ydE4GTbGwzVC5jGFpoS8C20IikiB-DEMNQU,747
+docassert/_data/criteria/runbook.criteria.yaml,sha256=BRziVcsrxJz3YfrpJ4cJ4WSvPaIVvfWb2YIgynybPtg,725
+docassert/_data/criteria/status-report.criteria.yaml,sha256=BxSEA_zK6_Y6ZcDMPdry-4NeDNUawQGnhvgBJ8LT4_k,717
+docassert/_data/criteria/test-cases.criteria.yaml,sha256=9R-9bBW0Tnyh4DxN2BYl035C_YZnWpr3nCWb0_NrM_c,729
+docassert/_data/criteria/user-story.criteria.yaml,sha256=Z_CZpb1F4S_X2zQt7mV7y3DjI9gZIs_jQKyUhTK6u1Y,829
+docassert/_data/profiles/agile-delivery.yaml,sha256=BKELKUX2288YJ8jXtFiXOoX-VdcYmDq8PPI_SSnTmTc,486
+docassert/_data/profiles/lean-startup.yaml,sha256=uxHvGvb-aLE97SbdpGKubOAbe5mrR04-LYiDlUKZyTE,449
+docassert/_data/profiles/regulated-industry.yaml,sha256=rId3JCU9uMiSseP9eDz-4xQMDN5jkjVAWZKzBh2J4Lw,948
+docassert/_data/schema/adr.schema.json,sha256=EpBNzWNDX-pcVtfLmz0O_91mUmnWrFgeDw-sxxWCeNk,1002
+docassert/_data/schema/benefits-realization.schema.json,sha256=CnLIl26L88mjZEsQH0rIYB8zxJCQACSddnvQGSsxaCI,1005
+docassert/_data/schema/brd.schema.json,sha256=FZBUFu_V7l7x5LkAjkmQTWZBYSQU4PsH5Oafod2OzhU,998
+docassert/_data/schema/business-case.schema.json,sha256=yEu7tzw-kqioNZDi4InrBfQK0JArGXox6LMHYgFjTdg,995
+docassert/_data/schema/charter.schema.json,sha256=Sf_KV1cWqudAC6qTSaHgWc-ZhKjCUthg1cBHjcTf4k0,1853
+docassert/_data/schema/data-migration-plan.schema.json,sha256=KHPLI541f9LmXoGYBxS51Wa_O7Ub5nhrzaEtPR4ZOCc,1003
+docassert/_data/schema/frnfr.schema.json,sha256=u2B8camWpNKeIph-kFzNkUQvX6xPA_HVI8MOTuA4VAA,1010
+docassert/_data/schema/hypercare-plan.schema.json,sha256=dmAGt9esQwnNs1cMwhStOXf1zRH8xuWXLS21p3iouBo,993
+docassert/_data/schema/post-implementation-review.schema.json,sha256=LC35mO2FuWmbnUfLseb2T4XnIvsnk3-m-94m3paFut8,1017
+docassert/_data/schema/prd.schema.json,sha256=ib_znW0Z8wfbe5_x2o0eQZUynJxvTedL_MXYpmEUWCA,997
+docassert/_data/schema/project.schema.json,sha256=pHByCi1h8H8OS6REOBXMPxqmlSrAHfgZ975cfT1wYYU,1198
+docassert/_data/schema/qa-test-plan.schema.json,sha256=0V7BLmfQcI4ggvEdNJ6uOuYmPzc2AwCvZstu9OBNCBE,991
+docassert/_data/schema/raci-stakeholder.schema.json,sha256=6vyXjl4OJTSik5h8p6dSFjt8-bgzsY2TdvzhvzwazI4,1008
+docassert/_data/schema/release-cutover-plan.schema.json,sha256=PScrP5QqpKs37AVk_vQGjt5uEToZRnf3AjBSrBkSe50,1007
+docassert/_data/schema/risk-register.schema.json,sha256=XmMkK88km78fZuHx53tCTIpY-5X3hmaoogQU4iulTv0,991
+docassert/_data/schema/rollback-plan.schema.json,sha256=a29Se0qm656XkP4d3eEdVLT68ieU0bO4GpZ-_zxa-3A,991
+docassert/_data/schema/runbook.schema.json,sha256=6OE1P3DfWNDQ_W8YGLyqz9Zd4V1jP4PS7Uv3N6pY9gg,979
+docassert/_data/schema/status-report.schema.json,sha256=LfrEpGyrahn4TybEdBCdf2cgeLEB_TGYYwFsh0mKH5U,1178
+docassert/_data/schema/test-cases.schema.json,sha256=Lawn-Zi2t4vBf3P4SRSfrwHrdtaV_Mj0lkqdDSkbYxs,985
+docassert/_data/schema/user-story.schema.json,sha256=NL5TtXVtmeK6ysO2viwVaobImwtBghK_t2ga9a9PNxU,987
+docassert/_data/templates/adr.template.md,sha256=36Jh7najTUM8vSKqnkceIW26RnTWZLLiFnZULvWkH3A,396
+docassert/_data/templates/benefits-realization.template.md,sha256=liJ4cLJRkVX4mMK_JQDh_nJMIAf_6rFnx_NzOehLhkk,498
+docassert/_data/templates/brd.template.md,sha256=9Z6YN9hqfxfaAyt4Ub9achrcLdolkWlCTSRrtQSH9sw,439
+docassert/_data/templates/business-case.template.md,sha256=Zk4ijavPO6btlpUlbedGy-NrRrDbbUWbPP-Xmvu9ROY,457
+docassert/_data/templates/charter.template.md,sha256=qdLVQicWGxSt9HO6LDMjAoiF_w_ld4sMoOkCQQ8BlGQ,1335
+docassert/_data/templates/data-migration-plan.template.md,sha256=mFl0nijXISoEQtnaxyYKra6d-rFGyQaIU2P_RQTwAO4,603
+docassert/_data/templates/frnfr.template.md,sha256=kvg47hrpNdLWWA9wc7-D3q6_R1ISjr1aUQi1aUOcGmY,383
+docassert/_data/templates/hypercare-plan.template.md,sha256=UOk0FWlKoZA4Uu0xE44nJ4SnnlSIWcc1z_e71yo3U0s,524
+docassert/_data/templates/post-implementation-review.template.md,sha256=F3BWgMdEFJuxx9vbebTEFfmuMA20lCiSuFZf5-HWA00,475
+docassert/_data/templates/prd.template.md,sha256=GgaMCNZjGSEIQ8fKgSH04oILpAZMW6xtGX-3vFsWZHQ,472
+docassert/_data/templates/project.template.md,sha256=oqYclBtMRSyvn-Jc3wHyElM1in7Dj9xDfhBm6xHvEgI,539
+docassert/_data/templates/qa-test-plan.template.md,sha256=btpDuJ7cyEvO19SOSSZQaetKZ7zV1ctnifxQjDDCyu4,600
+docassert/_data/templates/raci-stakeholder.template.md,sha256=lzgKvXz7G-VKIePlji6J4uYQs_WDIF_JPrKbVFeeDlI,422
+docassert/_data/templates/release-cutover-plan.template.md,sha256=KD-uwP7q8cPX9befWgzRjGV6WtUfHOVz2O_4kOG7d7Q,468
+docassert/_data/templates/risk-register.template.md,sha256=qB8AGkgA_zevbUfZFuCvb1YZy0u7Wx47NHYeuZJhUCA,437
+docassert/_data/templates/rollback-plan.template.md,sha256=TitKTHUQ54oUr2WTbEhJWfdmznMuhwaB9LkRWRWgrRo,383
+docassert/_data/templates/runbook.template.md,sha256=duHGiIvueDNpk1HX5ZJlkJFdPNjLzA8BtstDxx-9Cco,425
+docassert/_data/templates/status-report.template.md,sha256=y_08jiUg1yCt2GvvBY5YfwyXZg_riO3ixlFMh6MiVbE,495
+docassert/_data/templates/test-cases.template.md,sha256=0iZXwA-VLEcbTdW-RGL7B7W46s7hav0NyqP_8a2_HDw,290
+docassert/_data/templates/user-story.template.md,sha256=KKQrxQrBqMTAwv6LUDG1ktkGcMdjhO5qj-kOutkJ_Vg,332
+docassert-0.1.0.dist-info/licenses/LICENSE,sha256=xBe1Yr3cUoPAUIQEuhY3lYqIl9g9Sz2-7TFyPJrEyIk,11350
+docassert-0.1.0.dist-info/licenses/NOTICE,sha256=X68MqGpL0ZAaP0yxmH4R8v5pZOcU0w5chz4USnTp44M,125
+docassert-0.1.0.dist-info/METADATA,sha256=VQvQkpYGr652Y7XSoUfQMZY14oKy_P-kW0fWuyvDL08,5458
+docassert-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+docassert-0.1.0.dist-info/entry_points.txt,sha256=TMhMaSwJcQWPMydjO1CWK0IuLQTBO_b4655glFXsBms,49
+docassert-0.1.0.dist-info/top_level.txt,sha256=JrVdJYhp8XhcWeuXFoV7FZmI9PZ6TmcaTukUKKsVePU,10
+docassert-0.1.0.dist-info/RECORD,,

docassert-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

docassert-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+docassert = docassert.cli:main