tac-validate 0.1.0__py3-none-any.whl

tac_validate/__init__.py

@@ -0,0 +1,11 @@
+"""TAC parse gate and business-rule pack (F6 lint)."""
+
+from __future__ import annotations
+
+from tac_validate.api import lint
+from tac_validate.models import Fix, Issue, LintReport
+from tac_validate.products import PRODUCTS
+
+__version__ = "0.1.0"
+
+__all__ = ["PRODUCTS", "Fix", "Issue", "LintReport", "__version__", "lint"]

tac_validate/api.py

@@ -0,0 +1,35 @@
+"""Public ``lint()`` entrypoint for TAC parse gate + rule pack."""
+
+from __future__ import annotations
+
+from tac_validate.models import LintReport
+from tac_validate.products import PRODUCTS
+from tac_validate.rules import check_parse_gate, check_product_rules
+
+
+def lint(tac_text: str, *, product: str = "METAR") -> LintReport:
+    """
+    Lint TAC text for ``product`` using the shared rule-pack skeleton.
+
+    Parameters
+    ----------
+    tac_text :
+        TAC report or fragment.
+    product :
+        One of AIRMET, METAR, SIGMET, SPECI, TAF, VAA, TCA.
+
+    Returns
+    -------
+    LintReport
+        ``ok`` is ``False`` when any error-severity issue is present.
+        Optional ``fixes`` may suggest repairs (Q9=C).
+    """
+    issues, fixes = check_parse_gate(tac_text, product)
+    if not any(i.severity == "error" for i in issues):
+        issues.extend(check_product_rules(tac_text, product))
+
+    ok = not any(i.severity == "error" for i in issues)
+    return LintReport(ok=ok, product=product, issues=issues, fixes=fixes)
+
+
+__all__ = ["PRODUCTS", "lint"]

tac_validate/cli.py

@@ -0,0 +1,79 @@
+"""Command-line interface for ``tac-validate`` (F12)."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+from typing import Sequence
+
+from tac_validate.api import lint
+from tac_validate.codec import json_encoder
+from tac_validate.products import PRODUCTS
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="tac-validate",
+        description="Lint TAC text for F6 products (parse-gate + checklist/template gates).",
+    )
+    parser.add_argument(
+        "path",
+        type=Path,
+        help="Path to a TAC text file",
+    )
+    parser.add_argument(
+        "--product",
+        required=True,
+        choices=list(PRODUCTS),
+        help="F6 product id",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Emit LintReport as JSON on stdout",
+    )
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """
+    Run ``tac-validate`` CLI.
+
+    Parameters
+    ----------
+    argv :
+        Argument vector (defaults to ``sys.argv[1:]``).
+
+    Returns
+    -------
+    int
+        ``0`` when ``report.ok``; ``1`` on lint errors or I/O failure.
+    """
+    parser = _build_parser()
+    args = parser.parse_args(list(argv) if argv is not None else None)
+    path: Path = args.path
+    try:
+        text = path.read_text(encoding="utf-8")
+    except OSError as exc:
+        print(f"error: cannot read {path}: {exc}", file=sys.stderr)
+        return 1
+
+    report = lint(text, product=args.product)
+    if args.json:
+        sys.stdout.write(json_encoder.encode(report).decode("utf-8"))
+        sys.stdout.write("\n")
+    else:
+        status = "ok" if report.ok else "fail"
+        print(f"{status} product={report.product} issues={len(report.issues)}")
+        for issue in report.issues:
+            span = ""
+            if issue.start is not None and issue.end is not None:
+                span = f" [{issue.start}:{issue.end}]"
+            print(f"  {issue.severity}:{issue.code}{span} {issue.message}")
+
+    return 0 if report.ok else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

tac_validate/codec.py

@@ -0,0 +1,12 @@
+"""Reusable msgspec JSON codec for LintReport (ADR-016)."""
+
+from __future__ import annotations
+
+import msgspec
+
+from tac_validate.models import LintReport
+
+json_encoder = msgspec.json.Encoder()
+json_decoder = msgspec.json.Decoder(LintReport)
+
+__all__ = ["json_decoder", "json_encoder"]

tac_validate/models.py

@@ -0,0 +1,77 @@
+"""msgspec models for TAC lint issues and fixes (ADR-016 / Q9=C)."""
+
+from __future__ import annotations
+
+import msgspec
+
+
+class Issue(msgspec.Struct, frozen=True):
+    """
+    Structured TAC lint finding.
+
+    Parameters
+    ----------
+    severity :
+        ``error``, ``warning``, or ``info``.
+    code :
+        Machine-readable rule id.
+    message :
+        Human-readable description.
+    location :
+        Optional token / field hint (e.g. ``wind``).
+    start :
+        Optional inclusive character offset into the TAC string.
+    end :
+        Optional exclusive character offset into the TAC string.
+    """
+
+    severity: str
+    code: str
+    message: str
+    location: str | None = None
+    start: int | None = None
+    end: int | None = None
+
+
+class Fix(msgspec.Struct, frozen=True):
+    """
+    Optional repair suggestion for a lint finding.
+
+    Parameters
+    ----------
+    code :
+        Fix identifier (e.g. ``add_terminator``).
+    message :
+        Human-readable description.
+    replacement :
+        Suggested replacement fragment or full TAC.
+    """
+
+    code: str
+    message: str
+    replacement: str
+
+
+class LintReport(msgspec.Struct, frozen=True):
+    """
+    Result of ``lint()``.
+
+    Parameters
+    ----------
+    ok :
+        ``True`` when no error-severity issues.
+    product :
+        Product id used for rule selection.
+    issues :
+        Structured findings.
+    fixes :
+        Optional repair suggestions.
+    """
+
+    ok: bool
+    product: str
+    issues: list[Issue]
+    fixes: list[Fix] = msgspec.field(default_factory=list)
+
+
+__all__ = ["Fix", "Issue", "LintReport"]

tac_validate/product_rules.py

@@ -0,0 +1,364 @@
+"""Product-specific TAC checklist and template-gate rules (F12 / E10-21).
+
+Cite paraphrase tables in ``docs/domain/TAC_VALIDATION.md`` only — no Annex prose.
+"""
+
+from __future__ import annotations
+
+import re
+
+from tac_validate.models import Issue
+
+_ICAO = re.compile(r"\b[A-Z]{4}\b")
+_OBS_TIME = re.compile(r"\b\d{6}Z\b")
+_WIND = re.compile(r"\b(?:(?:VRB|\d{3})\d{2,3}(?:G\d{2,3})?(?:KT|MPS)|CALM)\b")
+_VIS = re.compile(r"\b(?:CAVOK|P?\d{1,2}SM|\d{4})\b")
+_TEMP = re.compile(r"\bM?\d{2}/M?\d{2}\b")
+_QNH = re.compile(r"\b[QA]\d{4}\b")
+_CLOUD_OK = re.compile(r"\b(?:FEW|SCT|BKN|OVC|VV|NSC|NCD|SKC|CLR)\d{0,3}(?:CB|TCU)?\b")
+_CLOUD_BAD = re.compile(r"\b([A-Z]{3}\d{3})\b")
+_TAF_VALIDITY = re.compile(r"\b\d{4}/\d{4}\b")
+_VALID_PERIOD = re.compile(r"\bVALID\s+\d{6}/\d{6}\b", re.IGNORECASE)
+_DTG_LINE = re.compile(r"(?m)^\s*DTG\s*:", re.IGNORECASE)
+_VAAC_LINE = re.compile(r"(?m)^\s*VAAC\s*:", re.IGNORECASE)
+_MAX_WIND_LINE = re.compile(r"(?m)^\s*MAX\s+WIND\s*:", re.IGNORECASE)
+
+# Phenomenon family markers (template+gate — not exhaustive Annex vocab).
+_SIGMET_FAMILIES: tuple[tuple[str, re.Pattern[str]], ...] = (
+    ("TS", re.compile(r"\b(?:OBSC|EMBD|FRQ|SQL)?\s*TS(?:GR)?\b")),
+    ("TURB", re.compile(r"\b(?:SEV|MOD)?\s*TURB\b")),
+    ("ICE", re.compile(r"\b(?:SEV|MOD)?\s*ICE\b")),
+    ("MTW", re.compile(r"\b(?:SEV|MOD)?\s*MTW\b")),
+    ("DS_SS", re.compile(r"\b(?:HVY\s+)?(?:DS|SS)\b")),
+    ("VA", re.compile(r"\bVA\b")),
+    ("TC", re.compile(r"\bTC\b")),
+    ("RDOACT", re.compile(r"\bRDOACT\s+CLD\b")),
+)
+_AIRMET_FAMILIES: tuple[tuple[str, re.Pattern[str]], ...] = (
+    ("TS", re.compile(r"\b(?:ISOL|OCNL|FRQ)\s+TS\b")),
+    ("ICE", re.compile(r"\b(?:MOD|SEV)?\s*ICE\b")),
+    ("TURB", re.compile(r"\b(?:MOD|SEV)?\s*TURB\b")),
+    ("MTW", re.compile(r"\b(?:MOD|SEV)?\s*MTW\b")),
+    ("MT_OBSC", re.compile(r"\bMT\s+OBSC\b")),
+    ("CLD", re.compile(r"\b(?:BKN|OVC)\s+CLD\b")),
+    ("CB_TCU", re.compile(r"\b(?:ISOL|OCNL|FRQ)\s+(?:CB|TCU)\b")),
+    ("SFC", re.compile(r"\bSFC\s+(?:WIND|VIS)\b")),
+)
+
+_METAR_SPECI_SKIP = frozenset({"METAR", "SPECI", "COR", "AUTO", "NIL", "CAVOK", "NOSIG"})
+_TAF_SKIP = frozenset({"TAF", "AMD", "COR", "NIL", "CNL", "CAVOK"})
+
+
+def _issue(
+    code: str,
+    message: str,
+    *,
+    start: int,
+    end: int,
+    location: str = "body",
+) -> Issue:
+    return Issue(
+        severity="error",
+        code=code,
+        message=message,
+        location=location,
+        start=start,
+        end=end,
+    )
+
+
+def _body_span(tac: str) -> tuple[int, int, str]:
+    stripped = tac.strip()
+    if not stripped:
+        return 0, len(tac), ""
+    leading = len(tac) - len(tac.lstrip())
+    return leading, leading + len(stripped), stripped
+
+
+def _first_icao(tokens: list[str], skip: frozenset[str]) -> str | None:
+    for tok in tokens:
+        if tok in skip:
+            continue
+        if _ICAO.fullmatch(tok) and tok not in {"KT", "MPS", "SM"}:
+            return tok
+    return None
+
+
+def _check_metar_speci(tac: str, product: str) -> list[Issue]:
+    start, end, body = _body_span(tac)
+    upper = body.upper()
+    # Drop trailing '=' for token scans.
+    core = upper[:-1] if upper.endswith("=") else upper
+    tokens = core.replace("=", " ").split()
+    issues: list[Issue] = []
+
+    cccc = _first_icao(tokens, _METAR_SPECI_SKIP)
+    if cccc is None:
+        issues.append(
+            _issue(
+                "MISSING_CCCC",
+                f"{product} missing ICAO location (CCCC) — A3-2 #2",
+                start=start,
+                end=end,
+                location="station",
+            )
+        )
+
+    if not _OBS_TIME.search(core):
+        issues.append(
+            _issue(
+                "MISSING_OBS_TIME",
+                f"{product} missing observation time ddhhmmZ — A3-2 #3",
+                start=start,
+                end=end,
+                location="time",
+            )
+        )
+
+    if not _WIND.search(core):
+        issues.append(
+            _issue(
+                "MISSING_WIND",
+                f"{product} missing surface wind group — A3-2 #5",
+                start=start,
+                end=end,
+                location="wind",
+            )
+        )
+
+    if not _VIS.search(core):
+        issues.append(
+            _issue(
+                "MISSING_VISIBILITY",
+                f"{product} missing visibility or CAVOK — A3-2 #6",
+                start=start,
+                end=end,
+                location="visibility",
+            )
+        )
+
+    if not _TEMP.search(core):
+        issues.append(
+            _issue(
+                "MISSING_TEMP_DEWPOINT",
+                f"{product} missing temperature/dewpoint tt/td — A3-2 #10",
+                start=start,
+                end=end,
+                location="temperature",
+            )
+        )
+
+    if not _QNH.search(core):
+        issues.append(
+            _issue(
+                "MISSING_QNH",
+                f"{product} missing QNH/altimeter (Qnnnn/Annnn) — A3-2 #11",
+                start=start,
+                end=end,
+                location="pressure",
+            )
+        )
+
+    # Flag unknown XXX### cloud-like tokens that are not valid cloud groups.
+    for match in _CLOUD_BAD.finditer(core):
+        token = match.group(1)
+        if _CLOUD_OK.fullmatch(token):
+            continue
+        # Wind already matched as \d{3}\d{2}KT — not XXX###.
+        if token[:3] in {"FEW", "SCT", "BKN", "OVC"}:
+            continue
+        abs_start = start + match.start(1)
+        abs_end = start + match.end(1)
+        issues.append(
+            _issue(
+                "INVALID_CLOUD_TOKEN",
+                f"{product} invalid cloud/VV token {token!r} — A3-2 #9",
+                start=abs_start,
+                end=abs_end,
+                location="cloud",
+            )
+        )
+
+    return issues
+
+
+def _check_taf(tac: str) -> list[Issue]:
+    start, end, body = _body_span(tac)
+    upper = body.upper()
+    core = upper[:-1] if upper.endswith("=") else upper
+    tokens = core.replace("=", " ").split()
+    issues: list[Issue] = []
+
+    if _first_icao(tokens, _TAF_SKIP) is None:
+        issues.append(
+            _issue(
+                "MISSING_CCCC",
+                "TAF missing ICAO location (CCCC) — A5-1 #2",
+                start=start,
+                end=end,
+                location="station",
+            )
+        )
+
+    if not _OBS_TIME.search(core):
+        issues.append(
+            _issue(
+                "MISSING_ISSUE_TIME",
+                "TAF missing issue time ddhhmmZ — A5-1 #3",
+                start=start,
+                end=end,
+                location="time",
+            )
+        )
+
+    if not _TAF_VALIDITY.search(core):
+        issues.append(
+            _issue(
+                "MISSING_VALIDITY",
+                "TAF missing validity period ddhh/ddhh — A5-1 #5",
+                start=start,
+                end=end,
+                location="validity",
+            )
+        )
+
+    if "CNL" in tokens:
+        # CNL must terminate the forecast content (A5-1 #6 paraphrase).
+        cnl_idx = tokens.index("CNL")
+        trailing = [t for t in tokens[cnl_idx + 1 :] if t not in {"="}]
+        if trailing:
+            issues.append(
+                _issue(
+                    "INVALID_CNL_SHAPE",
+                    "TAF CNL must end the message — A5-1 #6",
+                    start=start,
+                    end=end,
+                    location="cnl",
+                )
+            )
+
+    return issues
+
+
+def _count_families(text: str, families: tuple[tuple[str, re.Pattern[str]], ...]) -> list[str]:
+    found: list[str] = []
+    for name, pattern in families:
+        if pattern.search(text):
+            found.append(name)
+    return found
+
+
+def _check_sigmet_airmet(tac: str, product: str) -> list[Issue]:
+    start, end, body = _body_span(tac)
+    upper = body.upper()
+    issues: list[Issue] = []
+
+    if not _VALID_PERIOD.search(upper):
+        issues.append(
+            _issue(
+                "MISSING_VALID",
+                f"{product} missing VALID ddhhmm/ddhhmm period — A6 identity",
+                start=start,
+                end=end,
+                location="valid",
+            )
+        )
+
+    families = _SIGMET_FAMILIES if product == "SIGMET" else _AIRMET_FAMILIES
+    hit = _count_families(upper, families)
+    if len(hit) > 1:
+        issues.append(
+            _issue(
+                "MULTIPLE_PHENOMENA",
+                f"{product} encodes multiple phenomenon families {hit} — A6 one-phenomenon gate",
+                start=start,
+                end=end,
+                location="phenomenon",
+            )
+        )
+
+    return issues
+
+
+def _check_vaa(tac: str) -> list[Issue]:
+    start, end, body = _body_span(tac)
+    issues: list[Issue] = []
+    if not _DTG_LINE.search(body):
+        issues.append(
+            _issue(
+                "MISSING_DTG",
+                "VAA missing DTG: template field — A2-1",
+                start=start,
+                end=end,
+                location="dtg",
+            )
+        )
+    if not _VAAC_LINE.search(body):
+        issues.append(
+            _issue(
+                "MISSING_VAAC",
+                "VAA missing VAAC: template field — A2-1",
+                start=start,
+                end=end,
+                location="vaac",
+            )
+        )
+    return issues
+
+
+def _check_tca(tac: str) -> list[Issue]:
+    start, end, body = _body_span(tac)
+    issues: list[Issue] = []
+    if not _DTG_LINE.search(body):
+        issues.append(
+            _issue(
+                "MISSING_DTG",
+                "TCA missing DTG: template field — A2-2",
+                start=start,
+                end=end,
+                location="dtg",
+            )
+        )
+    if not _MAX_WIND_LINE.search(body):
+        issues.append(
+            _issue(
+                "MISSING_MAX_WIND",
+                "TCA missing MAX WIND: template field — A2-2",
+                start=start,
+                end=end,
+                location="max_wind",
+            )
+        )
+    return issues
+
+
+def check_product_rules(tac_text: str, product: str) -> list[Issue]:
+    """
+    Run product checklist / template-gate rules after parse-gate success.
+
+    Parameters
+    ----------
+    tac_text :
+        Raw TAC text.
+    product :
+        F6 product id.
+
+    Returns
+    -------
+    list[Issue]
+        Error-severity findings with spans when possible.
+    """
+    if product in {"METAR", "SPECI"}:
+        return _check_metar_speci(tac_text, product)
+    if product == "TAF":
+        return _check_taf(tac_text)
+    if product in {"SIGMET", "AIRMET"}:
+        return _check_sigmet_airmet(tac_text, product)
+    if product == "VAA":
+        return _check_vaa(tac_text)
+    if product == "TCA":
+        return _check_tca(tac_text)
+    return []
+
+
+__all__ = ["check_product_rules"]

tac_validate/products.py

@@ -0,0 +1,18 @@
+"""Product constants and keyword map for the seven F6 TAC forms."""
+
+from __future__ import annotations
+
+PRODUCTS: tuple[str, ...] = ("AIRMET", "METAR", "SIGMET", "SPECI", "TAF", "VAA", "TCA")
+
+# Leading TAC keywords / bulletin markers used by the parse-gate skeleton.
+PRODUCT_KEYWORDS: dict[str, tuple[str, ...]] = {
+    "AIRMET": ("AIRMET",),
+    "METAR": ("METAR",),
+    "SIGMET": ("SIGMET",),
+    "SPECI": ("SPECI",),
+    "TAF": ("TAF",),
+    "VAA": ("VA ADVISORY", "VAA"),
+    "TCA": ("TC ADVISORY", "TCA"),
+}
+
+__all__ = ["PRODUCT_KEYWORDS", "PRODUCTS"]

tac_validate/rules.py

@@ -0,0 +1,120 @@
+"""Shared TAC business-rule pack skeleton (seven products)."""
+
+from __future__ import annotations
+
+from tac_validate.models import Fix, Issue
+from tac_validate.products import PRODUCT_KEYWORDS, PRODUCTS
+
+
+def _content_bounds(tac_text: str) -> tuple[int, int, str]:
+    """
+    Return inclusive start, exclusive end, and stripped body for ``tac_text``.
+
+    Offsets are relative to the original string so editors can highlight in-place.
+    Empty / whitespace-only input spans the entire original string.
+    """
+    stripped = tac_text.strip()
+    if not stripped:
+        return 0, len(tac_text), ""
+    leading = len(tac_text) - len(tac_text.lstrip())
+    return leading, leading + len(stripped), stripped
+
+
+def check_parse_gate(tac_text: str, product: str) -> tuple[list[Issue], list[Fix]]:
+    """
+    Run parse-gate checks shared across products.
+
+    Parameters
+    ----------
+    tac_text :
+        Raw TAC text.
+    product :
+        F6 product id.
+
+    Returns
+    -------
+    issues, fixes
+        Structured findings and optional repairs. Issues include ``start``/``end``
+        character offsets when the rule can locate a span in ``tac_text``.
+    """
+    issues: list[Issue] = []
+    fixes: list[Fix] = []
+
+    if product not in PRODUCTS:
+        issues.append(
+            Issue(
+                severity="error",
+                code="UNKNOWN_PRODUCT",
+                message=f"Unknown product {product!r}; expected one of {list(PRODUCTS)}",
+            )
+        )
+        return issues, fixes
+
+    start, end, stripped = _content_bounds(tac_text)
+    if not stripped:
+        issues.append(
+            Issue(
+                severity="error",
+                code="EMPTY_TAC",
+                message="TAC text is empty",
+                location="body",
+                start=start,
+                end=end,
+            )
+        )
+        return issues, fixes
+
+    keywords = PRODUCT_KEYWORDS[product]
+    upper = stripped.upper()
+    if not any(keyword in upper for keyword in keywords):
+        issues.append(
+            Issue(
+                severity="error",
+                code="MISSING_PRODUCT_KEYWORD",
+                message=f"{product} TAC must contain one of {list(keywords)}",
+                location="header",
+                start=start,
+                end=end,
+            )
+        )
+
+    # Common repairable: missing report terminator '=' on METAR/SPECI/TAF
+    if product in {"METAR", "SPECI", "TAF"} and not stripped.rstrip().endswith("="):
+        if not any(i.code == "MISSING_PRODUCT_KEYWORD" for i in issues):
+            core = stripped.rstrip()
+            # Highlight the final character of the report (terminator should follow).
+            term_end = start + len(core)
+            term_start = term_end - 1 if core else start
+            issues.append(
+                Issue(
+                    severity="info",
+                    code="MISSING_TERMINATOR",
+                    message="Reports in bulletins end with '=' — add it before publishing",
+                    location="terminator",
+                    start=term_start,
+                    end=term_end,
+                )
+            )
+            fixes.append(
+                Fix(
+                    code="add_terminator",
+                    message="Add '='",
+                    replacement=stripped.rstrip() + "=",
+                )
+            )
+
+    return issues, fixes
+
+
+def check_product_rules(tac_text: str, product: str) -> list[Issue]:
+    """
+    Product-specific checklist / template-gate rules (F12 / E10-21).
+
+    Delegates to ``product_rules`` after parse-gate success.
+    """
+    from tac_validate.product_rules import check_product_rules as _impl
+
+    return _impl(tac_text, product)
+
+
+__all__ = ["check_parse_gate", "check_product_rules"]

tac_validate-0.1.0.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: tac-validate
+Version: 0.1.0
+Summary: TAC parse gate and business-rule pack (F6 lint)
+License: MIT
+Requires-Python: >=3.12
+Requires-Dist: msgspec>=0.19
+Description-Content-Type: text/markdown
+
+# tac-validate
+
+TAC parse gate and shared business-rule pack for F6 products. MIT licensed.
+
+## Install
+
+```bash
+pip install tac-validate==0.1.0
+# or from the monorepo workspace:
+uv sync --package tac-validate
+```
+
+## Library
+
+```python
+from tac_validate import lint
+
+report = lint("METAR KJFK ...=", product="METAR")
+if not report.ok:
+    for issue in report.issues:
+        print(issue.code, issue.message)
+    for fix in report.fixes:
+        print(fix.code, fix.replacement)
+```
+
+## CLI
+
+```bash
+tac-validate --product METAR path/to/report.tac
+tac-validate --product METAR --json path/to/report.tac
+```
+
+Exit code `0` when lint `ok`; `1` when error-severity issues are present (or the file cannot be read).
+
+Rule depth (E10-21): METAR/SPECI/TAF full checklist; SIGMET/AIRMET/VAA/TCA template+gates.
+Citations live in `docs/domain/TAC_VALIDATION.md` — no Annex prose in the wheel.
+
+See ADR-015 / ADR-016. No FastAPI/Supabase imports; HTTP maps msgspec → pydantic.

tac_validate-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+tac_validate/__init__.py,sha256=HytxKloGsoa2Vpz2DqJYpks7OYoYv1lwuPwMPrC_ZH8,324
+tac_validate/api.py,sha256=7rxhXBCTa31zLC5rm7ENNrBnpYAWwVlF_sEErAzQoBQ,1068
+tac_validate/cli.py,sha256=r3V-TInkPHCGrEsdlvHraMgG3ZXxctUzeSpZ9l9iHmg,2150
+tac_validate/codec.py,sha256=HYBQ0ToQk7aI5qUZu0DpqL79kdrT9Jt72gLPoEQl-Qc,287
+tac_validate/models.py,sha256=3KFdyBi3KZVlnwLwXYWEJC6j_2MZXWNNx8ul5wRocKY,1617
+tac_validate/product_rules.py,sha256=bkiK8ZvsU2F7OeiOmvvezygDFK4YwfYC1zaVhRH-fh0,10805
+tac_validate/products.py,sha256=Yb2U3AdqN76jlSFyHawdDy5Waj3eqFUmZmeF4PtQvik,559
+tac_validate/rules.py,sha256=lG9vHE8ABu6L9rPgbRFahoIWka8LblDvaptq8CTY7Ac,3785
+tac_validate-0.1.0.dist-info/METADATA,sha256=uZC5c4Vd8DZcpq6Y3E4KMrYdO4ynCpGJSwnO9LDQ8Qk,1191
+tac_validate-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+tac_validate-0.1.0.dist-info/entry_points.txt,sha256=xlQaW5C352r0GtFGdNAdUyLYNKwgpA6FcExgUjn9EME,55
+tac_validate-0.1.0.dist-info/RECORD,,

tac_validate-0.1.0.dist-info/WHEEL

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

tac_validate-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tac-validate = tac_validate.cli:main