jupyter-opensysml-kernel 0.9.3.dev20261008__py3-none-win_amd64.whl

jupyter_opensysml_kernel/__init__.py

@@ -0,0 +1,14 @@
+"""Jupyter kernel for SysML v2, backed by the OpenSysML REPL.
+
+The kernel itself is the `sysml-jupyter-kernel` binary every OpenSysML release
+publishes. A platform wheel of this package bundles the build for its machine
+and registers it as the `sysml` kernelspec when it is installed. An install
+from the sdist, or on another platform, downloads the build for the machine,
+verifies it against the digest pinned here for that release, and registers it::
+
+    python -m jupyter_opensysml_kernel install
+"""
+
+from ._version import VERSION as __version__
+
+__all__ = ["__version__"]

jupyter_opensysml_kernel/__main__.py

@@ -0,0 +1,168 @@
+"""`python -m jupyter_opensysml_kernel`: start the bundled kernel, or install or remove the kernelspec.
+
+Given the kernel's own flags (`-connection-file FILE`, the form the kernelspec a
+platform wheel installs uses), the bundled `sysml-jupyter-kernel` is started
+with them; given a subcommand, the kernelspec is managed.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import stat
+import subprocess
+import sys
+from collections.abc import Sequence
+
+from . import kernelspec
+from ._version import VERSION
+from .binary import BINARY_MODE, KernelBinaryError, binary_name, bundled_binary
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="jupyter-opensysml-kernel",
+        description="Install the SysML v2 (OpenSysML) Jupyter kernel.",
+        epilog="Kernel flags (-connection-file FILE, -version, ...) start the kernel bundled in this package.",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {VERSION}")
+    commands = parser.add_subparsers(dest="command", required=True)
+
+    install = commands.add_parser(
+        "install",
+        help="register the kernelspec, with the bundled kernel binary or a verified download of the release's",
+    )
+    where = install.add_mutually_exclusive_group()
+    where.add_argument("--user", action="store_true", help="install for the current user")
+    where.add_argument("--sys-prefix", action="store_true", help="install into the current Python environment")
+    where.add_argument("--prefix", metavar="DIR", help="install under DIR/share/jupyter")
+    where.add_argument("--system", action="store_true", help="install system-wide")
+    install.add_argument("--binary", metavar="PATH", help="install this sysml-jupyter-kernel instead of the bundled or downloaded one")
+    install.add_argument("--release", metavar="TAG", help="download the kernel of this release (default: the bundled kernel, or the release this package pins)")
+    install.add_argument("--name", default=kernelspec.KERNEL_NAME, help="kernelspec name (default: %(default)s)")
+    install.add_argument("--display-name", default=kernelspec.DISPLAY_NAME, help="name shown by front ends (default: %(default)s)")
+
+    uninstall = commands.add_parser("uninstall", help="remove the kernelspec and the kernel binary in it")
+    uninstall.add_argument("--name", default=kernelspec.KERNEL_NAME, help="kernelspec name (default: %(default)s)")
+
+    commands.add_parser("kernelspec", help="print the kernel.json an install writes")
+    return parser
+
+
+def is_kernel_invocation(argv: Sequence[str]) -> bool:
+    """Whether the arguments are the kernel's (single-dash flags), not a subcommand."""
+    return bool(argv) and argv[0].startswith("-") and not argv[0].startswith("--") and argv[0] != "-h"
+
+
+# The kernel's flags the launcher forwards: the one Jupyter passes, and the
+# ones that only print. Those of the native `-install` are not among them; the
+# `install` subcommand is the package's way to the same end.
+CONNECTION_FILE_FLAG = "-connection-file"
+KERNEL_SWITCHES = frozenset({"-verbose", "-version", "-man", "-print-kernelspec"})
+
+
+class KernelArgumentError(KernelBinaryError):
+    """Arguments that are not the kernel's flags, so are not passed to it."""
+
+
+def kernel_arguments(argv: Sequence[str]) -> list[str]:
+    """The kernel's command line for the arguments, each checked against its flag.
+
+    Raises:
+        KernelArgumentError: If an argument is not a kernel flag, or names no
+            connection file
+    """
+    command: list[str] = []
+    connection_file: str | None = None
+    args = iter(argv)
+    for arg in args:
+        flag, has_value, value = arg.partition("=")
+        if flag == CONNECTION_FILE_FLAG:
+            if not has_value:
+                value = next(args, "")
+            if connection_file is not None:
+                raise KernelArgumentError(f"kernel flag {flag} is given twice")
+            if not value or not os.path.isfile(value):
+                raise KernelArgumentError(f"kernel flag {flag} needs the connection file Jupyter wrote, not {value!r}")
+            connection_file = value
+            command += [flag, value]
+        elif flag in KERNEL_SWITCHES and not has_value:
+            command.append(flag)
+        else:
+            raise KernelArgumentError(
+                f"{arg!r} is not a kernel flag; the kernel takes {CONNECTION_FILE_FLAG} FILE and "
+                + ", ".join(sorted(KERNEL_SWITCHES))
+            )
+    return command
+
+
+def launch(argv: Sequence[str]) -> int:
+    """Run the bundled kernel with the given arguments, in this process where the OS allows.
+
+    Raises:
+        KernelBinaryError: If this install bundles no kernel, or the arguments
+            are not its flags
+    """
+    path = bundled_binary()
+    if path is None:
+        raise KernelBinaryError(
+            f"this install of {kernelspec.PACKAGE} bundles no {binary_name()} (it was not installed "
+            "from a platform wheel); `python -m jupyter_opensysml_kernel install` registers a verified one"
+        )
+    command = [path, *kernel_arguments(argv)]
+    if sys.platform == "win32":
+        process = subprocess.Popen(command)
+        try:
+            return process.wait()
+        except BaseException:
+            process.terminate()
+            raise
+    if stat.S_IMODE(os.stat(path).st_mode) != BINARY_MODE:
+        try:
+            os.chmod(path, BINARY_MODE)
+        except OSError:
+            # Another user's, or a read-only, install: not ours to tighten, as long as it runs.
+            if not os.access(path, os.X_OK):
+                raise
+    os.execv(path, command)
+    return 0  # pragma: no cover - execv does not return
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    if argv is None:
+        argv = sys.argv[1:]
+    try:
+        if is_kernel_invocation(argv):
+            return launch(argv)
+        args = build_parser().parse_args(argv)
+        if args.command == "install":
+            prefix = args.prefix
+            if args.sys_prefix:
+                prefix = sys.prefix
+            user = args.user
+            if args.system:
+                prefix = "/usr/local" if sys.platform != "win32" else sys.prefix
+            path = kernelspec.install(
+                binary=args.binary,
+                version=args.release,
+                user=user,
+                prefix=prefix,
+                name=args.name,
+                display_name=args.display_name,
+            )
+            print(f"Installed kernelspec {args.name} in {path}")
+        elif args.command == "uninstall":
+            path = kernelspec.uninstall(args.name)
+            print(f"Removed kernelspec {args.name} from {path}")
+        else:
+            json.dump(kernelspec.kernel_json(binary_name()), sys.stdout, indent=2, sort_keys=True)
+            print()
+    except (KernelBinaryError, kernelspec.InvalidKernelNameError) as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

jupyter_opensysml_kernel/_version.py

@@ -0,0 +1,8 @@
+"""The one place the jupyter-opensysml-kernel version is written.
+
+The package is released in lockstep with the core and the opensysml client:
+`client/python/scripts/check_version.py --jupyter-kernel` compares this value
+with the tag and with client/python/opensysml/_version.py before a release.
+"""
+
+VERSION = "0.9.3.dev20261008"

jupyter_opensysml_kernel/bin/sysml-jupyter-kernel

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: jupyter_opensysml_kernel/bin/sysml-jupyter-kernel
+size: 42670002 bytes
+sha256: 0689b94a71f7a915305e5516889620a8385f2eda4df0b8420a4bc6b2ad3a2b2f

jupyter_opensysml_kernel/bin/sysml-jupyter-kernel.exe

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: jupyter_opensysml_kernel/bin/sysml-jupyter-kernel.exe
+size: 46546432 bytes
+sha256: e0db31ccddd5af405c4e6f30bc6f8e549f983b03124f31ddfe68933328d5e409

jupyter_opensysml_kernel/binary.py

@@ -0,0 +1,316 @@
+"""Fetching the kernel binary of a release, verified against a pinned digest.
+
+A release publishes `sysml-jupyter-kernel-<os>-<arch>[.exe]` for each supported
+platform beside a `.sha256` sidecar. The sidecar comes from whoever served the
+binary, so it is only a consistency check; what the download is held to is the
+digest this package shipped with for the release it was built against, which
+is independent of the serving origin. Nothing unpinned is ever installed.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import platform
+import re
+import tempfile
+import urllib.error
+import urllib.request
+
+from ._version import VERSION
+
+# Permissions of an installed kernel binary: its owner writes it, everyone
+# runs it, as a system-wide kernelspec needs.
+BINARY_MODE = 0o755
+
+DEFAULT_GITHUB_REPO = "Open-MBEE/OpenSysML"
+GITHUB_REPO_ENV = "OPENSYSML_GITHUB_REPO"
+
+#: The kernel binary, as every release publishes and installs it.
+BINARY_NAME = "sysml-jupyter-kernel"
+ASSET_PREFIX = BINARY_NAME + "-"
+SIDECAR_SUFFIX = ".sha256"
+
+#: The moving alias of the newest nightly snapshot; per-night releases are tagged
+#: `nightly-<yyyymmdd>-<commit>`, and a snapshot of this package pins its own.
+SNAPSHOT_TAG = "nightly"
+
+NETWORK_TIMEOUT = 30
+#: Bounds on what is read from the network, so a misbehaving origin cannot fill memory.
+MAX_BINARY_BYTES = 512 * 1024 * 1024
+MAX_SIDECAR_BYTES = 4096
+
+PINNED_DIGESTS_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "release-digests.json")
+
+_SHA256 = re.compile(r"[0-9a-f]{64}\Z")
+_VERSION_FORM = re.compile(
+    r"^(?P<release>\d+\.\d+\.\d+)(?:(?P<phase>a|b|rc)(?P<number>\d+))?(?:\.dev(?P<snapshot>\d+))?$"
+)
+_SEMVER_PHASE = {"a": "alpha", "b": "beta", "rc": "rc"}
+
+
+class KernelBinaryError(Exception):
+    """The kernel binary could not be obtained."""
+
+
+class UnsupportedPlatformError(KernelBinaryError):
+    """No release publishes a kernel for this operating system or architecture."""
+
+
+class UnpinnedReleaseError(KernelBinaryError):
+    """This package pins no digest for the asset, so it cannot be verified."""
+
+
+class ChecksumMismatchError(KernelBinaryError):
+    """What was downloaded does not hash to the pinned digest."""
+
+
+class DownloadError(KernelBinaryError):
+    """The release could not be reached, or served something malformed."""
+
+
+def _load_pinned_digests() -> dict[str, dict[str, dict[str, str]]]:
+    with open(PINNED_DIGESTS_FILE, encoding="utf-8") as f:
+        table = json.load(f)
+    if not isinstance(table, dict):
+        raise KernelBinaryError(f"{PINNED_DIGESTS_FILE} is not a digest table")
+    return table
+
+
+#: repo -> release tag -> asset name -> SHA-256 hex digest.
+PINNED_SHA256 = _load_pinned_digests()
+
+
+def default_github_repo() -> str:
+    """The repository releases are downloaded from: $OPENSYSML_GITHUB_REPO or the default."""
+    return os.environ.get(GITHUB_REPO_ENV) or DEFAULT_GITHUB_REPO
+
+
+def detect_platform() -> tuple[str, str]:
+    """This machine as the (GOOS, GOARCH) pair a release names its builds by.
+
+    Raises:
+        UnsupportedPlatformError: If no release is published for the machine
+    """
+    system = platform.system().lower()
+    goos = {"linux": "linux", "darwin": "darwin", "windows": "windows"}.get(system)
+    if goos is None:
+        raise UnsupportedPlatformError(
+            f"unsupported operating system {platform.system()!r}: releases are built for "
+            "Linux, macOS and Windows; `go build ./cmd/sysml-jupyter-kernel` builds one "
+            "here, to install with --binary"
+        )
+    machine = platform.machine().lower()
+    goarch = {"x86_64": "amd64", "amd64": "amd64", "aarch64": "arm64", "arm64": "arm64"}.get(machine)
+    if goarch is None or (goos == "windows" and goarch != "amd64"):
+        raise UnsupportedPlatformError(
+            f"unsupported architecture {platform.machine()!r} on {goos}: releases are built "
+            "for amd64 and arm64 (amd64 alone on Windows); `go build ./cmd/sysml-jupyter-kernel` "
+            "builds one here, to install with --binary"
+        )
+    return goos, goarch
+
+
+def binary_name(goos: str | None = None) -> str:
+    """The file the kernel is installed as: `sysml-jupyter-kernel`, `.exe` on Windows."""
+    if goos is None:
+        goos = platform.system().lower()
+    return BINARY_NAME + ".exe" if goos == "windows" else BINARY_NAME
+
+
+def release_asset_name(goos: str | None = None, goarch: str | None = None) -> str:
+    """The asset a release publishes the kernel for a platform under."""
+    if goos is None or goarch is None:
+        detected_os, detected_arch = detect_platform()
+        goos = goos or detected_os
+        goarch = goarch or detected_arch
+    name = f"{ASSET_PREFIX}{goos}-{goarch}"
+    return name + ".exe" if goos == "windows" else name
+
+
+BUNDLED_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "bin")
+
+# The wheel tags a platform's build is published under. The Linux kernels are
+# static, so one wheel serves glibc and musl systems; the macOS floor is Go's.
+WHEEL_PLATFORM_TAGS = {
+    ("linux", "amd64"): "manylinux_2_17_x86_64.manylinux2014_x86_64.musllinux_1_1_x86_64",
+    ("linux", "arm64"): "manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64",
+    ("darwin", "amd64"): "macosx_11_0_x86_64",
+    ("darwin", "arm64"): "macosx_11_0_arm64",
+    ("windows", "amd64"): "win_amd64",
+}
+
+
+def bundled_binary() -> str | None:
+    """The kernel a platform wheel carries, or None in an install from the sdist."""
+    path = os.path.join(BUNDLED_DIR, binary_name())
+    return path if os.path.isfile(path) else None
+
+
+def wheel_platform_tag(goos: str, goarch: str) -> str:
+    """The platform tag of the wheel that bundles the kernel built for (GOOS, GOARCH).
+
+    Raises:
+        UnsupportedPlatformError: If no release is built for the pair
+    """
+    try:
+        return WHEEL_PLATFORM_TAGS[(goos, goarch)]
+    except KeyError:
+        raise UnsupportedPlatformError(f"no kernel is released for {goos}-{goarch}") from None
+
+
+def built_against_releases(version: str | None = None, github_repo: str | None = None) -> list[str]:
+    """The release tags a version of this package (by default, this one) was built against.
+
+    A release version names its tag; a pre-release both spellings the tag may
+    use; a snapshot (`.dev<yyyymmdd>`) the per-night releases its table pins for
+    that date, else the moving alias.
+    """
+    if version is None:
+        version = VERSION
+    match = _VERSION_FORM.fullmatch(version)
+    if match is None:
+        return [f"v{version}"]
+    if match["snapshot"] is not None:
+        repo = github_repo or default_github_repo()
+        prefix = f"{SNAPSHOT_TAG}-{match['snapshot']}-"
+        pinned = sorted(tag for tag in PINNED_SHA256.get(repo, {}) if tag.startswith(prefix))
+        return pinned or [SNAPSHOT_TAG]
+    if match["phase"] is None:
+        return [f"v{match['release']}"]
+    suffix = _SEMVER_PHASE[match["phase"]]
+    return [
+        f"v{match['release']}-{suffix}{match['number']}",
+        f"v{match['release']}-{suffix}.{match['number']}",
+    ]
+
+
+def pinned_digest(version: str, asset: str, github_repo: str | None = None) -> str | None:
+    """The digest this package pins for an asset of a release, or None."""
+    repo = github_repo or default_github_repo()
+    return PINNED_SHA256.get(repo, {}).get(version, {}).get(asset)
+
+
+def pinned_release(asset: str | None = None, github_repo: str | None = None) -> str:
+    """The release this package installs by default: the one it was built
+    against that pins the asset for this machine.
+
+    Raises:
+        UnpinnedReleaseError: If none of them pins it
+    """
+    asset = asset or release_asset_name()
+    candidates = built_against_releases(github_repo=github_repo)
+    for tag in candidates:
+        if pinned_digest(tag, asset, github_repo) is not None:
+            return tag
+    raise UnpinnedReleaseError(
+        f"jupyter-opensysml-kernel {VERSION} pins no digest for {asset} of "
+        f"{' or '.join(candidates)}, so it cannot verify a download of it. "
+        "Pass --version with a release this package pins, or --binary with a "
+        "sysml-jupyter-kernel built or downloaded and verified by hand."
+    )
+
+
+def release_download_url(version: str, asset: str, github_repo: str | None = None) -> str:
+    """The URL a release publishes an asset at."""
+    repo = github_repo or default_github_repo()
+    return f"https://github.com/{repo}/releases/download/{version}/{asset}"
+
+
+def fetch(url: str, limit: int) -> bytes:
+    """What a URL serves, up to a size bound.
+
+    Raises:
+        DownloadError: If the URL cannot be read or serves more than the bound
+    """
+    try:
+        with urllib.request.urlopen(url, timeout=NETWORK_TIMEOUT) as response:
+            data: bytes = response.read(limit + 1)
+    except (urllib.error.URLError, OSError, ValueError) as e:
+        raise DownloadError(f"cannot download {url}: {e}") from e
+    if len(data) > limit:
+        raise DownloadError(f"{url} serves more than the {limit} bytes allowed for it")
+    return data
+
+
+def sidecar_digest(url: str) -> str:
+    """The digest a `.sha256` sidecar serves, in `sha256sum` form or bare.
+
+    Raises:
+        DownloadError: If the sidecar is missing or malformed
+    """
+    text = fetch(url, MAX_SIDECAR_BYTES).decode("ascii", errors="replace")
+    fields = text.split()
+    if not fields or _SHA256.fullmatch(fields[0]) is None:
+        raise DownloadError(f"{url} does not serve a SHA-256 digest")
+    return fields[0]
+
+
+def download_binary(
+    dest_dir: str,
+    version: str | None = None,
+    github_repo: str | None = None,
+) -> str:
+    """Download the kernel for this machine into a directory, verified.
+
+    The download is hashed and compared with the digest this package pins for
+    the release before anything is written; the served sidecar must agree too,
+    so an inconsistent release is refused rather than trusted on one side.
+
+    Args:
+        dest_dir: Directory the binary is written into, under its installed name
+        version: Release tag; the package's own pinned release when omitted
+        github_repo: GitHub repository (owner/repo)
+
+    Returns:
+        The path of the verified binary
+
+    Raises:
+        UnpinnedReleaseError: If this package pins no digest for the asset
+        ChecksumMismatchError: If the download or the sidecar disagrees with the pin
+        DownloadError: If the release cannot be reached
+    """
+    asset = release_asset_name()
+    if version is None:
+        version = pinned_release(asset, github_repo)
+    expected = pinned_digest(version, asset, github_repo)
+    if expected is None:
+        raise UnpinnedReleaseError(
+            f"jupyter-opensysml-kernel {VERSION} pins no digest for {asset} of {version}, "
+            "so it cannot verify a download of it. Install the package released with "
+            f"{version}, or pass --binary with a sysml-jupyter-kernel verified by hand."
+        )
+    url = release_download_url(version, asset, github_repo)
+    served = sidecar_digest(url + SIDECAR_SUFFIX)
+    if served != expected:
+        raise ChecksumMismatchError(
+            f"{asset}{SIDECAR_SUFFIX} of {version} serves {served}, but this package pins "
+            f"{expected}; the release is not the one this package was built against"
+        )
+    data = fetch(url, MAX_BINARY_BYTES)
+    actual = hashlib.sha256(data).hexdigest()
+    if actual != expected:
+        raise ChecksumMismatchError(
+            f"{asset} of {version} hashes to {actual}, not the pinned {expected}; "
+            "the download is corrupt or tampered with, and was not installed"
+        )
+    return write_binary(data, os.path.join(dest_dir, binary_name()))
+
+
+def write_binary(data: bytes, path: str) -> str:
+    """Write verified bytes to a path atomically, executable."""
+    os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
+    fd, tmp = tempfile.mkstemp(prefix=".kernel-", dir=os.path.dirname(path) or ".")
+    try:
+        with os.fdopen(fd, "wb") as f:
+            f.write(data)
+        os.chmod(tmp, BINARY_MODE)
+        os.replace(tmp, path)
+    except BaseException:
+        try:
+            os.unlink(tmp)
+        except OSError:
+            pass
+        raise
+    return path

jupyter_opensysml_kernel/kernelspec.py

@@ -0,0 +1,212 @@
+"""The `sysml` kernelspec, and installing it where Jupyter looks.
+
+A kernelspec is a directory holding a `kernel.json` and, here, the logos front
+ends show for the kernel. A platform wheel installs one under
+`<prefix>/share/jupyter/kernels/sysml` as package data, whose command line is
+`python -m jupyter_opensysml_kernel`, which starts the kernel bundled in the
+wheel; `pip install` alone registers the kernel. `install` writes a kernelspec
+holding the kernel binary itself, named through the `{resource_dir}`
+placeholder Jupyter substitutes with the directory the spec was found in, so
+that spec can be installed per user, into a prefix, or copied, and
+`jupyter kernelspec remove sysml` removes everything it wrote.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from importlib import resources
+import shutil
+import stat
+import sys
+import tempfile
+from typing import Any
+
+from ._version import VERSION
+from .binary import BINARY_MODE, KernelBinaryError, binary_name, bundled_binary, download_binary
+
+KERNEL_NAME = "sysml"
+DISPLAY_NAME = "SysML v2 (OpenSysML)"
+LANGUAGE = "sysml"
+IMPLEMENTATION = "sysml-jupyter-kernel"
+PACKAGE = "jupyter-opensysml-kernel"
+SPEC_FILE = "kernel.json"
+# Permissions of kernel.json and the logos: owner writes, everyone reads.
+SPEC_MODE = 0o644
+LOGO_FILES = ("logo-32x32.png", "logo-64x64.png")
+
+# One directory name under the kernels directory: no path, and no name beginning
+# with a dot, `..` above all, which jupyter_client's own check lets through.
+KERNEL_NAME_PATTERN = re.compile(r"[a-z0-9][a-z0-9._-]*", re.IGNORECASE)
+
+
+class InvalidKernelNameError(ValueError):
+    """A kernelspec name that is not one directory name."""
+
+
+def validate_name(name: str) -> str:
+    """The kernelspec name, if it is one that stays inside the kernels directory.
+
+    Raises:
+        InvalidKernelNameError: For a path, an empty name, or one beginning with a dot
+    """
+    if KERNEL_NAME_PATTERN.fullmatch(name) is None:
+        raise InvalidKernelNameError(
+            f"kernelspec name {name!r} must be letters, digits, '.', '_' or '-', "
+            "beginning with a letter or digit"
+        )
+    return name
+
+
+def _spec(argv: list[str], display_name: str) -> dict[str, Any]:
+    return {
+        "argv": argv,
+        "display_name": display_name,
+        "language": LANGUAGE,
+        "interrupt_mode": "message",
+        "metadata": {"implementation": IMPLEMENTATION, "package": PACKAGE, "package_version": VERSION},
+    }
+
+
+def kernel_json(binary_file: str, display_name: str = DISPLAY_NAME) -> dict[str, Any]:
+    """The `kernel.json` for a kernel binary installed beside it."""
+    return _spec(["{resource_dir}/" + binary_file, "-connection-file", "{connection_file}"], display_name)
+
+
+def launcher_kernel_json(display_name: str = DISPLAY_NAME) -> dict[str, Any]:
+    """The `kernel.json` a platform wheel installs: the kernel it bundles, started
+    through the `python` of the environment Jupyter runs in, as ipykernel's is."""
+    return _spec(["python", "-m", __package__, "-connection-file", "{connection_file}"], display_name)
+
+
+def stage_binary(binary: str, staging_dir: str) -> str:
+    """Copy a kernel binary supplied by hand into the spec being built.
+
+    Raises:
+        KernelBinaryError: If the path is not an executable file
+    """
+    if not os.path.isfile(binary):
+        raise KernelBinaryError(f"{binary} is not a file")
+    if sys.platform != "win32" and not os.access(binary, os.X_OK):
+        raise KernelBinaryError(f"{binary} is not executable")
+    dest = os.path.join(staging_dir, binary_name())
+    shutil.copyfile(binary, dest)
+    os.chmod(dest, BINARY_MODE)
+    return dest
+
+
+def _write_json(spec: dict[str, Any], staging_dir: str) -> str:
+    path = os.path.join(staging_dir, SPEC_FILE)
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(spec, f, indent=2, sort_keys=True)
+        f.write("\n")
+    os.chmod(path, SPEC_MODE)
+    return path
+
+
+def write_spec(staging_dir: str, binary_path: str, display_name: str = DISPLAY_NAME) -> str:
+    """Write `kernel.json` beside a staged binary."""
+    return _write_json(kernel_json(os.path.basename(binary_path), display_name), staging_dir)
+
+
+def write_launcher_spec(staging_dir: str) -> list[str]:
+    """Write the kernelspec a platform wheel ships as data: `kernel.json` and the logos."""
+    return [_write_json(launcher_kernel_json(), staging_dir), *write_logos(staging_dir)]
+
+
+def write_logos(staging_dir: str) -> list[str]:
+    """Put the OpenSysML mark beside `kernel.json`, at the sizes front ends read."""
+    written = []
+    for name in LOGO_FILES:
+        path = os.path.join(staging_dir, name)
+        with open(path, "wb") as f:
+            f.write(resources.files(__package__).joinpath(name).read_bytes())
+        written.append(path)
+    return written
+
+
+def default_location() -> dict[str, Any]:
+    """Where an install goes when no location is asked for.
+
+    Inside a virtual environment or a conda environment the kernel belongs to
+    that environment (`--sys-prefix`); elsewhere it is installed for the user.
+    """
+    in_env = sys.prefix != getattr(sys, "base_prefix", sys.prefix) or "CONDA_PREFIX" in os.environ
+    return {"prefix": sys.prefix} if in_env else {"user": True}
+
+
+def install(
+    binary: str | None = None,
+    version: str | None = None,
+    user: bool = False,
+    prefix: str | None = None,
+    name: str = KERNEL_NAME,
+    display_name: str = DISPLAY_NAME,
+    github_repo: str | None = None,
+) -> str:
+    """Install the kernelspec, with the kernel binary inside it.
+
+    The binary is the one bundled in this package when it was installed from a
+    platform wheel; otherwise it is downloaded and verified.
+
+    Args:
+        binary: A `sysml-jupyter-kernel` to install instead of the bundled or downloaded one
+        version: The release to download, instead of the bundled kernel; the package's
+            pinned release when omitted
+        user: Install for the current user (`~/.local/share/jupyter`, or $JUPYTER_DATA_DIR)
+        prefix: Install under `<prefix>/share/jupyter`
+        name: The kernelspec's directory name, which notebooks bind to
+        display_name: The name front ends list the kernel under
+        github_repo: GitHub repository (owner/repo) the release is downloaded from
+
+    Returns:
+        The directory the kernelspec was installed into
+
+    Raises:
+        KernelBinaryError: If no verified binary could be obtained
+        InvalidKernelNameError: If name is not one directory name
+    """
+    from jupyter_client.kernelspec import KernelSpecManager
+
+    validate_name(name)
+    if binary is not None and version is not None:
+        raise KernelBinaryError("--binary names the kernel to install; --version chooses one to download")
+    if binary is None and version is None:
+        binary = bundled_binary()
+    if not user and prefix is None:
+        location = default_location()
+        user = bool(location.get("user"))
+        prefix = location.get("prefix")
+    with tempfile.TemporaryDirectory(prefix="jupyter-opensysml-kernel-") as staging:
+        if binary is not None:
+            staged = stage_binary(binary, staging)
+        else:
+            staged = download_binary(staging, version=version, github_repo=github_repo)
+        write_spec(staging, staged, display_name)
+        write_logos(staging)
+        destination: str = KernelSpecManager().install_kernel_spec(
+            staging, kernel_name=name, user=user, prefix=prefix
+        )
+    return destination
+
+
+def uninstall(name: str = KERNEL_NAME) -> str:
+    """Remove the installed kernelspec and the binary inside it.
+
+    Returns:
+        The directory that was removed
+
+    Raises:
+        KernelBinaryError: If no kernelspec of that name is installed
+        InvalidKernelNameError: If name is not one directory name
+    """
+    from jupyter_client.kernelspec import KernelSpecManager, NoSuchKernel
+
+    validate_name(name)
+    manager = KernelSpecManager()
+    try:
+        removed: str = manager.remove_kernel_spec(name)
+    except (NoSuchKernel, KeyError) as e:
+        raise KernelBinaryError(f"no kernelspec named {name!r} is installed") from e
+    return removed

jupyter_opensysml_kernel/release-digests.json

@@ -0,0 +1,165 @@
+{
+  "Open-MBEE/OpenSysML": {
+    "nightly-20261008-9bb631957": {
+      "sysml-jupyter-kernel-darwin-amd64": "f99371a2ad4aad87653d853bd04011a4ecb4144e69c5cec78f7a8ef361852a97",
+      "sysml-jupyter-kernel-darwin-arm64": "0689b94a71f7a915305e5516889620a8385f2eda4df0b8420a4bc6b2ad3a2b2f",
+      "sysml-jupyter-kernel-linux-amd64": "0c4eed2827b96b4cf9a05af5f6f67f70ec2001bda8ca282ec4b53f9188b5a816",
+      "sysml-jupyter-kernel-linux-arm64": "ca8fb5cae84a43893398f8dadaaf70fdd90c0b005d5d3c286fde14e36c1909ea",
+      "sysml-jupyter-kernel-windows-amd64.exe": "e0db31ccddd5af405c4e6f30bc6f8e549f983b03124f31ddfe68933328d5e409"
+    },
+    "v0.0.5": {
+      "sysml-grpc-darwin-amd64": "ab2933f168341bed3157bac0026d2c5a51bdb1c4629618178123f7ca8e071e72",
+      "sysml-grpc-darwin-arm64": "6e839899c93954671d39ebc91a751302d8329864e9671fc38f7549aa52bddde9",
+      "sysml-grpc-linux-amd64": "9bc8203f05a3dfa3d5c4b784f87e38d70f0db416732a73ddf56aaa4c57c2a566",
+      "sysml-grpc-linux-arm64": "fd6addc9cb717787d12225c3092d653708e6f5aac19d987582228180b529ca13",
+      "sysml-grpc-windows-amd64.exe": "0033248b904e0d10f83a5e033953372108ccad024ae530092431325339bc1179"
+    },
+    "v0.0.6": {
+      "sysml-grpc-darwin-amd64": "5954ae0838858ea585943c7a986a049ac9109874047310e9612b292259c07937",
+      "sysml-grpc-darwin-arm64": "a46792146388f0ed8b736754c6f675d287769bb026a8dd5503f1abc8ed9036c3",
+      "sysml-grpc-linux-amd64": "cb6a4a6152b79321c1d432cdc895acd4d0c4d8e43dd72d38ce6b07d7ce427dd6",
+      "sysml-grpc-linux-arm64": "8133f113c07b6f9f2772077add61c3c7e4ba3065000e8405d2c01bc67f3ec17d",
+      "sysml-grpc-windows-amd64.exe": "ae01081af3acc467fad7dbbfce10ec15c9307995a98a30773885622ba2e467db"
+    },
+    "v0.0.7": {
+      "sysml-grpc-darwin-amd64": "f83bc05ca77137e142e682f8b5e3858d223dc4be5637755b989d19094d6c9cf0",
+      "sysml-grpc-darwin-arm64": "84d6e87ae7af59cad17d1e41b0a5234a78a2c1495c298ba9184e856d5582b9f5",
+      "sysml-grpc-linux-amd64": "00ede1e52851ac9cf52e6a69d090ff81a0b188cd7b08ca83d75e27e708bddb58",
+      "sysml-grpc-linux-arm64": "54a92ccd80868c3c02fb95f90d3714d0d517d68e9d42dbe5d0d1421ee6b52951",
+      "sysml-grpc-windows-amd64.exe": "0bee1545673423dcad761e3d02453d6736ee56989aa17ee82c9a26553bb5bae6"
+    },
+    "v0.0.8": {
+      "sysml-grpc-darwin-amd64": "ac0b8f3d24ffe5250d1c375c90425014eed87a786bb977b848f274b2eaeb2ced",
+      "sysml-grpc-darwin-arm64": "0e15230e8636f19a0c145652296faa7f4a18279755f201b396f23d49ba159a6e",
+      "sysml-grpc-linux-amd64": "3afc97748c206cd9e52cb55d3e5918fe456f577a121f2fd67800e7383d4ec139",
+      "sysml-grpc-linux-arm64": "31e3b10edc8e0cc53537f3be0d56e1a78ea703899afaec76875b502b9919c438",
+      "sysml-grpc-windows-amd64.exe": "6bf92438d139e21f1005c41c3fcca5693bad3abf9c5fd8ca6dd18a041d20b101"
+    },
+    "v0.1.0": {
+      "sysml-grpc-darwin-amd64": "60a05614a278c5c17fd27717416fdf957c7f90ba69f31d9a14d531013861601e",
+      "sysml-grpc-darwin-arm64": "a31a96d6de5e43ae5071ba0cc469be7f5854b8458aad9d8cd20e5a14c64eb48b",
+      "sysml-grpc-linux-amd64": "6bf718f8ade6c67a86cad39fcbc335ae019916b50e10530608bd832986e5b1fa",
+      "sysml-grpc-linux-arm64": "09db2db4490fc07efd371ee114b395f9a7650fa9d1dc3de7ad0d2855e5958be5",
+      "sysml-grpc-windows-amd64.exe": "7367261c2f82f4dd2d473d580d4410eaf0f8c22532ba94890e33482e509b2d8c"
+    },
+    "v0.2.0": {
+      "sysml-grpc-darwin-amd64": "52c34a3048e5fa03f45189264b85fbd21523ac45d91a65b1dff8fbe0187b5541",
+      "sysml-grpc-darwin-arm64": "7caf5d8539c15cde8a076cd217b1f0581049436c092574ddcbf0f5a5af5c9a99",
+      "sysml-grpc-linux-amd64": "bc2a1aa124bbb9205953d256c1348ca38a4f57c5723fb09e6f4464a065dc6088",
+      "sysml-grpc-linux-arm64": "6f370241e327dd1277e2b8f35bed4388bae1e4172ff4d2a213c24dee2452536d",
+      "sysml-grpc-windows-amd64.exe": "1464a3aca63dd2c4d6cb8639f9958b6d887035cb7a7edd197aaa039fb5ab19f2"
+    },
+    "v0.2.1": {
+      "sysml-grpc-darwin-amd64": "589c6e248f69bc373c536d05379b9339d0c77443e67682aa06fc045dadc0606a",
+      "sysml-grpc-darwin-arm64": "f0397b0b1b9219470a1346d4e4a9135a3e2c3e480951e5aa54a55e593adb7214",
+      "sysml-grpc-linux-amd64": "b1885a0c956a69201f7d00d6d1a4f19f9df12831cedcee8ad4682a9918ffd8a6",
+      "sysml-grpc-linux-arm64": "3451bb569c1c2993a5c648df27cadcec900d46e6e1d957f87aac979c8a16c9e5",
+      "sysml-grpc-windows-amd64.exe": "3a630d38c2691a27c8f6e3b781f48e05b727c559b219b9c2e7bd8651c222628d"
+    },
+    "v0.3.0": {
+      "sysml-grpc-darwin-amd64": "8c034172f604ec78c6c045b8eef0ddb2fdebac4f22852480ad3289a3e940cf14",
+      "sysml-grpc-darwin-arm64": "c9f8fb0a424277cc83ab3f388e11e54fcc9328b9a2cb86a911e7b96fb6cb316a",
+      "sysml-grpc-linux-amd64": "b39b720e020c325020af95c33640ad3583c938d74c40d29a0741fab6c03412de",
+      "sysml-grpc-linux-arm64": "2faeacdbc3dcd20053b2dc79b559bbbf2f53b7470d982b9908c7665a53b37462",
+      "sysml-grpc-windows-amd64.exe": "f50f1b53008154c1a5fb39eb56f09464dedcf081037af765978304b2f33615c6"
+    },
+    "v0.3.1": {
+      "sysml-grpc-darwin-amd64": "9e320e71064d4fd4dfb721bc08e86f420c1dd39da6a6229a10d683f299f1b43c",
+      "sysml-grpc-darwin-arm64": "9dc40683594ff7f4c679d19ff6c1a4e220f74ad0b94b9e871293ede473bda112",
+      "sysml-grpc-linux-amd64": "f3e3e4bc6f7786437932db69148658dd0f64d9e291bec5957754b75b87630c6e",
+      "sysml-grpc-linux-arm64": "1b4009712c1f74c83fae35fa927393867844c983835f2663af85a5c0373df6c7",
+      "sysml-grpc-windows-amd64.exe": "a14aa294a096e7eed54145b867ed19dfb604e1e77be4bbd8dc5dd0d84a1e4cf4"
+    },
+    "v0.4.0": {
+      "sysml-grpc-darwin-amd64": "fec8a8e647cfea68935f28c54691bd7c692685727cdf0052492aec3a440bac80",
+      "sysml-grpc-darwin-arm64": "1f3bf8caba84d60949add1426cb3be92d4e6ffe50ae6530ab3fea8dd9430a368",
+      "sysml-grpc-linux-amd64": "8b5d10b2f0f4175fd78936a7be3083668f0262c525a1ae7581d73b80a278a427",
+      "sysml-grpc-linux-arm64": "62718407f0606bad8673eb28a03dec37745bd7c30fbeea4c2e2d41bc2bb61b64",
+      "sysml-grpc-windows-amd64.exe": "72a532175348d73f23b208fc638715c6f9020b1a626517a04ca500afd2831ef2"
+    },
+    "v0.4.1": {
+      "sysml-grpc-darwin-amd64": "e7a03ea3e9f5d6681656d9f8fb9419b5a54e04b0ce64b465ec0fdc6abc8d6a3f",
+      "sysml-grpc-darwin-arm64": "ad6aa276842ee4e60fa18e158421b5a3e0adda605cfb166a3a0588eb7aef712b",
+      "sysml-grpc-linux-amd64": "125dadd7ee27738d62461cef12766a622494d9c69e18ddc5c12d51957abcf68b",
+      "sysml-grpc-linux-arm64": "9d7c835e2b61ed3357afa47dbd210f5c7d4afa8ec6a254f24f3f6909e3c4796c",
+      "sysml-grpc-windows-amd64.exe": "222a4ec5b8f535a654b53f684dc01da8004114e7944e5ea3bf2b65adfdca6966"
+    },
+    "v0.4.2": {
+      "sysml-grpc-darwin-amd64": "e137c8b41efedda4f2dd511e4bd98443bbcb40373c0b034ca19bed8594bc7773",
+      "sysml-grpc-darwin-arm64": "b931eafa0b56f3319e221b5524a6315fa44f3b5660db9f9ce98b2df8af9d683f",
+      "sysml-grpc-linux-amd64": "4719bc621befa5d5d9b1eb588393f0cee05f7329f9eee5a517016bfd56383923",
+      "sysml-grpc-linux-arm64": "a48fc6f29556b5aa1d0dd7ca3eb62362160e21fb6baa676336d35162a882ef7c",
+      "sysml-grpc-windows-amd64.exe": "08a931bc7c0af9df2f9a4bd03cd51f597974bb176467f8b1da71cd50d4ccbdbf"
+    },
+    "v0.4.3": {
+      "sysml-grpc-darwin-amd64": "12dcf12c09083261480db3f0533e455015f36a598fcf57f898071f5d0a38f55f",
+      "sysml-grpc-darwin-arm64": "f25f3f1a6b2e766f6355b6cb2fa9872102184eacee059bb784213b3cd550709f",
+      "sysml-grpc-linux-amd64": "24132eeafa93e23cb01e8759b469ea62bdb99e53834cc684995a5c7305675bcc",
+      "sysml-grpc-linux-arm64": "f54dff9572c625d415b527e81515dfed4cdd9075bb9d3b822b463f79c9e803dd",
+      "sysml-grpc-windows-amd64.exe": "0b188ec140872c0f93618602d5aa880daa864a84c00d4a8806cf97c80e8333fe"
+    },
+    "v0.5.0": {
+      "sysml-grpc-darwin-amd64": "8da7071431f7dec63bbab7465c9e9766ec45cc602ee55a5bcecc2df150132bf2",
+      "sysml-grpc-darwin-arm64": "17363e6aa06b1e83122e9b68bd9e1942333ec2eccd7ffc53b804585c5e672227",
+      "sysml-grpc-linux-amd64": "119b15545dea975e45636682cab075de551395536a4d42c4666776d71b70e990",
+      "sysml-grpc-linux-arm64": "8a6ef48a998e21b6a34cd3cce68d202135d8f9285ffe0f022a27550b5b93048a",
+      "sysml-grpc-windows-amd64.exe": "053de029407b1255e312a9836d2972a69826c98f64fe425866dfe81a931d154c"
+    },
+    "v0.5.1": {
+      "sysml-grpc-darwin-amd64": "32e11b447b221bad34c477afffb1b05c00eebfede5ba33da6864feddd74e8e3b",
+      "sysml-grpc-darwin-arm64": "3149379869d2f8f753053dae06e86dd0a22ac2ce04c410973b84523e592bbb48",
+      "sysml-grpc-linux-amd64": "9b1d33ae570f83eaf8deb1626f920d3bcbf65eff5a5b3c4b2ada53606ac9dd01",
+      "sysml-grpc-linux-arm64": "b4824822e36115474871658907fec6e311dee6db954c2ee12d8f43b5aca9795a",
+      "sysml-grpc-windows-amd64.exe": "5bc8de29420af2906da9aa2aa578ccd0eb3ebf56482d31e97b2df1fa53275f8f"
+    },
+    "v0.6.0": {
+      "sysml-grpc-darwin-amd64": "6195c3127ebb258032bc3e6a2478c67149e9718c6540995c796c4b4bcf3b0a0e",
+      "sysml-grpc-darwin-arm64": "e6489a5e2ba77ef6c3c906feaef83bc342c014b5943487d59eba037bfd83ec31",
+      "sysml-grpc-linux-amd64": "9368097f9e6ee9bec6cc2155403c3b0ff80202dba33eda0fc7938fb4b41d1168",
+      "sysml-grpc-linux-arm64": "b77852e30015a1bdde72da889a712174447dcd53696400980b0c0717f34daf91",
+      "sysml-grpc-windows-amd64.exe": "16447e3ff1e16bad36b2419f73f70b4b5f73bb8ad609f3a288412eef9fa54a62"
+    },
+    "v0.7.0": {
+      "sysml-grpc-darwin-amd64": "2e125afec790b674ac85c4445acc6b591d69a4eecfe49a390115644084e6ccb9",
+      "sysml-grpc-darwin-arm64": "223596d1990eedbfc091e30a7e469f411574f5adb3b3149ee63ed6ff134edb29",
+      "sysml-grpc-linux-amd64": "bd953bb9462fd99c588e6111bb22d235b863c2cb81d3afa8c2a116aa3589b534",
+      "sysml-grpc-linux-arm64": "806250c40ccb5ba84d84d92e39ffffdda0e2fc878af88574524f6728d205d51f",
+      "sysml-grpc-windows-amd64.exe": "ce5a795c5bb680eba6d22dbe555ca16c4cbb0fcf79f4611da62f83b3104c5753"
+    },
+    "v0.8.0": {
+      "sysml-grpc-darwin-amd64": "9b66402e3e6483c2b6e8c983fbea68463a1f51603b0f1246ba932a13af1e528c",
+      "sysml-grpc-darwin-arm64": "7a18e07bc3994bcc5965667ef7abee18efe015923b480e658a89644918b3af51",
+      "sysml-grpc-linux-amd64": "229d129b0051e008aab3bd077fd3087b82f322f15ad91135effdd3f65aae197c",
+      "sysml-grpc-linux-arm64": "4e844d0a415307507e88e6e2de40314207eb83bafa960e9b5a374ef8a942b3a6",
+      "sysml-grpc-windows-amd64.exe": "fbbc8c8cf35c0a5a6d4802dbe14980a8df89871ddd955341b0913e23d9da7625"
+    },
+    "v0.8.1": {
+      "sysml-grpc-darwin-amd64": "277df0b768c58709d99b3301fe954d3478ef69c44173b04e82359ad49b00dd56",
+      "sysml-grpc-darwin-arm64": "0c4d896ec61ca19085a0f67a7c5f28be4fef84f46ebc6df5e25c519a4fee5cff",
+      "sysml-grpc-linux-amd64": "c928b5e3a8bb6374b18a2a8de0d5694d9727d3a863f35dbb7b91cf2b1f85cc3a",
+      "sysml-grpc-linux-arm64": "b75ef2f1f3c3fe76932e84f94ac1cac3c4628f77e22eaaab439219b07c7d2a2d",
+      "sysml-grpc-windows-amd64.exe": "2f21bb9471ce913450e65d077f9f4ce1995ee5215f7b281cbf7c461e6b93c218"
+    },
+    "v0.9.0": {
+      "sysml-grpc-darwin-amd64": "0b707d2ad04f1e4ad074ebc529be32792f083a05edf8fad72a8bd5aee450dd89",
+      "sysml-grpc-darwin-arm64": "d2c0a5eeca4ffb8309712ae0f6da29e1a15dfdc3b2a201fa30920a76e863b166",
+      "sysml-grpc-linux-amd64": "930c85cc74a4da0ff9761b80688d30da5aade04d1f6ecf2c0c8235bad10e5449",
+      "sysml-grpc-linux-arm64": "3664264060fe1b59c9da278c2f10b6d57bec0f7ee9cc8fa2784d565916a74dcf",
+      "sysml-grpc-windows-amd64.exe": "b5268560bcff72ed3a64f93342cf3b3ff72b0145bf2c14ae3ffc6a4b5ab3f2b6"
+    },
+    "v0.9.1": {
+      "sysml-grpc-darwin-amd64": "ade96cc53eeb7bfbfd44db76a5c67f4566ccc2c4d36fc3d82e28759cd27745df",
+      "sysml-grpc-darwin-arm64": "1579ce333281cdf0ba83d76907850d628214331f319cc546b2215e6173a851c0",
+      "sysml-grpc-linux-amd64": "07cf2bca89531328b0f5ad3e21533f62ef6c9b1605ceaf308b951b44361ef463",
+      "sysml-grpc-linux-arm64": "6cde66836b884171650fcb246cbc976f66fc564bebb233a82a2ff1a0cb58e377",
+      "sysml-grpc-windows-amd64.exe": "74c55402c86b27fba749275750bb3ffd769c25428eaf4cad7cacaf843596a9ce"
+    },
+    "v0.9.2": {
+      "sysml-grpc-darwin-amd64": "e0a899530c03dfc4364c472d04e3f8748338ae72132f75f9351b9d162c8cb2cc",
+      "sysml-grpc-darwin-arm64": "f216818f2b37767d1aa7531a692612c7235e64ae9a21efe6b4de13d6832422f4",
+      "sysml-grpc-linux-amd64": "8577dacafa512416942639a3b2a7e38dc4a0bd89e64abce2e5e4faca581ee7c3",
+      "sysml-grpc-linux-arm64": "289f3fdff259f1a49960abbdead31a9cd7bb4d3789430303d1823beffda1b3cf",
+      "sysml-grpc-windows-amd64.exe": "d58a5b3ace4a627e59988b85d94d1b753ba7403b1477860f3ae2e8d83b3c3e99"
+    }
+  }
+}

jupyter_opensysml_kernel-0.9.3.dev20261008.data/data/share/jupyter/kernels/sysml/kernel.json

@@ -0,0 +1,17 @@
+{
+  "argv": [
+    "python",
+    "-m",
+    "jupyter_opensysml_kernel",
+    "-connection-file",
+    "{connection_file}"
+  ],
+  "display_name": "SysML v2 (OpenSysML)",
+  "interrupt_mode": "message",
+  "language": "sysml",
+  "metadata": {
+    "implementation": "sysml-jupyter-kernel",
+    "package": "jupyter-opensysml-kernel",
+    "package_version": "0.9.3.dev20261008"
+  }
+}

jupyter_opensysml_kernel-0.9.3.dev20261008.dist-info/METADATA

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: jupyter-opensysml-kernel
+Version: 0.9.3.dev20261008
+Summary: Jupyter kernel for SysML v2, backed by the OpenSysML REPL
+Author: Open-MBEE
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/Open-MBEE/OpenSysML
+Project-URL: Repository, https://github.com/Open-MBEE/OpenSysML
+Project-URL: Documentation, https://opensysml.org/guide/12-jupyter/
+Project-URL: Changelog, https://github.com/Open-MBEE/OpenSysML/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/Open-MBEE/OpenSysML/issues
+Keywords: jupyter,kernel,sysml,sysmlv2,kerml,mbse,systems-engineering
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Jupyter
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jupyter_client>=7.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: mypy>=1.8.0; extra == "dev"
+Dynamic: license-file
+
+# jupyter-opensysml-kernel
+
+A [Jupyter](https://jupyter.org) kernel for SysML v2, backed by the
+[OpenSysML](https://github.com/Open-MBEE/OpenSysML) REPL. A notebook cell is a
+REPL submission: declarations accumulate into one model across cells, a bare
+expression is evaluated, and every `%` command of the `sysml` REPL — `%eval`,
+`%instantiate`, `%action`, `%render`, `%render-document`, `%load`, … — works as
+it does at the prompt. Views render as Mermaid, Graphviz (SVG), Markdown, CSV
+and JSON; documents as Markdown and HTML.
+
+## Install
+
+Python 3.10 or later and a Jupyter front end (JupyterLab, Notebook, VS Code,
+`nbconvert`, …) are required.
+
+```bash
+pip install jupyter-opensysml-kernel
+```
+
+The wheel for your platform (Linux x64 and arm64, macOS Intel and Apple
+Silicon, Windows x64) bundles the `sysml-jupyter-kernel` binary of the OpenSysML
+release this package was built for and registers the `sysml` kernelspec under
+the Python environment it is installed into, so that is the whole install:
+
+```bash
+jupyter kernelspec list            # shows: sysml  …/share/jupyter/kernels/sysml
+jupyter lab                        # pick "SysML v2 (OpenSysML)"
+```
+
+Install with the Python that runs your notebook server (or in its environment);
+`pip uninstall` removes the kernel and its kernelspec together.
+
+Where no wheel applies, `pip` installs the sdist, which bundles no binary. Then
+one more command downloads the release's binary, verifies it against the SHA-256
+digest the package ships for that release, and registers the kernelspec with the
+binary inside it:
+
+```bash
+python -m jupyter_opensysml_kernel install
+```
+
+Nothing unverified is installed: a download that does not hash to the pinned
+digest is refused, and so is a release the package pins no digest for. The same
+command registers the kernel for the user (`--user`) or under another prefix
+(`--prefix DIR`, `--system`) when the notebook server does not run in the
+environment the package is in, copying the bundled binary when there is one. To
+use a kernel built from source (`go build ./cmd/sysml-jupyter-kernel`) or
+installed another way, pass it explicitly:
+
+```bash
+python -m jupyter_opensysml_kernel install --binary ./sysml-jupyter-kernel
+```
+
+`python -m jupyter_opensysml_kernel uninstall` removes a kernelspec `install`
+wrote and the binary in it; `jupyter kernelspec remove sysml` does the same.
+
+The conda-forge recipe for this package is kept in the OpenSysML repository
+under `packaging/conda`; once it is accepted there,
+`conda install -c conda-forge jupyter-opensysml-kernel` installs the kernel and
+its kernelspec into the environment directly. Until then, `pip install` inside
+the conda environment registers the kernel under that environment's prefix the
+same way.
+
+A development snapshot of this package is published every night as
+`jupyter-opensysml-kernel==<next release>.dev<yyyymmdd>`, which `pip install`
+never picks up on its own; it carries the kernel of the same night's snapshot.
+
+## Documentation
+
+- [Using SysML in Jupyter](https://opensysml.org/guide/12-jupyter/) — the guide
+  chapter: cells, `%` commands, rich output, interrupts.
+- [REPL commands](https://opensysml.org/reference/repl-commands/) — every `%`
+  command the kernel serves.
+
+## Development
+
+```bash
+pip install -e '.[dev]'
+pytest
+mypy jupyter_opensysml_kernel
+```
+
+The tests need no network: downloads are served from fixtures, and the wheel
+tests build from a staged stand-in binary (`python -m build` is required). The
+package's copy of `release-digests.json` is synced from
+`client/release-digests.json` by `scripts/sync-release-digests.py`; the release
+pipeline stamps the digests of the kernel binaries it built into the copy, then
+`scripts/build-jupyter-kernel-dist.sh` builds the sdist and, with each binary
+staged under `jupyter_opensysml_kernel/bin/` and
+`JUPYTER_OPENSYSML_KERNEL_PLATFORM=<goos>-<goarch>` set, one wheel per platform
+(`setup.py` tags the wheel and adds the kernelspec as shared data).
+
+## License
+
+Apache-2.0.

jupyter_opensysml_kernel-0.9.3.dev20261008.dist-info/RECORD

@@ -0,0 +1,20 @@
+jupyter_opensysml_kernel/__init__.py,sha256=GGl3udR4wfVRFNfLdRk8iVEAMZ60KwSx98PisgCL4hY,578
+jupyter_opensysml_kernel/__main__.py,sha256=LT5aRaKEPKyopRhxK6DQeSGWxPfyjQpNUF7s-vurtYQ,7041
+jupyter_opensysml_kernel/_version.py,sha256=IR9XeCmRCdZriEY71Vob4hvemiUcck0DrdegPkqg4Pw,332
+jupyter_opensysml_kernel/binary.py,sha256=JkXi6qFPs8dzAL4R8TbKuuOfU0J4kic0Q98AZYfy_Cg,12257
+jupyter_opensysml_kernel/kernelspec.py,sha256=GaE5XA15KvQQA4JbViTPRXeFmB_8YoTiQY1d1trCAQg,8185
+jupyter_opensysml_kernel/logo-32x32.png,sha256=arrl5G1Lw0ER1Npb8nXIOpaUkQGkjhI8ii0HTKGOvIg,2488
+jupyter_opensysml_kernel/logo-64x64.png,sha256=0o2drGjR4SArJjkxsiwlZCQ3rV3_jQgo2oJlLO7pGLg,6673
+jupyter_opensysml_kernel/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jupyter_opensysml_kernel/release-digests.json,sha256=LAwC-jj99i37V8P_TOYQcRGhW8hJIjsUhvvkxXV7kFk,12294
+jupyter_opensysml_kernel/bin/sysml-jupyter-kernel,sha256=Bom5SnH3qRUwXlUWiJYgqDhfLtpN8LhCCkvGsq06Ky8,42670002
+jupyter_opensysml_kernel/bin/sysml-jupyter-kernel.exe,sha256=4NsxzN3Vr0BcTm8wvG-OVJ-YOwMSTzHd_miTMyjV5Ak,46546432
+jupyter_opensysml_kernel-0.9.3.dev20261008.data/data/share/jupyter/kernels/sysml/kernel.json,sha256=2wzQjDwmW2iXr2uch1Q5jefGDOjGBRtmhYu1Nsd6b2Q,373
+jupyter_opensysml_kernel-0.9.3.dev20261008.data/data/share/jupyter/kernels/sysml/logo-32x32.png,sha256=arrl5G1Lw0ER1Npb8nXIOpaUkQGkjhI8ii0HTKGOvIg,2488
+jupyter_opensysml_kernel-0.9.3.dev20261008.data/data/share/jupyter/kernels/sysml/logo-64x64.png,sha256=0o2drGjR4SArJjkxsiwlZCQ3rV3_jQgo2oJlLO7pGLg,6673
+jupyter_opensysml_kernel-0.9.3.dev20261008.dist-info/licenses/LICENSE,sha256=iLtmNdAW7Fw_0eAPVZMPW3EMwJLnUD5_NWGI7NJSa9Y,11340
+jupyter_opensysml_kernel-0.9.3.dev20261008.dist-info/METADATA,sha256=fAKTB5rDNP3HV7rdcBizIPqIlLUDTCNM6cint6NyUA8,5490
+jupyter_opensysml_kernel-0.9.3.dev20261008.dist-info/WHEEL,sha256=Zx98gwb_dQKckJK3HEOVKnxxD52EfU_PXDG_usMJ2ng,98
+jupyter_opensysml_kernel-0.9.3.dev20261008.dist-info/entry_points.txt,sha256=jvrw7325lHzjFfRd5trPGPemDZJVngdNZQRRYcZbhOM,84
+jupyter_opensysml_kernel-0.9.3.dev20261008.dist-info/top_level.txt,sha256=_8rtYZqoq8Tf1OdFn-zhpNFLMQa8o2pJFPqDMbhOpFM,25
+jupyter_opensysml_kernel-0.9.3.dev20261008.dist-info/RECORD,,

jupyter_opensysml_kernel-0.9.3.dev20261008.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: false
+Tag: py3-none-win_amd64
+

jupyter_opensysml_kernel-0.9.3.dev20261008.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jupyter-opensysml-kernel = jupyter_opensysml_kernel.__main__:main

jupyter_opensysml_kernel-0.9.3.dev20261008.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 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 2026 Open-MBEE
+
+   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.

jupyter_opensysml_kernel-0.9.3.dev20261008.dist-info/top_level.txt

@@ -0,0 +1 @@
+jupyter_opensysml_kernel