dndwright 0.2.0__tar.gz

dndwright-0.2.0/.github/workflows/ci.yml

@@ -0,0 +1,27 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+      - name: Lint (ruff)
+        run: ruff check src tests
+      - name: Test (pytest)
+        run: pytest -q

dndwright-0.2.0/.github/workflows/publish.yml

@@ -0,0 +1,41 @@
+name: Publish to PyPI
+
+# Publishes to PyPI via Trusted Publishing (OIDC) when a GitHub Release is
+# published. No API token needed — PyPI verifies this repo + workflow + env.
+# To release: tag (vX.Y.Z) and create a GitHub Release for that tag, e.g.
+#   gh release create v0.2.0 --generate-notes
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Build sdist + wheel
+        run: |
+          python -m pip install --upgrade build
+          python -m build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi          # must match the "Environment name" in PyPI's publisher config
+    permissions:
+      id-token: write          # REQUIRED for Trusted Publishing (OIDC)
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

dndwright-0.2.0/.gitignore

@@ -0,0 +1,23 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+
+# Virtualenvs
+.venv/
+venv/
+env/
+
+# Test / tooling caches
+.pytest_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+
+# Editors / OS
+.vscode/
+.idea/
+.DS_Store

dndwright-0.2.0/CHANGELOG.md

@@ -0,0 +1,53 @@
+# Changelog
+
+All notable changes to dndwright are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/), and the project aims to follow
+[Semantic Versioning](https://semver.org/).
+
+**Public API** = the names exported in `dndwright.__all__` (pinned by
+`tests/test_api_contract.py`). While the version is `0.x`, minor versions may make
+breaking changes; these will always be noted here.
+
+## [Unreleased]
+
+## [0.3.0] — 2026-06-01
+
+### Added
+- **Bundled starter content** — `load_content(category)` + `categories()`: original
+  homebrew classes/species/creatures, plus 236 SRD 5.2 (CC-BY) magic items.
+- **LLM-agnostic content generator** — `generate_library(llm, ...)` (and
+  `generate_classes`/`species`/`creatures`): you pass a `complete_json(prompt, system)
+  -> dict` callable wrapping your own LLM; prompts produce *original homebrew* (no
+  official content), matching the bundled schema and component ontology.
+
+## [0.2.0] — 2026-06-01
+
+### Added
+- **Component ontology** — `load_ontology()` → `Ontology`: a graph schema for D&D
+  building blocks (Class, Species, Spell, Equipment, MagicItem, Background, Feat,
+  Subclass, Creature) and how a Character connects to them (`HAS_*`, `INSTANCE_OF`,
+  `HAS_STAT_BLOCK`). Typed models (`NodeTypeDef`, `EdgeTypeDef`, `PropertyDef`) with
+  `edges_from`/`edges_to` helpers, parsed from the bundled `dnd.yaml`.
+- Dependency: `pyyaml` (for the ontology loader).
+
+## [0.1.0] — 2026-06-01
+
+Initial release. The D&D 5e (2024) rules & character-computation engine, extracted
+from a working application.
+
+### Added
+- `evaluate_character(data) -> dict` — one-call evaluation: character data in,
+  computed sheet out (ability modifiers, proficiency, saves, spell DC/attack, HP,
+  AC, initiative, …).
+- The computation engine: `DND_5E_2024_RULESET` (a 135-node DAG), `evaluate`,
+  `assemble_character_inputs`, `apply_modifiers`, and the `Ruleset` / `ComputationNode`
+  / `FormulaSpec` / `NodeType` schema — formulas as data, not code.
+- Neutral adapters: `character_data_to_inputs`, `computed_values_to_sheet`.
+- Typed component models under `dndwright.rules.components`
+  (`ClassMechanics`, `SpeciesMechanics`, …) and SRD-derived rules tables.
+
+Pure (pydantic + stdlib); no application/framework coupling. Rules content derives
+from the SRD 5.2 (CC-BY-4.0); see NOTICE.
+
+[Unreleased]: https://github.com/sligara7/dndwright/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/sligara7/dndwright/releases/tag/v0.1.0

dndwright-0.2.0/LICENSE

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

dndwright-0.2.0/NOTICE

@@ -0,0 +1,24 @@
+dndwright
+Copyright (c) 2026 Anthony Sligar
+Licensed under the MIT License (see LICENSE).
+
+------------------------------------------------------------------------------
+Game-rules content
+------------------------------------------------------------------------------
+
+dndwright's rules tables (hit dice, spellcasting progression / spell slots,
+armor base AC, save proficiencies, class spellcasting abilities, etc.) encode
+game *mechanics* — facts about how D&D 5e (2024) characters are computed. Where
+those facts come from published game content, they derive from the:
+
+    Dungeons & Dragons System Reference Document 5.2 (SRD 5.2)
+    © Wizards of the Coast LLC, licensed under
+    Creative Commons Attribution 4.0 International (CC-BY-4.0).
+    https://creativecommons.org/licenses/by/4.0/
+
+This project is not affiliated with, endorsed, or sponsored by Wizards of the
+Coast. It contains no content from the Player's Handbook, Dungeon Master's
+Guide, Monster Manual, or any other non-SRD source.
+
+"Dungeons & Dragons" and "D&D" are trademarks of Wizards of the Coast; they are
+used here only nominatively to describe the rules system this engine computes.

dndwright-0.2.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: dndwright
+Version: 0.2.0
+Summary: Domain-neutral D&D 5e (2024) rules & character-sheet computation engine: a data-driven DAG of formulas (ability mods, proficiency, spell DC/slots, HP, AC).
+Project-URL: Homepage, https://github.com/sligara7/dndwright
+Project-URL: Repository, https://github.com/sligara7/dndwright
+Author: Anthony Sligar
+License: MIT
+License-File: LICENSE
+License-File: NOTICE
+Keywords: character-sheet,computation-graph,dnd,dnd5e,rules-engine,srd,ttrpg
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Games/Entertainment :: Role-Playing
+Requires-Python: >=3.10
+Requires-Dist: pydantic>=2.5
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4; extra == 'dev'
+Requires-Dist: ruff>=0.1; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# dndwright
+
+> ⚠️ **Early development (v0.1, alpha).** The API is still moving and may change without
+> notice between minor versions. Extracted from a working application; usable today, but
+> pin a tag/commit if you depend on it.
+
+**A domain-neutral D&D 5e (2024) rules & character-sheet computation engine.** A character
+sheet is modelled as a **directed acyclic computation graph** — nodes are values, edges are
+dependencies, and formulas are *data* (a JSON-serialisable DSL), not code. Pure Python
+(`pydantic` + stdlib), no application or framework coupling: map your own character data in,
+read computed stats out.
+
+## Install
+
+```bash
+pip install git+https://github.com/sligara7/dndwright.git
+# or, for local development:
+pip install -e ".[dev]"
+```
+
+## Quickstart
+
+```python
+from dndwright import evaluate_character
+
+sheet = evaluate_character({
+    "ability_scores": {"strength": 8, "dexterity": 14, "constitution": 14,
+                       "intelligence": 18, "wisdom": 12, "charisma": 10},
+    "class_data": {"class_name": "wizard"},
+    "species_data": {"name": "Human", "speed": 30},
+    "level": 5,
+})
+
+sheet["proficiency_bonus"]    # 3
+sheet["ability_modifiers"]    # {"intelligence": 4, "dexterity": 2, ...}
+sheet["spellcasting_type"]    # "full_caster"
+# ...plus armor_class, hit_points, hit_dice, initiative, saves, features, ...
+```
+
+Lower level — assemble typed inputs and evaluate against the ruleset:
+
+```python
+from dndwright import DND_5E_2024_RULESET, assemble_character_inputs, evaluate, apply_modifiers
+from dndwright.rules.components import ClassMechanics
+
+inputs   = assemble_character_inputs(class_mechanics=..., ability_scores={...}, level=5)
+computed = apply_modifiers(evaluate(DND_5E_2024_RULESET, inputs), inputs)
+```
+
+## Why a computation graph?
+
+Derived character values form a dependency DAG: ability scores → modifiers → proficiency →
+save DCs / spell slots / AC / HP. dndwright represents that DAG explicitly and stores the
+formulas as **data** (`FormulaSpec`: an op + args), so the rules are inspectable, testable,
+and serialisable — not buried in imperative code. `DND_5E_2024_RULESET` is a 135-node graph.
+
+## What's inside
+
+| Component | What it does |
+|-----------|--------------|
+| `evaluate_character` | One call: character data dict → fully computed sheet. |
+| `DND_5E_2024_RULESET` | The 135-node 5e-2024 computation DAG (formulas as data). |
+| `evaluate` / `assemble_character_inputs` / `apply_modifiers` | The lower-level engine. |
+| `Ruleset` / `ComputationNode` / `FormulaSpec` / `NodeType` | The DAG schema. |
+| `dndwright.rules.components` | Typed inputs (`ClassMechanics`, `SpeciesMechanics`, …). |
+| `dndwright.rules.lookup_tables` | SRD-derived rules tables (hit dice, spell slots, AC, saves). |
+
+## API stability
+
+The public API is exactly `dndwright.__all__`, pinned by `tests/test_api_contract.py`.
+Versioning follows [SemVer](https://semver.org/); at `0.x` minor versions may break, with
+every change recorded in `CHANGELOG.md`.
+
+## Credits & license
+
+MIT licensed (see `LICENSE`). The rules tables encode game *mechanics* derived from the
+**D&D System Reference Document 5.2** (© Wizards of the Coast, **CC-BY-4.0**); see `NOTICE`.
+Not affiliated with or endorsed by Wizards of the Coast. Contains no PHB/DMG/MM content.

dndwright-0.2.0/README.md

@@ -0,0 +1,78 @@
+# dndwright
+
+> ⚠️ **Early development (v0.1, alpha).** The API is still moving and may change without
+> notice between minor versions. Extracted from a working application; usable today, but
+> pin a tag/commit if you depend on it.
+
+**A domain-neutral D&D 5e (2024) rules & character-sheet computation engine.** A character
+sheet is modelled as a **directed acyclic computation graph** — nodes are values, edges are
+dependencies, and formulas are *data* (a JSON-serialisable DSL), not code. Pure Python
+(`pydantic` + stdlib), no application or framework coupling: map your own character data in,
+read computed stats out.
+
+## Install
+
+```bash
+pip install git+https://github.com/sligara7/dndwright.git
+# or, for local development:
+pip install -e ".[dev]"
+```
+
+## Quickstart
+
+```python
+from dndwright import evaluate_character
+
+sheet = evaluate_character({
+    "ability_scores": {"strength": 8, "dexterity": 14, "constitution": 14,
+                       "intelligence": 18, "wisdom": 12, "charisma": 10},
+    "class_data": {"class_name": "wizard"},
+    "species_data": {"name": "Human", "speed": 30},
+    "level": 5,
+})
+
+sheet["proficiency_bonus"]    # 3
+sheet["ability_modifiers"]    # {"intelligence": 4, "dexterity": 2, ...}
+sheet["spellcasting_type"]    # "full_caster"
+# ...plus armor_class, hit_points, hit_dice, initiative, saves, features, ...
+```
+
+Lower level — assemble typed inputs and evaluate against the ruleset:
+
+```python
+from dndwright import DND_5E_2024_RULESET, assemble_character_inputs, evaluate, apply_modifiers
+from dndwright.rules.components import ClassMechanics
+
+inputs   = assemble_character_inputs(class_mechanics=..., ability_scores={...}, level=5)
+computed = apply_modifiers(evaluate(DND_5E_2024_RULESET, inputs), inputs)
+```
+
+## Why a computation graph?
+
+Derived character values form a dependency DAG: ability scores → modifiers → proficiency →
+save DCs / spell slots / AC / HP. dndwright represents that DAG explicitly and stores the
+formulas as **data** (`FormulaSpec`: an op + args), so the rules are inspectable, testable,
+and serialisable — not buried in imperative code. `DND_5E_2024_RULESET` is a 135-node graph.
+
+## What's inside
+
+| Component | What it does |
+|-----------|--------------|
+| `evaluate_character` | One call: character data dict → fully computed sheet. |
+| `DND_5E_2024_RULESET` | The 135-node 5e-2024 computation DAG (formulas as data). |
+| `evaluate` / `assemble_character_inputs` / `apply_modifiers` | The lower-level engine. |
+| `Ruleset` / `ComputationNode` / `FormulaSpec` / `NodeType` | The DAG schema. |
+| `dndwright.rules.components` | Typed inputs (`ClassMechanics`, `SpeciesMechanics`, …). |
+| `dndwright.rules.lookup_tables` | SRD-derived rules tables (hit dice, spell slots, AC, saves). |
+
+## API stability
+
+The public API is exactly `dndwright.__all__`, pinned by `tests/test_api_contract.py`.
+Versioning follows [SemVer](https://semver.org/); at `0.x` minor versions may break, with
+every change recorded in `CHANGELOG.md`.
+
+## Credits & license
+
+MIT licensed (see `LICENSE`). The rules tables encode game *mechanics* derived from the
+**D&D System Reference Document 5.2** (© Wizards of the Coast, **CC-BY-4.0**); see `NOTICE`.
+Not affiliated with or endorsed by Wizards of the Coast. Contains no PHB/DMG/MM content.

dndwright-0.2.0/pyproject.toml

@@ -0,0 +1,37 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dndwright"
+version = "0.2.0"
+description = "Domain-neutral D&D 5e (2024) rules & character-sheet computation engine: a data-driven DAG of formulas (ability mods, proficiency, spell DC/slots, HP, AC)."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Anthony Sligar" }]
+keywords = ["dnd", "dnd5e", "ttrpg", "rules-engine", "character-sheet", "srd", "computation-graph"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Games/Entertainment :: Role-Playing",
+]
+dependencies = ["pydantic>=2.5", "pyyaml>=6.0"]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.4", "ruff>=0.1"]
+
+[project.urls]
+Homepage = "https://github.com/sligara7/dndwright"
+Repository = "https://github.com/sligara7/dndwright"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dndwright"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"

dndwright-0.2.0/src/dndwright/__init__.py

@@ -0,0 +1,69 @@
+"""dndwright — a domain-neutral D&D 5e (2024) rules & character-computation engine.
+
+A character sheet is modelled as a **directed acyclic computation graph**: nodes
+are values, edges are dependencies, and formulas are *data* (a JSON-serialisable
+DSL), not code. The engine is pure (pydantic + stdlib) — no application or
+framework coupling — so any tool can map its own character data in and read
+computed stats out.
+
+Quickstart (one call — dict in, computed sheet out):
+
+    from dndwright import evaluate_character
+    sheet = evaluate_character({
+        "ability_scores": {"strength": 8, "dexterity": 14, "constitution": 14,
+                            "intelligence": 18, "wisdom": 12, "charisma": 10},
+        "class_data": {"class_name": "wizard"},
+        "species_data": {"name": "Human", "speed": 30},
+        "level": 5,
+    })
+    sheet["proficiency_bonus"]   # 3
+    sheet["ability_modifiers"]   # {"intelligence": 4, ...}
+
+Lower level (assemble typed inputs, evaluate against the ruleset):
+
+    from dndwright import (DND_5E_2024_RULESET, assemble_character_inputs,
+                           evaluate, apply_modifiers)
+    from dndwright.rules.components import ClassMechanics
+    inputs = assemble_character_inputs(class_mechanics=..., ability_scores={...}, level=5)
+    computed = apply_modifiers(evaluate(DND_5E_2024_RULESET, inputs), inputs)
+
+The rules tables (hit dice, spell slots, armour AC, save proficiencies) encode
+game mechanics derived from the **D&D SRD 5.2 (CC-BY-4.0)** — see NOTICE.
+"""
+
+from .content import categories, generate_library, load_content
+from .ontology import Ontology, load_ontology
+from .rules.adapters import character_data_to_inputs, computed_values_to_sheet
+from .rules.assembler import apply_modifiers, assemble_character_inputs
+from .rules.character_evaluator import compute_key_stats, evaluate_character
+from .rules.dnd_5e_2024 import DND_5E_2024_RULESET
+from .rules.evaluator import evaluate
+from .rules.schema import ComputationNode, FormulaSpec, NodeType, Ruleset
+
+__version__ = "0.3.0"
+
+__all__ = [
+    # high-level (dict in -> computed sheet out)
+    "evaluate_character",
+    "compute_key_stats",
+    # ruleset + low-level evaluation
+    "DND_5E_2024_RULESET",
+    "evaluate",
+    "assemble_character_inputs",
+    "apply_modifiers",
+    # neutral adapters
+    "character_data_to_inputs",
+    "computed_values_to_sheet",
+    # schema types
+    "Ruleset",
+    "ComputationNode",
+    "FormulaSpec",
+    "NodeType",
+    # component ontology (graph schema)
+    "load_ontology",
+    "Ontology",
+    # content (bundled starter + generator)
+    "load_content",
+    "categories",
+    "generate_library",
+]

dndwright-0.2.0/src/dndwright/content/__init__.py

@@ -0,0 +1,56 @@
+"""Bundled starter content + a generator for original homebrew.
+
+    from dndwright.content import load_content, categories
+    load_content("creatures")   # list of creature dicts (bundled samples)
+    categories()                # ["classes", "creatures", "magic_items", "species"]
+
+The bundled ``classes`` / ``species`` / ``creatures`` are original homebrew (no
+official content); ``magic_items`` are SRD 5.2 (CC-BY) — see NOTICE. Grow the
+library with :func:`generate_library` (you supply the LLM).
+"""
+
+from __future__ import annotations
+
+import importlib.resources
+import json
+
+from .generate import (
+    JsonLLM,
+    generate_classes,
+    generate_creatures,
+    generate_library,
+    generate_species,
+)
+
+# category -> (filename, top-level array key)
+_CONTENT = {
+    "classes": ("classes.json", "classes"),
+    "species": ("species.json", "species"),
+    "creatures": ("creatures.json", "creatures"),
+    "magic_items": ("magic_items.json", "magic_items"),
+}
+
+
+def categories() -> list[str]:
+    """The bundled content categories."""
+    return sorted(_CONTENT)
+
+
+def load_content(category: str) -> list[dict]:
+    """Load the bundled starter content for ``category`` as a list of dicts."""
+    if category not in _CONTENT:
+        raise ValueError(f"unknown category {category!r}; choose from {categories()}")
+    filename, key = _CONTENT[category]
+    text = (importlib.resources.files("dndwright.content") / filename).read_text(encoding="utf-8")
+    return json.loads(text).get(key, [])
+
+
+__all__ = [
+    "load_content",
+    "categories",
+    "generate_library",
+    "generate_classes",
+    "generate_species",
+    "generate_creatures",
+    "JsonLLM",
+]