openspacehdl 0.0.1__tar.gz

openspacehdl-0.0.1/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+All notable changes of the package. Versions follow [semantic versioning](https://semver.org).
+
+## 0.0.1 - 2026-10-22
+
+### Added
+
+- `openspacehdl --version` and `openspacehdl info [project]`: the projects of the family as the website shows them
+  (website commit 1b3d619).

openspacehdl-0.0.1/LICENSE

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

openspacehdl-0.0.1/MANIFEST.in

@@ -0,0 +1,3 @@
+include CHANGELOG.md
+include requirements-dev.txt
+include tools/family_data.py

openspacehdl-0.0.1/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: openspacehdl
+Version: 0.0.1
+Summary: Open Space HDL, open-source VHDL IP cores for spacecraft on-board data handling: early release that lists the family
+Author-email: Julian Schneider <julian.schneider@openspacehdl.org>
+License-Expression: MIT
+Project-URL: Homepage, https://openspacehdl.org
+Keywords: vhdl,fpga,ip-core,space,spacewire,spacefibre,ccsds,ecss
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# openspacehdl
+
+Python package of [Open Space HDL](https://openspacehdl.org), a family of open-source VHDL IP cores for spacecraft
+on-board data handling.
+
+This is an early release. It lists the projects of the family as the website shows them; it does not contain the
+cores or any tools yet.
+
+## Install
+
+```shell
+pip install openspacehdl
+```
+
+The package needs Python 3.10 or later and has no dependencies. On a machine without network access, copy the wheel
+and install it from the file:
+
+```shell
+pip install openspacehdl-<version>-py3-none-any.whl
+```
+
+## Use
+
+```shell
+openspacehdl --version          # version of the package
+openspacehdl info               # every project of the family: standard, summary, TRL, documentation and source
+openspacehdl info OpenFibre     # one project, by name or repository name
+```
+
+`python -m openspacehdl` works the same way.
+
+The list comes from the project cards of [openspacehdl.org](https://openspacehdl.org) at the time of the release.
+A project that is not yet public is listed as "Coming soon", without links.
+
+## Development
+
+```shell
+pip install -r requirements-dev.txt
+pip install -e .
+pytest
+python tools/family_data.py --site <clone of open-space-hdl.github.io> --check
+python -m build
+```
+
+`tools/family_data.py` writes `src/openspacehdl/data/family.json` from `_data/projects.yml` and
+`_data/project_groups.yml` of the website repository; `--check` only compares.
+
+## Licence
+
+The package is released under the [MIT License](LICENSE). The IP cores of the family have their own licence (PSI HDL
+Library License), stated in each repository.

openspacehdl-0.0.1/README.md

@@ -0,0 +1,51 @@
+# openspacehdl
+
+Python package of [Open Space HDL](https://openspacehdl.org), a family of open-source VHDL IP cores for spacecraft
+on-board data handling.
+
+This is an early release. It lists the projects of the family as the website shows them; it does not contain the
+cores or any tools yet.
+
+## Install
+
+```shell
+pip install openspacehdl
+```
+
+The package needs Python 3.10 or later and has no dependencies. On a machine without network access, copy the wheel
+and install it from the file:
+
+```shell
+pip install openspacehdl-<version>-py3-none-any.whl
+```
+
+## Use
+
+```shell
+openspacehdl --version          # version of the package
+openspacehdl info               # every project of the family: standard, summary, TRL, documentation and source
+openspacehdl info OpenFibre     # one project, by name or repository name
+```
+
+`python -m openspacehdl` works the same way.
+
+The list comes from the project cards of [openspacehdl.org](https://openspacehdl.org) at the time of the release.
+A project that is not yet public is listed as "Coming soon", without links.
+
+## Development
+
+```shell
+pip install -r requirements-dev.txt
+pip install -e .
+pytest
+python tools/family_data.py --site <clone of open-space-hdl.github.io> --check
+python -m build
+```
+
+`tools/family_data.py` writes `src/openspacehdl/data/family.json` from `_data/projects.yml` and
+`_data/project_groups.yml` of the website repository; `--check` only compares.
+
+## Licence
+
+The package is released under the [MIT License](LICENSE). The IP cores of the family have their own licence (PSI HDL
+Library License), stated in each repository.

openspacehdl-0.0.1/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openspacehdl"
+dynamic = ["version"]
+description = "Open Space HDL, open-source VHDL IP cores for spacecraft on-board data handling: early release that lists the family"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+authors = [{ name = "Julian Schneider", email = "julian.schneider@openspacehdl.org" }]
+keywords = ["vhdl", "fpga", "ip-core", "space", "spacewire", "spacefibre", "ccsds", "ecss"]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)",
+]
+
+[project.urls]
+Homepage = "https://openspacehdl.org"
+
+[project.scripts]
+openspacehdl = "openspacehdl.cli:main"
+
+[tool.setuptools.dynamic]
+version = { attr = "openspacehdl.__version__" }
+
+[tool.setuptools.package-data]
+openspacehdl = ["data/*.json"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

openspacehdl-0.0.1/requirements-dev.txt

@@ -0,0 +1,4 @@
+build>=1.2
+pytest>=8
+pyyaml>=6
+twine>=6

openspacehdl-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

openspacehdl-0.0.1/src/openspacehdl/__init__.py

@@ -0,0 +1,3 @@
+"""Open Space HDL: open-source VHDL IP cores for spacecraft on-board data handling."""
+
+__version__ = "0.0.1"

openspacehdl-0.0.1/src/openspacehdl/__main__.py

@@ -0,0 +1,7 @@
+"""Entry point of python -m openspacehdl."""
+
+import sys
+
+from openspacehdl.cli import main
+
+sys.exit(main())

openspacehdl-0.0.1/src/openspacehdl/cli.py

@@ -0,0 +1,75 @@
+"""Command line of openspacehdl."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+import textwrap
+
+from openspacehdl import __version__
+from openspacehdl.family import Family, Project, load
+
+WIDTH = 100
+INDENT = "    "
+
+
+def _wrap(text: str, indent: str) -> list[str]:
+    return textwrap.wrap(text, WIDTH, initial_indent=indent, subsequent_indent=indent)
+
+
+def _project_lines(family: Family, p: Project) -> list[str]:
+    state = "Coming soon" if not p.public else (f"TRL {p.trl}" if p.trl else "")
+    head = "  ".join(x for x in (p.name, state) if x)
+    lines = [f"  {head}"]
+    if p.tagline:
+        lines.append(f"{INDENT}{', '.join(p.tagline)}")
+    lines += _wrap(p.summary, INDENT)
+    if p.public:
+        if p.trl and p.trl_status:
+            lines += _wrap(f"Status: {p.trl_status}", INDENT)
+        docs = family.docs_url(p)
+        if docs:
+            lines.append(f"{INDENT}Documentation: {docs}")
+        lines.append(f"{INDENT}Source: {family.source_url(p)}")
+    return lines
+
+
+def info(family: Family, name: str | None) -> int:
+    if name is not None:
+        p = family.find(name)
+        if p is None:
+            names = ", ".join(x.name for x in family.projects)
+            print(f"openspacehdl: no project named {name!r}; the family has {names}", file=sys.stderr)
+            return 2
+        print("\n".join(_project_lines(family, p)))
+        return 0
+
+    out = ["Open Space HDL: open-source VHDL IP cores for spacecraft on-board data handling", family.site]
+    for g in family.groups:
+        members = family.members(g)
+        if not members:
+            continue
+        out += ["", g.title, *_wrap(g.summary, "  ")]
+        for p in members:
+            out += ["", *_project_lines(family, p)]
+    print("\n".join(out))
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(errors="replace")
+    parser = argparse.ArgumentParser(
+        prog="openspacehdl",
+        description="Open Space HDL: open-source VHDL IP cores for spacecraft on-board data handling.",
+    )
+    parser.add_argument("--version", action="version", version=f"openspacehdl {__version__}")
+    sub = parser.add_subparsers(dest="command", metavar="<command>")
+    p_info = sub.add_parser("info", help="list the projects of the family, as the website shows them")
+    p_info.add_argument("project", nargs="?", help="show only this project (name or repository)")
+    args = parser.parse_args(argv)
+
+    if args.command == "info":
+        return info(load(), args.project)
+    parser.print_help()
+    return 0

openspacehdl-0.0.1/src/openspacehdl/data/family.json

@@ -0,0 +1,158 @@
+{
+  "source": {
+    "repository": "open-space-hdl/open-space-hdl.github.io",
+    "commit": "1b3d619cb4b4cef3fe7a3893a0d0040c1d4049bb"
+  },
+  "site": "https://openspacehdl.org",
+  "github": "https://github.com/open-space-hdl",
+  "groups": [
+    {
+      "id": "interfaces-protocols",
+      "title": "Interfaces & Protocols",
+      "summary": "SpaceWire and SpaceFibre links, CAN and 1553 buses, and the protocols that run over them."
+    },
+    {
+      "id": "processing-modules",
+      "title": "Processing Modules",
+      "summary": "Cores that process payload data on board, such as image compression and encryption."
+    },
+    {
+      "id": "system-infrastructure",
+      "title": "System Infrastructure",
+      "summary": "Cores that move data between the memories and the peripherals of an on-board system."
+    },
+    {
+      "id": "building-blocks",
+      "title": "Building Blocks",
+      "summary": "The fault-tolerant Open Logic entities that every core is built on."
+    }
+  ],
+  "projects": [
+    {
+      "name": "OpenWire",
+      "group": "interfaces-protocols",
+      "tagline": [
+        "ECSS-E-ST-50-12C Rev.1"
+      ],
+      "summary": "SpaceWire port with node interface: Data-Strobe encoding, link control, packets, time-codes and distributed interrupts.",
+      "public": true,
+      "repo": "openwire",
+      "docs": true,
+      "trl": 3,
+      "trl_status": "Fully verified by simulation. Not yet tested on hardware, no flight heritage."
+    },
+    {
+      "name": "OpenFibre",
+      "group": "interfaces-protocols",
+      "tagline": [
+        "ECSS-E-ST-50-11C"
+      ],
+      "summary": "SpaceFibre port with 1 to 4 lanes, up to 32 virtual channels, quality of service, broadcast and error recovery.",
+      "public": true,
+      "repo": "openfibre",
+      "docs": true,
+      "trl": 3,
+      "trl_status": "Fully verified by simulation. Not yet tested on hardware, no flight heritage."
+    },
+    {
+      "name": "OpenRMAP",
+      "group": "interfaces-protocols",
+      "tagline": [
+        "ECSS-E-ST-50-52C"
+      ],
+      "summary": "RMAP target and initiator for reading and writing remote memory over SpaceWire and SpaceFibre networks.",
+      "public": true,
+      "repo": "openrmap",
+      "docs": true,
+      "trl": 3,
+      "trl_status": "Fully verified by simulation. Not yet tested on hardware, no flight heritage."
+    },
+    {
+      "name": "OpenSPP",
+      "group": "interfaces-protocols",
+      "tagline": [
+        "CCSDS 133.0-B-2"
+      ],
+      "summary": "Space Packet service with APID routing and loss detection for up to 16 send and 16 receive ports, over SpaceWire, SpaceFibre or other links.",
+      "public": true,
+      "repo": "openspp",
+      "docs": true,
+      "trl": 3,
+      "trl_status": "Fully verified by simulation. Not yet tested on hardware, no flight heritage."
+    },
+    {
+      "name": "OpenCAN",
+      "group": "interfaces-protocols",
+      "tagline": [
+        "ECSS-E-ST-50-15C"
+      ],
+      "summary": "CAN network core with nominal and redundant bus, bus redundancy management, CANopen services and time distribution.",
+      "public": false
+    },
+    {
+      "name": "Open1553",
+      "group": "interfaces-protocols",
+      "tagline": [
+        "ECSS-E-ST-50-13C"
+      ],
+      "summary": "Bus controller, remote terminal and bus monitor for the dual-redundant 1553 data bus, with the Manchester II codec in the core.",
+      "public": false
+    },
+    {
+      "name": "OpenCompact",
+      "group": "processing-modules",
+      "tagline": [
+        "CCSDS 123.0-B-2"
+      ],
+      "summary": "Lossless and near-lossless compressor for multispectral and hyperspectral images, with all predictors and entropy coders of the standard.",
+      "public": true,
+      "repo": "opencompact",
+      "docs": true,
+      "trl": 3,
+      "trl_status": "Fully verified by simulation. Not yet tested on hardware, no flight heritage."
+    },
+    {
+      "name": "OpenCrypto",
+      "group": "processing-modules",
+      "tagline": [
+        "CCSDS 352.0-B-2"
+      ],
+      "summary": "Authenticated encryption and decryption of real-time data streams with AES-GCM, key table and IV generation.",
+      "public": true,
+      "repo": "opencrypto",
+      "docs": true,
+      "trl": 3,
+      "trl_status": "Fully verified by simulation. Not yet tested on hardware, no flight heritage."
+    },
+    {
+      "name": "OpenDMA",
+      "group": "system-infrastructure",
+      "tagline": [
+        "AXI4",
+        "AXI4-Stream",
+        "Scatter/Gather"
+      ],
+      "summary": "DMA core between AXI4 memory and AXI4-Stream peripherals, register-compatible with the AMD AXI DMA so that its drivers run unchanged.",
+      "public": true,
+      "repo": "opendma",
+      "docs": true,
+      "trl": 3,
+      "trl_status": "Fully verified by simulation. Not yet tested on hardware, no flight heritage."
+    },
+    {
+      "name": "Open Logic FT",
+      "group": "building-blocks",
+      "tagline": [
+        "ECC",
+        "TMR",
+        "Safe FSMs"
+      ],
+      "summary": "Fault-tolerant fork of Open Logic: RAMs and FIFOs with SECDED ECC, clock crossings with triplicated synchronisers.",
+      "public": true,
+      "repo": "open-logic-ft",
+      "docs": true,
+      "trl": 3,
+      "trl_status": "Fully verified by simulation. Not yet tested on hardware, no flight heritage."
+    }
+  ]
+}

openspacehdl-0.0.1/src/openspacehdl/family.py

@@ -0,0 +1,71 @@
+"""The projects of the family, as the website shows them (data/family.json, written by tools/family_data.py)."""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from importlib import resources
+
+
+@dataclass(frozen=True)
+class Group:
+    id: str
+    title: str
+    summary: str
+
+
+@dataclass(frozen=True)
+class Project:
+    name: str
+    group: str
+    tagline: tuple[str, ...]
+    summary: str
+    public: bool
+    repo: str | None = None
+    docs: bool = False
+    trl: int | None = None
+    trl_status: str | None = None
+
+
+@dataclass(frozen=True)
+class Family:
+    site: str
+    github: str
+    source_commit: str
+    groups: tuple[Group, ...]
+    projects: tuple[Project, ...]
+
+    def docs_url(self, project: Project) -> str | None:
+        """Documentation site of a public project, or None."""
+        return f"{self.site}/{project.repo}/" if project.public and project.docs else None
+
+    def source_url(self, project: Project) -> str | None:
+        """Repository of a public project, or None."""
+        return f"{self.github}/{project.repo}" if project.public else None
+
+    def members(self, group: Group) -> list[Project]:
+        return [p for p in self.projects if p.group == group.id]
+
+    def find(self, name: str) -> Project | None:
+        """The project with this name or repository name, ignoring case, spaces and hyphens."""
+        key = _key(name)
+        for p in self.projects:
+            if key in (_key(p.name), _key(p.repo or "")):
+                return p
+        return None
+
+
+def _key(text: str) -> str:
+    return re.sub(r"[^a-z0-9]", "", text.lower())
+
+
+def load() -> Family:
+    data = json.loads(resources.files("openspacehdl").joinpath("data/family.json").read_text(encoding="utf-8"))
+    return Family(
+        site=data["site"],
+        github=data["github"],
+        source_commit=data["source"]["commit"],
+        groups=tuple(Group(**g) for g in data["groups"]),
+        projects=tuple(Project(**{**p, "tagline": tuple(p["tagline"])}) for p in data["projects"]),
+    )

openspacehdl-0.0.1/src/openspacehdl.egg-info/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: openspacehdl
+Version: 0.0.1
+Summary: Open Space HDL, open-source VHDL IP cores for spacecraft on-board data handling: early release that lists the family
+Author-email: Julian Schneider <julian.schneider@openspacehdl.org>
+License-Expression: MIT
+Project-URL: Homepage, https://openspacehdl.org
+Keywords: vhdl,fpga,ip-core,space,spacewire,spacefibre,ccsds,ecss
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Electronic Design Automation (EDA)
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# openspacehdl
+
+Python package of [Open Space HDL](https://openspacehdl.org), a family of open-source VHDL IP cores for spacecraft
+on-board data handling.
+
+This is an early release. It lists the projects of the family as the website shows them; it does not contain the
+cores or any tools yet.
+
+## Install
+
+```shell
+pip install openspacehdl
+```
+
+The package needs Python 3.10 or later and has no dependencies. On a machine without network access, copy the wheel
+and install it from the file:
+
+```shell
+pip install openspacehdl-<version>-py3-none-any.whl
+```
+
+## Use
+
+```shell
+openspacehdl --version          # version of the package
+openspacehdl info               # every project of the family: standard, summary, TRL, documentation and source
+openspacehdl info OpenFibre     # one project, by name or repository name
+```
+
+`python -m openspacehdl` works the same way.
+
+The list comes from the project cards of [openspacehdl.org](https://openspacehdl.org) at the time of the release.
+A project that is not yet public is listed as "Coming soon", without links.
+
+## Development
+
+```shell
+pip install -r requirements-dev.txt
+pip install -e .
+pytest
+python tools/family_data.py --site <clone of open-space-hdl.github.io> --check
+python -m build
+```
+
+`tools/family_data.py` writes `src/openspacehdl/data/family.json` from `_data/projects.yml` and
+`_data/project_groups.yml` of the website repository; `--check` only compares.
+
+## Licence
+
+The package is released under the [MIT License](LICENSE). The IP cores of the family have their own licence (PSI HDL
+Library License), stated in each repository.

openspacehdl-0.0.1/src/openspacehdl.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+CHANGELOG.md
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+requirements-dev.txt
+src/openspacehdl/__init__.py
+src/openspacehdl/__main__.py
+src/openspacehdl/cli.py
+src/openspacehdl/family.py
+src/openspacehdl.egg-info/PKG-INFO
+src/openspacehdl.egg-info/SOURCES.txt
+src/openspacehdl.egg-info/dependency_links.txt
+src/openspacehdl.egg-info/entry_points.txt
+src/openspacehdl.egg-info/top_level.txt
+src/openspacehdl/data/family.json
+tests/test_cli.py
+tools/family_data.py

openspacehdl-0.0.1/src/openspacehdl.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

openspacehdl-0.0.1/src/openspacehdl.egg-info/entry_points.txt

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

openspacehdl-0.0.1/src/openspacehdl.egg-info/top_level.txt

@@ -0,0 +1 @@
+openspacehdl

openspacehdl-0.0.1/tests/test_cli.py

@@ -0,0 +1,137 @@
+"""Tests of the command line: --version and info."""
+
+import json
+import re
+import subprocess
+import sys
+from importlib import resources
+
+import pytest
+
+from openspacehdl import __version__
+from openspacehdl.cli import main
+from openspacehdl.family import Family, Group, Project, load
+
+URL = re.compile(r"https?://")
+
+
+def data() -> dict:
+    return json.loads(resources.files("openspacehdl").joinpath("data/family.json").read_text(encoding="utf-8"))
+
+
+def blocks(text: str) -> dict[str, str]:
+    """The text of each project in the output of info, keyed by its name."""
+    names = [p["name"] for p in data()["projects"]]
+    found = {}
+    for block in text.split("\n\n"):
+        first = block.splitlines()[0].strip()
+        for n in names:
+            if first == n or first.startswith(n + "  "):
+                found[n] = block
+    return found
+
+
+def test_version(capsys):
+    with pytest.raises(SystemExit) as e:
+        main(["--version"])
+    assert e.value.code == 0
+    assert capsys.readouterr().out.strip() == f"openspacehdl {__version__}"
+
+
+def test_version_is_semantic():
+    assert re.fullmatch(r"\d+\.\d+\.\d+", __version__)
+
+
+def test_python_m():
+    r = subprocess.run([sys.executable, "-m", "openspacehdl", "--version"], capture_output=True, text=True)
+    assert r.returncode == 0
+    assert r.stdout.strip() == f"openspacehdl {__version__}"
+
+
+def test_no_command_prints_help(capsys):
+    assert main([]) == 0
+    assert "info" in capsys.readouterr().out
+
+
+def test_info_lists_every_card_in_group_order(capsys):
+    assert main(["info"]) == 0
+    out = capsys.readouterr().out
+    d = data()
+    assert set(blocks(out)) == {p["name"] for p in d["projects"]}
+    # Groups in the order of project_groups.yml, projects in the order of projects.yml within a group.
+    expected = [p["name"] for g in d["groups"] for p in d["projects"] if p["group"] == g["id"]]
+    assert [n for n in sorted(expected, key=out.index)] == expected
+    for g in d["groups"]:
+        if any(p["group"] == g["id"] for p in d["projects"]):
+            assert g["title"] in out
+
+
+def test_public_projects_show_trl_and_links(capsys):
+    main(["info"])
+    out = blocks(capsys.readouterr().out)
+    for p in data()["projects"]:
+        if not p["public"]:
+            continue
+        b = out[p["name"]]
+        assert f"Source: https://github.com/open-space-hdl/{p['repo']}" in b
+        assert ("Documentation: https://openspacehdl.org/" + p["repo"] + "/" in b) == p["docs"]
+        if p.get("trl"):
+            assert f"TRL {p['trl']}" in b.splitlines()[0]
+
+
+def test_coming_soon_projects_have_no_links_and_no_trl(capsys):
+    main(["info"])
+    out = blocks(capsys.readouterr().out)
+    hidden = [p for p in data()["projects"] if not p["public"]]
+    assert hidden, "the data has no Coming soon card to test"
+    for p in hidden:
+        b = out[p["name"]]
+        assert "Coming soon" in b.splitlines()[0]
+        assert not URL.search(b)
+        assert "TRL" not in b
+        assert "Source:" not in b and "Documentation:" not in b and "Status:" not in b
+
+
+def test_coming_soon_data_keeps_only_card_fields():
+    for p in data()["projects"]:
+        if not p["public"]:
+            assert set(p) == {"name", "group", "tagline", "summary", "public"}
+
+
+@pytest.mark.parametrize("name", ["OpenFibre", "openfibre", "OPENFIBRE", "Open Logic FT", "open-logic-ft"])
+def test_info_one_project(capsys, name):
+    assert main(["info", name]) == 0
+    out = capsys.readouterr().out
+    expected = load().find(name)
+    assert expected is not None
+    assert out.splitlines()[0].strip().startswith(expected.name)
+    assert len(blocks(out)) == 1
+
+
+def test_info_unknown_project(capsys):
+    assert main(["info", "NoSuchCore"]) == 2
+    err = capsys.readouterr().err
+    assert "NoSuchCore" in err
+    assert "OpenFibre" in err
+
+
+def test_data_names_the_website_commit():
+    d = data()
+    assert d["source"]["repository"] == "open-space-hdl/open-space-hdl.github.io"
+    assert re.fullmatch(r"[0-9a-f]{40}", d["source"]["commit"])
+
+
+def test_find_by_repository_name():
+    g = Group("g", "G", "")
+    p = Project(name="Example Core", group="g", tagline=(), summary="", public=True, repo="excore")
+    f = Family(
+        site="https://example.org", github="https://example.org/gh", source_commit="0" * 40, groups=(g,), projects=(p,)
+    )
+    assert f.find("excore") is p
+    assert f.find("example-core") is p
+    assert f.find("other") is None
+    assert f.docs_url(p) is None
+    assert f.source_url(p) == "https://example.org/gh/excore"
+    hidden = Project(name="Hidden", group="g", tagline=(), summary="", public=False, repo="hidden", docs=True)
+    assert f.source_url(hidden) is None
+    assert f.docs_url(hidden) is None

openspacehdl-0.0.1/tools/family_data.py

@@ -0,0 +1,91 @@
+"""Writes src/openspacehdl/data/family.json from the project cards of the website.
+
+The cards come from _data/projects.yml and _data/project_groups.yml of the website repository
+(open-space-hdl/open-space-hdl.github.io) at one commit. The file keeps only what a card shows: a project that is
+not public keeps its name, group, tagline and summary, without repository, links or TRL, as its "Coming soon" card.
+
+    python tools/family_data.py --site <clone of the website> [--commit <rev>] [--check]
+
+--commit defaults to origin/main. --check compares the file with what the commit gives and writes nothing; the exit
+status is 1 when they differ.
+
+Needs PyYAML (development only; the package itself has no dependencies).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import yaml
+
+ROOT = Path(__file__).resolve().parent.parent
+OUT = ROOT / "src" / "openspacehdl" / "data" / "family.json"
+SITE_REPO = "open-space-hdl/open-space-hdl.github.io"
+
+
+def git(site: Path, *args: str) -> str:
+    return subprocess.run(
+        ["git", "-C", str(site), *args], check=True, capture_output=True, text=True, encoding="utf-8"
+    ).stdout
+
+
+def card(project: dict) -> dict:
+    """The fields a card of the website shows (_includes/project-card.html)."""
+    out = {
+        "name": project["name"],
+        "group": project["group"],
+        "tagline": list(project.get("tagline") or []),
+        "summary": project["summary"],
+        "public": bool(project.get("public")),
+    }
+    if out["public"]:
+        out["repo"] = project["repo"]
+        out["docs"] = bool(project.get("docs"))
+        if project.get("trl"):
+            out["trl"] = int(project["trl"])
+            out["trl_status"] = project.get("trl_status", "")
+    return out
+
+
+def build(site: Path, commit: str) -> dict:
+    sha = git(site, "rev-parse", "--verify", f"{commit}^{{commit}}").strip()
+    config = yaml.safe_load(git(site, "show", f"{sha}:_config.yml"))
+    groups = yaml.safe_load(git(site, "show", f"{sha}:_data/project_groups.yml"))
+    projects = yaml.safe_load(git(site, "show", f"{sha}:_data/projects.yml"))
+    ids = [g["id"] for g in groups]
+    return {
+        "source": {"repository": SITE_REPO, "commit": sha},
+        "site": config["url"],
+        "github": config["github_org"],
+        "groups": [{"id": g["id"], "title": g["title"], "summary": g["summary"]} for g in groups],
+        # The start page shows a project only under a known group, in the order of projects.yml.
+        "projects": [card(p) for p in projects if p.get("group") in ids],
+    }
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument("--site", type=Path, required=True, help="clone of the website repository")
+    parser.add_argument("--commit", default="origin/main", help="revision of the website (default origin/main)")
+    parser.add_argument("--check", action="store_true", help="compare only, write nothing")
+    args = parser.parse_args(argv)
+
+    text = json.dumps(build(args.site, args.commit), indent=2, ensure_ascii=False) + "\n"
+    if args.check:
+        current = OUT.read_text(encoding="utf-8") if OUT.exists() else ""
+        if current != text:
+            print(f"{OUT.relative_to(ROOT)} differs from {args.commit} of the website", file=sys.stderr)
+            return 1
+        print(f"{OUT.relative_to(ROOT)} is current")
+        return 0
+    OUT.write_text(text, encoding="utf-8", newline="\n")
+    print(f"wrote {OUT.relative_to(ROOT)}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())