psiqdk-workbench 4.45.0__py3-none-any.whl

psiqdk/workbench/__init__.py

@@ -0,0 +1,16 @@
+"""
+..  Copyright © 2026 PsiQuantum Corp.  All rights reserved.
+    PSIQUANTUM CORP. CONFIDENTIAL
+    This file includes unpublished proprietary source code of PsiQuantum Corp.
+    The copyright notice above does not evidence any actual or intended publication
+    of such source code. Disclosure of this source code or any related proprietary
+    information is strictly prohibited without the express written permission of
+    PsiQuantum Corp.
+
+Curated namespace package; exports are driven by the YAML mapping co-located with ``_curated_loader.py``.
+
+"""
+
+from psiqdk.workbench._curated_loader import apply_curated_exports
+
+apply_curated_exports(globals())

psiqdk/workbench/__init__.pyi

@@ -0,0 +1,39 @@
+# Generated by scripts/generate_psiqdk_workbench_stubs.py; do not edit.
+from __future__ import annotations
+
+from . import filter_presets as filter_presets
+from . import compilation as compilation
+from . import ops as ops
+from . import opcodes as opcodes
+from . import utils as utils
+from . import flow_control as flow_control
+from . import qubrick_machinery as qubrick_machinery
+from . import qpu as qpu
+from . import filter_machinery as filter_machinery
+from . import utility_filters as utility_filters
+from . import interoperability as interoperability
+from . import registers as registers
+from . import units as units
+from . import arithmetic as arithmetic
+from . import comparators as comparators
+from . import rotations as rotations
+from . import qft as qft
+from . import usp as usp
+from . import phase_gradients as phase_gradients
+from . import qre as qre
+from . import qubrick_interfaces as qubrick_interfaces
+from . import integrations as integrations
+from . import errors as errors
+from . import experimental as experimental
+from . import simulators as simulators
+from psiqworkbench import QPU as QPU
+from psiqworkbench.qpu.base_qpu import BaseQPU as BaseQPU
+from psiqworkbench import Qubits as Qubits
+from psiqworkbench.qubits.base_qubits import BaseQubits as BaseQubits
+from psiqworkbench import Qubrick as Qubrick
+from psiqworkbench import QUInt as QUInt
+from psiqworkbench import QInt as QInt
+from psiqworkbench import QUFixed as QUFixed
+from psiqworkbench import QFixed as QFixed
+
+__all__: tuple[str, ...]

psiqdk/workbench/_curated_loader.py

@@ -0,0 +1,389 @@
+# GENERATED BY create-psiqdk-namespace-package — do not edit by hand.
+# Regenerate via scripts/regenerate_psiqdk_*_namespace.sh in the owning repository.
+
+"""
+..  Copyright © 2026 PsiQuantum Corp.  All rights reserved.
+    PSIQUANTUM CORP. CONFIDENTIAL
+    This file includes unpublished proprietary source code of PsiQuantum Corp.
+    The copyright notice above does not evidence any actual or intended publication
+    of such source code. Disclosure of this source code or any related proprietary
+    information is strictly prohibited without the express written permission of
+    PsiQuantum Corp.
+
+Loader for the curated ``psiqdk.workbench`` surface defined in ``workbench-curated-mapping.yaml``.
+
+The mapping YAML has ``remapped`` (layout-only moves plus optional ``"*"`` root re-export list),
+optional ``renamed``, and optional ``aliased`` (re-exports from another installed package using
+fully-qualified ``<module>.<Symbol>`` leaf specs and the same ``"*"`` wildcard rules as ``remapped``,
+but with fully-qualified module paths). Entries listed under ``unsupported`` are not imported here
+(they remain on the legacy package only). Wildcard domains expand via ``_mapping_expand``.
+"""
+
+from __future__ import annotations
+
+import copy
+import importlib
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+
+from ._mapping_expand import (
+    assert_no_deprecated_root_blocks,
+    default_legacy_src_root_next_to_mapping,
+    expand_aliased_star_wildcards,
+    expand_remapped_module_redirects,
+    expand_star_wildcards,
+    extract_remapped_star_to_root,
+)
+
+_MAPPING_PATH = Path(__file__).with_name("workbench-curated-mapping.yaml")
+
+
+def _is_leaf(val: Any) -> bool:
+    return isinstance(val, str)
+
+
+def _deep_merge_export_trees(base: dict[str, Any], extra: dict[str, Any], path: str = "") -> None:
+    """Merge ``extra`` into ``base`` (mutates ``base``). Dict + dict recurse; conflict raises."""
+    for k, v in extra.items():
+        loc = f"{path}.{k}" if path else k
+        if k not in base:
+            base[k] = copy.deepcopy(v)
+            continue
+        if isinstance(base[k], dict) and isinstance(v, dict):
+            _deep_merge_export_trees(base[k], v, loc)
+        else:
+            msg = f"Duplicate export at {loc!r} (present in more than one of remapped / renamed / aliased)"
+            raise ValueError(msg)
+
+
+def _merge_remapped_renamed(remapped: dict[str, Any], renamed: dict[str, Any]) -> dict[str, Any]:
+    out = copy.deepcopy(remapped)
+    _deep_merge_export_trees(out, renamed)
+    return out
+
+
+def _validate_remapped_leaf_symmetry(export_key: str, spec: str, loc: str) -> None:
+    """``remapped`` leaves are layout-only: YAML key must match the imported symbol."""
+    s = spec.strip()
+    imported = s.rsplit(".", 1)[-1] if "." in s else s
+    if imported != export_key:
+        msg = (
+            f"{loc}: export {export_key!r} must match legacy imported symbol {imported!r} from spec "
+            f"{spec!r}; put intentional renames under `renamed`."
+        )
+        raise ValueError(msg)
+
+
+def _walk_validate_remapped_tree(node: dict[str, Any], path: str = "remapped") -> None:
+    for k, v in node.items():
+        loc = f"{path}.{k}"
+        if isinstance(v, dict):
+            _walk_validate_remapped_tree(v, loc)
+        elif isinstance(v, str):
+            _validate_remapped_leaf_symmetry(k, v, loc)
+        else:
+            msg = f"{loc}: expected dict or str leaf, got {type(v).__name__}"
+            raise TypeError(msg)
+
+
+def _validate_aliased_leaf_symmetry(export_key: str, spec: str, loc: str) -> None:
+    """``aliased`` re-exports keep the upstream symbol name as the public name."""
+    s = spec.strip()
+    if "." not in s:
+        msg = f"{loc}: aliased spec must be <fully.qualified.module>.<Symbol>, got {spec!r}"
+        raise ValueError(msg)
+    sym = s.rsplit(".", 1)[-1]
+    if sym != export_key:
+        msg = (
+            f"{loc}: export {export_key!r} must match upstream symbol {sym!r} from spec {spec!r}; "
+            "aliased entries are not for renaming."
+        )
+        raise ValueError(msg)
+
+
+def _walk_validate_aliased_tree(node: dict[str, Any], path: str = "aliased") -> None:
+    for k, v in node.items():
+        loc = f"{path}.{k}"
+        if isinstance(v, dict):
+            _walk_validate_aliased_tree(v, loc)
+        elif isinstance(v, str):
+            _validate_aliased_leaf_symmetry(k, v, loc)
+        else:
+            msg = f"{loc}: expected dict or str leaf, got {type(v).__name__}"
+            raise TypeError(msg)
+
+
+def _navigate_safe(node: dict[str, Any], segments: list[str]) -> dict[str, Any]:
+    cur: Any = node
+    for seg in segments:
+        if not isinstance(cur, dict) or seg not in cur:
+            return {}
+        cur = cur[seg]
+    return cur if isinstance(cur, dict) else {}
+
+
+def _ordered_subpackage_keys(nleg: dict[str, Any], nal: dict[str, Any]) -> list[str]:
+    out: list[str] = []
+    seen: set[str] = set()
+    for k, v in nleg.items():
+        if isinstance(v, dict) and k not in seen:
+            seen.add(k)
+            out.append(k)
+    for k, v in nal.items():
+        if isinstance(v, dict) and k not in seen:
+            seen.add(k)
+            out.append(k)
+    return out
+
+
+def load_workbook_mapping_at_path(mapping_path: Path) -> tuple[
+    str,
+    dict[str, Any],
+    dict[str, Any],
+    dict[str, Any],
+    dict[str, Any],
+    dict[str, Any],
+    dict[str, str],
+    dict[str, str],
+]:
+    """
+    Load and expand a Workbench-style curated mapping YAML (same semantics as the packaged
+    ``workbench-curated-mapping.yaml``).
+
+    Used by the migration assistant and tests that need a non-default mapping path. Prefer
+    :func:`mapping_path` + cached :func:`mapping_merged_tree` for normal package resolution.
+    """
+    import yaml
+
+    raw = yaml.safe_load(mapping_path.read_text(encoding="utf-8"))
+    assert_no_deprecated_root_blocks(raw)
+    domains_old: str = raw["domains"]["old"]
+    _src = default_legacy_src_root_next_to_mapping(mapping_path)
+    remapped_pre, wr_pre = extract_remapped_star_to_root(raw["remapped"])
+    remapped_star: dict[str, Any] = expand_star_wildcards(
+        remapped_pre, domains_old, legacy_src_root=_src
+    )
+    remapped, module_redirects = expand_remapped_module_redirects(
+        remapped_star, domains_old, legacy_src_root=_src
+    )
+    renamed: dict[str, Any] = expand_star_wildcards(
+        copy.deepcopy(raw.get("renamed") or {}), domains_old, legacy_src_root=_src
+    )
+    aliased: dict[str, Any] = expand_aliased_star_wildcards(
+        copy.deepcopy(raw.get("aliased") or {}), legacy_src_root=_src
+    )
+    _walk_validate_remapped_tree(remapped)
+    _walk_validate_aliased_tree(aliased)
+    merged_legacy = _merge_remapped_renamed(remapped, renamed)
+    merged_public = copy.deepcopy(merged_legacy)
+    _deep_merge_export_trees(merged_public, copy.deepcopy(aliased))
+    root_exports: dict[str, Any] = expand_star_wildcards(wr_pre, domains_old, legacy_src_root=_src)
+    _walk_validate_remapped_tree(root_exports, path="remapped['*'] (root exports)")
+    _bad = set(merged_public.keys()) & set(root_exports.keys())
+    if _bad:
+        msg = f"remapped['*'] root export keys conflict with remapped top-level packages: {sorted(_bad)!r}"
+        raise ValueError(msg)
+    _wr_out: dict[str, str] = {}
+    for _k, _v in root_exports.items():
+        if not isinstance(_v, str):
+            msg = (
+                f"remapped['*'] root export {_k!r} must be a string legacy spec after expansion, "
+                f"got {type(_v).__name__}"
+            )
+            raise TypeError(msg)
+        _wr_out[_k] = _v
+    return (
+        domains_old,
+        remapped,
+        renamed,
+        aliased,
+        merged_legacy,
+        merged_public,
+        _wr_out,
+        module_redirects,
+    )
+
+
+@lru_cache(maxsize=1)
+def _load_workbook_mapping() -> tuple[
+    str,
+    dict[str, Any],
+    dict[str, Any],
+    dict[str, Any],
+    dict[str, Any],
+    dict[str, Any],
+    dict[str, str],
+    dict[str, str],
+]:
+    return load_workbook_mapping_at_path(_MAPPING_PATH)
+
+
+def _resolve_legacy_leaf(domains_old: str, spec: Any, *, yaml_key: str | None = None) -> Any:
+    if not isinstance(spec, str):
+        msg = f"Invalid curated leaf spec: {spec!r}"
+        raise TypeError(msg)
+    _ctx = f" (YAML entry: {yaml_key!r}: {spec!r})" if yaml_key else f" (spec: {spec!r})"
+    if "." in spec:
+        mod_path, sym = spec.rsplit(".", 1)
+        if mod_path and sym:
+            full_mod = f"{domains_old}.{mod_path}"
+            try:
+                mod = importlib.import_module(full_mod)
+            except ImportError as exc:
+                msg = (
+                    f"Cannot import legacy module {full_mod!r}{_ctx}. "
+                    f"Check that the dotted path in the YAML spec is correct. "
+                    f"Original error: {exc}"
+                )
+                raise ImportError(msg) from exc
+            try:
+                return getattr(mod, sym)
+            except AttributeError as exc:
+                # Fallback: ``sym`` may be a submodule the parent's ``__init__``
+                # doesn't pre-import. Try importing it directly.
+                try:
+                    return importlib.import_module(f"{full_mod}.{sym}")
+                except ImportError:
+                    pass
+                msg = (
+                    f"Module {full_mod!r} has no attribute {sym!r}{_ctx}. "
+                    f"The symbol may not be re-exported from the package __init__; "
+                    f"use the full sub-module path in the spec (e.g. "
+                    f"{mod_path}.submodule.{sym})."
+                )
+                raise AttributeError(msg) from exc
+    try:
+        root = importlib.import_module(domains_old)
+        return getattr(root, spec)
+    except AttributeError as exc:
+        # Fallback: ``spec`` may be a submodule of the root package.
+        try:
+            return importlib.import_module(f"{domains_old}.{spec}")
+        except ImportError:
+            pass
+        msg = (
+            f"Package {domains_old!r} has no attribute {spec!r}{_ctx}. "
+            f"Check that the symbol is exported from {domains_old}.__init__."
+        )
+        raise AttributeError(msg) from exc
+
+
+def _resolve_fq_leaf(spec: str) -> Any:
+    """Resolve ``package.submodule.Symbol`` from an installed module."""
+    if not isinstance(spec, str):
+        msg = f"Invalid aliased leaf spec: {spec!r}"
+        raise TypeError(msg)
+    s = spec.strip()
+    if "." not in s:
+        msg = f"Invalid aliased leaf spec: {spec!r}"
+        raise ValueError(msg)
+    mod_path, sym = s.rsplit(".", 1)
+    if not mod_path or not sym:
+        msg = f"Invalid aliased leaf spec: {spec!r}"
+        raise ValueError(msg)
+    mod = importlib.import_module(mod_path)
+    try:
+        return getattr(mod, sym)
+    except AttributeError:
+        # Fallback: ``sym`` may be a submodule of ``mod_path``.
+        return importlib.import_module(f"{mod_path}.{sym}")
+
+
+def apply_curated_exports(module_globals: dict[str, Any]) -> None:
+    """
+    Populate ``module_globals`` for ``psiqdk.workbench`` or a subpackage,
+    using the sibling YAML file as the single source of truth.
+
+    Resolution is lazy: ``__all__`` is computed up front from the mapping,
+    but the legacy modules backing each export are not imported until the
+    corresponding attribute is accessed (via PEP 562 ``__getattr__``).
+    """
+    name: str = module_globals["__name__"]
+    domains_old, _, _, aliased_tree, merged_legacy, _, root_exports, _module_redirects = _load_workbook_mapping()
+
+    if name == "psiqdk.workbench":
+        segments: list[str] = []
+    else:
+        prefix = "psiqdk.workbench."
+        if not name.startswith(prefix):
+            msg = f"Unexpected module applying curated exports: {name}"
+            raise ValueError(msg)
+        suffix = name.removeprefix(prefix)
+        segments = suffix.split(".") if suffix else []
+
+    nleg = _navigate_safe(merged_legacy, segments)
+    nal = _navigate_safe(aliased_tree, segments)
+
+    subpackage_keys: list[str] = list(_ordered_subpackage_keys(nleg, nal))
+    leaf_specs: dict[str, str] = {k: v for k, v in nleg.items() if _is_leaf(v)}
+    aliased_specs: dict[str, str] = {k: v for k, v in nal.items() if _is_leaf(v)}
+    root_specs: dict[str, str] = (
+        dict(root_exports) if name == "psiqdk.workbench" else {}
+    )
+
+    exports: list[str] = (
+        list(subpackage_keys)
+        + list(root_specs.keys())
+        + list(leaf_specs.keys())
+        + list(aliased_specs.keys())
+    )
+
+    def __getattr__(attr: str) -> Any:
+        if attr in subpackage_keys:
+            sub = importlib.import_module(f"{name}.{attr}")
+            module_globals[attr] = sub
+            return sub
+        if attr in root_specs:
+            val = _resolve_legacy_leaf(domains_old, root_specs[attr], yaml_key=attr)
+            module_globals[attr] = val
+            return val
+        if attr in leaf_specs:
+            val = _resolve_legacy_leaf(domains_old, leaf_specs[attr], yaml_key=attr)
+            module_globals[attr] = val
+            return val
+        if attr in aliased_specs:
+            val = _resolve_fq_leaf(aliased_specs[attr])
+            module_globals[attr] = val
+            return val
+        msg = f"module {name!r} has no attribute {attr!r}"
+        raise AttributeError(msg)
+
+    def __dir__() -> list[str]:
+        return sorted(set(exports) | set(module_globals.keys()))
+
+    module_globals["__all__"] = tuple(exports)
+    module_globals["__getattr__"] = __getattr__
+    module_globals["__dir__"] = __dir__
+
+
+def mapping_merged_tree() -> dict[str, Any]:
+    """Return the merged ``remapped`` + ``renamed`` + ``aliased`` tree (installed export layout)."""
+    return copy.deepcopy(_load_workbook_mapping()[5])
+
+
+def mapping_workbench_root() -> dict[str, str]:
+    """Return root star re-exports for ``from psiqdk.workbench import …`` (legacy specs from ``remapped['*']``)."""
+    return copy.deepcopy(_load_workbook_mapping()[6])
+
+
+def mapping_remapped_tree() -> dict[str, Any]:
+    return copy.deepcopy(_load_workbook_mapping()[1])
+
+
+def mapping_renamed_tree() -> dict[str, Any]:
+    return copy.deepcopy(_load_workbook_mapping()[2])
+
+
+def mapping_aliased_tree() -> dict[str, Any]:
+    """Return the ``aliased`` subtree (dependency re-exports; values are ``<module>.<Symbol>``)."""
+    return copy.deepcopy(_load_workbook_mapping()[3])
+
+
+def curated_public_tree() -> dict[str, Any]:
+    """Backward-compatible alias for :func:`mapping_merged_tree`."""
+    return mapping_merged_tree()
+
+
+def mapping_path() -> Path:
+    return _MAPPING_PATH