gstwatch 0.1.0__tar.gz

gstwatch-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 calasdan-sketch
+
+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.

gstwatch-0.1.0/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: gstwatch
+Version: 0.1.0
+Summary: GST/HST small-supplier companion: C$30k threshold tests, registration timing, filing frequency, 6-year record retention
+Author: calasdan-sketch
+License-Expression: MIT
+Keywords: gst,hst,cra,small-supplier,threshold,registration,canada,tax
+Classifier: Programming Language :: Python :: 3
+Classifier: Environment :: Console
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# gstwatch
+
+**The C$30,000 GST/HST threshold has two tests, a 29-day registration clock, and a 6-year memory.** `gstwatch` applies Canada's published small-supplier rules to your quarterly revenue and tells you: are you still a small supplier, when registration takes effect, when you must register by, what filing frequency CRA will assign, and how long to keep records.
+
+Rules verified against Canada.ca, October 2026. **Not tax advice** — it applies published rules to your numbers and shows its work.
+
+## Install
+
+```bash
+pip install gstwatch
+```
+
+## Check the threshold
+
+```bash
+gstwatch check --quarter 2025-12-31=8000 --quarter 2026-03-31=8000 \
+               --quarter 2026-06-30=8000 --quarter 2026-09-30=8000
+
+# or from a CSV: quarter_end,amount
+gstwatch check quarters.csv
+```
+
+Both CRA tests are run:
+
+1. **Single quarter** — one calendar quarter alone over C$30,000: you must charge GST/HST on the supply that takes you over; effective registration is no later than that supply; **register within 29 days**. Pass `--crossing YYYY-MM-DD` if you know the exact supply date (otherwise the quarter end is used and the output says so).
+2. **Four-or-fewer consecutive quarters** — total over C$30,000: small-supplier status ends at the **end of the month following** the quarter in which you crossed; collect from the first supply after that; register within 29 days of that effective date.
+
+Exit codes: `0` still a small supplier, `3` registration required (distinct on purpose, so scripts can branch), `2` usage error. `--json` for automation.
+
+## Filing frequency
+
+```bash
+gstwatch freq 1400000     # -> annual   (assigned: annual <= C$1.5M)
+gstwatch freq 7000000     # -> monthly  (quarterly up to C$6M, monthly above)
+```
+
+## Record retention
+
+```bash
+gstwatch records 2026-05-10   # -> keep records until 2032-12-31
+```
+
+Six years from the **end of the year** the record relates to.
+
+## What's modeled — and what isn't
+
+Modeled: the two threshold tests, 29-day registration clock, effective-date rules (single vs rolling), assigned filing bands, 6-year retention.
+
+**Not** modeled: the detailed supply inclusions/exclusions (exempt supplies, financial services, capital property, goodwill, associates' rules), voluntary-registration date elections and the one-year minimum, deregistration decisions, and filing obligations themselves. The threshold test includes worldwide taxable supplies (including zero-rated) per CRA's description — bring your accountant for the exclusions.
+
+Sources: [when to register and start charging](https://www.canada.ca/en/revenue-agency/services/tax/businesses/topics/gst-hst-businesses/when-register-charge.html) · [assigned reporting periods](https://www.canada.ca/en/revenue-agency/services/tax/businesses/topics/gst-hst-businesses/gst-hst-account/change-account.html) · [records to keep](https://www.canada.ca/en/revenue-agency/services/tax/businesses/topics/gst-hst-businesses/calculate-prepare-report/gst-hst-records-keep.html)
+
+## License
+
+MIT-style: use it, ship it, no warranty.

gstwatch-0.1.0/README.md

@@ -0,0 +1,55 @@
+# gstwatch
+
+**The C$30,000 GST/HST threshold has two tests, a 29-day registration clock, and a 6-year memory.** `gstwatch` applies Canada's published small-supplier rules to your quarterly revenue and tells you: are you still a small supplier, when registration takes effect, when you must register by, what filing frequency CRA will assign, and how long to keep records.
+
+Rules verified against Canada.ca, October 2026. **Not tax advice** — it applies published rules to your numbers and shows its work.
+
+## Install
+
+```bash
+pip install gstwatch
+```
+
+## Check the threshold
+
+```bash
+gstwatch check --quarter 2025-12-31=8000 --quarter 2026-03-31=8000 \
+               --quarter 2026-06-30=8000 --quarter 2026-09-30=8000
+
+# or from a CSV: quarter_end,amount
+gstwatch check quarters.csv
+```
+
+Both CRA tests are run:
+
+1. **Single quarter** — one calendar quarter alone over C$30,000: you must charge GST/HST on the supply that takes you over; effective registration is no later than that supply; **register within 29 days**. Pass `--crossing YYYY-MM-DD` if you know the exact supply date (otherwise the quarter end is used and the output says so).
+2. **Four-or-fewer consecutive quarters** — total over C$30,000: small-supplier status ends at the **end of the month following** the quarter in which you crossed; collect from the first supply after that; register within 29 days of that effective date.
+
+Exit codes: `0` still a small supplier, `3` registration required (distinct on purpose, so scripts can branch), `2` usage error. `--json` for automation.
+
+## Filing frequency
+
+```bash
+gstwatch freq 1400000     # -> annual   (assigned: annual <= C$1.5M)
+gstwatch freq 7000000     # -> monthly  (quarterly up to C$6M, monthly above)
+```
+
+## Record retention
+
+```bash
+gstwatch records 2026-05-10   # -> keep records until 2032-12-31
+```
+
+Six years from the **end of the year** the record relates to.
+
+## What's modeled — and what isn't
+
+Modeled: the two threshold tests, 29-day registration clock, effective-date rules (single vs rolling), assigned filing bands, 6-year retention.
+
+**Not** modeled: the detailed supply inclusions/exclusions (exempt supplies, financial services, capital property, goodwill, associates' rules), voluntary-registration date elections and the one-year minimum, deregistration decisions, and filing obligations themselves. The threshold test includes worldwide taxable supplies (including zero-rated) per CRA's description — bring your accountant for the exclusions.
+
+Sources: [when to register and start charging](https://www.canada.ca/en/revenue-agency/services/tax/businesses/topics/gst-hst-businesses/when-register-charge.html) · [assigned reporting periods](https://www.canada.ca/en/revenue-agency/services/tax/businesses/topics/gst-hst-businesses/gst-hst-account/change-account.html) · [records to keep](https://www.canada.ca/en/revenue-agency/services/tax/businesses/topics/gst-hst-businesses/calculate-prepare-report/gst-hst-records-keep.html)
+
+## License
+
+MIT-style: use it, ship it, no warranty.

gstwatch-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "gstwatch"
+version = "0.1.0"
+description = "GST/HST small-supplier companion: C$30k threshold tests, registration timing, filing frequency, 6-year record retention"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [{ name = "calasdan-sketch" }]
+keywords = ["gst", "hst", "cra", "small-supplier", "threshold", "registration", "canada", "tax"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Environment :: Console",
+    "Topic :: Office/Business :: Financial",
+]
+
+[project.scripts]
+gstwatch = "gstwatch.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

gstwatch-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

gstwatch-0.1.0/src/gstwatch/__init__.py

@@ -0,0 +1,11 @@
+"""gstwatch — GST/HST small-supplier threshold companion.
+
+Rules verified against Canada.ca in October 2026 (see README). Not tax advice:
+it applies the published rules to the numbers you give it and shows its work.
+"""
+
+from .evaluate import Status, evaluate, filing_frequency, retention_deadline, quarter_end
+
+__version__ = "0.1.0"
+__all__ = ["Status", "evaluate", "filing_frequency", "retention_deadline", "quarter_end",
+           "__version__"]

gstwatch-0.1.0/src/gstwatch/cli.py

@@ -0,0 +1,127 @@
+"""gstwatch CLI: threshold check, filing frequency, record retention dates."""
+from __future__ import annotations
+
+import argparse
+import csv
+import datetime as dt
+import json
+import sys
+from typing import List
+
+from . import __version__
+from .evaluate import Quarter, evaluate, filing_frequency, retention_deadline
+
+
+def _date(text: str) -> dt.date:
+    try:
+        return dt.date.fromisoformat(text)
+    except ValueError:
+        raise argparse.ArgumentTypeError(f"expected YYYY-MM-DD, got {text!r}")
+
+
+def load_quarters(path: str) -> List[Quarter]:
+    """CSV with columns quarter_end,amount (extra columns ignored)."""
+    out: List[Quarter] = []
+    try:
+        with open(path, newline="", encoding="utf-8-sig") as fh:
+            reader = csv.DictReader(fh)
+            fields = {(f or "").strip().lower() for f in (reader.fieldnames or [])}
+            if "quarter_end" not in fields or "amount" not in fields:
+                raise ValueError("CSV needs quarter_end and amount columns")
+            for row in reader:
+                norm = {(k or "").strip().lower(): (v or "").strip() for k, v in row.items()}
+                out.append((dt.date.fromisoformat(norm["quarter_end"]),
+                            float(norm["amount"].replace(",", "").replace("$", ""))))
+    except FileNotFoundError:
+        raise SystemExit(f"gstwatch: not found: {path}")
+    if not out:
+        raise SystemExit(f"gstwatch: no quarters in {path}")
+    return out
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(
+        prog="gstwatch",
+        description="GST/HST small-supplier threshold tests and dates (CRA rules, Oct 2026). "
+                    "Not tax advice.",
+    )
+    ap.add_argument("--version", action="version", version=f"gstwatch {__version__}")
+    ap.add_argument("--json", action="store_true")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    c = sub.add_parser("check", help="run the small-supplier tests over your quarters")
+    c.add_argument("csvfile", nargs="?", help="CSV: quarter_end,amount")
+    c.add_argument("--quarter", action="append", metavar="YYYY-MM-DD=AMOUNT",
+                   help="inline quarter (repeatable; combined with csvfile if given)")
+    c.add_argument("--crossing", type=_date, help="exact date of the supply that crossed the threshold")
+    c.add_argument("--json", action="store_true", default=argparse.SUPPRESS,
+                   help="machine-readable output (also accepted before the subcommand)")
+
+    f = sub.add_parser("freq", help="assigned filing frequency from annualized supplies")
+    f.add_argument("annualized", type=float, help="worldwide taxable supplies, annualized")
+    f.add_argument("--json", action="store_true", default=argparse.SUPPRESS)
+
+    r = sub.add_parser("records", help="6-year record retention deadline for a transaction")
+    r.add_argument("transaction", type=_date)
+    r.add_argument("--json", action="store_true", default=argparse.SUPPRESS)
+
+    args = ap.parse_args(argv)
+
+    if args.cmd == "freq":
+        band = filing_frequency(args.annualized)
+        if args.json:
+            print(json.dumps({"annualized": args.annualized, "filing_frequency": band}))
+        else:
+            print(f"C${args.annualized:,.0f} annualized -> {band} filing "
+                  "(CRA assigned periods: annual <= 1.5M, quarterly <= 6M, monthly above)")
+        return 0
+
+    if args.cmd == "records":
+        deadline = retention_deadline(args.transaction)
+        if args.json:
+            print(json.dumps({"transaction": args.transaction.isoformat(),
+                              "retain_until": deadline.isoformat()}))
+        else:
+            print(f"Transaction {args.transaction.isoformat()}: keep records until "
+                  f"{deadline.isoformat()} (6 years from the end of the year it relates to)")
+        return 0
+
+    quarters: List[Quarter] = []
+    if args.csvfile:
+        try:
+            quarters.extend(load_quarters(args.csvfile))
+        except ValueError as e:
+            print(f"gstwatch: {e}", file=sys.stderr)
+            return 2
+    for inline in args.quarter or []:
+        try:
+            d, amt = inline.split("=", 1)
+            quarters.append((dt.date.fromisoformat(d), float(amt.replace(",", ""))))
+        except (ValueError, AttributeError):
+            print(f"gstwatch: bad --quarter {inline!r}, expected YYYY-MM-DD=AMOUNT", file=sys.stderr)
+            return 2
+    if not quarters:
+        print("gstwatch: give a CSV file or at least one --quarter", file=sys.stderr)
+        return 2
+
+    status = evaluate(quarters, crossing_date=args.crossing)
+    if args.json:
+        print(json.dumps(status.as_dict(), indent=2))
+        return 0 if status.small_supplier else 3
+
+    print(f"Total across {len(quarters)} quarter(s): C${status.total:,.2f}")
+    print(f"Filing frequency (assigned): {status.filing_frequency}")
+    print(f"Small supplier: {'YES' if status.small_supplier else 'NO'} (trigger: {status.trigger})")
+    if status.effective_date:
+        print(f"Effective registration date: {status.effective_date.isoformat()}")
+        print(f"Register by:                {status.register_by.isoformat()} "
+              "(29 days from the effective date)")
+    for note in status.notes:
+        print(f"  - {note}")
+    print("\nPublished CRA rules applied to your numbers — not tax advice.")
+    # 3 = exceeded, useful for scripts that treat "needs registration" distinctly
+    return 0 if status.small_supplier else 3
+
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main())

gstwatch-0.1.0/src/gstwatch/evaluate.py

@@ -0,0 +1,144 @@
+"""Small-supplier tests and the dates CRA's rules produce.
+
+Verified October 2026 (canada.ca):
+* C$30,000 threshold: exceeded in ONE calendar quarter, or across FOUR OR
+  FEWER consecutive calendar quarters (worldwide taxable supplies incl.
+  zero-rated supplies and associates', minus the listed exclusions).
+* Single-quarter exceedance: charge GST/HST on the supply that takes you over;
+  effective registration no later than that supply; register within 29 days.
+* Rolling exceedance: small-supplier status ends the END OF THE MONTH
+  FOLLOWING the quarter in which the threshold was exceeded; collect from the
+  first supply after that; register within 29 days of the effective date.
+* Assigned filing periods: annual at <= C$1.5M; quarterly > C$1.5M to C$6M;
+  monthly > C$6M.
+* Records: keep 6 years from the end of the year to which they relate.
+"""
+from __future__ import annotations
+
+import calendar
+import datetime as dt
+from dataclasses import dataclass, field
+from typing import List, Optional, Sequence, Tuple
+
+THRESHOLD = 30000
+REGISTER_DAYS = 29
+FILING_ANNUAL_MAX = 1_500_000
+FILING_QUARTERLY_MAX = 6_000_000
+
+Quarter = Tuple[dt.date, float]  # (quarter end, taxable supplies)
+
+
+def quarter_end(year: int, quarter: int) -> dt.date:
+    month = quarter * 3
+    return dt.date(year, month, calendar.monthrange(year, month)[1])
+
+
+def next_month_end(d: dt.date) -> dt.date:
+    year, month = (d.year + 1, 1) if d.month == 12 else (d.year, d.month + 1)
+    return dt.date(year, month, calendar.monthrange(year, month)[1])
+
+
+@dataclass
+class Status:
+    total: float
+    small_supplier: bool
+    trigger: str                       # none | single-quarter | rolling
+    crossing_quarter: Optional[dt.date] = None
+    window: List[dt.date] = field(default_factory=list)
+    window_total: float = 0.0
+    effective_date: Optional[dt.date] = None
+    register_by: Optional[dt.date] = None
+    filing_frequency: str = ""
+    notes: List[str] = field(default_factory=list)
+
+    def as_dict(self):
+        return {
+            "total": self.total,
+            "small_supplier": self.small_supplier,
+            "trigger": self.trigger,
+            "crossing_quarter": self.crossing_quarter.isoformat() if self.crossing_quarter else None,
+            "window": [d.isoformat() for d in self.window],
+            "window_total": self.window_total,
+            "effective_date": self.effective_date.isoformat() if self.effective_date else None,
+            "register_by": self.register_by.isoformat() if self.register_by else None,
+            "filing_frequency": self.filing_frequency,
+            "notes": self.notes,
+        }
+
+
+def evaluate(quarters: Sequence[Quarter],
+             threshold: float = THRESHOLD,
+             crossing_date: Optional[dt.date] = None) -> Status:
+    """Apply both small-supplier tests to ordered (quarter_end, amount) pairs."""
+    qs = sorted(quarters, key=lambda q: q[0])
+    if not qs:
+        raise ValueError("no quarters supplied")
+    total = sum(amount for _, amount in qs)
+    annualized = total * 4 if len(qs) < 4 else total
+    freq = filing_frequency(annualized)
+
+    # Test 1: a single quarter over the threshold
+    for end, amount in qs:
+        if amount > threshold:
+            effective = crossing_date or end
+            return Status(
+                total=total, small_supplier=False, trigger="single-quarter",
+                crossing_quarter=end, window=[end], window_total=amount,
+                effective_date=effective,
+                register_by=effective + dt.timedelta(days=REGISTER_DAYS),
+                filing_frequency=freq,
+                notes=[
+                    f"one quarter alone is C${amount:,.2f} > C${threshold:,.0f}",
+                    "charge GST/HST on the supply that takes you over the threshold; "
+                    f"effective registration is no later than that supply"
+                    + (f" (you supplied {crossing_date.isoformat()})" if crossing_date else
+                       " — pass --crossing YYYY-MM-DD if you know the exact supply date; "
+                       "using the quarter end as the best known date"),
+                    f"register within {REGISTER_DAYS} days of the effective date",
+                ],
+            )
+
+    # Test 2: four-or-fewer consecutive quarters together over the threshold
+    best: Optional[Tuple[List[Quarter], float]] = None
+    for size in range(2, 5):  # 2, 3, 4 consecutive quarters
+        for i in range(len(qs) - size + 1):
+            window = qs[i:i + size]
+            s = sum(a for _, a in window)
+            if s > threshold and (best is None or window[-1][0] < best[0][-1][0]):
+                best = (window, s)
+    if best:
+        window, s = best
+        crossing_end = window[-1][0]
+        effective = next_month_end(crossing_end)
+        return Status(
+            total=total, small_supplier=False, trigger="rolling",
+            crossing_quarter=crossing_end, window=[w[0] for w in window], window_total=s,
+            effective_date=effective,
+            register_by=effective + dt.timedelta(days=REGISTER_DAYS),
+            filing_frequency=freq,
+            notes=[
+                f"{len(window)} consecutive quarter(s) total C${s:,.2f} > C${threshold:,.0f}",
+                "small-supplier status ends at the end of the month following the quarter "
+                "in which the threshold was exceeded",
+                "start charging on the first supply after that date; "
+                f"register within {REGISTER_DAYS} days of the effective date",
+            ],
+        )
+
+    return Status(total=total, small_supplier=True, trigger="none", filing_frequency=freq,
+                  notes=[f"total C${total:,.2f} stays within C${threshold:,.0f} "
+                         "for both tests (any single quarter, and 4-or-fewer consecutive quarters)"])
+
+
+def filing_frequency(annualized: float) -> str:
+    """CRA assigned reporting periods by worldwide taxable supplies."""
+    if annualized <= FILING_ANNUAL_MAX:
+        return "annual"
+    if annualized <= FILING_QUARTERLY_MAX:
+        return "quarterly"
+    return "monthly"
+
+
+def retention_deadline(transaction_date: dt.date) -> dt.date:
+    """Keep records 6 years from the END of the year they relate to."""
+    return dt.date(transaction_date.year + 6, 12, 31)

gstwatch-0.1.0/src/gstwatch.egg-info/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: gstwatch
+Version: 0.1.0
+Summary: GST/HST small-supplier companion: C$30k threshold tests, registration timing, filing frequency, 6-year record retention
+Author: calasdan-sketch
+License-Expression: MIT
+Keywords: gst,hst,cra,small-supplier,threshold,registration,canada,tax
+Classifier: Programming Language :: Python :: 3
+Classifier: Environment :: Console
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# gstwatch
+
+**The C$30,000 GST/HST threshold has two tests, a 29-day registration clock, and a 6-year memory.** `gstwatch` applies Canada's published small-supplier rules to your quarterly revenue and tells you: are you still a small supplier, when registration takes effect, when you must register by, what filing frequency CRA will assign, and how long to keep records.
+
+Rules verified against Canada.ca, October 2026. **Not tax advice** — it applies published rules to your numbers and shows its work.
+
+## Install
+
+```bash
+pip install gstwatch
+```
+
+## Check the threshold
+
+```bash
+gstwatch check --quarter 2025-12-31=8000 --quarter 2026-03-31=8000 \
+               --quarter 2026-06-30=8000 --quarter 2026-09-30=8000
+
+# or from a CSV: quarter_end,amount
+gstwatch check quarters.csv
+```
+
+Both CRA tests are run:
+
+1. **Single quarter** — one calendar quarter alone over C$30,000: you must charge GST/HST on the supply that takes you over; effective registration is no later than that supply; **register within 29 days**. Pass `--crossing YYYY-MM-DD` if you know the exact supply date (otherwise the quarter end is used and the output says so).
+2. **Four-or-fewer consecutive quarters** — total over C$30,000: small-supplier status ends at the **end of the month following** the quarter in which you crossed; collect from the first supply after that; register within 29 days of that effective date.
+
+Exit codes: `0` still a small supplier, `3` registration required (distinct on purpose, so scripts can branch), `2` usage error. `--json` for automation.
+
+## Filing frequency
+
+```bash
+gstwatch freq 1400000     # -> annual   (assigned: annual <= C$1.5M)
+gstwatch freq 7000000     # -> monthly  (quarterly up to C$6M, monthly above)
+```
+
+## Record retention
+
+```bash
+gstwatch records 2026-05-10   # -> keep records until 2032-12-31
+```
+
+Six years from the **end of the year** the record relates to.
+
+## What's modeled — and what isn't
+
+Modeled: the two threshold tests, 29-day registration clock, effective-date rules (single vs rolling), assigned filing bands, 6-year retention.
+
+**Not** modeled: the detailed supply inclusions/exclusions (exempt supplies, financial services, capital property, goodwill, associates' rules), voluntary-registration date elections and the one-year minimum, deregistration decisions, and filing obligations themselves. The threshold test includes worldwide taxable supplies (including zero-rated) per CRA's description — bring your accountant for the exclusions.
+
+Sources: [when to register and start charging](https://www.canada.ca/en/revenue-agency/services/tax/businesses/topics/gst-hst-businesses/when-register-charge.html) · [assigned reporting periods](https://www.canada.ca/en/revenue-agency/services/tax/businesses/topics/gst-hst-businesses/gst-hst-account/change-account.html) · [records to keep](https://www.canada.ca/en/revenue-agency/services/tax/businesses/topics/gst-hst-businesses/calculate-prepare-report/gst-hst-records-keep.html)
+
+## License
+
+MIT-style: use it, ship it, no warranty.

gstwatch-0.1.0/src/gstwatch.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/gstwatch/__init__.py
+src/gstwatch/cli.py
+src/gstwatch/evaluate.py
+src/gstwatch.egg-info/PKG-INFO
+src/gstwatch.egg-info/SOURCES.txt
+src/gstwatch.egg-info/dependency_links.txt
+src/gstwatch.egg-info/entry_points.txt
+src/gstwatch.egg-info/top_level.txt
+tests/test_cli.py
+tests/test_evaluate.py

gstwatch-0.1.0/src/gstwatch.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

gstwatch-0.1.0/src/gstwatch.egg-info/entry_points.txt

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

gstwatch-0.1.0/src/gstwatch.egg-info/top_level.txt

@@ -0,0 +1 @@
+gstwatch

gstwatch-0.1.0/tests/test_cli.py

@@ -0,0 +1,69 @@
+"""CLI tests."""
+import json
+
+from gstwatch.cli import main
+
+
+def write_csv(tmp, rows):
+    p = tmp / "quarters.csv"
+    p.write_text("quarter_end,amount\n" + "\n".join(f"{d},{a}" for d, a in rows) + "\n",
+                 encoding="utf-8")
+    return str(p)
+
+
+def test_check_below_threshold(capsys):
+    assert main(["check", "--quarter", "2026-03-31=7000", "--quarter", "2026-06-30=7000"]) == 0
+    out = capsys.readouterr().out
+    assert "Small supplier: YES" in out and "not tax advice" in out
+
+
+def test_check_exceeded_returns_3(tmp_path, capsys):
+    csv = write_csv(tmp_path, [("2026-03-31", "31000")])
+    assert main(["check", csv]) == 3
+    out = capsys.readouterr().out
+    assert "Register by:                2026-04-29" in out
+
+
+def test_check_json(tmp_path, capsys):
+    csv = write_csv(tmp_path, [("2026-03-31", "8000"), ("2026-06-30", "8000"),
+                          ("2026-09-30", "8000"), ("2026-12-31", "8000")])
+    assert main(["check", csv, "--json"]) == 3
+    data = json.loads(capsys.readouterr().out)
+    assert data["trigger"] == "rolling" and data["effective_date"] == "2027-01-31"
+
+
+def test_crossing_flag(tmp_path, capsys):
+    csv = write_csv(tmp_path, [("2026-03-31", "31000")])
+    assert main(["check", csv, "--crossing", "2026-02-15"]) == 3
+    assert "2026-02-15" in capsys.readouterr().out
+
+
+def test_freq(capsys):
+    assert main(["freq", "1400000"]) == 0
+    assert "annual" in capsys.readouterr().out
+    assert main(["freq", "7000000"]) == 0
+    assert "monthly" in capsys.readouterr().out
+
+
+def test_records(capsys):
+    assert main(["records", "2026-05-10"]) == 0
+    assert "2032-12-31" in capsys.readouterr().out
+    assert main(["records", "2026-05-10", ]) == 0
+
+
+def test_records_json(capsys):
+    assert main(["records", "2026-05-10"]) == 0
+    capsys.readouterr()
+    assert main(["--json", "records", "2026-05-10"]) == 0
+    assert json.loads(capsys.readouterr().out)["retain_until"] == "2032-12-31"
+
+
+def test_no_input_is_usage_error(capsys):
+    assert main(["check"]) == 2
+    assert main(["check", "--quarter", "bogus"]) == 2
+
+
+def test_bad_csv_columns(tmp_path, capsys):
+    p = tmp_path / "bad.csv"
+    p.write_text("date,amount\n2026-03-31,100\n", encoding="utf-8")
+    assert main(["check", str(p)]) == 2

gstwatch-0.1.0/tests/test_evaluate.py

@@ -0,0 +1,99 @@
+"""Threshold evaluation tests — dates hand-computed from the verified rules."""
+import datetime as dt
+
+import pytest
+
+from gstwatch.evaluate import (
+    evaluate,
+    filing_frequency,
+    next_month_end,
+    quarter_end,
+    retention_deadline,
+)
+
+D = dt.date
+
+
+def test_quarter_ends():
+    assert quarter_end(2026, 1) == D(2026, 3, 31)
+    assert quarter_end(2026, 4) == D(2026, 12, 31)
+    assert quarter_end(2028, 1) == D(2028, 3, 31)  # leap Feb
+
+
+def test_next_month_end():
+    assert next_month_end(D(2026, 9, 30)) == D(2026, 10, 31)
+    assert next_month_end(D(2026, 12, 31)) == D(2027, 1, 31)
+    assert next_month_end(D(2026, 2, 28)) == D(2026, 3, 31)
+
+
+def test_below_threshold_is_small_supplier():
+    qs = [(D(2025, 12, 31), 7000), (D(2026, 3, 31), 7000),
+          (D(2026, 6, 30), 7000), (D(2026, 9, 30), 7000)]
+    s = evaluate(qs)
+    assert s.small_supplier and s.trigger == "none"
+    assert s.effective_date is None and s.filing_frequency == "annual"
+
+
+def test_single_quarter_trigger_and_dates():
+    s = evaluate([(D(2026, 3, 31), 31000)])
+    assert not s.small_supplier and s.trigger == "single-quarter"
+    assert s.effective_date == D(2026, 3, 31)
+    assert s.register_by == D(2026, 4, 29)          # +29 days
+    assert any("supply that takes you over" in n for n in s.notes)
+
+
+def test_crossing_date_override():
+    s = evaluate([(D(2026, 3, 31), 31000)], crossing_date=D(2026, 2, 15))
+    assert s.effective_date == D(2026, 2, 15)
+    assert s.register_by == D(2026, 3, 16)          # Feb 15 + 29
+
+
+def test_exact_threshold_not_exceeded():
+    # "exceed" means strictly more than C$30,000
+    assert evaluate([(D(2026, 3, 31), 30000)]).small_supplier
+    qs = [(D(2025, 12, 31), 10000), (D(2026, 3, 31), 10000),
+          (D(2026, 6, 30), 10000), (D(2026, 9, 30), 0)]
+    assert evaluate(qs).small_supplier                # four quarters = 30,000 exactly
+
+
+def test_rolling_four_quarter_trigger():
+    qs = [(D(2025, 12, 31), 8000), (D(2026, 3, 31), 8000),
+          (D(2026, 6, 30), 8000), (D(2026, 9, 30), 8000)]
+    s = evaluate(qs)
+    assert not s.small_supplier and s.trigger == "rolling"
+    assert s.crossing_quarter == D(2026, 9, 30)
+    assert s.window_total == 32000
+    assert s.effective_date == D(2026, 10, 31)       # end of month FOLLOWING the quarter
+    assert s.register_by == D(2026, 11, 29)          # +29 days
+    assert any("end of the month following" in n for n in s.notes)
+
+
+def test_rolling_window_of_two():
+    qs = [(D(2026, 3, 31), 16000), (D(2026, 6, 30), 16000)]
+    s = evaluate(qs)
+    assert s.trigger == "rolling" and len(s.window) == 2
+    assert s.effective_date == D(2026, 7, 31)
+
+
+def test_filing_frequency_bands():
+    assert filing_frequency(0) == "annual"
+    assert filing_frequency(1_500_000) == "annual"       # <= 1.5M
+    assert filing_frequency(1_500_001) == "quarterly"
+    assert filing_frequency(6_000_000) == "quarterly"    # <= 6M
+    assert filing_frequency(6_000_001) == "monthly"
+
+
+def test_retention_deadline():
+    assert retention_deadline(D(2026, 5, 10)) == D(2032, 12, 31)  # 6 years from end of year
+    assert retention_deadline(D(2026, 12, 31)) == D(2032, 12, 31)
+
+
+def test_empty_input_rejected():
+    with pytest.raises(ValueError):
+        evaluate([])
+
+
+def test_as_dict_shape():
+    d = evaluate([(D(2026, 3, 31), 31000)]).as_dict()
+    assert d["trigger"] == "single-quarter" and d["register_by"] == "2026-04-29"
+    assert isinstance(d["notes"], list)