bbfmodels 0.2.1__tar.gz → 0.3.0__tar.gz

bbfmodels-0.3.0/.github/workflows/announce-release.yml

@@ -0,0 +1,70 @@
+name: announce-release
+
+# Posts a release's notes to the ispx Discord when they land on main.
+# release-notes/<version>.md is written after the Release PR merges and
+# lands by its own PR, so the notes file
+# arriving on main is the moment the release is told, and only a file
+# added by the push counts: an edit to existing notes is a wording fix,
+# not a release. The dispatch input re-posts one version by hand, which
+# is also how the webhook is tried out.
+on:
+  push:
+    branches: [main]
+    paths:
+      - "release-notes/**"
+  workflow_dispatch:
+    inputs:
+      version:
+        description: Version whose notes to post, for example 0.2.1
+        required: true
+        type: string
+
+permissions:
+  contents: read
+
+concurrency:
+  group: announce-release
+  cancel-in-progress: false
+
+jobs:
+  announce:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Find the versions to post
+        id: versions
+        env:
+          BEFORE: ${{ github.event.before }}
+          REQUESTED: ${{ inputs.version }}
+        run: |
+          if [ -n "$REQUESTED" ]; then
+            versions="$REQUESTED"
+          else
+            git fetch --quiet --depth=1 origin "$BEFORE"
+            versions=$(git diff --name-only --diff-filter=A "$BEFORE" "$GITHUB_SHA" -- release-notes/ \
+              | sed -n 's#^release-notes/\(.*\)\.md$#\1#p' | sort -V | tr '\n' ' ')
+          fi
+          echo "list=$versions" >> "$GITHUB_OUTPUT"
+          echo "versions: ${versions:-none}"
+
+      - name: Post the notes
+        if: steps.versions.outputs.list != ''
+        env:
+          DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_RELEASES_WEBHOOK }}
+          VERSIONS: ${{ steps.versions.outputs.list }}
+        run: |
+          if [ -z "$DISCORD_WEBHOOK_URL" ]; then
+            echo "::warning::DISCORD_RELEASES_WEBHOOK is not set, nothing posted"
+            exit 0
+          fi
+          for v in $VERSIONS; do
+            python hooks/announce.py "$v"
+          done

bbfmodels-0.3.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.3.0"
+}

{bbfmodels-0.2.1 → bbfmodels-0.3.0}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.3.0](https://github.com/ispx-limited/bbfmodels/compare/v0.2.1...v0.3.0) (2026-11-02)
+
+
+### Added
+
+* **paths:** typed paths with autocomplete for every model, no pydantic model needed ([#17](https://github.com/ispx-limited/bbfmodels/issues/17)) ([ba3a7b7](https://github.com/ispx-limited/bbfmodels/commit/ba3a7b7781129477aed7ee015d51f9079521b331))
+
 ## [0.2.1](https://github.com/ispx-limited/bbfmodels/compare/v0.2.0...v0.2.1) (2026-11-02)
 
 

{bbfmodels-0.2.1 → bbfmodels-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bbfmodels
-Version: 0.2.1
+Version: 0.3.0
 Summary: Typed models and schema tooling for Broadband Forum data models (TR-181, TR-098, TR-104 and more), generated from the published XML
 Project-URL: Homepage, https://github.com/ispx-limited/bbfmodels
 Project-URL: Documentation, https://docs.bbfmodels.ispx.co/
@@ -43,7 +43,10 @@ the same parameter paths as strings. bbfmodels does it once:
 - Generated typed bindings: pydantic models for Python, shipped for TR-181
   and TR-098 and the service models (TR-104 voice, TR-135 set-top box,
   TR-140 storage, TR-196 femtocell, TR-517 Matter), and generated on demand
-  for any other document, a vendor's included. JSON Schema and TypeScript follow from the
+  for any other document, a vendor's included.
+- Typed paths for code that only needs correct path strings:
+  `str(Device.WiFi.SSID[1].SSID)` with autocomplete over the whole model
+  and the parameter's definition one attribute away. JSON Schema and TypeScript follow from the
   same representation, Go when there is a consumer.
 
 Names stay as the Forum wrote them. `Device.WiFi.SSID.{i}.SSID` is a table of

{bbfmodels-0.2.1 → bbfmodels-0.3.0}/README.md

@@ -18,7 +18,10 @@ the same parameter paths as strings. bbfmodels does it once:
 - Generated typed bindings: pydantic models for Python, shipped for TR-181
   and TR-098 and the service models (TR-104 voice, TR-135 set-top box,
   TR-140 storage, TR-196 femtocell, TR-517 Matter), and generated on demand
-  for any other document, a vendor's included. JSON Schema and TypeScript follow from the
+  for any other document, a vendor's included.
+- Typed paths for code that only needs correct path strings:
+  `str(Device.WiFi.SSID[1].SSID)` with autocomplete over the whole model
+  and the parameter's definition one attribute away. JSON Schema and TypeScript follow from the
   same representation, Go when there is a consumer.
 
 Names stay as the Forum wrote them. `Device.WiFi.SSID.{i}.SSID` is a table of

{bbfmodels-0.2.1 → bbfmodels-0.3.0}/context/README.md

@@ -21,3 +21,4 @@ changes, a new record is written and the old one is marked superseded.
 | [0008](decisions/0008-python-toolchain.md) | Python toolchain: uv, ruff, mypy, pytest, standard library XML | Accepted |
 | [0009](decisions/0009-the-tree-keeps-wire-text.md) | The data tree keeps wire text and decodes on demand | Accepted |
 | [0010](decisions/0010-generated-python-packages.md) | One generated package per document, lenient on input, strict in `problems` | Accepted |
+| [0011](decisions/0011-typed-paths-are-a-stub-over-the-schema.md) | Typed paths are a generic runtime plus a stub, not generated classes | Accepted |

bbfmodels-0.3.0/context/decisions/0011-typed-paths-are-a-stub-over-the-schema.md

@@ -0,0 +1,44 @@
+# 0011: Typed paths are a generic runtime plus a stub, not generated classes
+
+## Context
+
+Not every user wants models. Code that queries an ACS API asks for a
+parameter by its path string and gets a string back, and what it needs
+from bbfmodels is a correct path with autocomplete and the parameter's
+definition one step away. Generating a class per object with a property
+per member would give that, at the cost of another megabyte of code per
+package, import time to match, and a second copy of every name the models
+already carry.
+
+## Decision
+
+Typed paths are one generic runtime (`bbfmodels.paths`) that walks the
+package's shipped IR, plus a generated stub file (`paths.pyi`) per package
+that declares every object and parameter with the Python type of its
+value. The runtime `paths.py` in a package is three lines: the root path
+over the package's schema. Editors and type checkers read the stub; the
+interpreter never does.
+
+- `str()` of a path is the data path. A table renders as its partial path
+  and offers `search` for the USP wildcard form and `schema_path` for the
+  `{i}` form. Paths compare and hash as strings.
+- `definition` returns the IR object or parameter.
+- An unknown name is an `AttributeError`. A name the schema does not list
+  is reached with `child()`, so a typo in a standard name is never taken
+  for a vendor parameter.
+- Identifiers follow the models' rule (`N11kEnable` for `11kEnable`), and
+  the runtime maps the identifier back to the Forum name.
+
+pydantic remains a dependency even for a user who only wants paths, because
+the IR the runtime walks is built on it. That is accepted: the cost is one
+ubiquitous package, and a second dependency-free distribution can be split
+out if someone needs it.
+
+## Consequences
+
+- Autocomplete over the whole of TR-181 with no import cost: the stub for
+  TR-181 is a few hundred kilobytes that only tools read.
+- The first attribute access loads the package's IR (about 50 ms); every
+  one after that is a dictionary lookup.
+- The value type in the stub (`ParamPath[int]`) is documentation for the
+  reader and the type checker; the runtime does not use it.

bbfmodels-0.3.0/docs/guides/paths.md

@@ -0,0 +1,86 @@
+# Typed paths
+
+Most code that talks to an ACS or a USP controller never builds a tree of
+values. It asks an API for `Device.WiFi.SSID.1.SSID` by name and reads a
+string back. Typed paths make that name a chain of attributes an editor
+completes and a type checker verifies, with no model involved:
+
+```python
+from bbfmodels.tr181_cwmp.paths import Device
+
+str(Device.WiFi.SSID[1].SSID)              # 'Device.WiFi.SSID.1.SSID'
+str(Device.IP.Interface[1].IPv4Address[2].IPAddress)
+Device.WiFi.Radio[2].Channel == "Device.WiFi.Radio.2.Channel"   # True
+```
+
+Every shipped package has a `paths` module whose root is the model's root
+object. A table is indexed by instance number; the table itself renders as
+the partial path CWMP uses to ask for all of it, and `search` gives the USP
+search path:
+
+```python
+str(Device.WiFi.Radio)          # 'Device.WiFi.Radio.'
+Device.WiFi.Radio.search        # 'Device.WiFi.Radio.*.'
+Device.WiFi.Radio.schema_path   # 'Device.WiFi.Radio.{i}.'
+```
+
+A path knows its definition in the shipped schema, so the type, access,
+constraints and description of a parameter are one attribute away:
+
+```python
+channel = Device.WiFi.Radio[1].Channel
+channel.definition.syntax.base_type        # <BaseType.UNSIGNED_INT: 'unsignedInt'>
+channel.definition.access                  # <Access.READ_WRITE: 'readWrite'>
+channel.definition.syntax.facets.ranges    # (Range(min_inclusive=1, max_inclusive=255, step=None),)
+channel.definition.description[:60]
+Device.WiFi.Radio.definition.num_entries_parameter   # 'RadioNumberOfEntries'
+```
+
+Paths compare and hash as their string, so they work as dictionary keys
+and in sets alongside plain strings.
+
+## Editors and type checkers
+
+At runtime one generic class walks the schema, so the `paths` module is
+three lines and costs nothing to import. Beside it, `paths.pyi` is a stub
+that declares every object and parameter with the Python type of its
+value, which is what the editor completes and the type checker reads:
+
+```python
+class WiFi_RadioPath(ObjectPathBase):
+    Enable: ParamPath[bool]
+    Channel: ParamPath[int]
+    SupportedFrequencyBands: ParamPath[list[str]]
+    Stats: WiFi_Radio_StatsPath
+```
+
+A typo is caught twice: the type checker rejects `Device.WiFi.Radioo`, and
+at runtime it raises `AttributeError` naming the object that has no such
+member.
+
+## Names the schema does not know
+
+A vendor parameter whose document was not generated is reached
+explicitly, so a typo in a standard name is never silently taken for one:
+
+```python
+str(Device.WiFi.Radio[1].child("X_ACME_TxPower"))   # 'Device.WiFi.Radio.1.X_ACME_TxPower'
+```
+
+Generate the vendor's document instead and the name completes like any
+other; see [vendor models](vendor-models.md). A Forum name that is not a
+Python identifier is exposed the way the models expose it, `N11kEnable` for
+`11kEnable`, and renders the Forum's spelling.
+
+## Service models
+
+A service model's root is a table, and the document does not say where a
+device mounts it, so its paths render from the document's root. Prefix the
+mount when calling an API:
+
+```python
+from bbfmodels.tr104_cwmp.paths import VoiceService
+
+str(VoiceService[1].Capabilities.MaxLineCount)   # 'VoiceService.1.Capabilities.MaxLineCount'
+"Device.Services." + str(VoiceService[1].Capabilities.MaxLineCount)
+```

{bbfmodels-0.2.1 → bbfmodels-0.3.0}/docs/guides/quickstart.md

@@ -31,6 +31,18 @@ device.flatten()                  # back to path and text pairs
 The [models guide](models.md) covers construction, validation, tables,
 vendor parameters and the service models.
 
+## Correct paths with autocomplete, no models
+
+```python
+from bbfmodels.tr181_cwmp.paths import Device
+
+str(Device.WiFi.SSID[1].SSID)                    # 'Device.WiFi.SSID.1.SSID'
+Device.WiFi.Radio[1].Channel.definition.access   # <Access.READ_WRITE: 'readWrite'>
+```
+
+The [typed paths guide](paths.md) covers tables, search paths and vendor
+names.
+
 ## Resolve and validate paths without generated code
 
 ```python

{bbfmodels-0.2.1 → bbfmodels-0.3.0}/docs/index.md

@@ -40,8 +40,8 @@ Resolve a path, validate a value against the model's constraints, and convert be
 </div>
 
 <div class="ispx-card" markdown>
-### Typed models
-pydantic models for TR-181, TR-098 and every service model, and a generator for any vendor's document. Names stay as the Forum wrote them.
+### Typed models and paths
+pydantic models for TR-181, TR-098 and every service model, typed paths with autocomplete for code that only needs the string, and a generator for any vendor's document.
 </div>
 
 </div>

bbfmodels-0.3.0/hooks/announce.py

@@ -0,0 +1,102 @@
+"""Post one release's notes to a Discord channel.
+
+The notes the docs site renders for a version (release-notes/<version>.md,
+see changelog.py) are also the text a reader of the ispx Discord gets when
+the release lands: one message per release, the version as the title linked
+to the version's section of the Changelog page, the notes as the body. The
+webhook URL arrives in DISCORD_WEBHOOK_URL and is never printed. A version
+whose notes are longer than a Discord embed allows (4096 characters) has its
+body cut at the last whole line that fits; the notes standard keeps them far
+shorter, so the cut is a guard, not a path.
+
+Run with: python hooks/announce.py <version>
+"""
+
+import json
+import os
+import re
+import sys
+import urllib.request
+from pathlib import Path
+
+CHANGELOG_URL = "https://docs.bbfmodels.ispx.co/changelog/"
+NOTES_DIR = "release-notes"
+EMBED_DESCRIPTION_LIMIT = 4096
+
+
+def anchor(changelog, version):
+    """The Changelog page's fragment for a version, derived the way mkdocs does.
+
+    The page heading is the generated "## [1.2.0](compare) (2026-10-29)" with
+    its link removed, so its slug is the version and the date with every
+    character outside letters, digits, spaces and hyphens dropped. A version
+    CHANGELOG.md does not list yet has no section to point at, so the link
+    goes to the page itself.
+    """
+    heading = re.search(
+        rf"^## \[?{re.escape(version)}\]?(?:\([^)]*\))? \((\d{{4}}-\d{{2}}-\d{{2}})\)",
+        changelog,
+        re.M,
+    )
+    if not heading:
+        return ""
+    slug = re.sub(r"[^\w\s-]", "", f"{version} ({heading.group(1)})").strip().lower()
+    return "#" + re.sub(r"\s+", "-", slug)
+
+
+def body(notes, limit=EMBED_DESCRIPTION_LIMIT):
+    text = notes.strip()
+    if len(text) <= limit:
+        return text
+    cut = text.rfind("\n", 0, limit)
+    return text[: cut if cut > 0 else limit].rstrip()
+
+
+def payload(version, notes, changelog):
+    return {
+        "username": "bbfmodels releases",
+        "allowed_mentions": {"parse": []},
+        "embeds": [
+            {
+                "title": f"bbfmodels {version}",
+                "url": CHANGELOG_URL + anchor(changelog, version),
+                "description": body(notes),
+            }
+        ],
+    }
+
+
+def post(url, message):
+    request = urllib.request.Request(
+        url,
+        data=json.dumps(message).encode("utf-8"),
+        headers={"Content-Type": "application/json", "User-Agent": "bbfmodels-release-notes"},
+        method="POST",
+    )
+    with urllib.request.urlopen(request, timeout=30) as response:
+        return response.status
+
+
+def main(argv):
+    if len(argv) != 2:
+        print("usage: announce.py <version>", file=sys.stderr)
+        return 2
+    version = argv[1]
+    url = os.environ.get("DISCORD_WEBHOOK_URL", "")
+    if not url:
+        print("DISCORD_WEBHOOK_URL is not set, nothing posted", file=sys.stderr)
+        return 2
+    root = Path(__file__).resolve().parent.parent
+    notes = root / NOTES_DIR / f"{version}.md"
+    if not notes.is_file():
+        print(f"no notes at {NOTES_DIR}/{version}.md", file=sys.stderr)
+        return 1
+    changelog = (root / "CHANGELOG.md").read_text(encoding="utf-8")
+    message = payload(version, notes.read_text(encoding="utf-8"), changelog)
+    status = post(url, message)
+    print(f"posted {version} ({status})")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv))

bbfmodels-0.3.0/hooks/test_announce.py

@@ -0,0 +1,89 @@
+"""Run with: python -m unittest discover -s hooks"""
+
+import json
+import threading
+import unittest
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+import announce
+
+CHANGELOG = """# Changelog
+
+## [0.76.0](https://example.test/compare/v0.75.2...v0.76.0) (2026-10-29)
+
+### Added
+
+* **scripts:** the System page shows what each script costs
+
+## 0.1.0 (2026-08-20)
+"""
+
+NOTES = """- The System page ranks scripts by run time, host time and failure rate
+- Action: previewing a topology rule now requires the config:write scope
+"""
+
+
+class Anchor(unittest.TestCase):
+    def test_matches_the_docs_page_heading_id(self):
+        self.assertEqual(announce.anchor(CHANGELOG, "0.76.0"), "#0760-2026-10-29")
+
+    def test_first_release_heading_has_no_link(self):
+        self.assertEqual(announce.anchor(CHANGELOG, "0.1.0"), "#010-2026-08-20")
+
+    def test_unlisted_version_links_to_the_page(self):
+        self.assertEqual(announce.anchor(CHANGELOG, "0.77.0"), "")
+        self.assertEqual(
+            announce.payload("0.77.0", NOTES, CHANGELOG)["embeds"][0]["url"],
+            announce.CHANGELOG_URL,
+        )
+
+
+class Payload(unittest.TestCase):
+    def test_one_embed_titled_by_version_linking_to_its_section(self):
+        message = announce.payload("0.76.0", NOTES, CHANGELOG)
+        self.assertEqual(message["allowed_mentions"], {"parse": []})
+        (embed,) = message["embeds"]
+        self.assertEqual(embed["title"], "bbfmodels 0.76.0")
+        self.assertEqual(embed["url"], announce.CHANGELOG_URL + "#0760-2026-10-29")
+        self.assertEqual(embed["description"], NOTES.strip())
+
+    def test_overlong_notes_are_cut_at_a_whole_line(self):
+        lines = "\n".join(f"- line {i} " + "x" * 100 for i in range(60))
+        text = announce.body(lines)
+        self.assertLessEqual(len(text), announce.EMBED_DESCRIPTION_LIMIT)
+        self.assertTrue(text.endswith("x"))
+        self.assertEqual(text, lines[: len(text)])
+        self.assertEqual(lines[len(text)], "\n")
+
+
+class Post(unittest.TestCase):
+    def test_posts_json_to_the_webhook(self):
+        received = {}
+
+        class Handler(BaseHTTPRequestHandler):
+            def do_POST(self):
+                length = int(self.headers["Content-Length"])
+                received["body"] = json.loads(self.rfile.read(length))
+                received["type"] = self.headers["Content-Type"]
+                self.send_response(204)
+                self.end_headers()
+
+            def log_message(self, *_):
+                pass
+
+        server = HTTPServer(("127.0.0.1", 0), Handler)
+        thread = threading.Thread(target=server.serve_forever, daemon=True)
+        thread.start()
+        try:
+            url = f"http://127.0.0.1:{server.server_port}/webhook"
+            status = announce.post(url, announce.payload("0.76.0", NOTES, CHANGELOG))
+        finally:
+            server.shutdown()
+            server.server_close()
+        self.assertEqual(status, 204)
+        self.assertEqual(received["type"], "application/json")
+        self.assertEqual(received["body"]["embeds"][0]["title"], "bbfmodels 0.76.0")
+
+
+if __name__ == "__main__":
+    unittest.main()

{bbfmodels-0.2.1 → bbfmodels-0.3.0}/mkdocs.yml

@@ -51,6 +51,7 @@ nav:
       - Documents and the IR: guides/documents.md
       - Schema, tree and codec: guides/runtime.md
       - Generated models: guides/models.md
+      - Typed paths: guides/paths.md
       - Vendor models: guides/vendor-models.md
       - Command line: guides/cli.md
   - Changelog: changelog.md

{bbfmodels-0.2.1 → bbfmodels-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "bbfmodels"
-version = "0.2.1"
+version = "0.3.0"
 description = "Typed models and schema tooling for Broadband Forum data models (TR-181, TR-098, TR-104 and more), generated from the published XML"
 readme = "README.md"
 license = "Apache-2.0"

bbfmodels-0.3.0/release-notes/0.3.0.md

@@ -0,0 +1,4 @@
+- Typed paths: `str(Device.WiFi.SSID[1].SSID)` renders the path, with autocomplete over the whole model
+- A path knows its definition: type, access, constraints and description one attribute away
+- A table renders as its partial path, and `search` gives the USP wildcard form
+- Type checkers reject a misspelled object or parameter name and suggest the right one

{bbfmodels-0.2.1 → bbfmodels-0.3.0}/src/bbfmodels/__init__.py

@@ -11,6 +11,6 @@ from importlib.metadata import PackageNotFoundError, version
 try:
     __version__ = version("bbfmodels")
 except PackageNotFoundError:  # running from a source tree that is not installed
-    __version__ = "0.2.1"
+    __version__ = "0.3.0"
 
 __all__ = ["__version__"]

{bbfmodels-0.2.1 → bbfmodels-0.3.0}/src/bbfmodels/generate.py

@@ -17,12 +17,12 @@ from __future__ import annotations
 
 import gzip
 import keyword
-import re
 from pathlib import Path
 
 from pydantic import BaseModel
 
 from bbfmodels.ir import BaseType, Document, Model, Object, Parameter
+from bbfmodels.paths import identifier
 
 # The documents the shipped packages are generated from. A package is named
 # after its document: the protocol suffix appears where the Forum publishes
@@ -110,19 +110,26 @@ def generate(doc: Document, package: str, out: Path) -> list[Path]:
     root_path.write_text(body)
     written.append(root_path)
 
+    paths_py = out / "paths.py"
+    paths_py.write_text(_emit_paths_module(model, root, package, source))
+    written.append(paths_py)
+    paths_pyi = out / "paths.pyi"
+    paths_pyi.write_text(_emit_paths_stub(model, root, source))
+    written.append(paths_pyi)
+
     init = (
         f'"""{model.name} from {source}.\n\n'
         f"Generated by bbfmodels. Do not edit: change the generator or the source\n"
         f"document and regenerate. ``schema()`` loads the IR the models were\n"
         f'generated from, for validation and descriptions.\n"""\n\n'
         f"from bbfmodels.model import load_schema\n"
-        f"from {package}.{modules['']} import {root}\n\n"
+        f"from {package}.{modules['']} import {identifier(root)}\n\n"
         f'SOURCE = "{source}"\n'
         f'SPEC = "{doc.spec}"\n'
         f'MODEL = "{model.name}"\n\n\n'
         f"def schema():  # type: ignore[no-untyped-def]\n"
         f"    return load_schema(__name__)\n\n\n"
-        f'__all__ = ["{root}", "MODEL", "SOURCE", "SPEC", "schema"]\n'
+        f'__all__ = ["{identifier(root)}", "MODEL", "SOURCE", "SPEC", "schema"]\n'
     )
     init_path = out / "__init__.py"
     init_path.write_text(init)
@@ -176,20 +183,6 @@ def _postorder(objects: list[Object]) -> list[Object]:
     return sorted(objects, key=lambda o: -o.path.count("."))
 
 
-def identifier(name: str) -> str:
-    """A Forum name as a Python identifier.
-
-    Forum names are identifiers already except in vendor documents, where a
-    name may start with a digit (``11kRSSIHighThresholdOffset``) or carry a
-    hyphen. A leading digit gets an ``N`` in front, because a leading
-    underscore would make pydantic treat the field as private, and any other
-    character Python rejects becomes an underscore. The wire name is kept
-    as the field's alias, so conversion is unaffected.
-    """
-    out = re.sub(r"\W", "_", name)
-    return "N" + out if out[:1].isdigit() else out
-
-
 def class_name(obj: Object, root: str) -> str:
     segments = [s for s in obj.path.rstrip(".").split(".") if s != "{i}"]
     return identifier(root) if len(segments) == 1 else identifier("_".join(segments[1:]))
@@ -269,3 +262,68 @@ def write_package(package: str, document: Path, root: Path) -> list[Path]:
 
     out = root.joinpath(*package.split("."))
     return generate(parse_file(document), package, out)
+
+
+_STUB_TYPE = {
+    BaseType.STRING: "str",
+    BaseType.INT: "int",
+    BaseType.UNSIGNED_INT: "int",
+    BaseType.LONG: "int",
+    BaseType.UNSIGNED_LONG: "int",
+    BaseType.BOOLEAN: "bool",
+    BaseType.DATE_TIME: "datetime",
+    BaseType.HEX_BINARY: "bytes",
+    BaseType.BASE64: "bytes",
+    BaseType.DECIMAL: "Decimal",
+}
+
+
+def _emit_paths_module(model: Model, root: str, package: str, source: str) -> str:
+    """The runtime half of typed paths: one root object over the package's schema."""
+    root_obj = next(iter(model.objects.values()))
+    kind = "TablePath" if root_obj.multi_instance else "ObjectPath"
+    data = root_obj.path.replace("{i}.", "")
+    return (
+        _HEADER.format(source=source)
+        + "from bbfmodels.model import load_schema as _load_schema\n"
+        + f"from bbfmodels.paths import {kind} as _{kind}\n\n\n"
+        + "def _schema():  # type: ignore[no-untyped-def]\n"
+        + f'    return _load_schema("{package}")\n\n\n'
+        + f'{identifier(root)} = _{kind}(_schema, "{data}", "{root_obj.path}")\n'
+    )
+
+
+def _emit_paths_stub(model: Model, root: str, source: str) -> str:
+    """The stub editors read: a class per object with every name and value type."""
+    lines = [
+        _HEADER.format(source=source),
+        "from datetime import datetime\n",
+        "from decimal import Decimal\n",
+        "from bbfmodels.paths import ObjectPathBase, ParamPath, TablePath\n\n",
+    ]
+    for obj in _postorder(list(model.objects.values())):
+        name = class_name(obj, root) + "Path"
+        lines.append(f"class {name}(ObjectPathBase):\n")
+        for param in obj.parameters.values():
+            s = param.syntax
+            value = _STUB_TYPE[s.base_type]
+            if s.list is not None:
+                value = f"list[{value}]"
+            lines.append(f"    {identifier(param.name)}: ParamPath[{value}]\n")
+        for child in _children(obj, model):
+            child_name = class_name(child, root) + "Path"
+            field = identifier(child.name)
+            if child.multi_instance:
+                lines.append(f"    {field}: TablePath[{child_name}]\n")
+            else:
+                lines.append(f"    {field}: {child_name}\n")
+        if not obj.parameters and not _children(obj, model):
+            lines.append("    pass\n")
+        lines.append("\n")
+    root_obj = next(iter(model.objects.values()))
+    root_name = class_name(root_obj, root) + "Path"
+    if root_obj.multi_instance:
+        lines.append(f"{identifier(root)}: TablePath[{root_name}]\n")
+    else:
+        lines.append(f"{identifier(root)}: {root_name}\n")
+    return "".join(lines)