bbfmodels 0.1.0__py3-none-any.whl

bbfmodels/sources.py

@@ -0,0 +1,79 @@
+"""Fetch published data model documents from the Forum.
+
+The Forum serves every published flattened document from two static sites,
+one per protocol. A file is named
+``tr-<number>-<issue>-<amendment>-<corrigendum>[-cwmp|-usp]-full.xml`` and
+never changes once published, so a downloaded copy is kept in a local cache
+and reused.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import urllib.request
+from pathlib import Path
+
+SITES = {
+    "cwmp": "https://cwmp-data-models.broadband-forum.org/",
+    "usp": "https://usp-data-models.broadband-forum.org/",
+}
+
+# The documents the test suite and the shipped models are generated from.
+# Moving one is a deliberate change: the generated output moves with it.
+CORE = (
+    "tr-098-1-8-0-full.xml",
+    "tr-104-1-1-0-full.xml",
+    "tr-104-2-0-2-cwmp-full.xml",
+    "tr-104-2-0-2-usp-full.xml",
+    "tr-135-1-4-1-cwmp-full.xml",
+    "tr-135-1-4-1-usp-full.xml",
+    "tr-140-1-3-1-cwmp-full.xml",
+    "tr-140-1-3-1-usp-full.xml",
+    "tr-157-1-3-0-full.xml",
+    "tr-181-2-21-0-cwmp-full.xml",
+    "tr-181-2-21-0-usp-full.xml",
+)
+
+_FILE = re.compile(r"^tr-\d+-\d+-\d+-\d+(?:-(cwmp|usp))?-full\.xml$")
+_HREF = re.compile(r'href="(tr-\d+-\d+-\d+-\d+(?:-(?:cwmp|usp))?-full\.xml)"')
+
+
+def cache_dir() -> Path:
+    """Where fetched documents live: ``$BBFMODELS_CACHE``, else the XDG cache."""
+    env = os.environ.get("BBFMODELS_CACHE")
+    if env:
+        return Path(env)
+    xdg = os.environ.get("XDG_CACHE_HOME") or str(Path.home() / ".cache")
+    return Path(xdg) / "bbfmodels"
+
+
+def site_for(name: str) -> str:
+    """The site a document is published on, from its name."""
+    m = _FILE.match(name)
+    if not m:
+        raise ValueError(f"{name!r} is not a published document name")
+    # Documents without a protocol suffix predate USP and live on the CWMP site.
+    return SITES["usp"] if m.group(1) == "usp" else SITES["cwmp"]
+
+
+def available(protocol: str) -> list[str]:
+    """Every flattened document the Forum lists for a protocol."""
+    with urllib.request.urlopen(SITES[protocol], timeout=30) as resp:
+        index = resp.read().decode("utf-8", errors="replace")
+    return sorted(set(_HREF.findall(index)))
+
+
+def fetch(name: str, into: Path | None = None) -> Path:
+    """Return the local copy of a document, downloading it if needed."""
+    target = (into or cache_dir()) / name
+    if target.exists():
+        return target
+    url = site_for(name) + name
+    target.parent.mkdir(parents=True, exist_ok=True)
+    with urllib.request.urlopen(url, timeout=60) as resp:
+        data = resp.read()
+    tmp = target.with_suffix(".part")
+    tmp.write_bytes(data)
+    tmp.replace(target)
+    return target

bbfmodels/tree.py

@@ -0,0 +1,200 @@
+"""A data tree: the values of one device, held against a schema.
+
+The wire shape of CWMP and USP is a flat list of path and text pairs with
+instance numbers inside the paths. ``Tree.from_flat`` arranges those into
+objects, tables and instances using the schema, decodes values on demand,
+and ``flatten`` writes them back out. Paths the schema does not define are
+kept where they belong and come back out unchanged, so a tree built from a
+device's values is never lossy.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator, Mapping
+
+from bbfmodels import codec
+from bbfmodels.ir import Object, Parameter
+from bbfmodels.schema import Schema, UnknownPath
+
+
+class Node:
+    """One object instance: its parameter texts, child objects and tables."""
+
+    def __init__(self, path: str, obj: Object | None) -> None:
+        self.path = path
+        self.object = obj
+        self.raw: dict[str, str] = {}
+        # Child objects and tables by name, in the order they were first seen,
+        # so a tree flattens in the order it was built from.
+        self.members: dict[str, Node | Table] = {}
+
+    def __repr__(self) -> str:
+        return f"Node({self.path!r})"
+
+    def __getitem__(self, name: str) -> Node | Table:
+        return self.members[name]
+
+    def __contains__(self, name: str) -> bool:
+        return name in self.raw or name in self.members
+
+    @property
+    def children(self) -> dict[str, Node]:
+        return {n: m for n, m in self.members.items() if isinstance(m, Node)}
+
+    @property
+    def tables(self) -> dict[str, Table]:
+        return {n: m for n, m in self.members.items() if isinstance(m, Table)}
+
+    def parameter(self, name: str) -> Parameter | None:
+        return self.object.parameters.get(name) if self.object else None
+
+    def text(self, name: str) -> str:
+        """The wire text of a parameter, exactly as given."""
+        return self.raw[name]
+
+    def value(self, name: str) -> codec.Value:
+        """The decoded value of a parameter; text when the schema has no syntax for it."""
+        text = self.raw[name]
+        param = self.parameter(name)
+        return codec.decode(param.syntax, text) if param else text
+
+    def get(self, name: str, default: codec.Value | None = None) -> codec.Value | None:
+        return self.value(name) if name in self.raw else default
+
+    def set(self, name: str, value: codec.Value) -> None:
+        """Store a value, encoding it for the parameter's syntax.
+
+        An unknown parameter takes text only. Values are not validated here;
+        ``Tree.problems`` reports violations of the schema's facets.
+        """
+        param = self.parameter(name)
+        if param is None:
+            if not isinstance(value, str):
+                raise codec.CodecError(f"{self.path}{name} is not in the schema; give text")
+            self.raw[name] = value
+        else:
+            self.raw[name] = codec.encode(param.syntax, value)
+
+    @property
+    def unknown_parameters(self) -> list[str]:
+        return [n for n in self.raw if self.parameter(n) is None]
+
+    def walk(self) -> Iterator[Node]:
+        yield self
+        for member in self.members.values():
+            if isinstance(member, Node):
+                yield from member.walk()
+            else:
+                for instance in member.values():
+                    yield from instance.walk()
+
+
+class Table(dict[int, Node]):
+    """The instances of a multi-instance object, by instance number."""
+
+    def __init__(self, path: str, obj: Object | None) -> None:
+        super().__init__()
+        self.path = path
+        self.object = obj
+
+    def __repr__(self) -> str:
+        return f"Table({self.path!r}, {sorted(self)})"
+
+
+class Tree:
+    def __init__(self, schema: Schema) -> None:
+        self.schema = schema
+        self.roots: dict[str, Node] = {}
+
+    @classmethod
+    def from_flat(cls, schema: Schema, values: Mapping[str, str]) -> Tree:
+        tree = cls(schema)
+        for path, text in values.items():
+            tree.set_text(path, text)
+        return tree
+
+    def __getitem__(self, root: str) -> Node:
+        return self.roots[root.rstrip(".")]
+
+    def node(self, object_path: str, create: bool = False) -> Node:
+        """The node for a data path ending in ``.``, created on the way if asked."""
+        segments = object_path.rstrip(".").split(".")
+        root_name = segments[0]
+        if root_name not in self.roots:
+            if not create:
+                raise KeyError(object_path)
+            self.roots[root_name] = Node(root_name + ".", self._object(root_name + "."))
+        node = self.roots[root_name]
+        path = root_name + "."
+        i = 1
+        while i < len(segments):
+            seg = segments[i]
+            table_path = path + seg + ".{i}."
+            is_table = (i + 1 < len(segments) and segments[i + 1].isdigit()) and (
+                table_path in self.schema.objects or path + seg + "." not in self.schema.objects
+            )
+            if is_table:
+                number = int(segments[i + 1])
+                table = node.members.get(seg)
+                if not isinstance(table, Table):
+                    if table is not None or not create:
+                        raise KeyError(object_path)
+                    table = node.members[seg] = Table(table_path, self._object(table_path))
+                instance_path = f"{path}{seg}.{number}."
+                instance = table.get(number)
+                if instance is None:
+                    if not create:
+                        raise KeyError(object_path)
+                    instance = table[number] = Node(instance_path, table.object)
+                node, path = instance, instance_path
+                i += 2
+            else:
+                child_path = path + seg + "."
+                child = node.members.get(seg)
+                if not isinstance(child, Node):
+                    if child is not None or not create:
+                        raise KeyError(object_path)
+                    child = node.members[seg] = Node(child_path, self._object(child_path))
+                node, path = child, child_path
+                i += 1
+        return node
+
+    def _object(self, data_path: str) -> Object | None:
+        try:
+            return self.schema.resolve(data_path).object
+        except UnknownPath:
+            return None
+
+    def set_text(self, path: str, text: str) -> None:
+        object_path, _, name = path.rpartition(".")
+        self.node(object_path + ".", create=True).raw[name] = text
+
+    def set(self, path: str, value: codec.Value) -> None:
+        object_path, _, name = path.rpartition(".")
+        self.node(object_path + ".", create=True).set(name, value)
+
+    def text(self, path: str) -> str:
+        object_path, _, name = path.rpartition(".")
+        return self.node(object_path + ".").text(name)
+
+    def value(self, path: str) -> codec.Value:
+        object_path, _, name = path.rpartition(".")
+        return self.node(object_path + ".").value(name)
+
+    def nodes(self) -> Iterator[Node]:
+        for root in self.roots.values():
+            yield from root.walk()
+
+    def flatten(self) -> dict[str, str]:
+        """Every parameter as path and wire text, in tree order."""
+        return {node.path + name: text for node in self.nodes() for name, text in node.raw.items()}
+
+    def problems(self) -> list[tuple[str, str]]:
+        """Every facet violation in the tree, as path and message."""
+        found: list[tuple[str, str]] = []
+        for node in self.nodes():
+            for name, text in node.raw.items():
+                param = node.parameter(name)
+                if param is not None:
+                    found.extend((node.path + name, p) for p in codec.problems(param.syntax, text))
+        return found

bbfmodels-0.1.0.dist-info/METADATA

@@ -0,0 +1,79 @@
+Metadata-Version: 2.5
+Name: bbfmodels
+Version: 0.1.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/
+Project-URL: Changelog, https://docs.bbfmodels.ispx.co/changelog/
+Author: ISPX LIMITED
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Keywords: broadband-forum,cwmp,data-model,tr-069,tr-098,tr-181,tr-369,usp
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Telecommunications Industry
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Networking
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: pydantic>=2.14
+Description-Content-Type: text/markdown
+
+# bbfmodels
+
+Typed models and schema tooling for Broadband Forum data models (TR-181,
+TR-098, TR-104 and the rest), generated from the XML the Forum publishes.
+
+The Forum defines what a broadband gateway exposes to its management system
+as XML in the TR-106 schema: thousands of objects and parameters, their types,
+ranges, enumerations, writability and multi-instance tables. Everyone who
+builds against those models, an ACS, a USP controller, a device simulator, an
+integration script, re-derives the same facts from the same XML and hand-types
+the same parameter paths as strings. bbfmodels does it once:
+
+- A parser that reads the published XML into a normalised intermediate
+  representation, published as JSON with its own schema.
+- A Python runtime that works from that representation: resolve a path,
+  validate a value against the model's constraints, convert between the flat
+  path and value lists that CWMP and USP carry on the wire and a typed tree.
+- Generated typed bindings: pydantic models for Python first, JSON Schema and
+  TypeScript 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
+`SSID` entries indexed by instance number, and the attribute is `SSID`, not
+`ssid`.
+
+## Status
+
+Pre-release. The parser, the intermediate representation and the runtime
+are in place: `bbfmodels fetch` downloads the Forum's published documents,
+`bbfmodels ir` turns one into JSON, and the `Schema` and `Tree` classes
+resolve paths, hold a device's values and validate them. Generated Python
+models come next. Until the first release there is no package on PyPI.
+
+The design decisions behind the code are in `context/decisions/`, indexed in
+`context/README.md`. Read them before changing the parser or the IR.
+
+## Development
+
+Prerequisites: git and [uv](https://docs.astral.sh/uv/). The pinned Python is
+installed by uv.
+
+```sh
+scripts/bootstrap.sh
+make test
+make lint
+```
+
+`make help` lists the rest. Documentation is built from `docs/` with
+`make docs` and published at https://docs.bbfmodels.ispx.co/.
+
+## Licence
+
+Apache-2.0, copyright ISPX LIMITED. The Broadband Forum publishes its data
+models under the BSD 3-clause licence; output derived from them carries the
+Forum's notice.

bbfmodels-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+bbfmodels/__init__.py,sha256=zVBow6BV3ehd7KEHHWqEZNVIRMJjcQlqctMcFmiImBA,611
+bbfmodels/cli.py,sha256=7nzDPxyO8Gl1qPOwJPvvPzQ3ob3_Rh1LqD4oRbWwxW0,2548
+bbfmodels/codec.py,sha256=TE2k_kE4mj5QOcX9bH7-EBlp7InmF_lAN4C5_9MWdjw,8933
+bbfmodels/ir.py,sha256=IGpkupWqryiWNQGj53XlAIKFFbqk_WuiXpim1-A515w,9680
+bbfmodels/parser.py,sha256=UQmWs3N7gPYio-ZyzLrSbUisRzM_O_oJ-48jLaIbl_E,18631
+bbfmodels/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bbfmodels/schema.py,sha256=vM5rKsg3lQSZEvsCxWiClGtmT62EU13bp0me1r5gNM4,5778
+bbfmodels/sources.py,sha256=tQCkh_ppv1Zm54xBfMjyK4o3w9ese2SNTMk3fQf6Aro,2673
+bbfmodels/tree.py,sha256=aeJjmFn0X29SfNY5C6C6FK4YFAHzN_eR0FwtdUzqzJs,7763
+bbfmodels-0.1.0.dist-info/METADATA,sha256=RuDtg9B599Sl8900_m7u9vONEwQzp5oY0Fn0_WKoFBw,3349
+bbfmodels-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+bbfmodels-0.1.0.dist-info/entry_points.txt,sha256=CZnzcwSGF9L4i7o_Iv7OL1IRORCbCRRieJKn86SDhsg,49
+bbfmodels-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+bbfmodels-0.1.0.dist-info/licenses/NOTICE,sha256=DBJsIc1s93frQB3YqrJtxxTdXWJVxtDqGdS2QPA7Rm4,38
+bbfmodels-0.1.0.dist-info/RECORD,,

bbfmodels-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

bbfmodels-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bbfmodels = bbfmodels.cli:main

bbfmodels-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

bbfmodels-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,2 @@
+bbfmodels
+Copyright 2026 ISPX LIMITED