catagg 0.1.0.dev0__tar.gz

catagg-0.1.0.dev0/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+All notable changes to this project are documented here.
+
+The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+- Repository scaffolding generated from the shared template: hatchling build
+  with src layout, ruff and mypy configuration, pytest setup, GitHub Actions
+  CI (lint, type-check, five-way test matrix, docs build, distribution build),
+  MkDocs Material documentation site, MIT licence, issue and pull request
+  templates.
+- Empty subpackages fixing the module layout: `io`, `frequency`, `severity`,
+  `dependence`, `simulate`, `financial`, `metrics`.
+- Packaging tests: version/metadata drift and `py.typed` installation.
+- Release workflow publishing to PyPI via Trusted Publishing, with a
+  tag-versus-package-version guard, and the release procedure documented in
+  `docs/releasing.md`.
+
+[Unreleased]: https://github.com/John-Amal/catagg/commits/main

catagg-0.1.0.dev0/LICENSE

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

catagg-0.1.0.dev0/PKG-INFO

@@ -0,0 +1,188 @@
+Metadata-Version: 2.5
+Name: catagg
+Version: 0.1.0.dev0
+Summary: Catastrophe loss aggregation, from event loss tables to net exceedance probability curves.
+Project-URL: Homepage, https://github.com/John-Amal/catagg
+Project-URL: Documentation, https://john-amal.github.io/catagg/
+Project-URL: Source, https://github.com/John-Amal/catagg
+Project-URL: Changelog, https://github.com/John-Amal/catagg/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/John-Amal/catagg/issues
+Author: Amal John
+License-Expression: MIT
+License-File: LICENSE
+Keywords: actuarial,catastrophe-modelling,exceedance-probability,monte-carlo,reinsurance
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: numpy>=1.26
+Requires-Dist: pandas>=2.1
+Requires-Dist: pyarrow>=15.0
+Requires-Dist: scipy>=1.11
+Provides-Extra: dev
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.5; extra == 'docs'
+Requires-Dist: mkdocs<2,>=1.6; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.26; extra == 'docs'
+Description-Content-Type: text/markdown
+
+# catagg
+
+**Catastrophe loss aggregation, from event loss tables to net exceedance probability curves.**
+
+[![CI](https://github.com/John-Amal/catagg/actions/workflows/ci.yml/badge.svg)](https://github.com/John-Amal/catagg/actions)
+[![PyPI](https://img.shields.io/pypi/v/catagg.svg)](https://pypi.org/project/catagg/)
+[![Docs](https://img.shields.io/badge/docs-catagg-blue)](https://john-amal.github.io/catagg/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+---
+
+## The question this answers
+
+A reinsurer holds a portfolio exposed to several perils. The catastrophe models produce an **event loss table** — for each modelled event, an annual rate and a loss distribution. Two questions follow immediately, and every pricing, capital and reinsurance-purchase decision depends on them:
+
+**How much loss should we expect in a bad year, and how much of it do we actually keep after our reinsurance programme responds?**
+
+`catagg` answers both. It simulates the year loss table, builds the gross exceedance probability curves, applies the reinsurance structures in the correct order, and returns gross, ceded and net views — with the validation checks that show the answer can be trusted.
+
+![Gross versus net OEP curve for the example Swiss multi-peril portfolio](docs/img/gross_vs_net_oep.png)
+
+*Example portfolio: three perils, 20% quota share, a 50m xs 50m per-occurrence layer with two reinstatements, and a 100m aggregate stop-loss. The programme removes roughly two thirds of the 200-year occurrence loss — and the reinstatement cap is visible as the point where the net curve stops flattening.*
+
+---
+
+## Install
+
+```bash
+pip install catagg
+```
+
+Python 3.11+. Runtime dependencies are numpy, pandas, pyarrow and scipy — nothing else.
+
+---
+
+## Quickstart
+
+```python
+import catagg as ca
+
+# 1. Load an event loss table
+elt = ca.read_elt("portfolio.parquet")
+
+# 2. Simulate 100,000 years
+yelt = ca.simulate(
+    elt,
+    n_years=100_000,
+    frequency="negative_binomial",   # or "poisson"
+    secondary_uncertainty=True,
+    seed=42,
+)
+
+# 3. Gross view
+gross = ca.ep_curve(yelt)
+print(gross.at_return_period([10, 50, 100, 200, 250]))
+
+# 4. Apply a reinsurance programme
+programme = ca.Programme([
+    ca.QuotaShare(cession=0.20),
+    ca.ExcessOfLoss(attachment=50e6, limit=50e6, reinstatements=2, basis="occurrence"),
+    ca.AggregateStopLoss(attachment=100e6, limit=100e6),
+])
+
+result = programme.apply(yelt)
+net = ca.ep_curve(result.net)
+
+# 5. Compare
+ca.plot.ep_comparison({"Gross": gross, "Net": net}, kind="OEP")
+```
+
+Everything runs from a clean clone — the example portfolio is generated synthetically by a documented generator, so there are no data dependencies and no licensing questions.
+
+---
+
+## Concepts
+
+If you already work in cat modelling, skip this. If you're reading the code to learn, this is the map.
+
+| Object | What it is |
+|---|---|
+| **ELT** | Event loss table. One row per modelled event: annual rate λ, mean loss, standard deviation, exposed value. |
+| **YELT** | Year event loss table. One row per event *occurrence* per simulated year. The engine's central output. |
+| **YLT** | Year loss table. One row per simulated year: aggregate loss and maximum occurrence loss. |
+| **OEP** | Occurrence exceedance probability. The distribution of the *largest single event* in a year. Drives per-occurrence cover. |
+| **AEP** | Aggregate exceedance probability. The distribution of *total annual* loss. Drives aggregate cover and capital. |
+| **AAL** | Average annual loss. The mean of the AEP distribution, and the cleanest check on the whole pipeline. |
+| **TVaR** | Tail value at risk. The mean loss given exceedance of a return period. What capital regimes actually ask for. |
+
+---
+
+## What's in the engine
+
+**Frequency.** Poisson, or negative binomial where event clustering matters — European windstorm and hurricane seasons are both over-dispersed, and a Poisson assumption understates the aggregate tail.
+
+**Secondary uncertainty.** Loss given occurrence is sampled from a beta distribution on `[0, exposed_value]`, fitted by moments to the ELT's mean and standard deviation, with probability mass at zero and at full exposure. Degenerate cases — zero variance, or a variance the beta support cannot accommodate — are handled explicitly rather than silently clipped.
+
+**Dependence.** Perils are correlated through a Gaussian or Student-t copula applied to annual losses. Independence is the default; the example shows what assuming it costs you in the tail.
+
+**Financial structures.** Applied in programme order:
+
+- Quota share, with optional ceding commission
+- Per-occurrence excess of loss: attachment, limit, *n* reinstatements at stated percentages, pro-rata to amount, with the aggregate cap of `limit × (1 + n)` enforced
+- Aggregate excess of loss and stop-loss
+- Franchise deductible
+
+**Metrics.** OEP, AEP, AAL, TVaR at any return period, full return-period tables, and Monte Carlo standard errors on every tail statistic.
+
+---
+
+## Validation
+
+Numerical libraries in this domain live or die on whether you can show they're right. `catagg` ships a validation suite that runs in CI and as a readable notebook:
+
+- Simulated AAL converges to the analytic `Σ λᵢ · μᵢ`
+- Sampled frequency moments match the specified Poisson or negative binomial
+- Sampled severity recovers the input mean and standard deviation
+- Ceded loss never exceeds the aggregate reinstatement cap
+- Net + ceded = gross, exactly, in every simulated year
+- Tail-metric standard error as a function of simulation count
+
+That last one matters more than it looks. A 200-year return period estimated from 10,000 simulation years carries a standard error large enough to change decisions, and most workflows never report it. `catagg` reports it by default.
+
+See [docs/validation](https://john-amal.github.io/catagg/validation/).
+
+---
+
+## Scope
+
+**In scope:** everything above.
+
+**Deliberately out of scope for v0.1:** hazard modelling, vulnerability curves, location-level financial terms, exposure data management, a graphical interface, cloud orchestration.
+
+`catagg` starts where the cat model stops. If you need the full modelling stack, use [Oasis LMF](https://oasislmf.org/). If you need to understand, audit or prototype the aggregation and financial layer, use this.
+
+---
+
+## Roadmap
+
+- **v0.2** — location and policy-level terms, surplus share, reinstatement premium calculation
+- **v0.3** — OED-compatible ELT ingest, `oasislmf` interoperability
+- **v0.4** — event-level correlation across sub-perils, seasonality in event timing
+
+Issues and pull requests are welcome, particularly from anyone who has implemented reinstatement logic in production and disagrees with this one.
+
+---
+
+## Citing
+
+If you use `catagg` in published work, cite the Zenodo record: *(DOI added on first release.)*
+
+## Licence
+
+MIT.

catagg-0.1.0.dev0/README.md

@@ -0,0 +1,153 @@
+# catagg
+
+**Catastrophe loss aggregation, from event loss tables to net exceedance probability curves.**
+
+[![CI](https://github.com/John-Amal/catagg/actions/workflows/ci.yml/badge.svg)](https://github.com/John-Amal/catagg/actions)
+[![PyPI](https://img.shields.io/pypi/v/catagg.svg)](https://pypi.org/project/catagg/)
+[![Docs](https://img.shields.io/badge/docs-catagg-blue)](https://john-amal.github.io/catagg/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+---
+
+## The question this answers
+
+A reinsurer holds a portfolio exposed to several perils. The catastrophe models produce an **event loss table** — for each modelled event, an annual rate and a loss distribution. Two questions follow immediately, and every pricing, capital and reinsurance-purchase decision depends on them:
+
+**How much loss should we expect in a bad year, and how much of it do we actually keep after our reinsurance programme responds?**
+
+`catagg` answers both. It simulates the year loss table, builds the gross exceedance probability curves, applies the reinsurance structures in the correct order, and returns gross, ceded and net views — with the validation checks that show the answer can be trusted.
+
+![Gross versus net OEP curve for the example Swiss multi-peril portfolio](docs/img/gross_vs_net_oep.png)
+
+*Example portfolio: three perils, 20% quota share, a 50m xs 50m per-occurrence layer with two reinstatements, and a 100m aggregate stop-loss. The programme removes roughly two thirds of the 200-year occurrence loss — and the reinstatement cap is visible as the point where the net curve stops flattening.*
+
+---
+
+## Install
+
+```bash
+pip install catagg
+```
+
+Python 3.11+. Runtime dependencies are numpy, pandas, pyarrow and scipy — nothing else.
+
+---
+
+## Quickstart
+
+```python
+import catagg as ca
+
+# 1. Load an event loss table
+elt = ca.read_elt("portfolio.parquet")
+
+# 2. Simulate 100,000 years
+yelt = ca.simulate(
+    elt,
+    n_years=100_000,
+    frequency="negative_binomial",   # or "poisson"
+    secondary_uncertainty=True,
+    seed=42,
+)
+
+# 3. Gross view
+gross = ca.ep_curve(yelt)
+print(gross.at_return_period([10, 50, 100, 200, 250]))
+
+# 4. Apply a reinsurance programme
+programme = ca.Programme([
+    ca.QuotaShare(cession=0.20),
+    ca.ExcessOfLoss(attachment=50e6, limit=50e6, reinstatements=2, basis="occurrence"),
+    ca.AggregateStopLoss(attachment=100e6, limit=100e6),
+])
+
+result = programme.apply(yelt)
+net = ca.ep_curve(result.net)
+
+# 5. Compare
+ca.plot.ep_comparison({"Gross": gross, "Net": net}, kind="OEP")
+```
+
+Everything runs from a clean clone — the example portfolio is generated synthetically by a documented generator, so there are no data dependencies and no licensing questions.
+
+---
+
+## Concepts
+
+If you already work in cat modelling, skip this. If you're reading the code to learn, this is the map.
+
+| Object | What it is |
+|---|---|
+| **ELT** | Event loss table. One row per modelled event: annual rate λ, mean loss, standard deviation, exposed value. |
+| **YELT** | Year event loss table. One row per event *occurrence* per simulated year. The engine's central output. |
+| **YLT** | Year loss table. One row per simulated year: aggregate loss and maximum occurrence loss. |
+| **OEP** | Occurrence exceedance probability. The distribution of the *largest single event* in a year. Drives per-occurrence cover. |
+| **AEP** | Aggregate exceedance probability. The distribution of *total annual* loss. Drives aggregate cover and capital. |
+| **AAL** | Average annual loss. The mean of the AEP distribution, and the cleanest check on the whole pipeline. |
+| **TVaR** | Tail value at risk. The mean loss given exceedance of a return period. What capital regimes actually ask for. |
+
+---
+
+## What's in the engine
+
+**Frequency.** Poisson, or negative binomial where event clustering matters — European windstorm and hurricane seasons are both over-dispersed, and a Poisson assumption understates the aggregate tail.
+
+**Secondary uncertainty.** Loss given occurrence is sampled from a beta distribution on `[0, exposed_value]`, fitted by moments to the ELT's mean and standard deviation, with probability mass at zero and at full exposure. Degenerate cases — zero variance, or a variance the beta support cannot accommodate — are handled explicitly rather than silently clipped.
+
+**Dependence.** Perils are correlated through a Gaussian or Student-t copula applied to annual losses. Independence is the default; the example shows what assuming it costs you in the tail.
+
+**Financial structures.** Applied in programme order:
+
+- Quota share, with optional ceding commission
+- Per-occurrence excess of loss: attachment, limit, *n* reinstatements at stated percentages, pro-rata to amount, with the aggregate cap of `limit × (1 + n)` enforced
+- Aggregate excess of loss and stop-loss
+- Franchise deductible
+
+**Metrics.** OEP, AEP, AAL, TVaR at any return period, full return-period tables, and Monte Carlo standard errors on every tail statistic.
+
+---
+
+## Validation
+
+Numerical libraries in this domain live or die on whether you can show they're right. `catagg` ships a validation suite that runs in CI and as a readable notebook:
+
+- Simulated AAL converges to the analytic `Σ λᵢ · μᵢ`
+- Sampled frequency moments match the specified Poisson or negative binomial
+- Sampled severity recovers the input mean and standard deviation
+- Ceded loss never exceeds the aggregate reinstatement cap
+- Net + ceded = gross, exactly, in every simulated year
+- Tail-metric standard error as a function of simulation count
+
+That last one matters more than it looks. A 200-year return period estimated from 10,000 simulation years carries a standard error large enough to change decisions, and most workflows never report it. `catagg` reports it by default.
+
+See [docs/validation](https://john-amal.github.io/catagg/validation/).
+
+---
+
+## Scope
+
+**In scope:** everything above.
+
+**Deliberately out of scope for v0.1:** hazard modelling, vulnerability curves, location-level financial terms, exposure data management, a graphical interface, cloud orchestration.
+
+`catagg` starts where the cat model stops. If you need the full modelling stack, use [Oasis LMF](https://oasislmf.org/). If you need to understand, audit or prototype the aggregation and financial layer, use this.
+
+---
+
+## Roadmap
+
+- **v0.2** — location and policy-level terms, surplus share, reinstatement premium calculation
+- **v0.3** — OED-compatible ELT ingest, `oasislmf` interoperability
+- **v0.4** — event-level correlation across sub-perils, seasonality in event timing
+
+Issues and pull requests are welcome, particularly from anyone who has implemented reinstatement logic in production and disagrees with this one.
+
+---
+
+## Citing
+
+If you use `catagg` in published work, cite the Zenodo record: *(DOI added on first release.)*
+
+## Licence
+
+MIT.

catagg-0.1.0.dev0/docs/api.md

@@ -0,0 +1,3 @@
+# API reference
+
+::: catagg

catagg-0.1.0.dev0/docs/changelog.md

@@ -0,0 +1 @@
+--8<-- "CHANGELOG.md"

catagg-0.1.0.dev0/docs/index.md

@@ -0,0 +1,23 @@
+# catagg
+
+Catastrophe loss aggregation, from event loss tables to net exceedance
+probability curves.
+
+!!! warning "Pre-release"
+
+    v0.1.0 is under development. The public API described in the README is the
+    specification being built against, not yet the shipped surface.
+
+## Install
+
+```bash
+pip install catagg
+```
+
+Python 3.11+. Runtime dependencies are numpy, pandas, pyarrow and scipy.
+
+## Where to start
+
+- **[Validation](validation.md)** — the checks that show the numbers can be trusted.
+- **[API reference](api.md)** — the public surface.
+- **[Changelog](changelog.md)** — what changed, and when.

catagg-0.1.0.dev0/docs/releasing.md

@@ -0,0 +1,70 @@
+# Releasing
+
+`catagg` publishes to PyPI from GitHub Actions using
+[Trusted Publishing](https://docs.pypi.org/trusted-publishers/). No API token
+is created, stored or rotated.
+
+## One-off setup
+
+Done once, before the project exists on PyPI.
+
+### 1. PyPI account
+
+Create an account on [pypi.org](https://pypi.org) and enable two-factor
+authentication. Uploads are refused without it.
+
+### 2. Register a pending publisher
+
+PyPI lets you configure a publisher for a project that does not exist yet; the
+first successful workflow run creates the project and claims the name.
+
+Go to **Account settings → Publishing → Add a new pending publisher** and enter:
+
+| Field | Value |
+|---|---|
+| PyPI project name | `catagg` |
+| Owner | `John-Amal` |
+| Repository name | `catagg` |
+| Workflow name | `release.yml` |
+| Environment name | `pypi` |
+
+These must match exactly. A mismatch in any field makes the OIDC token invalid
+and the upload fails with a permissions error rather than a helpful one.
+
+### 3. Create the GitHub environment
+
+In the repository: **Settings → Environments → New environment**, named `pypi`.
+
+Optionally add yourself as a required reviewer. That turns every publish into a
+manual approval — worth it, given that an upload can never be undone.
+
+## Claiming the name
+
+Run the workflow manually once, from **Actions → Release → Run workflow** on
+`main`, while the version in `src/catagg/__init__.py` is still `0.1.0.dev0`.
+
+This uploads a pre-release, which:
+
+- claims the name `catagg` permanently;
+- leaves `0.1.0` free for the real release;
+- is invisible to `pip install catagg`, since pip ignores pre-releases unless
+  `--pre` is passed.
+
+Confirm at <https://pypi.org/project/catagg/>.
+
+## Normal release
+
+1. Set the version in `src/catagg/__init__.py`. It is the single source; the
+   build reads it, and a test asserts it matches the distribution metadata.
+2. Move the `[Unreleased]` entries in `CHANGELOG.md` under the new version
+   heading with its date.
+3. Merge to `main` and wait for CI to pass.
+4. Tag and push: `git tag v0.1.0 && git push origin v0.1.0`.
+5. Publish the GitHub Release for that tag. The workflow refuses to run if the
+   tag and the package version disagree.
+6. Mint the Zenodo DOI and add it to the README's citation section.
+
+## Irreversibility
+
+A version, once uploaded, can never be uploaded again — deleting a release does
+not free its filename. Check the version number before publishing, not after.

catagg-0.1.0.dev0/docs/validation.md

@@ -0,0 +1,17 @@
+# Validation
+
+!!! note "Placeholder"
+
+    This page is a stub. It is filled by the validation notebook built at the
+    end of the v0.1.0 milestone; no results are published here yet.
+
+The suite this page will report on, each check running in CI:
+
+| Check | What it proves |
+|---|---|
+| Simulated AAL against analytic `Σ λᵢ · μᵢ` | The frequency–severity loop is unbiased |
+| Sampled frequency moments against Poisson / negative binomial | The sampler matches the specified distribution |
+| Sampled severity moments against the ELT input | Method-of-moments beta fitting recovers its own inputs |
+| Ceded loss against the aggregate reinstatement cap | Reinstatement accounting never over-recovers |
+| Net + ceded = gross, every simulated year | The financial module conserves loss exactly |
+| Tail-metric standard error against simulation count | How noisy a given return period estimate actually is |

catagg-0.1.0.dev0/pyproject.toml

@@ -0,0 +1,135 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "catagg"
+dynamic = ["version"]
+description = "Catastrophe loss aggregation, from event loss tables to net exceedance probability curves."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Amal John" }]
+keywords = [
+  "catastrophe-modelling",
+  "reinsurance",
+  "exceedance-probability",
+  "actuarial",
+  "monte-carlo",
+]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Science/Research",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Typing :: Typed",
+  "Topic :: Scientific/Engineering :: Mathematics",
+]
+dependencies = [
+  "numpy>=1.26",
+  "pandas>=2.1",
+  "pyarrow>=15.0",
+  "scipy>=1.11",
+]
+
+[project.optional-dependencies]
+dev = [
+  "mypy>=1.11",
+  "pytest>=8.0",
+  "ruff>=0.6",
+]
+docs = [
+  "mkdocs>=1.6,<2",
+  "mkdocs-material>=9.5",
+  "mkdocstrings[python]>=0.26",
+]
+
+[project.urls]
+Homepage = "https://github.com/John-Amal/catagg"
+Documentation = "https://john-amal.github.io/catagg/"
+Source = "https://github.com/John-Amal/catagg"
+Changelog = "https://github.com/John-Amal/catagg/blob/main/CHANGELOG.md"
+Issues = "https://github.com/John-Amal/catagg/issues"
+
+[tool.hatch.version]
+path = "src/catagg/__init__.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/catagg"]
+
+[tool.hatch.build.targets.sdist]
+include = ["src", "tests", "docs", "CHANGELOG.md", "LICENSE", "README.md"]
+
+# ---------------------------------------------------------------------------
+# Lint / format
+# ---------------------------------------------------------------------------
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+src = ["src", "tests"]
+# Ruff reformats Python blocks inside Markdown. The README is the project
+# specification and is author-owned prose; a formatter should not rewrite it.
+extend-exclude = ["*.md"]
+
+[tool.ruff.lint]
+select = [
+  "A",    # builtin shadowing
+  "B",    # bugbear
+  "C4",   # comprehensions
+  "D",    # docstrings
+  "E",    # pycodestyle errors
+  "F",    # pyflakes
+  "I",    # import order
+  "N",    # naming
+  "NPY",  # numpy-specific
+  "PD",   # pandas-vet
+  "PT",   # pytest style
+  "RUF",
+  "SIM",
+  "UP",   # pyupgrade
+  "W",
+]
+ignore = [
+  "D105",  # docstring in magic method
+  "D107",  # docstring in __init__
+]
+
+[tool.ruff.lint.pydocstyle]
+convention = "numpy"
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["D100", "D101", "D102", "D103", "D104"]
+# `catagg.io` is the industry-legible name for the ingest layer and is only ever
+# reached as an absolute import, so shadowing the stdlib module name is safe.
+"src/catagg/io/*" = ["A005"]
+"docs/*" = ["D"]
+
+[tool.ruff.format]
+docstring-code-format = true
+
+# ---------------------------------------------------------------------------
+# Types
+# ---------------------------------------------------------------------------
+[tool.mypy]
+python_version = "3.11"
+files = ["src", "tests"]
+strict = true
+warn_unreachable = true
+pretty = true
+
+# scipy and pyarrow ship incomplete type information; numpy and pandas are
+# checked normally. Narrow these as the stubs improve rather than widening them.
+[[tool.mypy.overrides]]
+module = ["scipy.*", "pyarrow.*"]
+ignore_missing_imports = true
+
+# ---------------------------------------------------------------------------
+# Tests
+# ---------------------------------------------------------------------------
+[tool.pytest.ini_options]
+minversion = "8.0"
+testpaths = ["tests"]
+addopts = "-ra --strict-markers --strict-config"
+xfail_strict = true

catagg-0.1.0.dev0/src/catagg/__init__.py

@@ -0,0 +1,5 @@
+"""Catastrophe loss aggregation, from event loss tables to net exceedance probability curves."""
+
+__version__ = "0.1.0.dev0"
+
+__all__ = ["__version__"]

catagg-0.1.0.dev0/src/catagg/dependence/__init__.py

@@ -0,0 +1 @@
+"""Cross-peril dependence: Gaussian and Student-t copulas over annual losses."""

catagg-0.1.0.dev0/src/catagg/financial/__init__.py

@@ -0,0 +1 @@
+"""Reinsurance structures: quota share, excess of loss with reinstatements, stop-loss."""

catagg-0.1.0.dev0/src/catagg/frequency/__init__.py

@@ -0,0 +1 @@
+"""Event-count samplers: Poisson and negative binomial."""

catagg-0.1.0.dev0/src/catagg/io/__init__.py

@@ -0,0 +1 @@
+"""ELT readers, schema validation, and the Parquet YELT writer."""

catagg-0.1.0.dev0/src/catagg/metrics/__init__.py

@@ -0,0 +1 @@
+"""EP curves, AAL, TVaR, return-period tables and Monte Carlo standard errors."""

catagg-0.1.0.dev0/src/catagg/severity/__init__.py

@@ -0,0 +1 @@
+"""Secondary uncertainty: beta-with-point-mass sampler and moment fitting."""

catagg-0.1.0.dev0/src/catagg/simulate/__init__.py

@@ -0,0 +1 @@
+"""The year loop: ELT to YELT to YLT."""

catagg-0.1.0.dev0/tests/test_packaging.py

@@ -0,0 +1,34 @@
+"""Checks that the distribution is assembled correctly.
+
+These are not smoke tests: each one fails on a specific, real packaging
+mistake that is otherwise silent until a user hits it.
+"""
+
+from __future__ import annotations
+
+import re
+from importlib.metadata import version as dist_version
+from importlib.resources import files
+
+import catagg
+
+PEP440 = re.compile(r"^\d+\.\d+\.\d+(?:(?:a|b|rc)\d+)?(?:\.post\d+)?(?:\.dev\d+)?$")
+
+
+def test_version_is_pep440() -> None:
+    assert PEP440.match(catagg.__version__), catagg.__version__
+
+
+def test_module_version_matches_distribution_metadata() -> None:
+    """The single source of truth must survive the build.
+
+    Fails if ``__init__.__version__`` and the built metadata drift apart --
+    the usual cause of a release tagged with one number and published under
+    another.
+    """
+    assert catagg.__version__ == dist_version("catagg")
+
+
+def test_py_typed_marker_is_installed() -> None:
+    """Without this file downstream type checkers silently ignore the package."""
+    assert files("catagg").joinpath("py.typed").is_file()