classiq 0.37.1__py3-none-any.whl → 0.39.0__py3-none-any.whl

classiq/model/logic_flow.py

@@ -1,149 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, Optional, Tuple
-
-import networkx as nx
-
-from classiq.interface.generator.function_params import PortDirection
-from classiq.interface.generator.quantum_function_call import (
-    ZERO_INDICATOR,
-    SynthesisQuantumFunctionCall,
-)
-
-from classiq.exceptions import ClassiqWiringError
-from classiq.model import logic_flow_change_handler
-from classiq.quantum_register import QReg, Qubit
-
-
-# We need the dataclass to be hashable for inserting it into the graph,
-# hence the dataclass is frozen.
-@dataclass(frozen=True)
-class _Pin:
-    pin_name: str
-    index: int
-    func_call: Optional[SynthesisQuantumFunctionCall]
-    io: PortDirection  # We need to store PortDirection because a function may have an input and an output pin with the same name
-
-    def __str__(self) -> str:
-        return f"{self.pin_name}[{self.index}]"
-
-
-@dataclass(frozen=True)
-class _ZeroPin(_Pin):
-    def __init__(self, io: PortDirection) -> None:
-        super().__init__(pin_name=ZERO_INDICATOR, index=0, func_call=None, io=io)
-
-    def __str__(self) -> str:
-        return ZERO_INDICATOR
-
-
-class _StrictDiGraph(nx.DiGraph):
-    def add_edge(self, u_of_edge: Any, v_of_edge: Any, **attr: Any) -> None:
-        if u_of_edge in self and v_of_edge in self[u_of_edge]:
-            raise ClassiqWiringError(
-                f"Cannot reconnect an already connected edge: {u_of_edge}, {v_of_edge}"
-            )
-        super().add_edge(u_of_edge, v_of_edge, **attr)
-
-
-INVALID_QUBITS_ERROR_MESSAGE = (
-    "Cannot use a QReg with consumed or uninitialized qubits:"
-)
-
-
-class LogicFlowBuilder:
-    def __init__(self) -> None:
-        self._logic_flow_graph = _StrictDiGraph()
-        self._connect_qubit_func = {
-            PortDirection.Input: self._connect_qubit_to_func_call,
-            PortDirection.Output: self._connect_func_call_to_qubit,
-        }
-
-    def _is_qubit_available(self, qubit: Qubit) -> bool:
-        return qubit in self._logic_flow_graph.nodes
-
-    def _validate_qreg(self, qreg: QReg) -> None:
-        invalid_qubit_indices = [
-            i
-            for i, qubit in enumerate(qreg.qubits)
-            if not self._is_qubit_available(qubit)
-        ]
-        if invalid_qubit_indices:
-            raise ClassiqWiringError(
-                f"{INVALID_QUBITS_ERROR_MESSAGE} {invalid_qubit_indices}"
-            )
-
-    def _verify_no_loops(self, dest_node: SynthesisQuantumFunctionCall) -> None:
-        if not nx.is_directed_acyclic_graph(self._logic_flow_graph):
-            raise ClassiqWiringError(f"Cannot wire function {dest_node} to itself")
-
-    def _connect_qubit_to_func_call(
-        self,
-        qubit: Qubit,
-        dest_pin: _Pin,
-        dest_node: Optional[SynthesisQuantumFunctionCall],
-    ) -> None:
-        if dest_node is not None:
-            self._logic_flow_graph.add_edge(dest_pin, dest_node)
-        source_node, source_pin = self._get_source_node_and_pin(qubit)
-        # relabel_nodes replaces a node with another (inplace and keeping the edges)
-        nx.relabel_nodes(self._logic_flow_graph, {qubit: dest_pin}, copy=False)
-        logic_flow_change_handler.handle_inner_connection(
-            source_node,
-            str(source_pin),
-            str(dest_pin),
-            dest_node,
-        )
-
-    def _get_source_node_and_pin(
-        self, qubit: Qubit
-    ) -> Tuple[SynthesisQuantumFunctionCall, _Pin]:
-        source_pin = next(self._logic_flow_graph.predecessors(qubit))
-        source_node = next(self._logic_flow_graph.predecessors(source_pin))
-        return source_node, source_pin
-
-    def _connect_func_call_to_qubit(
-        self, qubit: Qubit, source_pin: _Pin, source_node: SynthesisQuantumFunctionCall
-    ) -> None:
-        self._logic_flow_graph.add_edge(source_node, source_pin)
-        self._logic_flow_graph.add_edge(source_pin, qubit)
-
-    def _connect_io(
-        self,
-        io: PortDirection,
-        func_node: SynthesisQuantumFunctionCall,
-        pin_name: str,
-        qreg: QReg,
-        pin_indices: Optional[range] = None,
-    ) -> None:
-        if pin_indices is None:
-            pin_indices = range(len(qreg))
-        pins = [_Pin(pin_name, i, func_node, io) for i in pin_indices]
-        for pin, qubit in zip(pins, qreg.qubits):
-            self._connect_qubit_func[io](qubit, pin, func_node)
-
-    def connect_qreg_to_func_call(
-        self,
-        source: QReg,
-        dest_pin_name: str,
-        dest_func_call: SynthesisQuantumFunctionCall,
-        pin_indices: Optional[range] = None,
-    ) -> None:
-        self._validate_qreg(source)
-        self._connect_io(
-            PortDirection.Input, dest_func_call, dest_pin_name, source, pin_indices
-        )
-        self._verify_no_loops(dest_func_call)
-
-    def connect_func_call_to_qreg(
-        self,
-        source_func_call: SynthesisQuantumFunctionCall,
-        source_pin_name: str,
-        dest: QReg,
-    ) -> None:
-        self._connect_io(PortDirection.Output, source_func_call, source_pin_name, dest)
-
-    def connect_qreg_to_zero(self, source: QReg) -> None:
-        for qubit in source.qubits:
-            self._connect_qubit_to_func_call(
-                qubit, _ZeroPin(PortDirection.Output), None
-            )

classiq/model/logic_flow_change_handler.py

@@ -1,71 +0,0 @@
-from typing import Optional
-
-from classiq.interface.generator.function_params import PortDirection
-from classiq.interface.generator.quantum_function_call import (
-    ZERO_INDICATOR,
-    SynthesisQuantumFunctionCall,
-)
-
-
-def _get_io_wire_name(
-    name: str, call: SynthesisQuantumFunctionCall, io: PortDirection
-) -> str:
-    if io == PortDirection.Input:
-        return f"{io.name}:{name}->{call.name}:{name}"
-    else:
-        return f"{call.name}:{name}->{io.name}:{name}"
-
-
-def _get_wire_name(
-    source_call: SynthesisQuantumFunctionCall,
-    source_pin_name: str,
-    dest_pin_name: str,
-    dest_call: Optional[SynthesisQuantumFunctionCall],
-) -> str:
-    if dest_call is None:
-        assert dest_pin_name == ZERO_INDICATOR
-        return ZERO_INDICATOR
-    return f"{source_call.name}:{source_pin_name}->{dest_call.name}:{dest_pin_name}"
-
-
-def _set_model_output(
-    call: SynthesisQuantumFunctionCall, pin_name: str, wire_name: str
-) -> None:
-    call_outputs = dict(call.outputs_dict)
-    call_outputs[pin_name] = wire_name
-    call.outputs = call_outputs
-    if wire_name != ZERO_INDICATOR:
-        call.non_zero_output_wires.append(wire_name)
-
-
-def _set_model_input(
-    call: Optional[SynthesisQuantumFunctionCall], pin_name: str, wire_name: str
-) -> None:
-    if call is None:
-        return
-    call_inputs = dict(call.inputs_dict)
-    call_inputs[pin_name] = wire_name
-    call.inputs = call_inputs
-    call.non_zero_input_wires.append(wire_name)
-
-
-def handle_inner_connection(
-    source_call: SynthesisQuantumFunctionCall,
-    source_pin_name: str,
-    dest_pin_name: str,
-    dest_call: Optional[SynthesisQuantumFunctionCall],
-) -> None:
-    wire_name = _get_wire_name(source_call, source_pin_name, dest_pin_name, dest_call)
-    _set_model_output(source_call, source_pin_name, wire_name)
-    _set_model_input(dest_call, dest_pin_name, wire_name)
-
-
-def handle_io_connection(
-    io_dir: PortDirection, call: SynthesisQuantumFunctionCall, io_name: str
-) -> str:
-    wire_name = _get_io_wire_name(io_name, call, io_dir)
-    if io_dir == PortDirection.Input:
-        _set_model_input(call, io_name, wire_name)
-    else:
-        _set_model_output(call, io_name, wire_name)
-    return wire_name

classiq/model/model.py

@@ -1,246 +0,0 @@
-"""Model module, implementing facilities for designing models and generating circuits using Classiq platform."""
-
-from __future__ import annotations
-
-import logging
-import tempfile
-from contextlib import nullcontext
-from typing import IO, Any, ContextManager, Dict, List, Mapping, Optional, Union, cast
-
-from classiq.interface.chemistry.operator import PauliOperator
-from classiq.interface.executor.execution_preferences import (
-    ExecutionPreferences,
-    QaeWithQpeEstimationMethod,
-)
-from classiq.interface.generator.expressions.enums import Optimizer
-from classiq.interface.generator.function_params import IOName
-from classiq.interface.generator.functions import SynthesisNativeFunctionDefinition
-from classiq.interface.generator.model import (
-    Constraints,
-    Preferences,
-    SynthesisModel as APIModel,
-)
-from classiq.interface.generator.model.model import MAIN_FUNCTION_NAME, SerializedModel
-from classiq.interface.generator.quantum_function_call import (
-    SynthesisQuantumFunctionCall,
-)
-
-from classiq._internals.async_utils import AsyncifyABC
-from classiq.exceptions import ClassiqError, ClassiqValueError
-from classiq.model import function_handler
-from classiq.quantum_functions.function_library import FunctionLibrary
-from classiq.quantum_register import QReg, QRegGenericAlias
-
-_logger = logging.getLogger(__name__)
-
-_SupportedIO = Union[IO, str]
-
-# TODO: Add docstrings for auto generated methods.
-
-
-ILLEGAL_SETTING_MSG = "Illegal value type provided"
-
-
-def _pauli_str_to_enums(pauli_str: str) -> str:
-    return ", ".join(f"Pauli.{pauli_term}" for pauli_term in pauli_str)
-
-
-def _pauli_operator_to_qmod(hamiltonian: PauliOperator) -> str:
-    if not all(isinstance(summand[1], complex) for summand in hamiltonian.pauli_list):
-        raise ClassiqValueError(
-            "Supporting only Hamiltonian with numeric coefficients."
-        )
-    return ", ".join(
-        f"struct_literal(PauliTerm, pauli=[{_pauli_str_to_enums(pauli)}], coefficient={cast(complex, coeff).real})"
-        for pauli, coeff in hamiltonian.pauli_list
-    )
-
-
-def _file_handler(fp: Optional[_SupportedIO], mode: str = "r") -> ContextManager[IO]:
-    if fp is None:
-        temp_file = tempfile.NamedTemporaryFile(mode, suffix=".qmod", delete=False)
-        print(f"Using temporary file: {temp_file.name!r}")
-        return temp_file
-
-    if isinstance(fp, str):
-        return open(fp, mode)
-
-    return nullcontext(fp)
-
-
-DEFAULT_RESULT_NAME = "result"
-DEFAULT_AMPLITUDE_ESTIMATION_RESULT_NAME = "estimation"
-
-
-class Model(function_handler.FunctionHandler, metaclass=AsyncifyABC):
-    """Facility to generate circuits, based on the model."""
-
-    def __init__(self, **kwargs: Any) -> None:
-        """Init self."""
-        super().__init__()
-        self._model = APIModel(**kwargs)
-
-    @classmethod
-    def from_model(cls, model: APIModel) -> Model:
-        return cls(**dict(model))
-
-    @property
-    def _body(
-        self,
-    ) -> List[SynthesisQuantumFunctionCall]:
-        return self._model.body
-
-    @property
-    def constraints(self) -> Constraints:
-        """Get the constraints aggregated in self.
-
-        Returns:
-            The constraints data.
-        """
-        return self._model.constraints
-
-    @constraints.setter
-    def constraints(self, value: Any) -> None:
-        if not isinstance(value, Constraints):
-            raise ClassiqError(ILLEGAL_SETTING_MSG)
-        self._model.constraints = value
-
-    @property
-    def preferences(self) -> Preferences:
-        """Get the preferences aggregated in self.
-
-        Returns:
-            The preferences data.
-        """
-        return self._model.preferences
-
-    @preferences.setter
-    def preferences(self, value: Any) -> None:
-        if not isinstance(value, Preferences):
-            raise ClassiqError(ILLEGAL_SETTING_MSG)
-        self._model.preferences = value
-
-    @property
-    def execution_preferences(self) -> ExecutionPreferences:
-        return self._model.execution_preferences
-
-    @execution_preferences.setter
-    def execution_preferences(self, value: Any) -> None:
-        if not isinstance(value, ExecutionPreferences):
-            raise ClassiqError(ILLEGAL_SETTING_MSG)
-        self._model.execution_preferences = value
-
-    def create_inputs(
-        self, inputs: Mapping[IOName, QRegGenericAlias]
-    ) -> Dict[IOName, QReg]:
-        qregs = super().create_inputs(inputs=inputs)
-        self._model.set_inputs(inputs, self.input_wires)
-        return qregs
-
-    def set_outputs(self, outputs: Mapping[IOName, QReg]) -> None:
-        super().set_outputs(outputs=outputs)
-        self._model.set_outputs(outputs, self.output_wires)
-
-    def include_library(self, library: FunctionLibrary) -> None:
-        """Includes a user-defined custom function library.
-
-        Args:
-            library (FunctionLibrary): The custom function library.
-        """
-        super().include_library(library=library)
-        # It is important that the .functions list is shared between the library and
-        # the model, as it is modified in-place
-        self._model.functions = library._data
-        library.remove_function_definition(MAIN_FUNCTION_NAME)
-        self._model.functions.append(
-            SynthesisNativeFunctionDefinition(name=MAIN_FUNCTION_NAME)
-        )
-
-    def get_model(self) -> SerializedModel:
-        return self._model.get_model()
-
-    def create_library(self) -> None:
-        self._function_library = FunctionLibrary(*self._model.functions)
-        self._model.functions = self._function_library._data
-
-    def sample(
-        self,
-        execution_params: Optional[Dict[str, float]] = None,
-    ) -> None:
-        execution_params = execution_params or dict()
-
-        self._model.classical_execution_code += classical_sample_function(
-            execution_params=execution_params
-        )
-
-    def vqe(
-        self,
-        hamiltonian: PauliOperator,
-        maximize: bool,
-        optimizer: Optimizer,
-        max_iteration: int,
-        initial_point: Optional[List[int]] = None,
-        tolerance: float = 0,
-        step_size: float = 0,
-        skip_compute_variance: bool = False,
-        alpha_cvar: float = 1,
-    ) -> None:
-        initial_point = initial_point or []
-        vqe_classical_code = f"""
-{DEFAULT_RESULT_NAME} = vqe(
-    hamiltonian=[{_pauli_operator_to_qmod(hamiltonian)}],
-    maximize={maximize},
-    initial_point={initial_point},
-    optimizer=Optimizer.{optimizer.name},
-    max_iteration={max_iteration},
-    tolerance={tolerance},
-    step_size={step_size},
-    skip_compute_variance={skip_compute_variance},
-    alpha_cvar={alpha_cvar}
-)
-save({{{DEFAULT_RESULT_NAME!r}: {DEFAULT_RESULT_NAME}}})
-"""
-
-        self._model.classical_execution_code += vqe_classical_code
-
-    def iqae(
-        self,
-        epsilon: float,
-        alpha: float,
-        execution_params: Optional[Dict[str, float]] = None,
-    ) -> None:
-        execution_params = execution_params or {}
-
-        iqae_classical_code = f"""
-{DEFAULT_RESULT_NAME} = iqae(
-    epsilon={epsilon},
-    alpha={alpha},
-    execution_params={execution_params}
-)
-save({{{DEFAULT_RESULT_NAME!r}: {DEFAULT_RESULT_NAME}}})
-"""
-
-        self._model.classical_execution_code += iqae_classical_code
-
-    def post_process_amplitude_estimation(
-        self,
-        estimation_register_size: int,
-        estimation_method: QaeWithQpeEstimationMethod,
-    ) -> None:
-        postprocess_classical_code = f"""
-{DEFAULT_AMPLITUDE_ESTIMATION_RESULT_NAME} = qae_with_qpe_result_post_processing(
-    {estimation_register_size},
-    {estimation_method},
-    {DEFAULT_RESULT_NAME}
-)
-save({{{DEFAULT_AMPLITUDE_ESTIMATION_RESULT_NAME!r}: {DEFAULT_AMPLITUDE_ESTIMATION_RESULT_NAME}}})
-"""
-
-        self._model.classical_execution_code += postprocess_classical_code
-
-
-def classical_sample_function(execution_params: Dict[str, float]) -> str:
-    return f"""
-{DEFAULT_RESULT_NAME} = sample({execution_params})
-save({{{DEFAULT_RESULT_NAME!r}: {DEFAULT_RESULT_NAME}}})
-"""

classiq/quantum_functions/__init__.py

@@ -1,17 +0,0 @@
-from classiq.quantum_functions.decorators import quantum_function as qfunc
-from classiq.quantum_functions.function_library import (
-    QASM3_INTRO,
-    QASM_INTRO,
-    FunctionLibrary,
-    QuantumFunction,
-    QuantumFunctionFactory,
-)
-
-__all__ = [
-    "qfunc",
-    "QASM_INTRO",
-    "QASM3_INTRO",
-    "FunctionLibrary",
-    "QuantumFunction",
-    "QuantumFunctionFactory",
-]

classiq/quantum_functions/annotation_parser.py

@@ -1,207 +0,0 @@
-# type: ignore
-# We can either ignore each line individually, or ignore the entire file and wait until mypy can ignore
-# specific errors per-file.
-import inspect
-import sys
-from types import FunctionType
-from typing import Any, Dict, List, Tuple, Union, _GenericAlias
-
-from classiq.interface.generator.register_role import RegisterRole as Role
-
-from classiq.exceptions import ClassiqQFuncError
-from classiq.quantum_register import AuxQReg, QReg, QRegGenericAlias, QSFixed, ZeroQReg
-
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-else:
-    GenericAlias = _GenericAlias
-
-GenericAliasUnion = Union[GenericAlias, _GenericAlias]
-
-
-class AnnotationParser:
-    def __init__(self, func: FunctionType) -> None:
-        self._func = func
-
-        self.output_types: Dict[str, GenericAlias] = {}
-
-    def parse(self) -> None:
-        annotations = self._func.__annotations__.copy()
-
-        # Todo: remove this `if` after introducing `Inplace`
-        if "return" not in annotations:
-            raise ClassiqQFuncError("Return value annotations not found")
-
-        self.output_values = self._unpack_output_values(annotations.pop("return"))
-        self.input_names, self.input_values = self._unpack_input_values(annotations)
-
-        self._validate()
-
-    def _validate(self) -> None:
-        self._validate_type_hints()
-        self._validate_qubit_amount()
-        self._validate_io_length()
-        self._validate_io_correlation()
-
-    def _validate_type_hints(self) -> None:
-        # Validate type of type-hints
-        if not all(
-            map(
-                self.is_valid_generic_alias_of_qreg,
-                self.input_values + self.output_values,
-            )
-        ):
-            raise ClassiqQFuncError("Invalid GenericAlias convection")
-
-    def _validate_qubit_amount(self) -> None:
-        # Validate qubit amount
-        if sum(i.size for i in self.output_values) != sum(
-            i.size for i in self.input_values
-        ):
-            raise ClassiqQFuncError(
-                "Input and output values have different amounts of qubits"
-            )
-
-    # Todo: Remove this validation by introducing better heuristics
-    #   Or after introducing Inplace
-    def _validate_io_length(self) -> None:
-        # Validate amount of inputs and outputs
-        if len(self.input_values) != len(self.output_values):
-            raise ClassiqQFuncError(
-                "Inputs and outputs must have the same number of QRegs"
-            )
-
-    def _validate_io_correlation(self) -> None:
-        # Validate correspondence between inputs and outputs
-        for input_name, input_type, output_type in zip(
-            self.input_names, self.input_values, self.output_values
-        ):
-            # Is arithmetic QReg
-            if issubclass(input_type.__origin__, QSFixed):
-                if input_type != output_type:
-                    raise ClassiqQFuncError(
-                        f"Arithmetic QReg must be of the same type and size in both the input and the output. Got {input_type} and {output_type}"
-                    )
-
-            # Is Auxillary QReg
-            if issubclass(input_type.__origin__, AuxQReg):
-                if input_type != output_type:
-                    raise ClassiqQFuncError(
-                        f"Auxillary QReg must be of the same type and size in both the input and the output. Got {input_type} and {output_type}"
-                    )
-
-            # Is Zero QReg
-            if input_type.__origin__ is ZeroQReg:
-                if output_type.__origin__ is QReg or issubclass(
-                    output_type.__origin__, QSFixed
-                ):
-                    self.output_types[input_name] = output_type
-                else:
-                    raise ClassiqQFuncError(
-                        "Invalid output type. Any ZeroQReg in the input must have a corresponding QReg in the output"
-                    )
-
-    @classmethod
-    def _unpack_output_values(
-        cls, output_value_type_hint: Any
-    ) -> Tuple[GenericAlias, ...]:
-        # Handle QReg type hints
-        if cls.is_subclass_qreg(output_value_type_hint):
-            return (cls.to_generic_alias(output_value_type_hint),)
-
-        # Supporting both `typing._GenericAlias` and `types.GenericAlias`
-        if not cls.is_instance_generic_alias(output_value_type_hint):
-            raise ClassiqQFuncError(
-                "Output value type hint must be either a single QReg, `typing.Tuple[QReg, ...]` or, for python>=3.9, `tuple[QReg, ...]`"
-            )
-
-        # Allowing only a tuple of outputs:
-        if not cls.is_tuple_generic_alias(output_value_type_hint):
-            raise ClassiqQFuncError(
-                "Output value type hint must be either Tuple[QReg, ...] or tuple[QReg, ...]"
-            )
-
-        # This line may raise ClassiqQFuncError
-        return tuple(map(cls.to_generic_alias, output_value_type_hint.__args__))
-
-    def _unpack_input_values(
-        self, annotations: Dict[str, Any]
-    ) -> Tuple[List[str], Tuple[GenericAlias, ...]]:
-        input_names = list(annotations.keys())
-        input_values = tuple(map(self.to_generic_alias, annotations.values()))
-        return input_names, input_values
-
-    @staticmethod
-    def to_generic_alias(obj: Any) -> GenericAlias:
-        # Handle GenericAlias
-        if isinstance(obj, (QRegGenericAlias, GenericAlias)):
-            return obj
-        # Handle _GenericAlias, for python>3.9, i.e. when GenericAlias != _GenericAlias
-        if isinstance(obj, _GenericAlias):
-            return GenericAlias(obj.__origin__, obj.__args__)
-        # Handle a single QReg (not GenericAlias of QReg)
-        elif inspect.isclass(obj) and issubclass(obj, QReg):
-            return GenericAlias(obj, tuple())
-
-        raise ClassiqQFuncError(f"Invalid type hint object: {obj.__class__.__name__}")
-
-    @staticmethod
-    def is_instance_generic_alias(obj: Any) -> bool:
-        return isinstance(obj, (GenericAlias, _GenericAlias))
-
-    @classmethod
-    def is_subclass_qreg(cls, obj: Any) -> bool:
-        if inspect.isclass(obj):
-            return issubclass(obj, QReg)
-        elif cls.is_instance_generic_alias(obj):
-            return issubclass(obj.__origin__, QReg)
-        return False
-
-    @staticmethod
-    def is_tuple_generic_alias(obj: GenericAliasUnion) -> bool:
-        return obj.__origin__.__name__.lower() == "tuple"
-
-    @staticmethod
-    def is_valid_generic_alias_of_qreg(obj: GenericAlias) -> bool:
-        return isinstance(obj, QRegGenericAlias)
-
-
-def get_annotation_role(annotation: GenericAlias, default_role: Role) -> Role:
-    """
-    Note: this function cannot distinguish between inputs and outputs.
-        Thus, for inputs, all 3 options are valid
-        However, for outputs:
-            a) we don't expect to get ZERO
-            b) We treat INPUT as OUTPUT
-    """
-    ret = None
-
-    if getattr(annotation, "role", None) is not None:
-        ret = annotation.role
-    if getattr(annotation.__origin__, "role", None) is not None:
-        ret = annotation.role
-
-    if issubclass(annotation.__origin__, QReg) and not issubclass(
-        annotation.__origin__, ZeroQReg
-    ):
-        ret = default_role
-
-    if issubclass(annotation.__origin__, ZeroQReg) and not issubclass(
-        annotation.__origin__, AuxQReg
-    ):
-        ret = Role.ZERO_INPUT
-
-    if issubclass(annotation.__origin__, AuxQReg):
-        ret = Role.AUXILIARY
-
-    # Didn't match anything so far
-    if ret is None:
-        raise ClassiqQFuncError("Invalid annotation role")
-
-    if default_role == Role.INPUT and ret == Role.OUTPUT:
-        raise ClassiqQFuncError("input should not have Role.OUTPUT")
-
-    if default_role == Role.OUTPUT and ret in (Role.ZERO_INPUT, Role.INPUT):
-        raise ClassiqQFuncError("output should not have Role.ZERO / Role.INPUT")
-
-    return ret