lodgment-calendar 0.1.0__py3-none-any.whl

lodgment_calendar-0.1.0.dist-info/METADATA

@@ -0,0 +1,177 @@
+Metadata-Version: 2.4
+Name: lodgment-calendar
+Version: 0.1.0
+Summary: ATO lodgment program due dates for BAS, IAS and income tax returns, with cited rules and UNKNOWN for missing facts. Preparation aid, not a determination.
+Author: Ryan Duguid
+License-Expression: FSL-1.1-ALv2
+Project-URL: Homepage, https://github.com/ryanduguid/australian-accounting/tree/main/packages/lodgment-calendar
+Project-URL: Repository, https://github.com/ryanduguid/australian-accounting/tree/main/packages/lodgment-calendar
+Project-URL: Issues, https://github.com/ryanduguid/australian-accounting/issues
+Keywords: australia,ato,lodgment-program,bas,tax-agent,bas-agent,due-dates
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Office/Business :: Financial :: Accounting
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Provides-Extra: dev
+Requires-Dist: ruff==0.17.0; extra == "dev"
+Requires-Dist: pyright[nodejs]==1.1.414; extra == "dev"
+Requires-Dist: nodejs-wheel-binaries==24.19.0; extra == "dev"
+Requires-Dist: pytest==9.1.1; extra == "dev"
+Requires-Dist: coverage==7.16.2; extra == "dev"
+Requires-Dist: pytest-cov==7.1.0; extra == "dev"
+Requires-Dist: build==1.6.1; extra == "dev"
+Requires-Dist: setuptools==84.2.1; extra == "dev"
+Dynamic: license-file
+
+# Lodgment calendar
+
+`lodgment-calendar` works out lodgement and payment due dates for BAS, IAS and income tax
+returns under the ATO's 2026–27 lodgment program, for self-lodgers and for clients of
+registered tax and BAS agents. Each date carries its rule, the ATO page it comes from and
+the date that page was checked. A date that depends on a fact you did not supply, or that
+the ATO pages leave open, comes back `UNKNOWN` with the missing condition named.
+
+Distribution `lodgment-calendar`, import package `lodgmentcalendar`. Library only: this
+component ships no command.
+
+**Package lifecycle:** published. Install `lodgment-calendar` from PyPI with
+`pip install lodgment-calendar`; see [release notes](RELEASE_NOTES.md) and
+[DISCLAIMER.md](DISCLAIMER.md).
+
+It is a preparation aid. It reads the facts you pass, contacts no service, calls no ATO
+API and lodges nothing. Ryan Duguid is not a registered tax agent or BAS agent. Project
+support is limited to software issues reproduced with fabricated data. Do not send
+taxpayer information.
+
+## Example
+
+```python
+from lodgmentcalendar import Facts, due_dates
+
+result = due_dates(
+    "bas", "company", "2026-27", "bas_agent", reporting_cycle="quarterly",
+    facts=Facts(consolidated_head_company=False, lodges_electronically=True,
+                previous_statement_lodged_electronically=True,
+                includes_monthly_payg_obligation=False),
+)
+for row in result["obligations"]:
+    print(row["period"], row["status"], row["nominal_due_date"], row["due_date"], row["rule_id"])
+```
+
+```
+2026-27 Q1 DETERMINED 2026-11-25 2026-11-25 AS-Q-AGENT
+2026-27 Q2 DETERMINED 2027-02-28 2027-03-02 AS-Q-28
+2026-27 Q3 DETERMINED 2027-05-26 2027-05-26 AS-Q-AGENT
+2026-27 Q4 UNKNOWN 2027-08-25 None AS-Q-AGENT
+```
+
+Quarter 2 is due on Sunday 28 February 2027. Monday 1 March is Labour Day in Western
+Australia, which moves the date for every state, so the statement is due on 2 March.
+Quarter 4 is `UNKNOWN` because the ATO marks 25 August 2027 'to be confirmed'.
+
+## Inputs
+
+`due_dates(obligation, entity_type, financial_year, channel, *, reporting_cycle=None, facts=None, extra_holidays=None, holidays_complete_until=None)`
+
+| Input | Values |
+| --- | --- |
+| `obligation` | `bas`, `ias` or `income_tax_return` |
+| `entity_type` | `individual`, `trust`, `partnership`, `company` or `smsf` |
+| `financial_year` | The year of the statement periods, or the income year a return covers, as `2026-27` |
+| `channel` | `self`, `tax_agent` or `bas_agent` (a BAS agent cannot lodge an income tax return) |
+| `reporting_cycle` | `monthly` or `quarterly`, for `bas` and `ias` only. A monthly `bas` reports GST monthly; other monthly activity statements are `ias`. For a consolidated head company, a quarterly `ias` is its PAYG instalment activity statement |
+| `facts` | A `Facts` with the conditions below; each is `True`, `False` or `None` (not supplied) |
+| `extra_holidays` | Up to 50 `date: name` holidays the ATO table does not list (see below) |
+| `holidays_complete_until` | A `date` to which the ATO table and `extra_holidays` hold every holiday (see below) |
+
+This release records statement periods in 2026-27 and income tax returns for the 2025-26
+income year, which are the returns the 2026–27 program covers. Any other year returns one
+`UNKNOWN` row.
+
+The `Facts` fields are the conditions the ATO pages make the dates depend on:
+`prior_returns_outstanding`, `overdue_returns_lodged_by_31_october`,
+`on_agent_client_list_by_cutoff`, `large_or_medium`, `member_large_or_medium`,
+`new_registrant`, `prior_year_return_taxable`, `current_year_return_taxable`,
+`latest_tax_liability_20k_or_more`, `total_income_over_2m`,
+`prior_year_non_taxable_or_refund`, `current_year_non_taxable_or_refund`,
+`consolidated_head_company`, `first_consolidated_return`, `lodges_electronically`,
+`previous_statement_lodged_electronically`, `includes_monthly_payg_obligation`,
+`annual_turnover_up_to_10m` and
+`deferred_gst_registered`. `FACT_MEANINGS` in `lodgmentcalendar.due_dates` gives the
+ATO's wording for each. Only the facts on a date's decision path are read; a `None` on
+that path makes the date `UNKNOWN`.
+
+Invalid inputs raise `ValueError`: an unknown value, a malformed year, a cycle on an
+income tax return, a BAS agent lodging an income tax return or a fact that is not
+`True`, `False` or `None`.
+
+## Output
+
+The result holds `obligations`, `counts` by status, `request`, `facts_used`,
+`holiday_calendar`, `not_decided`, `warnings` and `source_checked`. Each obligation row has:
+
+| Field | Meaning |
+| --- | --- |
+| `kind` | `lodgment`, `payment` (only where the payment date differs) or `concession` |
+| `status` | `DETERMINED` or `UNKNOWN` |
+| `due_date` | The date after the next-business-day roll; `null` when `UNKNOWN` |
+| `nominal_due_date` | The date the rule names, before the roll, where the rule names one |
+| `rule_id`, `summary` | The rule applied, in plain English |
+| `source_url`, `source_provision`, `source_checked` | The ATO page, the table or heading on it, and the review date |
+| `holiday_roll` | The weekend days and holidays passed over, with the holiday table's URL |
+| `missing` | Each fact not supplied or question the ATO pages leave open |
+| `payment` | On lodgement rows: `with_lodgment`, `separate`, `none` or `unknown` |
+
+## Weekends and public holidays
+
+The holiday calendar is the ATO's own: Tables 1 and 2 of
+[Lodgment and payment dates on weekends or public holidays](https://www.ato.gov.au/tax-and-super-professionals/for-tax-professionals/prepare-and-lodge/registered-agent-lodgment-program/lodgment-and-payment-dates-on-weekends-or-public-holidays),
+checked on 20 October 2026 and again on 28 October 2026. Under that page, a date that
+falls on a Saturday, a Sunday or a public holiday for the whole of any state or territory
+moves to the next business day for taxpayers in every state. The tables cover 1 July 2026 to 30 June 2027. A later date
+that is not a weekend cannot be shown to be a business day, so it is `UNKNOWN` with its
+nominal date kept. A holiday missing from the tables can only move a date later.
+
+To settle those dates, pass the missing holidays from an official source as
+`extra_holidays` and the last date your list is complete to as
+`holidays_complete_until`. Holidays alone never extend coverage, because a list holding
+one 2027 holiday is not a list that has 2027 covered. Each one must be a weekday the ATO
+table does not already list, and shows in `holiday_roll` and `holiday_calendar` marked
+'(caller-supplied)'.
+
+```python
+from datetime import date
+
+result = due_dates("bas", "trust", "2026-27", "self", reporting_cycle="quarterly",
+                   facts=Facts(lodges_electronically=True),
+                   holidays_complete_until=date(2027, 8, 31))
+print(result["obligations"][3]["due_date"])
+```
+
+```
+2027-08-11
+```
+
+This assumes no whole-of-state holiday falls between 1 July and 31 August 2027 beyond
+those you pass; the calendar takes that statement as given.
+
+## Scope
+
+Modelled rules, open questions and every source are listed in the
+[primary-source review](docs/primary-source-review-2026-10-20.md). The calendar does not
+model substituted accounting periods, companies that are not full self-assessment
+taxpayers, APRA-regulated funds, annual GST returns, instalment notices, FBT or other
+obligation types. It does not check whether the facts you pass are true, apply a
+client-specific date the ATO has set, or decide whether anything was lodged or paid on
+time.
+
+## Licence
+
+Licensed under the Functional Source License, Version 1.1, ALv2 Future License (FSL-1.1-ALv2). You may use, modify and redistribute it for any purpose except a Competing Use as defined in LICENSE (making it available to others in a competing commercial product or service), and each version becomes available under Apache-2.0 two years after it is made available. See [LICENSE](LICENSE) and [NOTICE](NOTICE).

lodgment_calendar-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+lodgment_calendar-0.1.0.dist-info/licenses/LICENSE,sha256=6AxWPlVU_Ce-vmqUDCqY10KJKh33AR3QTazuNEN7uVw,3743
+lodgment_calendar-0.1.0.dist-info/licenses/NOTICE,sha256=ptxdTJjsS5yPxA8ju2a_0ST7Nxa5m_rf2dxfLhAa6Hw,866
+lodgmentcalendar/__init__.py,sha256=3bTglzXSYKD0PQWJotU1ODC9zqwlATVIpyk_TsaXA4Q,326
+lodgmentcalendar/_version.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+lodgmentcalendar/due_dates.py,sha256=JoveKeNFkTDNt8F8IEi0gGZae4ft_4439l02DXLJ0rY,12023
+lodgmentcalendar/holidays.py,sha256=69zzh314Q1dMO-1UzQ1QhfHTHinHNbauN6TNZRtRNU8,6389
+lodgmentcalendar/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lodgmentcalendar/returns.py,sha256=HVt6oHTp_k6e5Uduhpwhsg8LsbK_kDtFa-yVtUfIQ7o,17439
+lodgmentcalendar/rules.py,sha256=XUfbMZkDFo8bmlYiiGs2IDKUqnsdaAFtPJK1LbJAD8M,10633
+lodgmentcalendar/statements.py,sha256=qeHB9hVlcAnTWtAAKPPCXw3wwEaz0mOMzquNxIizCIE,7517
+lodgment_calendar-0.1.0.dist-info/METADATA,sha256=5GUGGxkx-M486srDOGUQjuhr2ElQjHEHWlod2gtkgv8,9476
+lodgment_calendar-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+lodgment_calendar-0.1.0.dist-info/top_level.txt,sha256=YCVyBC-sGD3tftQbTV78AUZbDbrrUYtQJ3w1urQPg_0,17
+lodgment_calendar-0.1.0.dist-info/RECORD,,

lodgment_calendar-0.1.0.dist-info/WHEEL

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

lodgment_calendar-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,105 @@
+# Functional Source License, Version 1.1, ALv2 Future License
+
+## Abbreviation
+
+FSL-1.1-ALv2
+
+## Notice
+
+Copyright 2026 Ryan Duguid
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the Apache License, Version 2.0 that is effective on the second anniversary of
+the date we make the Software available. On or after that date, you may use the
+Software under the Apache License, Version 2.0, in which case the following
+will apply:
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License.
+
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.

lodgment_calendar-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,20 @@
+lodgment-calendar
+Copyright 2026 Ryan Duguid (https://github.com/ryanduguid)
+
+This software is licensed under the Functional Source License,
+Version 1.1, ALv2 Future License (FSL-1.1-ALv2); see LICENSE.
+
+For each version licensed under FSL-1.1-ALv2, an additional licence under the
+Apache License, Version 2.0 becomes effective on the second anniversary of the
+date that version was made available.
+
+Versions made available before this change remain available under the
+licences they were released with.
+
+Redistribution under FSL-1.1-ALv2 requires including its terms or a link to
+them and keeping the copyright notices supplied with the software.
+Redistribution under another applicable licence follows that licence's
+conditions.
+
+This product includes work by Ryan Duguid
+(https://github.com/ryanduguid/australian-accounting/tree/main/packages/lodgment-calendar).

lodgment_calendar-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+lodgmentcalendar

lodgmentcalendar/__init__.py

@@ -0,0 +1,11 @@
+"""Lodgment and payment due dates under the ATO's 2026–27 lodgment program.
+
+A preparation aid, not a determination: it lodges nothing and contacts no service.
+"""
+
+from __future__ import annotations
+
+from ._version import __version__
+from .due_dates import Facts, due_dates
+
+__all__ = ["Facts", "__version__", "due_dates"]

lodgmentcalendar/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

lodgmentcalendar/due_dates.py

@@ -0,0 +1,259 @@
+"""Lodgment and payment due dates under the ATO's 2026–27 lodgment program.
+
+The calendar reads the facts the caller supplies, applies the dates the ATO
+publishes for self-lodgers and for registered tax and BAS agents, and moves each
+date to the next business day under the program's public holiday rule. A date
+that depends on a fact the caller did not supply, or that the ATO pages leave
+open, is UNKNOWN and names what is missing. It contacts no service and lodges
+nothing.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Mapping
+from dataclasses import fields
+from datetime import date
+from typing import Any
+
+from ._version import __version__
+from .holidays import COVERS_FROM, HOLIDAY_PROVISION, HOLIDAY_SOURCE, calendar, roll
+from .returns import return_rule
+from .rules import FACT_MEANINGS, SOURCES, Facts, Rule
+from .statements import statement_rules
+
+SOURCE_CHECKED = "2026-10-28"
+PROGRAM_YEAR = "2026-27"
+# The program dates cover activity statements for periods in 2026–27 and income
+# tax returns for the 2025–26 income year (the 2026 return).
+ACTIVITY_YEAR = "2026-27"
+RETURN_YEAR = "2025-26"
+
+DETERMINED, UNKNOWN = "DETERMINED", "UNKNOWN"
+OBLIGATIONS = ("bas", "ias", "income_tax_return")
+ENTITY_TYPES = ("individual", "trust", "partnership", "company", "smsf")
+CHANNELS = ("self", "tax_agent", "bas_agent")
+CYCLES = ("monthly", "quarterly")
+
+NOT_DECIDED = [
+    "Dates the ATO sets for one client override these: a notice requiring earlier "
+    "lodgement, a prosecution letter, a deferral, an advised first-year date for a new "
+    "SMSF, or the due date shown on the activity statement or in Online services for "
+    "agents.",
+    "Whether a fact supplied is true. Large or medium status, taxable status, income and "
+    "liability thresholds, registration and lodgement history are taken as given.",
+    "Substituted accounting periods, companies that are not full self-assessment "
+    "taxpayers, APRA-regulated funds, members exiting a consolidated group, annual GST "
+    "returns, instalment notices (forms R, S, T and N), PAYG instalments paid in 2 "
+    "instalments or annually, deferred BAS payers (who pay monthly PAYG instalments on the "
+    "28th) and every other obligation type.",
+    "Whether a lodgement or payment was on time, and any penalty or general interest charge.",
+    "Disaster or other deferrals, and holidays proclaimed after the ATO published its "
+    "2026–27 table.",
+]
+
+WARNINGS = [
+    "The ATO says its list of lodgment program due dates is a guide only. Confirm each "
+    "client's dates in Online services for agents or the practitioner lodgment service.",
+    "Retain the status and missing conditions of every UNKNOWN row; do not replace one "
+    "with a nominal date.",
+]
+
+_YEAR = re.compile(r"([0-9]{4})-([0-9]{2})")
+
+
+def due_dates(
+    obligation: str,
+    entity_type: str,
+    financial_year: str,
+    channel: str,
+    *,
+    reporting_cycle: str | None = None,
+    facts: Facts | None = None,
+    extra_holidays: Mapping[date, str] | None = None,
+    holidays_complete_until: date | None = None,
+) -> dict[str, Any]:
+    """Return each lodgement, payment and concession date with its rule and status.
+
+    ``financial_year`` is the year of the periods (activity statements) or the income
+    year the return covers (income tax returns), in the form 2026-27.
+
+    ``extra_holidays`` adds public holidays for the whole of a state or territory that
+    the ATO table does not list, by date and name. ``holidays_complete_until`` states
+    that the ATO table and those holidays hold every such holiday to that date, which
+    lets dates after 30 June 2027 be settled.
+    """
+    facts = Facts() if facts is None else facts
+    _check(obligation, entity_type, financial_year, channel, reporting_cycle, facts)
+    cal = calendar(extra_holidays, holidays_complete_until)
+    if obligation == "income_tax_return":
+        rows = _return_rows(entity_type, financial_year, channel, facts, cal)
+    else:
+        rows = _statement_rows(obligation, entity_type, financial_year, channel,
+                               reporting_cycle, facts, cal)
+    return {
+        "ok": True,
+        "engine": "lodgment-calendar",
+        "engine_version": __version__,
+        "calendar": "lodgment_due_dates",
+        "program_year": PROGRAM_YEAR,
+        "request": {"obligation": obligation, "entity_type": entity_type,
+                    "financial_year": financial_year, "channel": channel,
+                    "reporting_cycle": reporting_cycle},
+        "facts_used": {field.name: getattr(facts, field.name) for field in fields(facts)},
+        "obligations": rows,
+        "counts": {status: sum(1 for row in rows if row["status"] == status)
+                   for status in (DETERMINED, UNKNOWN)},
+        "holiday_calendar": _holiday_calendar(cal, holidays_complete_until),
+        "not_decided": NOT_DECIDED,
+        "warnings": WARNINGS,
+        "source_checked": SOURCE_CHECKED,
+    }
+
+
+def _return_rows(entity_type: str, financial_year: str, channel: str, facts: Facts,
+                 cal: Calendar) -> list[dict[str, Any]]:
+    label = f"Income tax return {financial_year}"
+    if financial_year != RETURN_YEAR:
+        return _rows(label, financial_year, _not_recorded(financial_year, RETURN_YEAR), [],
+                     cal=cal)
+    rule, missing, concessions = return_rule(entity_type, channel, facts)
+    # A partnership pays no income tax, whatever its lodgement date turns out to be.
+    rows = _rows(label, financial_year, rule, missing, family=_family(entity_type, channel),
+                 pending_payment="none" if entity_type == "partnership" else "unknown",
+                 cal=cal)
+    for concession, needed in concessions:
+        rows.append(_row(label, financial_year, "concession", concession, needed, cal=cal))
+    return rows
+
+
+def _statement_rows(obligation: str, entity_type: str, financial_year: str, channel: str,
+                    reporting_cycle: str | None, facts: Facts,
+                    cal: Calendar) -> list[dict[str, Any]]:
+    if financial_year != ACTIVITY_YEAR:
+        return _rows(f"{obligation.upper()} {financial_year}", financial_year,
+                     _not_recorded(financial_year, ACTIVITY_YEAR), [], cal=cal)
+    rows: list[dict[str, Any]] = []
+    for period, label, rule, missing in statement_rules(
+            obligation, entity_type, channel, reporting_cycle, facts):
+        rows += _rows(label, period, rule, missing, family=_family(obligation, channel),
+                      cal=cal)
+    return rows
+
+
+def _holiday_calendar(cal: Calendar, complete_until: date | None) -> dict[str, Any]:
+    return {
+        "definition": "Saturdays, Sundays and days that are a public holiday for the whole "
+        "of any state or territory move a due date to the next business day, for taxpayers "
+        "in every state.",
+        "source_url": HOLIDAY_SOURCE,
+        "source_provision": HOLIDAY_PROVISION,
+        "covers_from": COVERS_FROM.isoformat(),
+        "covers_to": cal[1].isoformat(),
+        "caller_holidays": {day.isoformat(): name for day, name in sorted(cal[0].items())
+                            if name.endswith(" (caller-supplied)")},
+        "caller_complete_until": None if complete_until is None else complete_until.isoformat(),
+    }
+
+
+def _check(obligation: str, entity_type: str, financial_year: object, channel: str,
+           reporting_cycle: str | None, facts: object) -> None:
+    for name, value, allowed in (("obligation", obligation, OBLIGATIONS),
+                                 ("entity_type", entity_type, ENTITY_TYPES),
+                                 ("channel", channel, CHANNELS)):
+        if value not in allowed:
+            raise ValueError(f"{name} must be one of {', '.join(allowed)}; got {value!r}")
+    match = _YEAR.fullmatch(financial_year) if isinstance(financial_year, str) else None
+    if match is None or int(match[2]) != (int(match[1]) + 1) % 100:
+        raise ValueError(f"financial_year must look like 2026-27; got {financial_year!r}")
+    if obligation == "income_tax_return":
+        if reporting_cycle is not None:
+            raise ValueError("reporting_cycle applies only to bas and ias")
+        if channel == "bas_agent":
+            raise ValueError("a BAS agent cannot lodge an income tax return; use tax_agent")
+    elif reporting_cycle not in CYCLES:
+        raise ValueError(f"reporting_cycle must be one of {', '.join(CYCLES)} for "
+                         f"{obligation}; got {reporting_cycle!r}")
+    if not isinstance(facts, Facts):
+        raise ValueError("facts must be a Facts instance")
+    for field in fields(facts):
+        value = getattr(facts, field.name)
+        # Identity, not isinstance: an object can claim bool as its class.
+        if value is not None and value is not True and value is not False:
+            raise ValueError(f"facts.{field.name} must be true, false or null; got {value!r}")
+
+
+def _family(kind: str, channel: str) -> str:
+    return f"{kind.upper()}-{'SELF' if channel == 'self' else 'AGENT'}"
+
+
+def _not_recorded(year: str, recorded: str) -> Rule:
+    return Rule(
+        "YEAR-NOT-RECORDED",
+        f"This release records the {PROGRAM_YEAR} lodgment program, which covers {recorded} "
+        f"for this obligation; {year} is not recorded.",
+        "about",
+        unresolved=f"rules for {year}: this release records only {recorded} for this "
+        "obligation",
+        payment="unknown",
+    )
+
+
+Calendar = tuple[dict[date, str], date]
+
+
+def _rows(label: str, period: str, rule: Rule | None, missing: list[str], *, cal: Calendar,
+          family: str = "", pending_payment: str = "unknown") -> list[dict[str, Any]]:
+    if rule is None or missing:
+        pending = Rule(family, "The date depends on facts not supplied: "
+                       + "; ".join(FACT_MEANINGS[name] for name in missing) + ".", "about")
+        return [_row(label, period, "lodgment", pending, missing, payment=pending_payment,
+                     cal=cal)]
+    payment = rule.payment
+    rows = [_row(label, period, "lodgment", rule, [],
+                 payment=payment if isinstance(payment, str) else "separate", cal=cal)]
+    if isinstance(payment, Rule):
+        rows.append(_row(label, period, "payment", payment, [], cal=cal))
+    return rows
+
+
+def _row(label: str, period: str, kind: str, rule: Rule, missing: list[str], *,
+         cal: Calendar, payment: str | None = None) -> dict[str, Any]:
+    url, provision = SOURCES[rule.source]
+    needed = [f"{name}: {FACT_MEANINGS[name]}" for name in missing]
+    due: date | None = None
+    holiday_roll = None
+    if rule.unresolved is not None:
+        needed.append(rule.unresolved)
+    elif rule.nominal is not None and not needed:
+        due, skipped, open_question = roll(rule.nominal, *cal)
+        if skipped or due is None:
+            holiday_roll = {"skipped": skipped, "source_url": HOLIDAY_SOURCE}
+        if open_question is not None:
+            needed.append(open_question)
+        elif kind == "concession" and skipped:
+            needed.append(
+                f"whether the next-business-day rule extends this concession: "
+                f"{rule.nominal.isoformat()} is not a business day, and the ATO pages call "
+                "it both a concessional due date and not a lodgment due date")
+            due = None
+    if needed:
+        due = None
+    row: dict[str, Any] = {
+        "obligation": label,
+        "period": period,
+        "kind": kind,
+        "status": UNKNOWN if needed else DETERMINED,
+        "due_date": None if due is None else due.isoformat(),
+        "nominal_due_date": None if rule.nominal is None else rule.nominal.isoformat(),
+        "rule_id": rule.id,
+        "summary": rule.summary,
+        "source_url": url,
+        "source_provision": provision,
+        "source_checked": SOURCE_CHECKED,
+        "holiday_roll": holiday_roll,
+        "missing": needed,
+    }
+    if kind == "lodgment":
+        row["payment"] = payment
+    return row