From fe7d43f234c1cb4084db3ebe682f9534ecd5f482 Mon Sep 17 00:00:00 2001 From: Nathaniel Ramm Date: Wed, 29 Apr 2026 18:19:01 +1000 Subject: [PATCH 1/5] docs: rules evaluation service design spec FastAPI service wrapping mountainash-utils-rules as an HTTP API. File-based ruleset registry with slugged IDs, POST /evaluate/{id} endpoint with top_n/min_specificity/dimensions query params. Co-Authored-By: Claude Opus 4.6 (1M context) --- ...6-04-29-rules-evaluation-service-design.md | 302 ++++++++++++++++++ 1 file changed, 302 insertions(+) create mode 100644 docs/superpowers/specs/2026-04-29-rules-evaluation-service-design.md diff --git a/docs/superpowers/specs/2026-04-29-rules-evaluation-service-design.md b/docs/superpowers/specs/2026-04-29-rules-evaluation-service-design.md new file mode 100644 index 0000000..dfabab7 --- /dev/null +++ b/docs/superpowers/specs/2026-04-29-rules-evaluation-service-design.md @@ -0,0 +1,302 @@ +# Rules Evaluation Service — Design Spec + +**Status:** Approved design. Ready for implementation planning. +**Date:** 2026-04-29 +**Author:** Nathaniel Ramm (with Claude) +**Repo:** `mountainash-rules-service` (new repo, imports `mountainash-utils-rules` as a dependency) + +--- + +## 1. Purpose + +A FastAPI service that wraps `mountainash-utils-rules` as an HTTP evaluation API. Callers POST a context to `/evaluate/{ruleset_id}` and get back matched rules ranked by specificity. Multiple rulesets are loaded from disk on startup, each identified by a slug derived from its directory name. + +This is the thinnest useful layer over the engine library — no database, no admin UI, no auth. It is the foundation for future MCP integration and SaaS management. + +--- + +## 2. Design Decisions + +| Decision | Choice | Rationale | +|----------|--------|-----------| +| Engine type | Filter only (`ExpressionRulesEngine`) | Accumulator support added in a follow-up | +| Ruleset storage | File-based — parquet/CSV + YAML per directory | Stateless, container-friendly, no database needed | +| Response shape | All survivors by default, `top_n`/`min_specificity`/`dimensions` query params | Maps directly to engine `evaluate()` signature | +| Repo | New (`mountainash-rules-service`) | Library and service have different deployment lifecycles | + +--- + +## 3. Ruleset Registry + +### 3.1 Directory structure + +A configurable root path (default `./rulesets/`) contains one directory per ruleset. The directory name is the `ruleset_id` slug: + +``` +rulesets/ +├── pricing-au/ +│ ├── ruleset.yaml +│ └── rules.parquet +├── fraud-detection/ +│ ├── ruleset.yaml +│ └── rules.parquet +└── entity-pool/ + ├── ruleset.yaml + └── rules.csv +``` + +### 3.2 Ruleset YAML schema + +Each `ruleset.yaml` declares the metadata needed to construct an `ExpressionRulesEngine`: + +```yaml +name: Australian Pricing Rules +description: Discretion margin rules for AU mortgage products + +# Rules file relative to this directory (parquet preferred, CSV supported) +rules_file: rules.parquet + +# Dimension definitions +dimensions: + - name: channel + strategy: EXACT + data_type: str + - name: lvr + strategy: RANGE + data_type: int + range_min_field: lvr_min + range_max_field: lvr_max + - name: region + strategy: EXACT + data_type: str +``` + +Supported fields per dimension: +- `name` (required): dimension name, used as the context field and rule field unless overridden +- `strategy` (required): one of `EXACT`, `RANGE`, `GREATER_THAN`, `LESS_THAN`, `NOT_EQUAL`, `PREFIX`, `SUFFIX`, `CONTAINS`, `REGEX`, `SET_MEMBERSHIP`, `SET_EXCLUSION` +- `data_type` (required): `str`, `int`, or `float` +- `context_field` (optional): override the context key name +- `rule_field` (optional): override the rule column name +- `range_min_field` / `range_max_field` (required for RANGE): column names for min/max bounds +- `range_min_inclusive` / `range_max_inclusive` (optional, default `true`): bound inclusivity +- `regex_pattern` (required for REGEX): the pattern string +- `valid_values` (optional): list of allowed values + +### 3.3 RulesetRegistry class + +Loads all rulesets from disk on startup. Immutable after load. Held on `app.state` via FastAPI lifespan. + +```python +class RulesetRegistry: + def __init__(self, rulesets_path: Path): + self._engines: dict[str, ExpressionRulesEngine] = {} + self._info: dict[str, RulesetInfo] = {} + self._load_all(rulesets_path) +``` + +**Loading logic:** +1. Scan `rulesets_path` for subdirectories +2. For each directory, read `ruleset.yaml` +3. Parse dimensions into `DimensionsMetadata` +4. Load rules file (parquet via `pl.read_parquet()`, CSV via `pl.read_csv()`) +5. Construct `ExpressionRulesEngine(rules=df, dimension_metadata=metadata)` +6. Store engine and metadata info keyed by directory name (the slug) + +**Error handling on startup:** +- Missing `ruleset.yaml`: log warning, skip directory +- Invalid YAML or missing required fields: log error with details, skip directory +- Missing rules file: log error, skip directory +- Engine construction failure: log error with traceback, skip directory +- If zero rulesets load successfully: raise, fail startup + +--- + +## 4. API Endpoints + +### 4.1 `GET /rulesets` — list available rulesets + +Response `200`: + +```json +{ + "rulesets": [ + { + "id": "pricing-au", + "name": "Australian Pricing Rules", + "description": "Discretion margin rules for AU mortgage products", + "dimensions": ["channel", "lvr", "region"], + "rule_count": 42 + } + ] +} +``` + +### 4.2 `GET /rulesets/{ruleset_id}` — ruleset detail + +Response `200`: + +```json +{ + "id": "pricing-au", + "name": "Australian Pricing Rules", + "description": "Discretion margin rules for AU mortgage products", + "dimensions": [ + {"name": "channel", "strategy": "EXACT", "data_type": "str"}, + {"name": "lvr", "strategy": "RANGE", "data_type": "int", "range_min_field": "lvr_min", "range_max_field": "lvr_max"}, + {"name": "region", "strategy": "EXACT", "data_type": "str"} + ], + "rule_count": 42 +} +``` + +Response `404`: `{"detail": "Ruleset 'unknown-id' not found"}` + +### 4.3 `POST /evaluate/{ruleset_id}` — evaluate a context + +Request body: + +```json +{ + "context": { + "channel": "BROKER", + "lvr": 75, + "region": "AU" + } +} +``` + +Query parameters (all optional): +- `top_n: int` — return only the top N matches by specificity +- `min_specificity: int` — minimum hard-match count to include +- `dimensions: str` — comma-separated subset of dimensions to evaluate + +Response `200`: + +```json +{ + "ruleset_id": "pricing-au", + "survivors": [ + { + "rule_name": "specific", + "channel": "BROKER", + "lvr_min": 60, + "lvr_max": 80, + "region": "AU", + "margin": -0.10, + "__specificity": 3, + "__rank": 1 + } + ], + "count": 1, + "evaluated_dimensions": ["channel", "lvr", "region"] +} +``` + +Response `404`: ruleset not found. +Response `422`: malformed context (FastAPI validation). + +**Serialisation:** `RuleResult.survivors` is a backend DataFrame. The route handler converts it to a list of dicts via `relation(result.survivors).to_dicts()`. Internal columns (`__t_*`, `__ctx_*`) are stripped from the response. `__specificity` and `__rank` are preserved. + +--- + +## 5. Application Structure + +### 5.1 Project layout + +``` +mountainash-rules-service/ +├── src/ +│ └── mountainash_rules_service/ +│ ├── __init__.py +│ ├── app.py # FastAPI app factory, lifespan, CORS +│ ├── config.py # Settings via pydantic-settings (rulesets_path, host, port) +│ ├── registry.py # RulesetRegistry: load rulesets, hold engines, evaluate +│ ├── models.py # Pydantic request/response models +│ └── routes.py # Route handlers: /rulesets, /evaluate/{ruleset_id} +├── tests/ +│ ├── conftest.py # Test registry with fixture rulesets +│ ├── test_registry.py # Loading, missing files, bad YAML, evaluate +│ ├── test_routes.py # HTTP-level tests via httpx TestClient +│ └── fixtures/ +│ └── sample-ruleset/ +│ ├── ruleset.yaml +│ └── rules.parquet +├── pyproject.toml +├── hatch.toml +├── Dockerfile +├── CLAUDE.md +└── README.md +``` + +### 5.2 Dependencies + +```toml +[project] +dependencies = [ + "fastapi>=0.115.0", + "uvicorn[standard]>=0.30.0", + "pydantic-settings>=2.0.0", + "polars>=1.16.0", + "pyyaml>=6.0", + "mountainash-utils-rules", +] +``` + +### 5.3 Configuration + +Via `pydantic-settings` with env var support: + +```python +class Settings(BaseModel): + rulesets_path: Path = Path("./rulesets") + host: str = "0.0.0.0" + port: int = 8000 + log_level: str = "info" +``` + +Env vars: `RULESETS_PATH`, `HOST`, `PORT`, `LOG_LEVEL`. + +### 5.4 App factory and lifespan + +```python +@asynccontextmanager +async def lifespan(app: FastAPI): + settings = get_settings() + app.state.registry = RulesetRegistry(settings.rulesets_path) + logger.info(f"Loaded {len(app.state.registry)} rulesets") + yield + +app = FastAPI( + title="Mountain Ash Rules Service", + description="Rules evaluation API", + lifespan=lifespan, +) +app.include_router(router) +``` + +### 5.5 Dockerfile + +```dockerfile +FROM python:3.12-slim AS base +WORKDIR /app +COPY pyproject.toml hatch.toml ./ +RUN pip install hatch && hatch env create default +COPY src/ src/ +EXPOSE 8000 +CMD ["hatch", "run", "uvicorn", "mountainash_rules_service.app:app", "--host", "0.0.0.0", "--port", "8000"] +``` + +Rulesets mounted at runtime: `docker run -v ./rulesets:/app/rulesets mountainash-rules-service` + +--- + +## 6. Scope Exclusions + +- **Accumulator engine support** — follow-up: add `engine: accumulator` to ruleset YAML, accumulator-specific response fields +- **MCP server** — follow-up: expose evaluate/list as MCP tools +- **Authentication / authorization** — no auth in v1 +- **Rule authoring / management UI** — SaaS management layer is a separate sub-project +- **Database persistence** — file-based only +- **Hot-reload** — rulesets loaded on startup only; restart to pick up changes +- **Rate limiting / caching** — not needed for v1 +- **Async evaluation** — the engine is synchronous; FastAPI wraps it in a threadpool executor by default for `def` routes, which is sufficient From bd3a8a2d48ffeadf0e866ae50aca9b1c12836e86 Mon Sep 17 00:00:00 2001 From: Nathaniel Ramm Date: Wed, 29 Apr 2026 19:06:31 +1000 Subject: [PATCH 2/5] docs: rules evaluation service implementation plan 8-task TDD plan for mountainash-rules-service: project scaffold, config, models, test fixtures, RulesetRegistry, FastAPI routes, Dockerfile, and final polish. Co-Authored-By: Claude Opus 4.6 (1M context) --- .../2026-04-29-rules-evaluation-service.md | 1348 +++++++++++++++++ 1 file changed, 1348 insertions(+) create mode 100644 docs/superpowers/plans/2026-04-29-rules-evaluation-service.md diff --git a/docs/superpowers/plans/2026-04-29-rules-evaluation-service.md b/docs/superpowers/plans/2026-04-29-rules-evaluation-service.md new file mode 100644 index 0000000..812cd83 --- /dev/null +++ b/docs/superpowers/plans/2026-04-29-rules-evaluation-service.md @@ -0,0 +1,1348 @@ +# Rules Evaluation Service Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Build a FastAPI service (`mountainash-rules-service`) that wraps the mountainash-utils-rules engine as an HTTP evaluation API with multi-ruleset support via slugged directory names. + +**Architecture:** File-based ruleset registry loaded on startup. Each ruleset is a directory containing a YAML metadata file and a parquet/CSV rules file. A single `POST /evaluate/{ruleset_id}` endpoint accepts a context and returns matched rules. The service is stateless — rulesets are immutable after load. + +**Tech Stack:** FastAPI, uvicorn, pydantic-settings, polars, PyYAML, mountainash-utils-rules, hatch, pytest, httpx + +**Spec:** `docs/superpowers/specs/2026-04-29-rules-evaluation-service-design.md` (in mountainash-utils-rules repo) + +**New repo location:** `/home/nathanielramm/git/mountainash-io/mountainash/mountainash-rules-service/` + +--- + +## File Map + +### Source files + +| File | Responsibility | +|------|----------------| +| `src/mountainash_rules_service/__init__.py` | Package marker | +| `src/mountainash_rules_service/__version__.py` | Version string | +| `src/mountainash_rules_service/config.py` | `Settings` via pydantic-settings (rulesets_path, host, port, log_level) | +| `src/mountainash_rules_service/models.py` | Pydantic request/response models for all endpoints | +| `src/mountainash_rules_service/registry.py` | `RulesetRegistry`: loads rulesets from disk, holds engines, evaluates contexts | +| `src/mountainash_rules_service/routes.py` | FastAPI router with all endpoint handlers | +| `src/mountainash_rules_service/app.py` | FastAPI app factory with lifespan | + +### Test files + +| File | Responsibility | +|------|----------------| +| `tests/conftest.py` | Fixture rulesets, test registry, TestClient fixture | +| `tests/test_registry.py` | Registry loading, error handling, evaluate | +| `tests/test_routes.py` | HTTP-level endpoint tests | +| `tests/fixtures/sample-ruleset/ruleset.yaml` | Sample YAML for testing | +| `tests/fixtures/sample-ruleset/rules.parquet` | Sample rules data | +| `tests/fixtures/bad-yaml/ruleset.yaml` | Invalid YAML for error testing | +| `tests/fixtures/missing-rules/ruleset.yaml` | YAML pointing to nonexistent rules file | + +### Config files + +| File | Responsibility | +|------|----------------| +| `pyproject.toml` | Project metadata, dependencies, build config | +| `hatch.toml` | Hatch environments (default, test, ruff) | +| `pytest.ini` | Pytest config | +| `Dockerfile` | Container build | +| `CLAUDE.md` | Dev guidance | + +--- + +## Task 1: Scaffold New Repo + +**Files:** +- Create: `pyproject.toml`, `hatch.toml`, `pytest.ini`, `src/mountainash_rules_service/__init__.py`, `src/mountainash_rules_service/__version__.py`, `CLAUDE.md` + +- [ ] **Step 1: Create repo directory and initialise git** + +```bash +mkdir -p /home/nathanielramm/git/mountainash-io/mountainash/mountainash-rules-service +cd /home/nathanielramm/git/mountainash-io/mountainash/mountainash-rules-service +git init +``` + +- [ ] **Step 2: Create pyproject.toml** + +Create `pyproject.toml`: + +```toml +[build-system] +requires = ["hatchling"] +build-backend = "hatchling.build" + +[project] +name = "mountainash_rules_service" +dynamic = ["version"] +description = "Mountain Ash Rules Evaluation Service — FastAPI wrapper for mountainash-utils-rules" +readme = "README.md" +requires-python = ">=3.12" +keywords = ["rules-engine", "fastapi", "evaluation"] +authors = [ + { name = "Nathaniel Ramm", email = "nathaniel.ramm@discretedatascience.com" }, +] +dependencies = [ + "fastapi>=0.115.0", + "uvicorn[standard]>=0.30.0", + "pydantic-settings>=2.0.0", + "polars>=1.16.0", + "pyyaml>=6.0", + "mountainash-utils-rules", + "mountainash-data", + "mountainash", +] + +[project.urls] +Documentation = "https://github.com/mountainash-io/mountainash-rules-service#readme" +Issues = "https://github.com/mountainash-io/mountainash-rules-service/issues" +Source = "https://github.com/mountainash-io/mountainash-rules-service" +``` + +- [ ] **Step 3: Create hatch.toml** + +Create `hatch.toml`: + +```toml +[metadata] +allow-direct-references = true + +[version] +path = "src/mountainash_rules_service/__version__.py" + +[build.targets.wheel] +packages = ["src/mountainash_rules_service"] + +[envs.default] +installer = "uv" +path = ".venv" +dependencies = [ + "mountainash_utils_rules @ {root:uri}/../mountainash-utils-rules", + "mountainash_data @ {root:uri}/../mountainash-data", + "mountainash @ {root:uri}/../mountainash", + "mountainash_settings @ {root:uri}/../mountainash-settings", +] + +[envs.default.scripts] +serve = "uvicorn mountainash_rules_service.app:app --reload --host 0.0.0.0 --port 8000" + +[envs.test] +installer = "uv" +dependencies = [ + "pytest==8.3.5", + "pytest-cov>=4.1.0", + "httpx>=0.27.0", + + "mountainash_utils_rules @ {root:uri}/../mountainash-utils-rules", + "mountainash_data @ {root:uri}/../mountainash-data", + "mountainash @ {root:uri}/../mountainash", + "mountainash_settings @ {root:uri}/../mountainash-settings", +] + +[envs.test.scripts] +test = "pytest -v" +test-cov = "pytest --cov --cov-report=term-missing -v" +test-target = "pytest {args} -v" + +[envs.ruff] +installer = "uv" +dependencies = ["ruff==0.3.7"] + +[envs.ruff.scripts] +check = "ruff check src/ tests/" +fix = "ruff check --fix src/ tests/" +``` + +- [ ] **Step 4: Create pytest.ini** + +Create `pytest.ini`: + +```ini +[pytest] +testpaths = tests +python_files = test_*.py +python_functions = test_* +addopts = -v -ra +``` + +- [ ] **Step 5: Create package init and version** + +Create `src/mountainash_rules_service/__init__.py`: + +```python +"""Mountain Ash Rules Evaluation Service.""" +``` + +Create `src/mountainash_rules_service/__version__.py`: + +```python +__version__ = "0.1.0" +``` + +- [ ] **Step 6: Create CLAUDE.md** + +Create `CLAUDE.md`: + +```markdown +# CLAUDE.md + +## Project Overview + +Mountain Ash Rules Evaluation Service — a FastAPI wrapper for the mountainash-utils-rules engine library. Loads rulesets from disk on startup and exposes them via HTTP endpoints for context-based rule evaluation. + +## Build/Test/Lint Commands + +- **Run dev server**: `hatch run serve` +- **Run tests**: `hatch run test:test` +- **Run single test**: `hatch run test:test-target tests/path/test.py::test_name` +- **Lint**: `hatch run ruff:check` + +## Architecture + +- `config.py` — pydantic-settings configuration +- `models.py` — request/response Pydantic models +- `registry.py` — RulesetRegistry: loads YAML + parquet/CSV, holds engines +- `routes.py` — FastAPI route handlers +- `app.py` — FastAPI app factory with lifespan + +## Ruleset Format + +Each ruleset is a directory under `rulesets/` containing: +- `ruleset.yaml` — metadata (name, description, dimensions with strategies) +- `rules.parquet` or `rules.csv` — rules data + +The directory name is the ruleset slug used in API URLs. +``` + +- [ ] **Step 7: Initial commit** + +```bash +git add -A +git commit -m "chore: scaffold mountainash-rules-service project" +``` + +--- + +## Task 2: Configuration + +**Files:** +- Create: `src/mountainash_rules_service/config.py` +- Create: `tests/test_config.py` + +- [ ] **Step 1: Write the failing test** + +Create `tests/test_config.py`: + +```python +"""Tests for service configuration.""" + +from pathlib import Path + +from mountainash_rules_service.config import Settings + + +class TestSettings: + def test_default_rulesets_path(self): + settings = Settings() + assert settings.rulesets_path == Path("./rulesets") + + def test_default_host(self): + settings = Settings() + assert settings.host == "0.0.0.0" + + def test_default_port(self): + settings = Settings() + assert settings.port == 8000 + + def test_default_log_level(self): + settings = Settings() + assert settings.log_level == "info" + + def test_override_via_constructor(self): + settings = Settings(rulesets_path=Path("/tmp/rules"), port=9000) + assert settings.rulesets_path == Path("/tmp/rules") + assert settings.port == 9000 +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `hatch run test:test-target tests/test_config.py -v` +Expected: FAIL — module does not exist. + +- [ ] **Step 3: Implement config.py** + +Create `src/mountainash_rules_service/config.py`: + +```python +"""Service configuration via pydantic-settings.""" + +from __future__ import annotations + +from pathlib import Path + +from pydantic_settings import BaseSettings + + +class Settings(BaseSettings): + """Service settings with env var support.""" + + rulesets_path: Path = Path("./rulesets") + host: str = "0.0.0.0" + port: int = 8000 + log_level: str = "info" + + model_config = {"env_prefix": ""} + + +_settings: Settings | None = None + + +def get_settings() -> Settings: + """Return cached settings instance.""" + global _settings + if _settings is None: + _settings = Settings() + return _settings +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `hatch run test:test-target tests/test_config.py -v` +Expected: ALL PASS. + +- [ ] **Step 5: Commit** + +```bash +git add src/mountainash_rules_service/config.py tests/test_config.py +git commit -m "feat: add service configuration via pydantic-settings" +``` + +--- + +## Task 3: Pydantic Models + +**Files:** +- Create: `src/mountainash_rules_service/models.py` +- Create: `tests/test_models.py` + +- [ ] **Step 1: Write the failing test** + +Create `tests/test_models.py`: + +```python +"""Tests for request/response models.""" + +import pytest + +from mountainash_rules_service.models import ( + EvaluateRequest, + EvaluateResponse, + RulesetSummary, + RulesetDetail, + RulesetListResponse, + DimensionInfo, +) + + +class TestEvaluateRequest: + def test_context_required(self): + req = EvaluateRequest(context={"channel": "BROKER", "lvr": 75}) + assert req.context == {"channel": "BROKER", "lvr": 75} + + def test_empty_context_allowed(self): + req = EvaluateRequest(context={}) + assert req.context == {} + + +class TestEvaluateResponse: + def test_fields(self): + resp = EvaluateResponse( + ruleset_id="pricing-au", + survivors=[{"rule_name": "r1", "__specificity": 2, "__rank": 1}], + count=1, + evaluated_dimensions=["channel"], + ) + assert resp.ruleset_id == "pricing-au" + assert resp.count == 1 + assert len(resp.survivors) == 1 + + +class TestRulesetSummary: + def test_fields(self): + s = RulesetSummary( + id="pricing-au", + name="AU Pricing", + description="Desc", + dimensions=["channel", "lvr"], + rule_count=10, + ) + assert s.id == "pricing-au" + assert s.rule_count == 10 + + +class TestDimensionInfo: + def test_exact_dimension(self): + d = DimensionInfo(name="channel", strategy="EXACT", data_type="str") + assert d.name == "channel" + + def test_range_dimension(self): + d = DimensionInfo( + name="lvr", strategy="RANGE", data_type="int", + range_min_field="lvr_min", range_max_field="lvr_max", + ) + assert d.range_min_field == "lvr_min" + + +class TestRulesetDetail: + def test_fields(self): + detail = RulesetDetail( + id="pricing-au", + name="AU Pricing", + description="Desc", + dimensions=[ + DimensionInfo(name="channel", strategy="EXACT", data_type="str"), + ], + rule_count=10, + ) + assert len(detail.dimensions) == 1 +``` + +- [ ] **Step 2: Run test to verify it fails** + +Run: `hatch run test:test-target tests/test_models.py -v` +Expected: FAIL — module does not exist. + +- [ ] **Step 3: Implement models.py** + +Create `src/mountainash_rules_service/models.py`: + +```python +"""Pydantic request/response models for the rules evaluation API.""" + +from __future__ import annotations + +import typing as t + +from pydantic import BaseModel + + +class EvaluateRequest(BaseModel): + """POST body for /evaluate/{ruleset_id}.""" + + context: dict[str, t.Any] + + +class EvaluateResponse(BaseModel): + """Response from /evaluate/{ruleset_id}.""" + + ruleset_id: str + survivors: list[dict[str, t.Any]] + count: int + evaluated_dimensions: list[str] + + +class DimensionInfo(BaseModel): + """Dimension metadata in API responses.""" + + name: str + strategy: str + data_type: str + range_min_field: str | None = None + range_max_field: str | None = None + regex_pattern: str | None = None + + +class RulesetSummary(BaseModel): + """Summary info for /rulesets list.""" + + id: str + name: str + description: str + dimensions: list[str] + rule_count: int + + +class RulesetDetail(BaseModel): + """Detailed info for /rulesets/{id}.""" + + id: str + name: str + description: str + dimensions: list[DimensionInfo] + rule_count: int + + +class RulesetListResponse(BaseModel): + """Response from GET /rulesets.""" + + rulesets: list[RulesetSummary] +``` + +- [ ] **Step 4: Run test to verify it passes** + +Run: `hatch run test:test-target tests/test_models.py -v` +Expected: ALL PASS. + +- [ ] **Step 5: Commit** + +```bash +git add src/mountainash_rules_service/models.py tests/test_models.py +git commit -m "feat: add Pydantic request/response models" +``` + +--- + +## Task 4: Test Fixtures + +**Files:** +- Create: `tests/fixtures/sample-ruleset/ruleset.yaml` +- Create: `tests/fixtures/sample-ruleset/rules.parquet` (generated by script) +- Create: `tests/fixtures/bad-yaml/ruleset.yaml` +- Create: `tests/fixtures/missing-rules/ruleset.yaml` +- Create: `tests/conftest.py` + +- [ ] **Step 1: Create sample ruleset YAML** + +Create `tests/fixtures/sample-ruleset/ruleset.yaml`: + +```yaml +name: Sample Pricing Rules +description: Test ruleset for unit tests + +rules_file: rules.parquet + +dimensions: + - name: region + strategy: EXACT + data_type: str + - name: amount + strategy: RANGE + data_type: int + range_min_field: amount_min + range_max_field: amount_max +``` + +- [ ] **Step 2: Generate sample rules parquet** + +Run this once to create the parquet fixture: + +```bash +hatch run python -c " +import polars as pl +df = pl.DataFrame({ + 'rule_name': ['specific', 'general', 'mid'], + 'region': ['AU', '', 'AU'], + 'amount_min': [0, -999999999, 0], + 'amount_max': [100, -999999999, 100], + 'margin': [-0.10, -0.01, -0.05], +}) +df.write_parquet('tests/fixtures/sample-ruleset/rules.parquet') +print('Written', len(df), 'rules') +" +``` + +- [ ] **Step 3: Create bad YAML fixture** + +Create `tests/fixtures/bad-yaml/ruleset.yaml`: + +```yaml +this is: [not valid: yaml: content + broken: true +``` + +- [ ] **Step 4: Create missing-rules fixture** + +Create `tests/fixtures/missing-rules/ruleset.yaml`: + +```yaml +name: Missing Rules File +description: Points to a file that does not exist + +rules_file: nonexistent.parquet + +dimensions: + - name: region + strategy: EXACT + data_type: str +``` + +- [ ] **Step 5: Create conftest.py** + +Create `tests/conftest.py`: + +```python +"""Shared fixtures for rules service tests.""" + +from __future__ import annotations + +from pathlib import Path + +import pytest + +from mountainash_rules_service.registry import RulesetRegistry + +FIXTURES_DIR = Path(__file__).parent / "fixtures" + + +@pytest.fixture +def fixtures_path() -> Path: + return FIXTURES_DIR + + +@pytest.fixture +def sample_registry(fixtures_path) -> RulesetRegistry: + return RulesetRegistry(fixtures_path) +``` + +- [ ] **Step 6: Commit** + +```bash +git add tests/fixtures/ tests/conftest.py +git commit -m "test: add fixture rulesets and conftest" +``` + +--- + +## Task 5: RulesetRegistry + +**Files:** +- Create: `src/mountainash_rules_service/registry.py` +- Create: `tests/test_registry.py` + +- [ ] **Step 1: Write the failing tests** + +Create `tests/test_registry.py`: + +```python +"""Tests for RulesetRegistry.""" + +from pathlib import Path + +import pytest +from mountainash.relations import relation + +from mountainash_rules_service.registry import RulesetRegistry + +FIXTURES_DIR = Path(__file__).parent / "fixtures" + + +class TestRegistryLoading: + def test_loads_sample_ruleset(self): + registry = RulesetRegistry(FIXTURES_DIR) + rulesets = registry.list_rulesets() + ids = [r.id for r in rulesets] + assert "sample-ruleset" in ids + + def test_skips_bad_yaml(self): + registry = RulesetRegistry(FIXTURES_DIR) + ids = [r.id for r in registry.list_rulesets()] + assert "bad-yaml" not in ids + + def test_skips_missing_rules(self): + registry = RulesetRegistry(FIXTURES_DIR) + ids = [r.id for r in registry.list_rulesets()] + assert "missing-rules" not in ids + + def test_sample_rule_count(self): + registry = RulesetRegistry(FIXTURES_DIR) + detail = registry.get_ruleset("sample-ruleset") + assert detail.rule_count == 3 + + def test_sample_dimensions(self): + registry = RulesetRegistry(FIXTURES_DIR) + detail = registry.get_ruleset("sample-ruleset") + dim_names = [d.name for d in detail.dimensions] + assert "region" in dim_names + assert "amount" in dim_names + + def test_unknown_ruleset_raises(self): + registry = RulesetRegistry(FIXTURES_DIR) + with pytest.raises(KeyError): + registry.get_ruleset("nonexistent") + + def test_empty_directory_raises(self, tmp_path): + empty = tmp_path / "empty_rulesets" + empty.mkdir() + with pytest.raises(RuntimeError, match="No rulesets"): + RulesetRegistry(empty) + + +class TestRegistryEvaluate: + def test_evaluate_returns_survivors(self): + registry = RulesetRegistry(FIXTURES_DIR) + result = registry.evaluate( + ruleset_id="sample-ruleset", + context={"region": "AU", "amount": 50}, + ) + assert result.count >= 1 + + def test_evaluate_specific_match(self): + registry = RulesetRegistry(FIXTURES_DIR) + result = registry.evaluate( + ruleset_id="sample-ruleset", + context={"region": "AU", "amount": 50}, + ) + names = [s["rule_name"] for s in result.survivors] + assert "specific" in names + + def test_evaluate_top_n(self): + registry = RulesetRegistry(FIXTURES_DIR) + result = registry.evaluate( + ruleset_id="sample-ruleset", + context={"region": "AU", "amount": 50}, + top_n=1, + ) + assert result.count == 1 + + def test_evaluate_unknown_ruleset_raises(self): + registry = RulesetRegistry(FIXTURES_DIR) + with pytest.raises(KeyError): + registry.evaluate(ruleset_id="nope", context={"region": "AU"}) +``` + +- [ ] **Step 2: Run tests to verify they fail** + +Run: `hatch run test:test-target tests/test_registry.py -v` +Expected: FAIL — module does not exist. + +- [ ] **Step 3: Implement registry.py** + +Create `src/mountainash_rules_service/registry.py`: + +```python +"""RulesetRegistry: loads rulesets from disk and holds engine instances.""" + +from __future__ import annotations + +import logging +import typing as t +from pathlib import Path + +import polars as pl +import yaml +from mountainash.relations import relation + +from mountainash_utils_rules.constants import MatchStrategy +from mountainash_utils_rules.dimension import Dimension, DimensionsMetadata +from mountainash_utils_rules.engine import ExpressionRulesEngine + +from mountainash_rules_service.models import ( + DimensionInfo, + EvaluateResponse, + RulesetDetail, + RulesetSummary, +) + +logger = logging.getLogger(__name__) + +_DATA_TYPE_MAP = {"str": str, "int": int, "float": float} +_STRATEGY_MAP = {s.name: s for s in MatchStrategy} + +_INTERNAL_PREFIXES = ("__t_", "__ctx_") + + +class RulesetRegistry: + """Loads rulesets from a directory and holds live engine instances.""" + + def __init__(self, rulesets_path: Path) -> None: + self._engines: dict[str, ExpressionRulesEngine] = {} + self._info: dict[str, _RulesetMeta] = {} + self._load_all(rulesets_path) + if not self._engines: + raise RuntimeError( + f"No rulesets loaded from {rulesets_path}. " + f"Check directory structure and ruleset.yaml files." + ) + + def __len__(self) -> int: + return len(self._engines) + + def list_rulesets(self) -> list[RulesetSummary]: + return [ + RulesetSummary( + id=slug, + name=meta.name, + description=meta.description, + dimensions=[d.dimension_name for d in meta.metadata.dimensions], + rule_count=meta.rule_count, + ) + for slug, meta in self._info.items() + ] + + def get_ruleset(self, ruleset_id: str) -> RulesetDetail: + if ruleset_id not in self._info: + raise KeyError(f"Ruleset '{ruleset_id}' not found") + meta = self._info[ruleset_id] + return RulesetDetail( + id=ruleset_id, + name=meta.name, + description=meta.description, + dimensions=[ + DimensionInfo( + name=d.dimension_name, + strategy=d.match_strategy.name, + data_type=d.data_type.__name__, + range_min_field=d.range_min_field, + range_max_field=d.range_max_field, + regex_pattern=d.regex_pattern, + ) + for d in meta.metadata.dimensions + ], + rule_count=meta.rule_count, + ) + + def evaluate( + self, + ruleset_id: str, + context: dict[str, t.Any], + top_n: int | None = None, + min_specificity: int | None = None, + dimensions: list[str] | None = None, + ) -> EvaluateResponse: + if ruleset_id not in self._engines: + raise KeyError(f"Ruleset '{ruleset_id}' not found") + + engine = self._engines[ruleset_id] + meta = self._info[ruleset_id] + + result = engine.evaluate( + context=context, + top_n=top_n, + min_specificity=min_specificity, + dimensions=dimensions, + ) + + rows = relation(result.survivors).to_dicts() + cleaned = [ + {k: v for k, v in row.items() if not any(k.startswith(p) for p in _INTERNAL_PREFIXES)} + for row in rows + ] + + return EvaluateResponse( + ruleset_id=ruleset_id, + survivors=cleaned, + count=result.count, + evaluated_dimensions=result.active_dimensions, + ) + + def _load_all(self, rulesets_path: Path) -> None: + if not rulesets_path.is_dir(): + logger.error(f"Rulesets path does not exist: {rulesets_path}") + return + + for entry in sorted(rulesets_path.iterdir()): + if not entry.is_dir(): + continue + slug = entry.name + try: + self._load_one(slug, entry) + except Exception: + logger.exception(f"Failed to load ruleset '{slug}'") + + def _load_one(self, slug: str, path: Path) -> None: + yaml_path = path / "ruleset.yaml" + if not yaml_path.exists(): + logger.warning(f"Skipping '{slug}': no ruleset.yaml") + return + + with open(yaml_path) as f: + raw = yaml.safe_load(f) + + if not isinstance(raw, dict): + logger.error(f"Skipping '{slug}': ruleset.yaml is not a mapping") + return + + name = raw.get("name", slug) + description = raw.get("description", "") + rules_file = raw.get("rules_file", "rules.parquet") + + rules_path = path / rules_file + if not rules_path.exists(): + logger.error(f"Skipping '{slug}': rules file not found: {rules_path}") + return + + if rules_path.suffix == ".parquet": + df = pl.read_parquet(rules_path) + elif rules_path.suffix == ".csv": + df = pl.read_csv(rules_path) + else: + logger.error(f"Skipping '{slug}': unsupported rules file format: {rules_path.suffix}") + return + + dims = self._parse_dimensions(raw.get("dimensions", [])) + metadata = DimensionsMetadata(dimensions=dims) + engine = ExpressionRulesEngine(rules=df, dimension_metadata=metadata) + + self._engines[slug] = engine + self._info[slug] = _RulesetMeta( + name=name, + description=description, + metadata=metadata, + rule_count=len(df), + ) + logger.info(f"Loaded ruleset '{slug}': {len(df)} rules, {len(dims)} dimensions") + + def _parse_dimensions(self, raw_dims: list[dict]) -> list[Dimension]: + dims: list[Dimension] = [] + for raw in raw_dims: + strategy = _STRATEGY_MAP[raw["strategy"]] + data_type = _DATA_TYPE_MAP[raw["data_type"]] + kwargs: dict[str, t.Any] = { + "dimension_name": raw["name"], + "match_strategy": strategy, + "data_type": data_type, + } + if "context_field" in raw: + kwargs["context_field"] = raw["context_field"] + if "rule_field" in raw: + kwargs["rule_field"] = raw["rule_field"] + if "range_min_field" in raw: + kwargs["range_min_field"] = raw["range_min_field"] + if "range_max_field" in raw: + kwargs["range_max_field"] = raw["range_max_field"] + if "range_min_inclusive" in raw: + kwargs["range_min_inclusive"] = raw["range_min_inclusive"] + if "range_max_inclusive" in raw: + kwargs["range_max_inclusive"] = raw["range_max_inclusive"] + if "regex_pattern" in raw: + kwargs["regex_pattern"] = raw["regex_pattern"] + if "valid_values" in raw: + kwargs["valid_values"] = raw["valid_values"] + dims.append(Dimension(**kwargs)) + return dims + + +class _RulesetMeta: + """Internal metadata holder for a loaded ruleset.""" + + def __init__( + self, + name: str, + description: str, + metadata: DimensionsMetadata, + rule_count: int, + ) -> None: + self.name = name + self.description = description + self.metadata = metadata + self.rule_count = rule_count +``` + +- [ ] **Step 4: Run tests to verify they pass** + +Run: `hatch run test:test-target tests/test_registry.py -v` +Expected: ALL PASS. + +- [ ] **Step 5: Commit** + +```bash +git add src/mountainash_rules_service/registry.py tests/test_registry.py +git commit -m "feat: implement RulesetRegistry with file-based loading" +``` + +--- + +## Task 6: FastAPI App and Routes + +**Files:** +- Create: `src/mountainash_rules_service/routes.py` +- Create: `src/mountainash_rules_service/app.py` +- Create: `tests/test_routes.py` + +- [ ] **Step 1: Write the failing tests** + +Create `tests/test_routes.py`: + +```python +"""HTTP-level tests for API routes.""" + +from pathlib import Path + +import pytest +from fastapi.testclient import TestClient + +from mountainash_rules_service.app import create_app +from mountainash_rules_service.registry import RulesetRegistry + +FIXTURES_DIR = Path(__file__).parent / "fixtures" + + +@pytest.fixture +def client(): + app = create_app(rulesets_path=FIXTURES_DIR) + return TestClient(app) + + +class TestListRulesets: + def test_returns_200(self, client): + resp = client.get("/rulesets") + assert resp.status_code == 200 + + def test_contains_sample_ruleset(self, client): + resp = client.get("/rulesets") + ids = [r["id"] for r in resp.json()["rulesets"]] + assert "sample-ruleset" in ids + + def test_sample_has_rule_count(self, client): + resp = client.get("/rulesets") + sample = [r for r in resp.json()["rulesets"] if r["id"] == "sample-ruleset"][0] + assert sample["rule_count"] == 3 + + +class TestGetRuleset: + def test_returns_200(self, client): + resp = client.get("/rulesets/sample-ruleset") + assert resp.status_code == 200 + + def test_returns_dimensions(self, client): + resp = client.get("/rulesets/sample-ruleset") + dims = resp.json()["dimensions"] + names = [d["name"] for d in dims] + assert "region" in names + assert "amount" in names + + def test_unknown_returns_404(self, client): + resp = client.get("/rulesets/nonexistent") + assert resp.status_code == 404 + + +class TestEvaluate: + def test_returns_200(self, client): + resp = client.post( + "/evaluate/sample-ruleset", + json={"context": {"region": "AU", "amount": 50}}, + ) + assert resp.status_code == 200 + + def test_returns_survivors(self, client): + resp = client.post( + "/evaluate/sample-ruleset", + json={"context": {"region": "AU", "amount": 50}}, + ) + data = resp.json() + assert data["count"] >= 1 + assert "specific" in [s["rule_name"] for s in data["survivors"]] + + def test_top_n_param(self, client): + resp = client.post( + "/evaluate/sample-ruleset?top_n=1", + json={"context": {"region": "AU", "amount": 50}}, + ) + assert resp.json()["count"] == 1 + + def test_min_specificity_param(self, client): + resp = client.post( + "/evaluate/sample-ruleset?min_specificity=2", + json={"context": {"region": "AU", "amount": 50}}, + ) + for s in resp.json()["survivors"]: + assert s["__specificity"] >= 2 + + def test_dimensions_param(self, client): + resp = client.post( + "/evaluate/sample-ruleset?dimensions=region", + json={"context": {"region": "AU", "amount": 50}}, + ) + assert resp.json()["evaluated_dimensions"] == ["region"] + + def test_unknown_ruleset_returns_404(self, client): + resp = client.post( + "/evaluate/nonexistent", + json={"context": {"region": "AU"}}, + ) + assert resp.status_code == 404 + + def test_internal_columns_stripped(self, client): + resp = client.post( + "/evaluate/sample-ruleset", + json={"context": {"region": "AU", "amount": 50}}, + ) + for s in resp.json()["survivors"]: + for key in s: + assert not key.startswith("__t_") + assert not key.startswith("__ctx_") + + def test_specificity_and_rank_preserved(self, client): + resp = client.post( + "/evaluate/sample-ruleset", + json={"context": {"region": "AU", "amount": 50}}, + ) + first = resp.json()["survivors"][0] + assert "__specificity" in first + assert "__rank" in first +``` + +- [ ] **Step 2: Run tests to verify they fail** + +Run: `hatch run test:test-target tests/test_routes.py -v` +Expected: FAIL — modules do not exist. + +- [ ] **Step 3: Implement routes.py** + +Create `src/mountainash_rules_service/routes.py`: + +```python +"""FastAPI route handlers for the rules evaluation API.""" + +from __future__ import annotations + +import typing as t + +from fastapi import APIRouter, HTTPException, Query, Request + +from mountainash_rules_service.models import ( + EvaluateRequest, + EvaluateResponse, + RulesetDetail, + RulesetListResponse, +) + +router = APIRouter() + + +def _get_registry(request: Request): + return request.app.state.registry + + +@router.get("/rulesets", response_model=RulesetListResponse) +def list_rulesets(request: Request) -> RulesetListResponse: + registry = _get_registry(request) + return RulesetListResponse(rulesets=registry.list_rulesets()) + + +@router.get("/rulesets/{ruleset_id}", response_model=RulesetDetail) +def get_ruleset(request: Request, ruleset_id: str) -> RulesetDetail: + registry = _get_registry(request) + try: + return registry.get_ruleset(ruleset_id) + except KeyError: + raise HTTPException(status_code=404, detail=f"Ruleset '{ruleset_id}' not found") + + +@router.post("/evaluate/{ruleset_id}", response_model=EvaluateResponse) +def evaluate( + request: Request, + ruleset_id: str, + body: EvaluateRequest, + top_n: int | None = Query(None), + min_specificity: int | None = Query(None), + dimensions: str | None = Query(None), +) -> EvaluateResponse: + registry = _get_registry(request) + dim_list = dimensions.split(",") if dimensions else None + try: + return registry.evaluate( + ruleset_id=ruleset_id, + context=body.context, + top_n=top_n, + min_specificity=min_specificity, + dimensions=dim_list, + ) + except KeyError: + raise HTTPException(status_code=404, detail=f"Ruleset '{ruleset_id}' not found") +``` + +- [ ] **Step 4: Implement app.py** + +Create `src/mountainash_rules_service/app.py`: + +```python +"""FastAPI application factory.""" + +from __future__ import annotations + +import logging +from contextlib import asynccontextmanager +from pathlib import Path + +from fastapi import FastAPI + +from mountainash_rules_service.config import get_settings +from mountainash_rules_service.registry import RulesetRegistry +from mountainash_rules_service.routes import router + +logger = logging.getLogger(__name__) + + +def create_app(rulesets_path: Path | None = None) -> FastAPI: + """Create the FastAPI app. + + Args: + rulesets_path: Override rulesets path (for testing). + If None, reads from Settings. + """ + + @asynccontextmanager + async def lifespan(app: FastAPI): + path = rulesets_path or get_settings().rulesets_path + app.state.registry = RulesetRegistry(path) + logger.info(f"Loaded {len(app.state.registry)} rulesets from {path}") + yield + + app = FastAPI( + title="Mountain Ash Rules Service", + description="Rules evaluation API", + lifespan=lifespan, + ) + app.include_router(router) + return app + + +app = create_app() +``` + +- [ ] **Step 5: Run tests to verify they pass** + +Run: `hatch run test:test-target tests/test_routes.py -v` +Expected: ALL PASS. + +- [ ] **Step 6: Run full test suite** + +Run: `hatch run test:test` +Expected: ALL PASS (config + models + registry + routes). + +- [ ] **Step 7: Commit** + +```bash +git add src/mountainash_rules_service/routes.py src/mountainash_rules_service/app.py tests/test_routes.py +git commit -m "feat: implement FastAPI routes and app factory" +``` + +--- + +## Task 7: Dockerfile and Smoke Test + +**Files:** +- Create: `Dockerfile` +- Create: `rulesets/` example directory (gitignored, for local dev) + +- [ ] **Step 1: Create Dockerfile** + +Create `Dockerfile`: + +```dockerfile +FROM python:3.12-slim AS base + +WORKDIR /app + +RUN pip install --no-cache-dir hatch + +COPY pyproject.toml hatch.toml ./ +COPY src/ src/ + +RUN hatch env create default + +EXPOSE 8000 + +CMD ["hatch", "run", "uvicorn", "mountainash_rules_service.app:app", "--host", "0.0.0.0", "--port", "8000"] +``` + +- [ ] **Step 2: Create .gitignore** + +Create `.gitignore`: + +``` +__pycache__/ +*.pyc +.venv/ +dist/ +*.egg-info/ +.pytest_cache/ +.coverage +rulesets/ +``` + +- [ ] **Step 3: Create example rulesets directory for local dev** + +Create `rulesets/example/ruleset.yaml`: + +```yaml +name: Example Rules +description: Example ruleset for local development + +rules_file: rules.csv + +dimensions: + - name: category + strategy: EXACT + data_type: str +``` + +Create `rulesets/example/rules.csv`: + +```csv +rule_name,category,score +high,A,100 +medium,B,50 +low,C,10 +wildcard,,1 +``` + +Note: The `rulesets/` directory is gitignored. These files are for local dev only — copy them manually or mount via Docker volume. + +- [ ] **Step 4: Smoke test — start the server and hit it** + +```bash +# Start the server (in background) +hatch run uvicorn mountainash_rules_service.app:app --host 0.0.0.0 --port 8000 & +sleep 2 + +# Hit the endpoints +curl -s http://localhost:8000/rulesets | python -m json.tool +curl -s http://localhost:8000/rulesets/example | python -m json.tool +curl -s -X POST http://localhost:8000/evaluate/example \ + -H "Content-Type: application/json" \ + -d '{"context": {"category": "A"}}' | python -m json.tool + +# Kill the server +kill %1 +``` + +Expected: JSON responses with the example ruleset listed, detail returned, and evaluation showing "high" and "wildcard" as survivors. + +- [ ] **Step 5: Commit** + +```bash +git add Dockerfile .gitignore +git commit -m "chore: add Dockerfile and gitignore" +``` + +--- + +## Task 8: Final Polish + +**Files:** +- Modify: `src/mountainash_rules_service/__init__.py` + +- [ ] **Step 1: Update __init__.py exports** + +Update `src/mountainash_rules_service/__init__.py`: + +```python +"""Mountain Ash Rules Evaluation Service.""" + +from mountainash_rules_service.__version__ import __version__ +from mountainash_rules_service.app import create_app +from mountainash_rules_service.registry import RulesetRegistry + +__all__ = ("__version__", "create_app", "RulesetRegistry") +``` + +- [ ] **Step 2: Run full test suite** + +Run: `hatch run test:test` +Expected: ALL PASS. + +- [ ] **Step 3: Run linter** + +Run: `hatch run ruff:check` +Expected: Clean. + +- [ ] **Step 4: Commit** + +```bash +git add src/mountainash_rules_service/__init__.py +git commit -m "feat: finalize public API exports" +``` From 7b3c550ebdd2b35dcbdf08cc07ce2a95f39d0466 Mon Sep 17 00:00:00 2001 From: Nathaniel Ramm Date: Fri, 1 May 2026 01:09:48 +1000 Subject: [PATCH 3/5] feat: expose metadata and aggregates as public Lattice properties --- ...tion for Further Rule Induction - 2015.pdf | Bin 0 -> 113911 bytes src/mountainash_utils_rules/lattice.py | 8 +++++ temp/mountainash | 1 + temp/mountainash-data | 1 + temp/mountainash-settings | 1 + tests/test_lattice_properties.py | 31 ++++++++++++++++++ 6 files changed, 42 insertions(+) create mode 100644 docs/superpowers/Mankowski - Decision Table Decomposition for Further Rule Induction - 2015.pdf create mode 160000 temp/mountainash create mode 160000 temp/mountainash-data create mode 160000 temp/mountainash-settings create mode 100644 tests/test_lattice_properties.py diff --git a/docs/superpowers/Mankowski - Decision Table Decomposition for Further Rule Induction - 2015.pdf b/docs/superpowers/Mankowski - Decision Table Decomposition for Further Rule Induction - 2015.pdf new file mode 100644 index 0000000000000000000000000000000000000000..b6a347547133a158e2bb2820a2a1155b6ebf840e GIT binary patch literal 113911 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 int: @property def partition_key(self) -> dict | None: return self._partition_key + + @property + def metadata(self) -> DimensionsMetadata: + return self._metadata + + @property + def aggregates(self) -> list[Aggregate]: + return self._aggregates diff --git a/temp/mountainash b/temp/mountainash new file mode 160000 index 0000000..e8fae5e --- /dev/null +++ b/temp/mountainash @@ -0,0 +1 @@ +Subproject commit e8fae5eb3b0a0b51eeefb2b75d39eb7cb92d9b89 diff --git a/temp/mountainash-data b/temp/mountainash-data new file mode 160000 index 0000000..e3837cb --- /dev/null +++ b/temp/mountainash-data @@ -0,0 +1 @@ +Subproject commit e3837cb6731b587576cf39d96f5dd6b5b5bd46d0 diff --git a/temp/mountainash-settings b/temp/mountainash-settings new file mode 160000 index 0000000..9d82592 --- /dev/null +++ b/temp/mountainash-settings @@ -0,0 +1 @@ +Subproject commit 9d82592f1dcdc03370dd60e1a0bd97c77a766403 diff --git a/tests/test_lattice_properties.py b/tests/test_lattice_properties.py new file mode 100644 index 0000000..c0c0b95 --- /dev/null +++ b/tests/test_lattice_properties.py @@ -0,0 +1,31 @@ +import polars as pl +from mountainash_utils_rules.aggregate import Aggregate +from mountainash_utils_rules.constants import MatchStrategy +from mountainash_utils_rules.dimension import Dimension, DimensionsMetadata +from mountainash_utils_rules.lattice import Lattice + + +def test_lattice_metadata_property(): + metadata = DimensionsMetadata( + dimensions=[ + Dimension(dimension_name="country", match_strategy=MatchStrategy.EXACT, data_type=str), + ] + ) + aggregates = [Aggregate(column_name="price", operation="sum")] + df = pl.DataFrame({"country": ["AU"], "price": [100]}) + lattice = Lattice(dataframe=df, metadata=metadata, aggregates=aggregates, partition_key=None) + + assert lattice.metadata is metadata + assert lattice.aggregates is aggregates + + +def test_lattice_aggregates_default_empty(): + metadata = DimensionsMetadata( + dimensions=[ + Dimension(dimension_name="country", match_strategy=MatchStrategy.EXACT, data_type=str), + ] + ) + df = pl.DataFrame({"country": ["AU"]}) + lattice = Lattice(dataframe=df, metadata=metadata, aggregates=[], partition_key=None) + + assert lattice.aggregates == [] From 25e050d738e2ff27fee18d237e56953bd7de00f1 Mon Sep 17 00:00:00 2001 From: Nathaniel Ramm Date: Mon, 4 May 2026 15:35:23 +1000 Subject: [PATCH 4/5] Removes subproject references - Deletes reference to mountainash subproject - Removes mountainash-data subproject link - Eliminates mountainash-settings subproject connection Relates to feature/lattice-public-properties --- temp/mountainash | 1 - temp/mountainash-data | 1 - temp/mountainash-settings | 1 - 3 files changed, 3 deletions(-) delete mode 160000 temp/mountainash delete mode 160000 temp/mountainash-data delete mode 160000 temp/mountainash-settings diff --git a/temp/mountainash b/temp/mountainash deleted file mode 160000 index e8fae5e..0000000 --- a/temp/mountainash +++ /dev/null @@ -1 +0,0 @@ -Subproject commit e8fae5eb3b0a0b51eeefb2b75d39eb7cb92d9b89 diff --git a/temp/mountainash-data b/temp/mountainash-data deleted file mode 160000 index e3837cb..0000000 --- a/temp/mountainash-data +++ /dev/null @@ -1 +0,0 @@ -Subproject commit e3837cb6731b587576cf39d96f5dd6b5b5bd46d0 diff --git a/temp/mountainash-settings b/temp/mountainash-settings deleted file mode 160000 index 9d82592..0000000 --- a/temp/mountainash-settings +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 9d82592f1dcdc03370dd60e1a0bd97c77a766403 From 4b324c442539ed19804970d9586023d92e1ae44d Mon Sep 17 00:00:00 2001 From: Nathaniel Ramm Date: Mon, 4 May 2026 15:35:35 +1000 Subject: [PATCH 5/5] Removes outdated documentation file - Deletes Mankowski - Decision Table Decomposition for Further Rule Induction - 2015.pdf - Cleans up stale content from docs directory --- ...ition for Further Rule Induction - 2015.pdf | Bin 113911 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 docs/superpowers/Mankowski - Decision Table Decomposition for Further Rule Induction - 2015.pdf diff --git a/docs/superpowers/Mankowski - Decision Table Decomposition for Further Rule Induction - 2015.pdf b/docs/superpowers/Mankowski - Decision Table Decomposition for Further Rule Induction - 2015.pdf deleted file mode 100644 index b6a347547133a158e2bb2820a2a1155b6ebf840e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 113911 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