ifrs16kit 1.0.0__tar.gz

ifrs16kit-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ayce Makbule (Lena) Acar
+
+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.

ifrs16kit-1.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include VIGNETTE.md
+include TESTING.md
+recursive-include tests *.py

ifrs16kit-1.0.0/PKG-INFO

@@ -0,0 +1,183 @@
+Metadata-Version: 2.4
+Name: ifrs16kit
+Version: 1.0.0
+Summary: Interactive IFRS 16 auditor re-performance tool producing liquid Excel workbooks
+Author: Ayce Makbule (Lena) Acar
+License-Expression: MIT
+Keywords: IFRS 16,lease accounting,audit,re-performance,ISA 540,excel,openpyxl,right-of-use asset,lease liability
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Topic :: Office/Business :: Financial :: Accounting
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+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: Operating System :: OS Independent
+Classifier: Environment :: Console
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openpyxl>=3.1
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4; extra == "dev"
+Requires-Dist: pytest-cov>=4.1; extra == "dev"
+Dynamic: license-file
+
+# LeaseAuditKit — Interactive IFRS 16 Re-performance Tool (LIQUID edition)
+
+A standalone Python tool that re-performs a lessee's IFRS 16 lease accounting from first principles, independently of the client's own calculation, and delivers the result as a fully formula-driven ("liquid") Excel audit workbook. It is designed for the substantive re-performance of management's lease estimates under ISA 540 (accounting estimates), ISA 500 (audit evidence, including para A21 on re-performance), and ISA 230 (documentation).
+
+Author: Ayce Makbule (Lena) Acar — MSc Business Analytics, Trinity College Dublin.
+
+## Why "liquid"?
+
+Every derived figure in the generated workbook is a live Excel formula, not a hard-coded value. Change any dark-red input cell — lease term, IBR, payment frequency, country, depreciation method — and the entire model (liability, ROU asset, 120-period schedule, annual summary, journals, deferred tax) recalculates instantly inside Excel. The Python script never bakes numbers into the calculation sheets; it only writes the inputs and the formula fabric around them. A separate, independent Python engine re-computes the same figures so the auditor can verify the Excel model against a second implementation (a "two-engine" control).
+
+## Requirements
+
+- Python 3.9+
+- openpyxl (installed automatically as a dependency)
+- Microsoft Excel (or LibreOffice) to fill the template and recalculate the output
+
+Works from any environment: terminal, VS Code, Spyder, PyCharm.
+
+## Installation
+
+From the package root (the folder containing `pyproject.toml`):
+
+```bash
+pip install -e .
+```
+
+The editable (`-e`) install means edits to `src/ifrs16kit/core.py` take
+effect immediately without reinstalling. Installation registers both the
+importable package (`import ifrs16kit`) and a terminal command
+(`ifrs16kit`), usable from any directory.
+
+## Quick start
+
+**Command line** (interactive flow):
+
+```bash
+# Guided flow — 3 questions, then a fillable template
+ifrs16kit
+
+# Instant demo — runs the CALISMA golden benchmark end-to-end
+ifrs16kit --demo
+```
+
+**Spyder / notebook — interactive flow** (asks the questions, waits while you fill the template):
+
+```python
+import ifrs16kit as lease
+lease.run()
+# 1. answers 3 questions in the console
+# 2. writes IFRS16_Input.xlsx and PAUSES — open it in Excel, fill the
+#    dark-red cells, save, return to the console and press Enter
+# 3. validates the template and writes IFRS16_Calculation.xlsx
+```
+
+**Spyder / notebook — non-interactive two-step** (no questions; you control each step):
+
+```python
+import ifrs16kit as lease
+
+lease.demo()                       # instantly writes BOTH Excel files (golden case)
+
+lease.create_input()               # step 1: writes IFRS16_Input.xlsx → fill in Excel
+lease.create_calculation()         # step 2: reads it back → writes IFRS16_Calculation.xlsx
+```
+
+`create_input()` accepts `country=`, `advance=`, `freq=` and a custom path;
+`create_calculation()` accepts custom template/output paths.
+
+**Python API** (programmatic — no interview, no template round-trip):
+
+```python
+import ifrs16kit as lease
+
+inp = lease.LeaseInputs(
+    entity="Example Co. Limited", country="Ireland",
+    commencement=__import__("datetime").date(2025, 1, 1),
+    term_years=2, freq=12, payment=650.0,
+    is_advance=True, ibr_annual=0.06, idc=600.0,
+)
+
+lease.cross_check(inp)                                     # dict of key figures
+lease.build_calculation_workbook(inp, "IFRS16_Calc.xlsx")  # 10-sheet liquid workbook
+lease.build_template({"country": "Ireland", "is_advance": True, "freq": 12},
+                   "IFRS16_Input.xlsx")                  # blank input template
+inp2 = lease.read_template("IFRS16_Input.xlsx")            # validated read-back
+```
+
+Public API: `LeaseInputs`, `cross_check`, `build_template`, `read_template`,
+`build_calculation_workbook`, `print_summary`, plus the `COUNTRIES`,
+`FREQUENCIES`, and `MAX_PERIODS` constants.
+
+## Workflow
+
+1. **Interview.** The script asks three questions: country/jurisdiction (Türkiye, Ireland, United Kingdom, UAE, Australia), payment timing (advance/arrears), and payment frequency (monthly, quarterly, semi-annual, annual).
+2. **Template.** It generates `IFRS16_Input.xlsx` — a single-sheet LIQUID input template. Only the dark-red, thick-bordered cells are editable inputs; everything else (total term, N, periodic rate, capacity checks) auto-calculates with live formulas. Dropdowns constrain frequency, timing, depreciation method, and country.
+3. **Fill and save.** Open the template in Excel, fill every dark-red cell, confirm the two green validation cells both say "OK", save, and return to the running script.
+4. **Validation.** The script reads the template back and validates it: non-empty entity, valid date, positive term/payment/useful life, IBR entered as a decimal or percentage below 100%, a whole number of payment periods, and N ≤ 120 (template capacity). Errors are listed cell-by-cell so they can be fixed and re-read without restarting.
+5. **Output.** It generates `IFRS16_Calculation.xlsx` — the full 10-sheet liquid workbook — and prints an independent Python cross-check of the key figures.
+
+## The generated workbook (10 sheets)
+
+| Sheet | Contents |
+|---|---|
+| **Inputs** | All lease inputs plus live-linked key outputs (liability, ROU, totals) and country-driven framework/audit-standard lookups from Setup. |
+| **Initial Measurement** | PV of lease payments period-by-period (IFRS 16 ¶26) and the ROU asset build-up (¶24: liability + IDC + prepayments − incentives + restoration). |
+| **Lease Schedule** | 120-period-capacity amortisation and depreciation schedule (¶36 effective interest; ¶31 depreciation), with year tags and a Final Payment status flag. Rows self-hide beyond N. |
+| **Annual Summary** | P&L impact and year-end balances by reporting year, a front-loading memo vs a straight-line charge, and five automated reconciliation checks (closing liability = 0, closing ROU = 0, principal = initial liability, expense = payments + IDC, front-loading sums to nil). |
+| **Journals** | Initial-recognition entry with debit/credit balance check, plus representative Period 1 entries (payment, interest unwind, depreciation). |
+| **Tax_Reconciliation** | Illustrative year-1 accounting-vs-cash-rental P&L difference and deferred-tax computation at the jurisdiction's rate. |
+| **Findings** | Findings-and-recommendations register wired to the reconciliation checks — flags "Y" and a recommendation automatically when a check fails. |
+| **Audit_Procedures** | 20 substantive procedures (P-1 to P-20) mapped to assertions (existence, completeness, accuracy, cut-off, classification, presentation). |
+| **PBC_List** | 18-item prepared-by-client request list with purpose, format, and due dates. |
+| **Setup** | Country lookup table driving currency, reporting framework, lease standard (IFRS 16 / TFRS 16 / AASB 16), audit standards (ISA / ISA (Ireland) / ISA (UK) / BDS / ASA 540-500-230), and illustrative tax rate. |
+
+## Colour and formatting conventions
+
+- **Dark red fill, thick border, bold** — your input (client data / auditor assumptions)
+- **Black** — formula / computed
+- **Green font on light-green fill** — link to another sheet, or an automated check
+- **Navy headers, Times New Roman throughout**
+
+## Calculation conventions
+
+- Periodic discount rate uses the effective (compound) conversion: `(1 + IBR)^(1/frequency) − 1`, not simple pro-rata.
+- Advance payments: the first payment is undiscounted (discount exponent `p − 1`); interest accrues on the opening liability net of the period's payment. Arrears: exponent `p`; interest on the full opening liability.
+- Depreciation: straight-line over the shorter of the lease term and useful life (no ownership transfer assumed), or reducing balance at `1 − (1 − annual rate)^(1/frequency)` per period with a final-period write-off of the remaining carrying amount.
+
+## Verification
+
+The tool ships with a golden benchmark (the CALISMA case: monthly advance, 24 periods, 6% IBR, 650/month, 600 IDC):
+
+| Figure | Expected |
+|---|---|
+| Lease liability at commencement | 14,761.09 |
+| ROU asset at commencement | 15,361.09 |
+| Total interest over term | 838.91 |
+| Total P&L charge | 16,200.00 |
+
+Run `ifrs16kit --demo` and compare the console cross-check and `Inputs!B36:B42` of the generated workbook against these values. The five reconciliation checks on the Annual Summary sheet must all read "OK".
+
+## Files
+
+| File | Role |
+|---|---|
+| `pyproject.toml` | Package metadata, dependency, and the `ifrs16kit` CLI entry point |
+| `src/ifrs16kit/core.py` | The engine, template builder, validator, and workbook builder |
+| `src/ifrs16kit/__init__.py` | Public API exports |
+| `IFRS16_Input.xlsx` | Generated input template (step 2) |
+| `IFRS16_Calculation.xlsx` | Generated liquid calculation workbook (step 5) |
+| `VIGNETTE.md` | Worked example mapped to IFRS 16 paragraphs and ISA requirements |
+
+The tool also runs without installation: `python src/ifrs16kit/core.py --demo`.
+
+## Limitations
+
+Single lease, fixed payments, no mid-term modifications or remeasurements, no CPI-linked variable payments, template capacity of 120 payment periods. These are audit re-performance scoping choices, not engine defects: modifications and variable payments are covered qualitatively as procedures P-12 and P-13 on the Audit_Procedures sheet.

ifrs16kit-1.0.0/README.md

@@ -0,0 +1,156 @@
+# LeaseAuditKit — Interactive IFRS 16 Re-performance Tool (LIQUID edition)
+
+A standalone Python tool that re-performs a lessee's IFRS 16 lease accounting from first principles, independently of the client's own calculation, and delivers the result as a fully formula-driven ("liquid") Excel audit workbook. It is designed for the substantive re-performance of management's lease estimates under ISA 540 (accounting estimates), ISA 500 (audit evidence, including para A21 on re-performance), and ISA 230 (documentation).
+
+Author: Ayce Makbule (Lena) Acar — MSc Business Analytics, Trinity College Dublin.
+
+## Why "liquid"?
+
+Every derived figure in the generated workbook is a live Excel formula, not a hard-coded value. Change any dark-red input cell — lease term, IBR, payment frequency, country, depreciation method — and the entire model (liability, ROU asset, 120-period schedule, annual summary, journals, deferred tax) recalculates instantly inside Excel. The Python script never bakes numbers into the calculation sheets; it only writes the inputs and the formula fabric around them. A separate, independent Python engine re-computes the same figures so the auditor can verify the Excel model against a second implementation (a "two-engine" control).
+
+## Requirements
+
+- Python 3.9+
+- openpyxl (installed automatically as a dependency)
+- Microsoft Excel (or LibreOffice) to fill the template and recalculate the output
+
+Works from any environment: terminal, VS Code, Spyder, PyCharm.
+
+## Installation
+
+From the package root (the folder containing `pyproject.toml`):
+
+```bash
+pip install -e .
+```
+
+The editable (`-e`) install means edits to `src/ifrs16kit/core.py` take
+effect immediately without reinstalling. Installation registers both the
+importable package (`import ifrs16kit`) and a terminal command
+(`ifrs16kit`), usable from any directory.
+
+## Quick start
+
+**Command line** (interactive flow):
+
+```bash
+# Guided flow — 3 questions, then a fillable template
+ifrs16kit
+
+# Instant demo — runs the CALISMA golden benchmark end-to-end
+ifrs16kit --demo
+```
+
+**Spyder / notebook — interactive flow** (asks the questions, waits while you fill the template):
+
+```python
+import ifrs16kit as lease
+lease.run()
+# 1. answers 3 questions in the console
+# 2. writes IFRS16_Input.xlsx and PAUSES — open it in Excel, fill the
+#    dark-red cells, save, return to the console and press Enter
+# 3. validates the template and writes IFRS16_Calculation.xlsx
+```
+
+**Spyder / notebook — non-interactive two-step** (no questions; you control each step):
+
+```python
+import ifrs16kit as lease
+
+lease.demo()                       # instantly writes BOTH Excel files (golden case)
+
+lease.create_input()               # step 1: writes IFRS16_Input.xlsx → fill in Excel
+lease.create_calculation()         # step 2: reads it back → writes IFRS16_Calculation.xlsx
+```
+
+`create_input()` accepts `country=`, `advance=`, `freq=` and a custom path;
+`create_calculation()` accepts custom template/output paths.
+
+**Python API** (programmatic — no interview, no template round-trip):
+
+```python
+import ifrs16kit as lease
+
+inp = lease.LeaseInputs(
+    entity="Example Co. Limited", country="Ireland",
+    commencement=__import__("datetime").date(2025, 1, 1),
+    term_years=2, freq=12, payment=650.0,
+    is_advance=True, ibr_annual=0.06, idc=600.0,
+)
+
+lease.cross_check(inp)                                     # dict of key figures
+lease.build_calculation_workbook(inp, "IFRS16_Calc.xlsx")  # 10-sheet liquid workbook
+lease.build_template({"country": "Ireland", "is_advance": True, "freq": 12},
+                   "IFRS16_Input.xlsx")                  # blank input template
+inp2 = lease.read_template("IFRS16_Input.xlsx")            # validated read-back
+```
+
+Public API: `LeaseInputs`, `cross_check`, `build_template`, `read_template`,
+`build_calculation_workbook`, `print_summary`, plus the `COUNTRIES`,
+`FREQUENCIES`, and `MAX_PERIODS` constants.
+
+## Workflow
+
+1. **Interview.** The script asks three questions: country/jurisdiction (Türkiye, Ireland, United Kingdom, UAE, Australia), payment timing (advance/arrears), and payment frequency (monthly, quarterly, semi-annual, annual).
+2. **Template.** It generates `IFRS16_Input.xlsx` — a single-sheet LIQUID input template. Only the dark-red, thick-bordered cells are editable inputs; everything else (total term, N, periodic rate, capacity checks) auto-calculates with live formulas. Dropdowns constrain frequency, timing, depreciation method, and country.
+3. **Fill and save.** Open the template in Excel, fill every dark-red cell, confirm the two green validation cells both say "OK", save, and return to the running script.
+4. **Validation.** The script reads the template back and validates it: non-empty entity, valid date, positive term/payment/useful life, IBR entered as a decimal or percentage below 100%, a whole number of payment periods, and N ≤ 120 (template capacity). Errors are listed cell-by-cell so they can be fixed and re-read without restarting.
+5. **Output.** It generates `IFRS16_Calculation.xlsx` — the full 10-sheet liquid workbook — and prints an independent Python cross-check of the key figures.
+
+## The generated workbook (10 sheets)
+
+| Sheet | Contents |
+|---|---|
+| **Inputs** | All lease inputs plus live-linked key outputs (liability, ROU, totals) and country-driven framework/audit-standard lookups from Setup. |
+| **Initial Measurement** | PV of lease payments period-by-period (IFRS 16 ¶26) and the ROU asset build-up (¶24: liability + IDC + prepayments − incentives + restoration). |
+| **Lease Schedule** | 120-period-capacity amortisation and depreciation schedule (¶36 effective interest; ¶31 depreciation), with year tags and a Final Payment status flag. Rows self-hide beyond N. |
+| **Annual Summary** | P&L impact and year-end balances by reporting year, a front-loading memo vs a straight-line charge, and five automated reconciliation checks (closing liability = 0, closing ROU = 0, principal = initial liability, expense = payments + IDC, front-loading sums to nil). |
+| **Journals** | Initial-recognition entry with debit/credit balance check, plus representative Period 1 entries (payment, interest unwind, depreciation). |
+| **Tax_Reconciliation** | Illustrative year-1 accounting-vs-cash-rental P&L difference and deferred-tax computation at the jurisdiction's rate. |
+| **Findings** | Findings-and-recommendations register wired to the reconciliation checks — flags "Y" and a recommendation automatically when a check fails. |
+| **Audit_Procedures** | 20 substantive procedures (P-1 to P-20) mapped to assertions (existence, completeness, accuracy, cut-off, classification, presentation). |
+| **PBC_List** | 18-item prepared-by-client request list with purpose, format, and due dates. |
+| **Setup** | Country lookup table driving currency, reporting framework, lease standard (IFRS 16 / TFRS 16 / AASB 16), audit standards (ISA / ISA (Ireland) / ISA (UK) / BDS / ASA 540-500-230), and illustrative tax rate. |
+
+## Colour and formatting conventions
+
+- **Dark red fill, thick border, bold** — your input (client data / auditor assumptions)
+- **Black** — formula / computed
+- **Green font on light-green fill** — link to another sheet, or an automated check
+- **Navy headers, Times New Roman throughout**
+
+## Calculation conventions
+
+- Periodic discount rate uses the effective (compound) conversion: `(1 + IBR)^(1/frequency) − 1`, not simple pro-rata.
+- Advance payments: the first payment is undiscounted (discount exponent `p − 1`); interest accrues on the opening liability net of the period's payment. Arrears: exponent `p`; interest on the full opening liability.
+- Depreciation: straight-line over the shorter of the lease term and useful life (no ownership transfer assumed), or reducing balance at `1 − (1 − annual rate)^(1/frequency)` per period with a final-period write-off of the remaining carrying amount.
+
+## Verification
+
+The tool ships with a golden benchmark (the CALISMA case: monthly advance, 24 periods, 6% IBR, 650/month, 600 IDC):
+
+| Figure | Expected |
+|---|---|
+| Lease liability at commencement | 14,761.09 |
+| ROU asset at commencement | 15,361.09 |
+| Total interest over term | 838.91 |
+| Total P&L charge | 16,200.00 |
+
+Run `ifrs16kit --demo` and compare the console cross-check and `Inputs!B36:B42` of the generated workbook against these values. The five reconciliation checks on the Annual Summary sheet must all read "OK".
+
+## Files
+
+| File | Role |
+|---|---|
+| `pyproject.toml` | Package metadata, dependency, and the `ifrs16kit` CLI entry point |
+| `src/ifrs16kit/core.py` | The engine, template builder, validator, and workbook builder |
+| `src/ifrs16kit/__init__.py` | Public API exports |
+| `IFRS16_Input.xlsx` | Generated input template (step 2) |
+| `IFRS16_Calculation.xlsx` | Generated liquid calculation workbook (step 5) |
+| `VIGNETTE.md` | Worked example mapped to IFRS 16 paragraphs and ISA requirements |
+
+The tool also runs without installation: `python src/ifrs16kit/core.py --demo`.
+
+## Limitations
+
+Single lease, fixed payments, no mid-term modifications or remeasurements, no CPI-linked variable payments, template capacity of 120 payment periods. These are audit re-performance scoping choices, not engine defects: modifications and variable payments are covered qualitatively as procedures P-12 and P-13 on the Audit_Procedures sheet.

ifrs16kit-1.0.0/TESTING.md

@@ -0,0 +1,39 @@
+# TESTING — the ifrs16kit automated verification protocol
+
+The suite verifies the package in six layers, from pure arithmetic up to a
+fully automated version of the two-engine control described in VIGNETTE.md.
+
+| Layer | File | What it proves |
+|---|---|---|
+| 1. Engine | `tests/test_engine.py` | The CALISMA golden benchmark (liability 14,761.09 · ROU 15,361.09 · interest 838.91); the periodic rate is an effective conversion; the liability matches an independent closed-form annuity ("third engine"); and across the full grid of frequency × timing × method × term × useful life, the accounting identities hold: closing liability = 0, liability + interest = payments, ROU = liability + IDC ± ¶24 items, total depreciation = ROU, closing ROU = 0, total P&L = payments + IDC. Includes the fractional useful-life regression. |
+| 2. Template | `tests/test_template.py` | Required cells are generated blank (the cannot-run-on-example-values control); derived cells are live formulas including `B33 = MIN(B14,INT(B32))`; the four dropdowns exist; a user-style fill round-trips through `read_template` to the golden figures; and every validation rule rejects cell-by-cell (empty cells, IBR as whole percentage, non-whole N, N > 120, bad country/frequency/method/timing/date, non-positive amounts). |
+| 3. Workbook | `tests/test_workbook.py` | Exactly ten sheets in documented order; the four core calculation sheets contain **zero** hard-coded numbers (the "liquid" claim); key outputs are cross-sheet links; the schedule is 120-row-capacity and row-guarded; the depreciation formula divides by the floored period count; Setup mirrors `COUNTRIES` exactly; Journals and Findings are wired across sheets; P-1…P-20 and the 18 PBC items are present; the workbook builds for all five jurisdictions. |
+| 4. CLI & flow | `tests/test_cli.py` | `--demo` writes only `_DEMO` files and never touches real workbooks (regression); `python -m ifrs16kit` works; the full scripted interview → fill → validate → confirm → build flow completes; an invalid fill is rejected and the retry loop recovers; an existing filled template is detected and reused. |
+| 5. API | `tests/test_api.py` | Every `__all__` export resolves; `__version__` equals the installed package metadata (single-sourcing); `create_input` / `create_calculation` work and reject bad arguments. |
+| 6. Two-engine | `tests/test_excel_recalc.py` | LibreOffice recalculates the generated workbooks head-lessly and Excel's computed figures must equal `cross_check` within half a cent, for four scenarios (golden, arrears-quarterly, annual-UK-reducing-balance, fractional-life regression). All five Annual Summary reconciliation checks must read "OK". Skips when LibreOffice is absent; CI installs it. |
+
+## Running
+
+```bash
+pip install -e .[dev]
+pytest                                  # layers 1–5 (~15 s); layer 6 auto-skips
+pytest --cov=ifrs16kit --cov-report=term-missing
+pytest tests/test_excel_recalc.py      # layer 6, needs LibreOffice (soffice)
+```
+
+If `soffice` is not on PATH, point `IFRS16KIT_SOFFICE` at a LibreOffice
+binary (or a `.py` wrapper) before running layer 6.
+
+## Continuous integration
+
+`.github/workflows/ci.yml` runs three jobs on every push and pull request:
+layers 1–5 on Python 3.9 / 3.11 / 3.13 with a 90% coverage gate, layer 6 on
+Ubuntu with `libreoffice-calc` installed, and a packaging job (`python -m
+build` + `twine check`). A release is publishable only when all three are
+green.
+
+## Extending
+
+New calculation features need, at minimum: a golden value or identity in
+layer 1, a formula/structure assertion in layer 3, and a recalc scenario in
+layer 6 — so every figure stays proven twice, in Python and in Excel.

ifrs16kit-1.0.0/VIGNETTE.md

@@ -0,0 +1,139 @@
+# Vignette — Re-performing a Lessee's IFRS 16 Calculation with ifrs16kit (LeaseAuditKit)
+
+This vignette walks the CALISMA golden case end-to-end through the tool, mapping each step to the requirement in IFRS 16 it implements and the auditing standard (ISA) it supports. It is written from the perspective of an audit senior re-performing management's lease estimate as a substantive procedure.
+
+## The engagement scenario
+
+Example Co. Limited (Ireland, EUR) leases a company car:
+
+| Input | Value |
+|---|---|
+| Commencement date | 1 January 2025 |
+| Lease term | 2 years (24 months) |
+| Payment | €650 per month, **in advance** |
+| Annual incremental borrowing rate (IBR) | 6.00% |
+| Initial direct costs (IDC) | €600 |
+| Prepayments / incentives / restoration | nil |
+| Depreciation | Straight-line; useful life 60 months |
+
+The client has recognised a lease liability and right-of-use (ROU) asset. Under ISA (Ireland) 540, the discounted liability is an accounting estimate; the auditor responds by **re-performing** the calculation independently — a form of audit evidence explicitly recognised in ISA (Ireland) 500 (re-performance, para A21). The tool documents that re-performance in a form retainable on file per ISA (Ireland) 230.
+
+## Step 1 — Configure
+
+```bash
+ifrs16kit
+```
+
+(Programmatic alternative for a scripted audit file: construct
+`ifrs16kit.LeaseInputs(...)` directly and call
+`build_calculation_workbook()` — see the README's Python API section.
+The vignette follows the interactive route an audit senior would use.)
+
+Three questions set the engagement conventions:
+
+1. **Country:** Ireland → the Setup lookup drives the currency (EUR €), reporting framework (IFRS, EU-adopted), lease standard (IFRS 16), audit standards (ISA (Ireland) 540/500/230), and an illustrative 12.5% tax rate. Choosing Türkiye, the UK, the UAE, or Australia swaps every one of these automatically (TFRS 16/BDS, UK-adopted IFRS, AASB 16/ASA, etc.).
+2. **Timing:** Advance.
+3. **Frequency:** Monthly (12/year).
+
+## Step 2 — The input template
+
+The tool writes `IFRS16_Input.xlsx`. Only dark-red cells are inputs; the sheet is already "liquid":
+
+- **Total term (B11)** `=B9*12+B10` — enter 2 years + 0 months and 24 appears.
+- **N (B14)** `=B11/B13` — 24 monthly periods.
+- **Periodic rate (B21)** `=(1+B20)^(1/B12)-1` = 0.4868% — an *effective* monthly conversion of the 6% annual IBR, not 0.5% simple pro-rata. This is the first common client error the re-performance can surface.
+- Two green checks guard the template: capacity (N ≤ 120) and whole-number-of-periods (a 25-month term at quarterly frequency would fail here, before the auditor wastes any time downstream).
+
+The auditor fills entity, asset, date, term, payment, IBR, IDC, and useful life, saves, and returns to the script.
+
+## Step 3 — Validation
+
+`read_template()` re-reads the raw inputs and enforces the same rules in Python: valid date, positive amounts, IBR between 0 and 1, whole N, N ≤ 120. Validation failures are listed cell-by-cell (e.g. "IBR (B20) looks like a percentage — enter 0.06 or 6%") so the reviewer can trace every rejection to a specific cell — an ISA 230 documentation property.
+
+## Step 4 — Initial measurement (IFRS 16 ¶¶22–28)
+
+The **Initial Measurement** sheet discounts each payment at the periodic rate. Because payments are in advance, the discount exponent is `p − 1`, so Period 1's €650 is undiscounted:
+
+| Period | Payment | Factor | PV |
+|---|---|---|---|
+| 1 | 650.00 | 1.000000 | 650.00 |
+| 2 | 650.00 | 0.995156 | 646.85 |
+| … | … | … | … |
+| 24 | 650.00 | 0.894329 | 581.31 |
+| **Total (¶26)** | 15,600.00 | | **14,761.09** |
+
+The ROU asset build-up applies ¶24 line by line:
+
+| | |
+|---|---|
+| Lease liability at commencement | 14,761.09 |
+| Add: initial direct costs | 600.00 |
+| Add: prepaid payments | 0.00 |
+| Less: incentives received | (0.00) |
+| Add: restoration provision | 0.00 |
+| **ROU asset at commencement (¶24)** | **15,361.09** |
+
+Every one of these is an Excel formula referencing the Inputs sheet — the auditor (or reviewer) can change IDC to €1,000 and watch the ROU asset move to 15,761.09 with no code involved.
+
+## Step 5 — Subsequent measurement (¶36, ¶31)
+
+The **Lease Schedule** sheet unwinds the liability using the effective interest method. For advance payments, interest accrues on the opening balance *net of* the period's payment:
+
+`Interest_p = (Opening_p − Payment) × 0.48676%`
+
+| Period | Opening | Interest | Principal | Closing | Depreciation |
+|---|---|---|---|---|---|
+| 1 | 14,761.09 | 68.69 | 581.31 | 14,179.78 | 640.05 |
+| 2 | 14,179.78 | 65.86 | 584.14 | 13,595.63 | 640.05 |
+| … | … | … | … | … | … |
+| 24 | 650.00 | 0.00 | 650.00 | **0.00** | 640.05 |
+
+Depreciation is straight-line over min(24, 60) = 24 periods: 15,361.09 ÷ 24 = 640.05 per period (¶31, no ownership transfer). The schedule is row-guarded to 120 periods — rows beyond N blank themselves out, so the same fabric serves a 6-month equipment lease or a 10-year property lease.
+
+## Step 6 — The audit assertions, automated
+
+The **Annual Summary** sheet aggregates by reporting year and runs five reconciliation checks that correspond to the arithmetic assertions of the re-performance:
+
+| Check | Balance | Status |
+|---|---|---|
+| Closing lease liability at end of term | ~0.00 | OK |
+| Closing ROU asset at end of term | ~0.00 | OK |
+| Total principal repaid − initial liability | 0.00 | OK |
+| Total expense − (total payments + IDC) | 0.00 | OK |
+| Sum of front-loading differences | ~0.00 | OK |
+
+The front-loading memo quantifies the IFRS 16 expense profile against a straight-line equivalent: 2025 carries €214.97 *more* expense than straight-line, 2026 exactly €214.97 less — the characteristic front-loading of interest-bearing lease accounting, useful when explaining the P&L effect to the client or in an audit committee summary.
+
+Any failed check propagates automatically to the **Findings** sheet, which flips the corresponding row to Adjustment = "Y" and switches the recommendation from "No adjustment required." to an investigation prompt.
+
+## Step 7 — Journals, tax, and the file
+
+- **Journals** posts the commencement entry (Dr ROU 15,361.09; Cr liability 14,761.09; Cr cash — IDC 600.00) with a live debits-equals-credits check, plus representative Period 1 entries for the payment, interest unwind, and depreciation.
+- **Tax_Reconciliation** contrasts the IFRS 16 P&L charge with a cash-rental deduction regime and computes the year-1 deferred tax at the Setup rate (12.5% for Ireland) — the temporary-difference mechanics an Irish or UK tax reviewer will ask about.
+- **Audit_Procedures** (P-1 to P-20) and **PBC_List** (18 items) scope the wider IFRS 16 audit response beyond the single re-performed lease: completeness search via AP listings, IBR benchmarking, modifications, variable payments, expedients, FX, impairment, subleases, and sale-and-leaseback.
+
+## Step 8 — The two-engine control
+
+Before writing the workbook, the tool prints an independent Python re-computation of the same figures (available programmatically as `ifrs16kit.cross_check(inp)`, which is how the package's own verification tests assert the golden values):
+
+```
+Lease Liability (Day 1)  : EUR      14,761.09   (IFRS 16, para 26)
+ROU Asset (Day 1)        : EUR      15,361.09   (IFRS 16, para 24)
+Total Interest Expense   : EUR         838.91
+Closing liability        : 0.000000   ✓ zero
+Reconciliation: Liability + Interest = 15,600.00 = Total Payments   ✓ RECONCILED
+```
+
+The Excel model and the Python engine are two separate implementations of ¶¶24, 26, and 36. Agreement to the cent between them — and between both and the client's figure — is the re-performance evidence; disagreement with the client's figure is a finding, quantified and carried to the Findings sheet. This dual-implementation design addresses the reliability of the auditor's own tool (ISA 500's accuracy-and-completeness consideration for information produced by the auditor).
+
+## Standards map
+
+| Tool element | IFRS 16 | ISA (Ireland) |
+|---|---|---|
+| PV of payments, discount rate | ¶26–¶27 | 540 ¶¶22–23 (estimate re-performance) |
+| ROU cost build-up | ¶24 | 540 |
+| Effective interest unwinding | ¶36 | 500 A21 (re-performance) |
+| Depreciation basis | ¶31–¶32 | 500 |
+| Reconciliation checks & findings | — | 540 ¶23, 450 (misstatement evaluation) |
+| Templates, validation trail, workbook | — | 230 (documentation) |
+| Procedures P-1–P-20, PBC list | ¶9, ¶42, ¶47, ¶B58, ¶99–103 | 500, 330 |

ifrs16kit-1.0.0/pyproject.toml

@@ -0,0 +1,53 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ifrs16kit"
+dynamic = ["version"]
+description = "Interactive IFRS 16 auditor re-performance tool producing liquid Excel workbooks"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Ayce Makbule (Lena) Acar" }]
+keywords = [
+    "IFRS 16", "lease accounting", "audit", "re-performance",
+    "ISA 540", "excel", "openpyxl", "right-of-use asset", "lease liability",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Financial and Insurance Industry",
+    "Topic :: Office/Business :: Financial :: Accounting",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: OS Independent",
+    "Environment :: Console",
+]
+dependencies = ["openpyxl>=3.1"]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.4", "pytest-cov>=4.1"]
+
+# Fill these in once the GitHub repo is public, then rebuild:
+# [project.urls]
+# Homepage = "https://github.com/<user>/ifrs16kit"
+# Repository = "https://github.com/<user>/ifrs16kit"
+# Issues = "https://github.com/<user>/ifrs16kit/issues"
+
+[project.scripts]
+ifrs16kit = "ifrs16kit.core:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.dynamic]
+version = { attr = "ifrs16kit.__version__" }
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q"

ifrs16kit-1.0.0/setup.cfg

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

ifrs16kit-1.0.0/src/ifrs16kit/__init__.py

@@ -0,0 +1,43 @@
+"""
+ifrs16kit — IFRS 16 auditor re-performance (LIQUID edition).
+
+Public API
+----------
+    import ifrs16kit as lease
+    # or:  from ifrs16kit import (
+        LeaseInputs, cross_check,
+        build_template, read_template, build_calculation_workbook,
+        COUNTRIES, FREQUENCIES,
+    )
+
+Command line
+------------
+    ifrs16kit           # guided interactive flow
+    ifrs16kit --demo    # CALISMA golden case end-to-end
+"""
+
+from .core import (
+    LeaseInputs,
+    create_input,
+    create_calculation,
+    demo,
+    cross_check,
+    build_template,
+    read_template,
+    build_calculation_workbook,
+    build_inputs_sheet,
+    print_summary,
+    COUNTRIES,
+    FREQUENCIES,
+    MAX_PERIODS,
+    main,
+    run,
+)
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "LeaseInputs", "create_input", "create_calculation", "demo", "cross_check", "build_template", "read_template",
+    "build_calculation_workbook", "build_inputs_sheet", "print_summary",
+    "COUNTRIES", "FREQUENCIES", "MAX_PERIODS", "main", "run", "__version__",
+]

ifrs16kit-1.0.0/src/ifrs16kit/__main__.py

@@ -0,0 +1,5 @@
+"""Allow `python -m ifrs16kit` to invoke the CLI."""
+from .core import main
+
+if __name__ == "__main__":
+    main()