hyperfold 0.1.1__cp313-cp313-win_amd64.whl

hyperfold/__init__.py

@@ -0,0 +1,153 @@
+"""NumPy-first Python API for Hyperfold HPC."""
+
+
+# start delvewheel patch
+def _delvewheel_patch_1_13_0():
+    import os
+    if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'hyperfold.libs'))):
+        os.add_dll_directory(libs_dir)
+
+
+_delvewheel_patch_1_13_0()
+del _delvewheel_patch_1_13_0
+# end delvewheel patch
+
+from ._cpu_features import require_wheel_baseline as _require_wheel_baseline
+from ._loader import prepare_cuda_runtime as _prepare_cuda_runtime
+from ._variant import require_single_distribution as _require_single_distribution
+
+_installed_distribution = _require_single_distribution()
+_require_wheel_baseline()
+_prepare_cuda_runtime(_installed_distribution == "hyperfold-cuda")
+del _prepare_cuda_runtime, _require_single_distribution, _require_wheel_baseline
+
+try:
+    from . import _native as _native_probe
+except ImportError as error:
+    detail = str(error).lower()
+    if any(name in detail for name in ("libcuda", "libcudart", "libcublas", "libcusolver", "libcusparse", "libnvjitlink")):
+        raise ImportError(
+            "Hyperfold's CUDA extension could not load its NVIDIA runtime libraries. "
+            "Reinstall hyperfold-cuda in a clean environment and ensure a compatible NVIDIA driver is available."
+        ) from error
+    raise
+
+from ._dtypes import complex32, pack_complex32, unpack_complex32
+from . import cuda
+from ._core import BackendError, Context, available_backends, build_info
+from ._extensions import (
+    AlgorithmParameter,
+    BackendKind,
+    BackendOperandSpec,
+    ComplexLayout,
+    ComplexityDescription,
+    ContextBuilder,
+    DataLocation,
+    EigenOperand,
+    ExtensionKind,
+    ExtensionProvenance,
+    ExtensionRegistrar,
+    ImplementationNumerics,
+    ImplementationOperandDescription,
+    Invocation,
+    KernelSpec,
+    LUOperand,
+    MatrixLayout,
+    OperandAccess,
+    OperandKind,
+    OperandRole,
+    OperandShape,
+    OperandSpec,
+    NumericalRequirement,
+    NumericalRequirementKind,
+    OperationDescription,
+    OperationId,
+    OperationImplementation,
+    OperationNumerics,
+    OperationOperandDescription,
+    OperationSpec,
+    PrecisionDescription,
+    PrecisionMode,
+    ReductionOrder,
+    RequirementEnforcement,
+    RequirementPurpose,
+    ShapeConstraint,
+    ShapeRelation,
+    Stability,
+    StorageFormat,
+    SymbolicExpression,
+    SymbolicOperator,
+)
+from ._operations import (
+    add,
+    adjoint,
+    conjugate,
+    divide,
+    eye,
+    inner,
+    is_unitary,
+    kron,
+    matmul,
+    matrix_power,
+    matvec,
+    multiply,
+    norm,
+    outer,
+    partial_trace,
+    scale,
+    sqrt,
+    subtract,
+    sum,
+    trace,
+    transpose,
+    vector_equal,
+)
+from ._solvers import (
+    LUFactor, eig, eigh, eigvalsh, logdet_positive_definite, lu_factor,
+    principal_eigenvector, slogdet, solve,
+)
+
+__version__ = str(_native_probe.build_info()["version"])
+
+
+def get_include() -> str:
+    """Return the include root containing Hyperfold's native plug-in SDK."""
+    from pathlib import Path
+
+    packaged = Path(__file__).resolve().parent / "include"
+    if packaged.is_dir():
+        return str(packaged)
+    return str(Path(__file__).resolve().parents[2] / "include")
+
+__all__ = [
+    "complex32",
+    "pack_complex32",
+    "unpack_complex32",
+    "BackendError", "Context", "add", "subtract", "multiply", "sqrt",
+    "conjugate", "sum", "scale", "divide", "transpose", "adjoint",
+    "matmul", "matvec", "kron", "outer", "trace", "inner", "norm",
+    "vector_equal", "eye", "LUFactor", "lu_factor", "solve", "eig",
+    "eigh", "eigvalsh", "slogdet", "logdet_positive_definite",
+    "principal_eigenvector", "matrix_power", "partial_trace", "is_unitary",
+    "available_backends", "build_info", "get_include", "cuda",
+    "ContextBuilder", "ExtensionRegistrar", "OperationId", "OperationSpec", "OperandSpec",
+    "BackendOperandSpec", "KernelSpec", "Invocation", "OperandAccess",
+    "OperandKind", "OperandRole", "BackendKind",
+    "MatrixLayout", "ExtensionKind", "DataLocation", "StorageFormat",
+    "ComplexLayout", "ExtensionProvenance", "OperationOperandDescription",
+    "ImplementationOperandDescription", "OperationImplementation",
+    "OperationDescription", "SymbolicOperator", "SymbolicExpression",
+    "ShapeRelation", "OperandShape", "ShapeConstraint",
+    "NumericalRequirementKind", "RequirementPurpose",
+    "RequirementEnforcement", "NumericalRequirement", "OperationNumerics",
+    "Stability", "PrecisionMode", "ReductionOrder",
+    "ComplexityDescription", "PrecisionDescription", "AlgorithmParameter",
+    "ImplementationNumerics",
+    "LUOperand", "EigenOperand",
+]
+
+for _public_name in __all__:
+    _public_object = globals()[_public_name]
+    if callable(_public_object):
+        _public_object.__module__ = __name__
+del _public_name, _public_object

hyperfold/__init__.pyi

@@ -0,0 +1,405 @@
+from collections.abc import Callable, Mapping, Sequence
+from enum import Enum, StrEnum
+from os import PathLike
+from typing import Any, Literal
+from . import cuda
+import numpy as np
+
+complex32: np.dtype[Any]
+def pack_complex32(values: Any) -> Any: ...
+def unpack_complex32(values: Any) -> Any: ...
+
+class BackendError(RuntimeError):
+    operation: str
+    reason: str
+    device: int | None
+    native_status: int | None
+    def __init__(self, message: str, *, operation: str = ..., reason: str = ..., device: int | None = ..., native_status: int | None = ...) -> None: ...
+
+class Context:
+    cpu_threads: int
+    parallel_work_threshold: int
+    numa_policy: str
+    pinning_policy: str
+    cuda_devices: int | Sequence[int] | None
+    stream_pool_size: int
+    external_stream: int | None
+    scheduling: str
+    cross_device: str
+    def __init__(self, *, cpu_threads: int = ..., parallel_work_threshold: int = ..., numa_policy: str = ..., pinning_policy: str = ..., cuda_devices: int | Sequence[int] | None = ..., stream_pool_size: int = ..., external_stream: int | None = ..., scheduling: str = ..., cross_device: str = ...) -> None: ...
+    def operations(self) -> tuple[OperationId, ...]: ...
+    def describe(self, operation: str | OperationId) -> OperationDescription: ...
+    def execute(self, operation: str | OperationId, bindings: Mapping[OperandRole, Any], *, compute_dtypes: Mapping[OperandRole, Any] | None = ...) -> Any: ...
+
+class OperandAccess(StrEnum):
+    READ: OperandAccess
+    WRITE: OperandAccess
+    READ_WRITE: OperandAccess
+
+class OperandRole(Enum):
+    INPUT_0: OperandRole
+    INPUT_1: OperandRole
+    INPUT_2: OperandRole
+    OUTPUT: OperandRole
+    OUTPUT_0: OperandRole
+    OUTPUT_1: OperandRole
+    OUTPUT_2: OperandRole
+    value: int
+    input_index: int
+    output_index: int
+    @classmethod
+    def input(cls, index: int) -> OperandRole: ...
+    @classmethod
+    def output(cls, index: int) -> OperandRole: ...
+
+class OperandKind(StrEnum):
+    SCALAR: OperandKind
+    VECTOR: OperandKind
+    MATRIX: OperandKind
+    LU: OperandKind
+    EIGEN: OperandKind
+
+class BackendKind(StrEnum):
+    CPU_SCALAR: BackendKind
+    CPU_SIMD: BackendKind
+    CUDA: BackendKind
+
+class MatrixLayout(StrEnum):
+    ROW_MAJOR: MatrixLayout
+    COLUMN_MAJOR: MatrixLayout
+
+class ExtensionKind(StrEnum):
+    BUILTIN: ExtensionKind
+    PYTHON: ExtensionKind
+    NATIVE: ExtensionKind
+
+class DataLocation(StrEnum):
+    PAGEABLE_HOST: DataLocation
+    PINNED_HOST: DataLocation
+    CUDA_DEVICE: DataLocation
+
+class StorageFormat(StrEnum):
+    DENSE: StorageFormat
+    SPARSE: StorageFormat
+    DIAGONAL: StorageFormat
+    CSR: StorageFormat
+    CSC: StorageFormat
+    COO: StorageFormat
+
+class ComplexLayout(StrEnum):
+    NONE: ComplexLayout
+    SPLIT: ComplexLayout
+    INTERLEAVED: ComplexLayout
+
+class SymbolicOperator(StrEnum):
+    UNKNOWN: SymbolicOperator
+    CONSTANT: SymbolicOperator
+    SYMBOL: SymbolicOperator
+    OPERAND_DIMENSION: SymbolicOperator
+    OPERAND_VALUE: SymbolicOperator
+    ADD: SymbolicOperator
+    MULTIPLY: SymbolicOperator
+    POWER: SymbolicOperator
+    DIVIDE: SymbolicOperator
+    MINIMUM: SymbolicOperator
+    MAXIMUM: SymbolicOperator
+    LOG2: SymbolicOperator
+
+class ShapeRelation(StrEnum):
+    EQUAL: ShapeRelation
+    LESS_EQUAL: ShapeRelation
+    GREATER_EQUAL: ShapeRelation
+    DIVISIBLE_BY: ShapeRelation
+
+class NumericalRequirementKind(StrEnum):
+    FINITE: NumericalRequirementKind
+    NONZERO: NumericalRequirementKind
+    NONNEGATIVE: NumericalRequirementKind
+    POSITIVE: NumericalRequirementKind
+    NONSINGULAR: NumericalRequirementKind
+    HERMITIAN: NumericalRequirementKind
+    NORMAL: NumericalRequirementKind
+    POSITIVE_DEFINITE: NumericalRequirementKind
+    UNIQUE_DOMINANT_EIGENVALUE: NumericalRequirementKind
+
+class RequirementPurpose(StrEnum):
+    EXECUTION: RequirementPurpose
+    DEFINED_RESULT: RequirementPurpose
+    UNIQUE_RESULT: RequirementPurpose
+    ACCURACY: RequirementPurpose
+
+class RequirementEnforcement(StrEnum):
+    CHECKED: RequirementEnforcement
+    GUARANTEED_BY_OPERAND: RequirementEnforcement
+    CALLER_RESPONSIBILITY: RequirementEnforcement
+
+class Stability(StrEnum):
+    EXACT: Stability
+    BACKWARD_STABLE: Stability
+    CONDITIONALLY_STABLE: Stability
+    NOT_GUARANTEED: Stability
+    UNKNOWN: Stability
+
+class PrecisionMode(StrEnum):
+    EXACT: PrecisionMode
+    NATIVE: PrecisionMode
+    WIDENED: PrecisionMode
+    MIXED: PrecisionMode
+    UNKNOWN: PrecisionMode
+
+class ReductionOrder(StrEnum):
+    NOT_APPLICABLE: ReductionOrder
+    SEQUENTIAL: ReductionOrder
+    PAIRWISE: ReductionOrder
+    PARALLEL_TREE: ReductionOrder
+    LIBRARY_DEFINED: ReductionOrder
+    UNKNOWN: ReductionOrder
+
+class SymbolicExpression:
+    operator: SymbolicOperator
+    operands: tuple[SymbolicExpression, ...]
+    integer: int | None
+    name: str | None
+    role: OperandRole | None
+    axis: int | None
+    canonical: str
+    def __init__(self, operator: SymbolicOperator, operands: tuple[SymbolicExpression, ...] = ..., integer: int | None = ..., name: str | None = ..., role: OperandRole | None = ..., axis: int | None = ...) -> None: ...
+    @classmethod
+    def unknown(cls) -> SymbolicExpression: ...
+    @classmethod
+    def constant(cls, value: int) -> SymbolicExpression: ...
+    @classmethod
+    def symbol(cls, name: str) -> SymbolicExpression: ...
+    @classmethod
+    def dimension(cls, role: OperandRole, axis: int) -> SymbolicExpression: ...
+    @classmethod
+    def scalar_value(cls, role: OperandRole) -> SymbolicExpression: ...
+    @classmethod
+    def operation(cls, operator: SymbolicOperator, *operands: SymbolicExpression) -> SymbolicExpression: ...
+
+class OperandShape:
+    role: OperandRole
+    rank: int
+    def __init__(self, role: OperandRole, rank: int) -> None: ...
+
+class ShapeConstraint:
+    left: SymbolicExpression
+    relation: ShapeRelation
+    right: SymbolicExpression
+    def __init__(self, left: SymbolicExpression, relation: ShapeRelation, right: SymbolicExpression) -> None: ...
+
+class NumericalRequirement:
+    kind: NumericalRequirementKind
+    roles: tuple[OperandRole, ...]
+    purpose: RequirementPurpose
+    enforcement: RequirementEnforcement
+    note: str
+    def __init__(self, kind: NumericalRequirementKind, roles: tuple[OperandRole, ...], purpose: RequirementPurpose, enforcement: RequirementEnforcement, note: str) -> None: ...
+
+class OperationNumerics:
+    shapes: tuple[OperandShape, ...]
+    constraints: tuple[ShapeConstraint, ...]
+    requirements: tuple[NumericalRequirement, ...]
+    notes: tuple[str, ...]
+    def __init__(self, shapes: tuple[OperandShape, ...], constraints: tuple[ShapeConstraint, ...] = ..., requirements: tuple[NumericalRequirement, ...] = ..., notes: tuple[str, ...] = ...) -> None: ...
+
+class ComplexityDescription:
+    work: SymbolicExpression
+    auxiliary_space: SymbolicExpression
+    notes: tuple[str, ...]
+    def __init__(self, work: SymbolicExpression, auxiliary_space: SymbolicExpression, notes: tuple[str, ...] = ...) -> None: ...
+
+class PrecisionDescription:
+    mode: PrecisionMode
+    accumulation_dtype: str | None
+    reduction_order: ReductionOrder
+    notes: tuple[str, ...]
+    def __init__(self, mode: PrecisionMode, accumulation_dtype: str | None, reduction_order: ReductionOrder, notes: tuple[str, ...] = ...) -> None: ...
+
+class AlgorithmParameter:
+    name: str
+    value: int | float | str
+    description: str
+    def __init__(self, name: str, value: int | float | str, description: str) -> None: ...
+
+class ImplementationNumerics:
+    algorithm: str
+    stability: Stability
+    complexity: ComplexityDescription
+    precision: PrecisionDescription
+    parameters: tuple[AlgorithmParameter, ...]
+    notes: tuple[str, ...]
+    def __init__(self, algorithm: str, stability: Stability, complexity: ComplexityDescription, precision: PrecisionDescription, parameters: tuple[AlgorithmParameter, ...] = ..., notes: tuple[str, ...] = ...) -> None: ...
+
+class OperationId:
+    name: str
+    major: int
+    canonical: str
+    def __init__(self, name: str, major: int = ...) -> None: ...
+    @classmethod
+    def parse(cls, value: str | OperationId) -> OperationId: ...
+
+class ExtensionProvenance:
+    kind: ExtensionKind
+    id: str
+    version: str | None
+    def __init__(self, kind: ExtensionKind, id: str, version: str | None = ...) -> None: ...
+
+class OperationOperandDescription:
+    role: OperandRole
+    access: OperandAccess
+    kind: OperandKind | None
+    def __init__(self, role: OperandRole, access: OperandAccess, kind: OperandKind | None) -> None: ...
+
+class ImplementationOperandDescription:
+    role: OperandRole
+    access: OperandAccess
+    kind: OperandKind
+    dtype: str
+    location: DataLocation
+    storage_format: StorageFormat | None
+    complex_layout: ComplexLayout
+    matrix_layout: MatrixLayout | None
+    compute_dtype: str
+    def __init__(self, role: OperandRole, access: OperandAccess, kind: OperandKind, dtype: str, location: DataLocation, storage_format: StorageFormat | None, complex_layout: ComplexLayout, matrix_layout: MatrixLayout | None, compute_dtype: str | None = ...) -> None: ...
+
+class OperationImplementation:
+    backend: BackendKind
+    operands: tuple[ImplementationOperandDescription, ...]
+    provenance: ExtensionProvenance
+    numerics: ImplementationNumerics | None
+    def __init__(self, backend: BackendKind, operands: tuple[ImplementationOperandDescription, ...], provenance: ExtensionProvenance, numerics: ImplementationNumerics | None = ...) -> None: ...
+
+class OperationDescription:
+    id: OperationId
+    operands: tuple[OperationOperandDescription, ...]
+    provenance: ExtensionProvenance
+    implementations: tuple[OperationImplementation, ...]
+    numerics: OperationNumerics | None
+    def __init__(self, id: OperationId, operands: tuple[OperationOperandDescription, ...], provenance: ExtensionProvenance, implementations: tuple[OperationImplementation, ...], numerics: OperationNumerics | None = ...) -> None: ...
+
+class OperandSpec:
+    role: OperandRole
+    kind: OperandKind
+    access: OperandAccess
+    def __init__(self, role: OperandRole, kind: OperandKind, access: OperandAccess = ...) -> None: ...
+
+class OperationSpec:
+    operation: OperationId
+    operands: Sequence[OperandSpec]
+    validator: Callable[[Mapping[OperandRole, Any]], None] | None
+    numerics: OperationNumerics | None
+    output: OperandSpec
+    outputs: tuple[OperandSpec, ...]
+    output_count: int
+    output_roles: tuple[OperandRole, ...]
+    def __init__(self, operation: str | OperationId, operands: Sequence[OperandSpec], validator: Callable[[Mapping[OperandRole, Any]], None] | None = ..., numerics: OperationNumerics | None = ...) -> None: ...
+    def preserves_output(self, role: OperandRole = ...) -> bool: ...
+
+class BackendOperandSpec:
+    role: OperandRole
+    kind: OperandKind
+    access: OperandAccess
+    dtype: str
+    matrix_layout: MatrixLayout | None
+    compute_dtype: str
+    def __init__(self, role: OperandRole, kind: OperandKind, access: OperandAccess = ..., dtype: str = ..., matrix_layout: MatrixLayout | str | None = ..., compute_dtype: str | None = ...) -> None: ...
+
+class Invocation:
+    bindings: Mapping[OperandRole, Any]
+    backend: BackendKind
+    cuda_device: int | None
+    stream: int | None
+    compute_dtypes: Mapping[OperandRole, str]
+
+class KernelSpec:
+    operation: OperationId
+    backend: BackendKind
+    operands: Sequence[BackendOperandSpec]
+    callback: Callable[[Invocation], None]
+    numerics: ImplementationNumerics | None
+    id: OperationId
+    def __init__(self, operation: str | OperationId, backend: BackendKind, operands: Sequence[BackendOperandSpec], callback: Callable[[Invocation], None], numerics: ImplementationNumerics | None = ...) -> None: ...
+
+class ExtensionRegistrar:
+    id: str
+    def register_operation(self, operation: OperationSpec) -> ExtensionRegistrar: ...
+    def register_kernel(self, kernel: KernelSpec) -> ExtensionRegistrar: ...
+
+class ContextBuilder:
+    def __init__(self, **context_options: Any) -> None: ...
+    def extension(self, extension_id: str) -> ExtensionRegistrar: ...
+    def load_plugin(self, path: str | PathLike[str]) -> ContextBuilder: ...
+    def build(self) -> Context: ...
+
+class LUOperand:
+    def __init__(self, value: int | Any, *, dtype: Any = ..., compute_dtype: Any = ...) -> None: ...
+    @property
+    def dtype(self) -> Any: ...
+    @property
+    def compute_dtype(self) -> Any: ...
+    @property
+    def size(self) -> int: ...
+    @property
+    def pivots(self) -> Any: ...
+    @property
+    def factors(self) -> Any: ...
+    @property
+    def swaps(self) -> int: ...
+
+class EigenOperand:
+    def __init__(self, size: int, *, dtype: Any = ..., compute_dtype: Any = ...) -> None: ...
+    @property
+    def dtype(self) -> Any: ...
+    @property
+    def compute_dtype(self) -> Any: ...
+    @property
+    def size(self) -> int: ...
+    @property
+    def values(self) -> Any: ...
+    @property
+    def vectors(self) -> Any: ...
+
+class LUFactor:
+    @property
+    def dtype(self) -> Any: ...
+    @property
+    def size(self) -> int: ...
+    def solve(self, b: Any, *, out: Any = ..., copy: bool | None = ...) -> Any: ...
+    def logdet(self) -> Any: ...
+
+def add(left: Any, right: Any, *, out: Any = ..., context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def get_include() -> str: ...
+def subtract(left: Any, right: Any, *, out: Any = ..., context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def multiply(left: Any, right: Any, *, out: Any = ..., context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def sqrt(value: Any, *, out: Any = ..., context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def conjugate(value: Any, *, out: Any = ..., context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def sum(value: Any, *, context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def scale(value: Any, scalar: Any, *, out: Any = ..., context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def divide(value: Any, scalar: Any, *, out: Any = ..., context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def transpose(value: Any, *, out: Any = ..., context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def adjoint(value: Any, *, out: Any = ..., context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def matmul(left: Any, right: Any, *, out: Any = ..., context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def matvec(matrix: Any, vector: Any, *, out: Any = ..., context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def kron(left: Any, right: Any, *, out: Any = ..., context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def outer(left: Any, right: Any, *, out: Any = ..., context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def trace(value: Any, *, context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def inner(left: Any, right: Any, *, context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def norm(value: Any, *, context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def vector_equal(left: Any, right: Any, *, context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def eye(n: int, *, like: Any = ..., dtype: Any = ..., out: Any = ..., context: Context | None = ...) -> Any: ...
+def lu_factor(a: Any, *, context: Context | None = ..., copy: bool | None = ...) -> LUFactor: ...
+def solve(a: Any, b: Any, *, out: Any = ..., context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def eig(a: Any, *, context: Context | None = ..., copy: bool | None = ...) -> tuple[Any, Any]: ...
+def eigh(a: Any, *, context: Context | None = ..., copy: bool | None = ...) -> tuple[Any, Any]: ...
+def eigvalsh(a: Any, *, context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def slogdet(a: Any, *, context: Context | None = ..., copy: bool | None = ...) -> tuple[Any, Any]: ...
+def logdet_positive_definite(a: Any, *, context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def principal_eigenvector(a: Any, *, out: Any = ..., context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def matrix_power(a: Any, n: int, *, out: Any = ..., context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def partial_trace(a: Any, dims: tuple[int, int], trace_out: Literal["left", "right"] = ..., *, out: Any = ..., context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def is_unitary(a: Any, *, context: Context | None = ..., copy: bool | None = ...) -> Any: ...
+def available_backends() -> tuple[str, ...]: ...
+def build_info() -> dict[str, Any]: ...
+
+__version__: str