pyaml-cs-osprey 2026.11.0__tar.gz

pyaml_cs_osprey-2026.11.0/.gitignore

@@ -0,0 +1,226 @@
+# Scratch notes (local idea capture)
+scratch/
+
+# NFS temporary files
+.nfs*
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+/build/
+develop-eggs/
+/dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage*
+.cache
+nosetests.xml
+coverage.xml
+coverage.json
+*.cover
+.hypothesis/
+
+# CI diagnostics drop (per-worker event logs, stack dumps, container logs).
+# Written by _harness/ci_diagnostics.py and .github/actions/capture-ci-diagnostics
+# whenever OSPREY_CI_DIAG_DIR is set; uploaded as an artifact, never committed.
+/ci-diag/
+.pytest_cache/
+.mypy_cache/
+# The import graph lint-imports (import-linter) caches between runs.
+.import_linter_cache/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# Environment directories
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE specific files
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS specific files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Data, models, and results
+!data/.gitkeep
+# models/ - Removed this to allow tracking model_config.py
+!models/.gitkeep
+results/
+!results/.gitkeep
+# Any source dir named results/ is SOURCE, not ML output — the broad unanchored
+# results/ ignore above must not swallow it (this negation is deliberately
+# path-independent: pinning it to one package broke when the bluesky-web
+# sidecar moved services/ -> interfaces/, silently dropping the panel from the move).
+!src/**/results/
+# Benchmark model-matrix run exhaust (#259) — regenerable from scripts/benchmark/.
+# All generated artifacts (dashboard.html, results_box/, live_updater.log) live
+# under one output dir co-located with the tooling, keeping the repo root clean.
+scripts/benchmark/_out/
+*.h5
+*.pkl
+*.pt
+*.pth
+*.onnx
+*.mlmodel
+
+# Logs
+logs/
+*.log
+!tests/deployment/fixtures/*.log
+tensorboard/
+
+# Temporary files
+tmp/
+temp/
+
+*.jpg
+*.gif
+*.bmp
+*.tiff
+*.ico
+# The demo template's CANOPY screens ship their images.
+!src/osprey/templates/apps/demo/data/canopy/library/screens/**/images/*.jpg
+
+# Landing-page demo video: recorded takes are never committed; the docs build
+# downloads the MP4s from the release manifest.json names. The posters and
+# manifest.json are committed, so the posters must override the `*.jpg` rule.
+docs/demo-video/
+docs/source/_static/demo/*.mp4
+!docs/source/_static/demo/*-poster.jpg
+
+# Credentials
+.env
+
+delete_me*
+valves.json
+*.code-workspace
+
+# Agent data directories
+_agent_data/*
+# Track only the Codex marketplace manifest; never Codex plugin state.
+.agents/*
+!.agents/plugins/
+.agents/plugins/*
+!.agents/plugins/marketplace.json
+
+# Local coding-agent guidance (kept out of git; see /CLAUDE.md below)
+AGENTS.md
+
+# Sample logbook data (large JSONL files)
+logbook_*.jsonl
+
+# Auto-generated documentation
+_autosummary/
+docs/build/
+
+# PID files
+*.pid
+
+# Development services and applications (keep locally but not in git)
+/.claude
+_ISSUES
+/CLAUDE.md
+.mcp.json
+
+# Git worktrees
+.worktrees/
+
+# Generated benchmark databases
+data/benchmarks/cross_paradigm/tier*/
+
+# OSPREY workspace (runtime data, not tracked — now covered by _agent_data/* above)
+
+# Vendor assets (fetched at build time via `osprey vendor fetch`)
+src/osprey/interfaces/artifacts/static/js/vendor/
+src/osprey/interfaces/artifacts/static/css/vendor/
+src/osprey/interfaces/web_terminal/static/vendor/*
+# The dock engine is tracked: vendored from CANOPY's screen runtime at a pinned commit.
+!src/osprey/interfaces/web_terminal/static/vendor/dock-engine.mjs
+!src/osprey/interfaces/web_terminal/static/vendor/dock-engine.d.mts
+src/osprey/interfaces/bluesky_web/panels/bluesky/vendor/
+src/osprey/interfaces/optimizer_web/panels/optimizer/vendor/
+# The okf panel's own vendored marked.min.js is tracked; only DOMPurify is fetched.
+src/osprey/interfaces/okf_panel/static/vendor/purify.min.js
+tests/e2e/claude_code/benchmark_results/
+
+# Model files staged by hand for hosts that cannot reach the model host. They
+# reach the qmd sidecar over the read-only mount `services.qmd.models_dir`
+# names, never through a build context — but the staging directory itself can
+# sit anywhere, this tree included. Gigabytes of GGUF, never source — keep them
+# out of git and out of the build (see also the hatch exclude in pyproject.toml)
+**/prefetched-models/
+
+# Playwright MCP browser-session cache (page snapshots, console logs)
+.playwright-mcp/
+
+# Node.js (dev-only JS toolchain; not part of the Python wheel)
+node_modules/
+
+# Working directory gitlab-ci-local writes when the deploy goldens are checked
+# against a real pipeline parser. Created wherever the check is run from.
+.gitlab-ci-local/
+
+# Version stamp written by the hatch-vcs build hook. Committing it would recreate
+# the stale-literal problem the git-derived version exists to remove. It is still
+# packaged into the wheel and sdist — the hook registers it as a build artifact.
+src/osprey/_version.py
+packages/osprey-connectors/src/osprey_connectors/_version.py
+packages/osprey-optimizer/src/osprey_optimizer/_version.py
+packages/pyaml-cs-osprey/src/pyaml_cs_osprey/_version.py
+
+# feature-scaffolding logs (not committed)
+.claude/.logs/
+
+# Process scaffolding — never committed (specs/plans live here uncommitted)
+docs/superpowers/
+
+# Locally scaffolded deployment project. Carries a real .env, build output and
+# run data; belongs to the working copy, never to the repo. Anchored to the root
+# so the pattern cannot swallow a same-named path elsewhere in the tree.
+/my-control-assistant/
+/osprey-demo/

pyaml_cs_osprey-2026.11.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, The Regents of the University of California, through Lawrence Berkeley National Laboratory (subject to receipt of any required approvals from the U.S. Dept. of Energy). All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

pyaml_cs_osprey-2026.11.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.5
+Name: pyaml-cs-osprey
+Version: 2026.11.0
+Summary: pyAML control-system backend that routes every access through the OSPREY connector
+License: BSD-3-Clause
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: accelerator-middle-layer-apg==0.3.2.post1
+Requires-Dist: osprey-connectors>=2026.11.11
+Description-Content-Type: text/markdown
+
+# pyaml-cs-osprey
+
+A pyAML control-system backend for OSPREY. pyAML installs from
+`accelerator-middle-layer-apg`, the staging distribution (upstream
+0.3.2 plus the first-turn trajectory tool), and imports as `pyaml`. The
+backend implements pyAML's `ControlSystem`, `DeviceAccess` and
+`DeviceAccessList` on top of `osprey.runtime`, so every pyAML read and write
+passes through the OSPREY `ControlSystemConnector`: channel limits, write
+posture, control-target pinning, write verification and audit all apply.
+pyAML's native backends, which open their own control-system clients, are not
+used.
+
+The package ships with `osprey-framework`, which depends on it; it is not meant
+to be installed on its own.
+
+## Selecting the backend
+
+In a pyAML configuration:
+
+```yaml
+controls:
+  - type: pyaml_cs_osprey.controlsystem
+    name: live
+```

pyaml_cs_osprey-2026.11.0/README.md

@@ -0,0 +1,24 @@
+# pyaml-cs-osprey
+
+A pyAML control-system backend for OSPREY. pyAML installs from
+`accelerator-middle-layer-apg`, the staging distribution (upstream
+0.3.2 plus the first-turn trajectory tool), and imports as `pyaml`. The
+backend implements pyAML's `ControlSystem`, `DeviceAccess` and
+`DeviceAccessList` on top of `osprey.runtime`, so every pyAML read and write
+passes through the OSPREY `ControlSystemConnector`: channel limits, write
+posture, control-target pinning, write verification and audit all apply.
+pyAML's native backends, which open their own control-system clients, are not
+used.
+
+The package ships with `osprey-framework`, which depends on it; it is not meant
+to be installed on its own.
+
+## Selecting the backend
+
+In a pyAML configuration:
+
+```yaml
+controls:
+  - type: pyaml_cs_osprey.controlsystem
+    name: live
+```

pyaml_cs_osprey-2026.11.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pyaml-cs-osprey"
+dynamic = ["version"]
+description = "pyAML control-system backend that routes every access through the OSPREY connector"
+readme = "README.md"
+requires-python = ">=3.11"
+license = {text = "BSD-3-Clause"}
+# `osprey-framework` is deliberately not declared: the framework depends on this
+# package, so declaring it back would be a cycle. The package is not meant to be
+# installed without the framework, whose `osprey.runtime` it calls.
+dependencies = [
+    # pyAML (imports as `pyaml`): the staging distribution, upstream 0.3.2
+    # plus the trajectory tool; never installed beside `accelerator-middle-layer`.
+    "accelerator-middle-layer-apg==0.3.2.post1",
+    # The backend raises and catches the connectors' own errors (device.py,
+    # devices.py, _run.py, errors.py). The same floor as the framework's
+    # `osprey-connectors` dependency (a test holds them together).
+    "osprey-connectors>=2026.11.11",
+]
+
+[project.entry-points."pyaml.schemas"]
+# A package value: pyAML's schema discovery imports the package and every submodule
+# under it, and `@register_schema` in `controlsystem.py` registers the schema.
+pyaml_cs_osprey = "pyaml_cs_osprey"
+
+[tool.hatch.version]
+source = "vcs"
+# Versions with the framework's calendar stream, from the same v-tags and the
+# same describe command as the framework (see the root pyproject.toml): the two
+# wheels built from one checkout carry the same number.
+raw-options = { root = "../..", version_scheme = "post-release", git_describe_command = "git describe --dirty --tags --long --abbrev=40 --match v[0-9]*" }
+
+[tool.hatch.build.hooks.vcs]
+version-file = "src/pyaml_cs_osprey/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pyaml_cs_osprey"]

pyaml_cs_osprey-2026.11.0/src/pyaml_cs_osprey/_run.py

@@ -0,0 +1,207 @@
+"""The process's pyAML run: where a pyAML write is accepted and recorded.
+
+A pyAML write is an ordinary checked connector write
+(``osprey.runtime.write_channel`` / ``write_channels``), accepted only while a
+:func:`pyaml_cs_osprey.run_tool.run_tool` call is in progress in this process;
+anywhere else it is refused as :data:`OUTSIDE_A_RUN` and nothing is read or
+written. The run lists, in memory for the call's result, each address's value
+before its first write. An address is listed unless the runtime showed its
+write never went out (no attempt, or ``refused``); a write whose outcome is
+unknown is listed. Nothing is written back.
+
+The run belongs to the process, not to the thread that opened it: a
+``run_tool`` on any thread joins the one run, and the last one to leave ends
+it. Its abort flag is a :class:`threading.Event`, so a ``SIGINT`` handler sets
+it without taking :data:`_GUARD`, and every thread reads it.
+
+A forked child starts with no run.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import threading
+from collections.abc import Callable, Iterator, Sequence
+from dataclasses import dataclass, field
+from typing import Any
+
+import osprey.runtime
+from pyaml_cs_osprey.errors import OspreyWriteRefused
+
+#: Why a device write outside a ``run_tool`` call is refused.
+OUTSIDE_A_RUN = "pyAML writes run only inside pyaml_measure"
+
+#: Held across one write's read, write and record, and over every change of
+#: :data:`_RUN`. Nothing taken under it takes it again.
+_GUARD = threading.Lock()
+
+
+@dataclass
+class _PyamlRun:
+    """The ``run_tool`` calls in progress in this process.
+
+    Attributes:
+        target: The control target whose run lock the run holds.
+        moved: Each address's value before its first write, in the order the
+            writes were made. An address is listed unless the runtime showed
+            its write never went out.
+        abort: A Ctrl-C asked every tool of the run to stop.
+        depth: How many ``run_tool`` calls are inside the run.
+    """
+
+    target: str
+    moved: dict[str, Any] = field(default_factory=dict)
+    abort: threading.Event = field(default_factory=threading.Event)
+    depth: int = 0
+
+
+#: The process's run, ``None`` when no ``run_tool`` call is in progress.
+_RUN: _PyamlRun | None = None
+
+
+@contextlib.contextmanager
+def opened(target: str) -> Iterator[None]:
+    """Be inside the process's run on *target* for the body, opening it when none is.
+
+    Raises:
+        RuntimeError: The process's run is on another target.
+    """
+    global _RUN
+    with _GUARD:
+        run = _RUN
+        if run is None:
+            run = _RUN = _PyamlRun(target=target)
+        elif run.target != target:
+            raise RuntimeError(
+                f"a pyAML run on {run.target} is in progress; it cannot open one on {target}"
+            )
+        run.depth += 1
+    try:
+        yield
+    finally:
+        with _GUARD:
+            run.depth -= 1
+            if run.depth == 0 and _RUN is run:
+                _RUN = None
+
+
+def request_abort() -> bool:
+    """Ask every tool of the process's run to stop; whether a run is open."""
+    run = _RUN
+    if run is None:
+        return False
+    run.abort.set()
+    return True
+
+
+def abort_requested() -> bool:
+    """Whether a Ctrl-C asked the process's run to stop."""
+    run = _RUN
+    return run is not None and run.abort.is_set()
+
+
+def moved() -> dict[str, Any]:
+    """A copy of what the process's run moved.
+
+    Each address whose write may have gone out, with its value before its
+    first write.
+    """
+    with _GUARD:
+        run = _RUN
+        return {} if run is None else dict(run.moved)
+
+
+def write(
+    addresses: Sequence[str],
+    write: Callable[..., object],
+    map_write: Callable[[Exception], Exception],
+    *,
+    map_read: Callable[[Exception, list[str]], Exception],
+    confirm: bool | None,
+) -> None:
+    """Write ``addresses`` inside the process's run only, recording what moved.
+
+    The addresses not yet listed are read in one ``read_channels`` call before
+    the write and listed with that value before the write is called. Once the
+    call ends, an address is taken off the list only when the runtime showed
+    its write never went out (no attempt, or ``refused``), whether or not the
+    call raised. An escape anywhere after the read, the write still running or
+    the list half pruned, leaves every address not yet taken off listed. An
+    escape that is not an ``Exception`` propagates unchanged. An address
+    already listed keeps its first value.
+
+    Args:
+        addresses: Every address the write touches.
+        write: The runtime write. It is called with ``confirm=confirm`` when
+            ``confirm`` is given and with no keyword otherwise, so each channel
+            resolves its own confirm default.
+        map_write: Maps an exception ``write`` raised onto the exception raised
+            in its place.
+        map_read: Maps an exception the pre-write read raised, with the
+            addresses asked for, onto the exception raised in its place.
+        confirm: Passed to ``write`` when not ``None``.
+
+    Raises:
+        OspreyWriteRefused: No ``run_tool`` call is in progress
+            (:data:`OUTSIDE_A_RUN`, naming the first address); nothing was read
+            or written.
+        Exception: ``map_read``'s mapping of a read failure, with nothing
+            written, or ``map_write``'s mapping of a write failure.
+    """
+    with _GUARD:
+        run = _RUN
+        if run is None:
+            raise OspreyWriteRefused(OUTSIDE_A_RUN, addresses[0] if addresses else None)
+        missing = [address for address in dict.fromkeys(addresses) if address not in run.moved]
+        pending: dict[str, Any] = {}
+        if missing:
+            try:
+                pending = dict(zip(missing, osprey.runtime.read_channels(missing), strict=True))
+            except Exception as exc:
+                raise map_read(exc, list(addresses)) from exc
+        run.moved.update(pending)
+        raised: BaseException | None = None
+        with osprey.runtime.record_writes() as records:
+            try:
+                write(**({} if confirm is None else {"confirm": confirm}))
+            except Exception as exc:
+                raised = exc
+                raise map_write(exc) from exc
+            except BaseException as exc:
+                raised = exc
+                raise
+            finally:
+                for address in pending:
+                    if not _moved(address, records, raised):
+                        del run.moved[address]
+
+
+def _moved(address: str, records: Sequence[tuple[str, str]], raised: BaseException | None) -> bool:
+    """Whether ``address``'s write may have put its value on the control system.
+
+    An escape that is not an ``Exception``, such as a ``KeyboardInterrupt``
+    while the write keeps running elsewhere, keeps every address, failing
+    closed: the write may still go out. Otherwise the runtime's phases alone
+    decide: ``sent`` or ``landed`` moved it, ``refused`` and no ``attempt``
+    mean it never went out, and an ``attempt`` with no later phase is an
+    unknown outcome, kept.
+    """
+    if raised is not None and not isinstance(raised, Exception):
+        return True
+    phases = {phase for recorded, phase in records if recorded == address}
+    if phases & {"sent", "landed"}:
+        return True
+    if "refused" in phases:
+        return False
+    return "attempt" in phases
+
+
+def _reset() -> None:
+    """Give a forked child no run and a guard of its own."""
+    global _GUARD, _RUN
+    _GUARD = threading.Lock()
+    _RUN = None
+
+
+os.register_at_fork(after_in_child=_reset)

pyaml_cs_osprey-2026.11.0/src/pyaml_cs_osprey/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '2026.11.0'
+__version_tuple__ = version_tuple = (2026, 11, 0)
+
+__commit_id__ = commit_id = None

pyaml_cs_osprey-2026.11.0/src/pyaml_cs_osprey/catalog.py

@@ -0,0 +1,97 @@
+"""Parse ``pyaml-cs-oa`` channel references.
+
+A pyAML configuration names each control-system channel with a short reference string.
+The grammar, shared with ``pyaml-cs-oa``, is::
+
+    ADDR[unit]            read-write: one address for both directions
+    (ADDR)[unit]          write-only
+    (RB, SP)[unit]        read-write: readback address RB, setpoint address SP
+    ...@i[unit]           any of the above, addressing element ``i`` of an array channel
+
+The ``[unit]`` suffix is optional; a missing unit is ``''``. Whitespace between parts is
+ignored. An indexed reference parses (so the control system can refuse it by name) and
+sets :attr:`ChannelReference.index`.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Literal
+
+from pyaml.common.exception import PyAMLException
+
+__all__ = ["ChannelReference", "parse_reference"]
+
+Mode = Literal["w", "rw"]
+
+_ADDR = r"[^\s()\[\],@]+"
+_REFERENCE_RE = re.compile(
+    rf"""
+    (?:
+        \(\s*(?P<rb>{_ADDR})\s*,\s*(?P<sp>{_ADDR})\s*\)    # (RB, SP)
+      | \(\s*(?P<wo>{_ADDR})\s*\)                          # (ADDR)
+      | (?P<bare>{_ADDR})                                  # ADDR
+    )
+    (?:\s*@\s*(?P<index>\d+))?
+    (?:\s*\[\s*(?P<unit>[^\[\]]*?)\s*\])?
+    """,
+    re.VERBOSE,
+)
+
+
+@dataclass(frozen=True)
+class ChannelReference:
+    """One parsed channel reference.
+
+    Attributes:
+        text: The reference as written, surrounding whitespace removed; excluded from
+            equality, so two spellings of one reference compare equal.
+        address: The address this reference writes; a bare reference also reads it.
+        readback: The separate readback address of a read-write pair, else ``None``.
+        mode: ``"w"`` for a write-only reference, else ``"rw"``.
+        unit: The unit suffix, ``''`` when absent.
+        index: The array element index, ``None`` for a scalar reference.
+    """
+
+    text: str = field(compare=False)
+    address: str
+    readback: str | None
+    mode: Mode
+    unit: str
+    index: int | None
+
+
+def parse_reference(text: object) -> ChannelReference:
+    """Parse a ``pyaml-cs-oa`` channel reference.
+
+    Args:
+        text: The reference string from a pyAML configuration; anything else is refused.
+
+    Returns:
+        The parsed reference.
+
+    Raises:
+        PyAMLException: The text does not follow the grammar; the message quotes it.
+    """
+    if not isinstance(text, str):
+        raise PyAMLException(f"channel reference must be a string, got {text!r}")
+    stripped = text.strip()
+    match = _REFERENCE_RE.fullmatch(stripped)
+    if match is None:
+        raise PyAMLException(
+            f"malformed channel reference {text!r}: expected ADDR[unit], (ADDR)[unit] "
+            "or (RB, SP)[unit], optionally with @index before the unit"
+        )
+    unit = match["unit"] or ""
+    index = int(match["index"]) if match["index"] is not None else None
+    address: str
+    readback: str | None = None
+    mode: Mode
+    if match["sp"] is not None:
+        address, readback, mode = match["sp"], match["rb"], "rw"
+    elif match["wo"] is not None:
+        address, mode = match["wo"], "w"
+    else:
+        address, mode = match["bare"], "rw"
+    return ChannelReference(stripped, address, readback, mode, unit, index)