classiq 0.38.0__py3-none-any.whl → 0.65.4__py3-none-any.whl

classiq/interface/model/validations/handles_validator.py

@@ -1,156 +0,0 @@
-from typing import Dict, Mapping, Set, Union
-
-from classiq.interface.generator.function_params import PortDirection
-from classiq.interface.generator.functions.core_lib_declarations.quantum_operators import (
-    APPLY_OPERATOR,
-)
-from classiq.interface.model.handle_binding import (
-    HandleBinding,
-    SlicedHandleBinding,
-    SubscriptHandleBinding,
-)
-from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.quantum_function_call import QuantumFunctionCall
-from classiq.interface.model.quantum_lambda_function import (
-    QuantumLambdaFunction,
-    QuantumOperand,
-)
-from classiq.interface.model.quantum_statement import QuantumOperation
-from classiq.interface.model.validation_handle import HandleState, ValidationHandle
-from classiq.interface.model.validations.handle_validation_base import (
-    HandleValidationBase,
-)
-from classiq.interface.model.variable_declaration_statement import (
-    VariableDeclarationStatement,
-)
-from classiq.interface.model.within_apply_operation import WithinApplyOperation
-
-from classiq.exceptions import ClassiqValueError
-
-
-def _initialize_handles_to_state(
-    port_declarations: Mapping[str, PortDeclaration],
-) -> Dict[str, ValidationHandle]:
-    handles_to_state: Dict[str, ValidationHandle] = dict()
-
-    for port_decl in port_declarations.values():
-        handles_to_state[port_decl.name] = ValidationHandle(
-            initial_state=(
-                HandleState.INITIALIZED
-                if port_decl.direction.includes_port_direction(PortDirection.Input)
-                else HandleState.UNINITIALIZED
-            )
-        )
-
-    return handles_to_state
-
-
-class HandleValidator(HandleValidationBase):
-    def __init__(
-        self,
-        port_declarations: Mapping[str, PortDeclaration],
-    ) -> None:
-        super().__init__(port_declarations)
-        self._port_declarations = port_declarations.values()
-        self._handles_to_state = _initialize_handles_to_state(port_declarations)
-
-    @property
-    def _validation_handles_state(self) -> Mapping[str, ValidationHandle]:
-        return self._handles_to_state
-
-    def handle_operation(self, op: QuantumOperation) -> None:
-        if isinstance(op, QuantumFunctionCall) and op.function == APPLY_OPERATOR.name:
-            self._handle_apply(op.operands[APPLY_OPERATOR.operand_names[0]])
-        elif isinstance(op, WithinApplyOperation):
-            self._handle_apply(op.action)
-        self._handle_inputs(op.wiring_inputs)
-        self._handle_outputs(op.wiring_outputs)
-        self._handle_inouts(op.wiring_inouts)
-
-    def handle_variable_declaration(
-        self, declaration: VariableDeclarationStatement
-    ) -> None:
-        handle_wiring_state = self._handles_to_state.get(declaration.name)
-        if handle_wiring_state is not None:
-            handle_wiring_state.append_error(
-                f"Trying to declare a variable of the same name as previously declared variable {declaration.name}"
-            )
-            return
-
-        self._handles_to_state[declaration.name] = ValidationHandle(
-            HandleState.UNINITIALIZED
-        )
-
-    def _handle_inputs(self, inputs: Mapping[str, HandleBinding]) -> None:
-        for handle_binding in inputs.values():
-            handle_wiring_state = self._handles_to_state[handle_binding.name]
-            if handle_wiring_state.state is not HandleState.INITIALIZED:
-                handle_wiring_state.append_error(
-                    f"Trying to access handle {handle_binding.name!r} as input but it is in incorrect state"
-                )
-                continue
-
-            handle_wiring_state.uninitialize()
-
-    def _handle_outputs(self, outputs: Mapping[str, HandleBinding]) -> None:
-        for handle_binding in outputs.values():
-            handle_wiring_state = self._handles_to_state[handle_binding.name]
-
-            if handle_wiring_state.state is not HandleState.UNINITIALIZED:
-                handle_wiring_state.append_error(
-                    f"Trying to access handle {handle_binding.name!r} as output but it is in incorrect state"
-                )
-                continue
-
-            handle_wiring_state.initialize()
-
-    def _handle_inouts(
-        self,
-        inouts: Mapping[
-            str, Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]
-        ],
-    ) -> None:
-        sliced_handles = set()
-        whole_handles = set()
-
-        for handle_binding in inouts.values():
-            handle_wiring_state = self._handles_to_state[handle_binding.name]
-
-            if handle_wiring_state.state is not HandleState.INITIALIZED:
-                handle_wiring_state.append_error(
-                    f"Trying to access handle {handle_binding.name!r} as inout but it is in incorrect state"
-                )
-
-            if isinstance(
-                handle_binding, (SlicedHandleBinding, SubscriptHandleBinding)
-            ):
-                sliced_handles.add(handle_binding.name)
-            else:
-                whole_handles.add(handle_binding.name)
-
-        for handle in sliced_handles & whole_handles:
-            self._handles_to_state[handle].append_error(
-                f"Invalid use of inout handle {handle!r}, used both in slice or subscript and whole"
-            )
-
-    def _handle_apply(self, operand: QuantumOperand) -> None:
-        if not isinstance(operand, QuantumLambdaFunction):
-            return
-        local_variables: Set[str] = set()
-        output_capturing_variables: Set[str] = set()
-        for statement in operand.body:
-            if isinstance(statement, VariableDeclarationStatement):
-                local_variables.add(statement.name)
-            elif isinstance(statement, QuantumOperation):
-                for handle in statement.wiring_outputs.values():
-                    if (
-                        handle.name in local_variables
-                        or handle.name in output_capturing_variables
-                    ):
-                        continue
-                    output_capturing_variables.add(handle.name)
-                    self._handles_to_state[handle.name].initialize()
-            else:
-                raise ClassiqValueError(
-                    f"Unknown statement type {type(statement).__name__}"
-                )

classiq/interface/model/validations/port_to_wire_name_generator.py

@@ -1,12 +0,0 @@
-import typing
-from collections import Counter
-
-
-class PortToWireNameGenerator:
-    def __init__(self) -> None:
-        self._name_counter: typing.Counter[str] = Counter()
-
-    def get(self, port_name: str) -> str:
-        counter = self._name_counter[port_name]
-        self._name_counter[port_name] += 1
-        return f"{port_name}_{counter}"

classiq/model/__init__.py

@@ -1,14 +0,0 @@
-from typing import List
-
-from classiq.interface.generator.model import *  # noqa: F403
-from classiq.interface.generator.model import __all__ as _model_all
-
-from classiq.model.composite_function_generator import FunctionGenerator
-from classiq.model.model import Model
-
-__all__ = ["FunctionGenerator", "Model"]
-__all__.extend(_model_all)
-
-
-def __dir__() -> List[str]:
-    return __all__

classiq/model/composite_function_generator.py

@@ -1,33 +0,0 @@
-from typing import List
-
-from classiq.interface.generator.function_params import PortDirection
-from classiq.interface.generator.functions import SynthesisNativeFunctionDefinition
-from classiq.interface.generator.quantum_function_call import (
-    SynthesisQuantumFunctionCall,
-)
-
-from classiq.model import function_handler
-from classiq.quantum_functions.function_library import FunctionLibrary
-
-
-class FunctionGenerator(function_handler.FunctionHandler):
-    def __init__(self, function_name: str) -> None:
-        super().__init__()
-        self._name = function_name
-        self._logic_flow_list: List[SynthesisQuantumFunctionCall] = list()
-
-    @property
-    def _body(self) -> List[SynthesisQuantumFunctionCall]:
-        return self._logic_flow_list
-
-    def to_function_definition(self) -> SynthesisNativeFunctionDefinition:
-        return SynthesisNativeFunctionDefinition(
-            name=self._name,
-            body=self._body,
-            port_declarations=self._port_declarations,
-            input_ports_wiring=self._external_port_wiring[PortDirection.Input],
-            output_ports_wiring=self._external_port_wiring[PortDirection.Output],
-        )
-
-    def create_library(self) -> None:
-        self.include_library(FunctionLibrary())

classiq/model/function_handler.py

@@ -1,462 +0,0 @@
-import abc
-import collections.abc
-import functools
-from typing import (
-    Any,
-    Callable,
-    Collection,
-    Dict,
-    Iterable,
-    List,
-    Mapping,
-    Optional,
-    Tuple,
-    Union,
-    cast,
-)
-
-from classiq.interface.generator import function_param_list, function_params
-from classiq.interface.generator.control_state import ControlState
-from classiq.interface.generator.function_params import IOName, PortDirection
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-    SynthesisPortDeclaration,
-)
-from classiq.interface.generator.identity import Identity
-from classiq.interface.generator.quantum_function_call import (
-    SynthesisQuantumFunctionCall,
-    WireDict,
-)
-from classiq.interface.generator.slice_parsing_utils import parse_io_slicing
-from classiq.interface.generator.user_defined_function_params import CustomFunction
-
-from classiq.exceptions import ClassiqValueError, ClassiqWiringError
-from classiq.model import logic_flow_change_handler
-from classiq.model.logic_flow import LogicFlowBuilder
-from classiq.quantum_functions.function_library import (
-    FunctionLibrary,
-    QuantumFunction,
-    SynthesisQuantumFunctionDeclaration,
-)
-from classiq.quantum_register import QReg, QRegGenericAlias
-
-SupportedInputArgs = Union[
-    Mapping[IOName, QReg],
-    Collection[QReg],
-    QReg,
-]
-
-_SAME_INPUT_NAME_ERROR_MSG: str = "Cannot create multiple inputs with the same name"
-_INPUT_AS_OUTPUT_ERROR_MSG: str = "Can't connect input directly to output"
-ILLEGAL_INPUT_OR_SLICING_ERROR_MSG: str = "is not a valid input name/slice"
-ILLEGAL_OUTPUT_ERROR_MSG: str = "Illegal output provided"
-
-ASSIGNED = "_assigned_"
-
-
-def _get_identity_call_name(name: str, io: PortDirection) -> str:
-    return f"{name}_{io.value}_Identity"
-
-
-class FunctionHandler(abc.ABC):
-    def __init__(self) -> None:
-        self._function_library: Optional[FunctionLibrary] = None
-        self._port_declarations: Dict[IOName, SynthesisPortDeclaration] = dict()
-        self._external_port_wiring: Dict[PortDirection, WireDict] = {
-            PortDirection.Input: dict(),
-            PortDirection.Output: dict(),
-        }
-        self._generated_qregs: Dict[IOName, QReg] = dict()
-        self._logic_flow_builder: LogicFlowBuilder = LogicFlowBuilder()
-
-    @property
-    def input_wires(self) -> WireDict:
-        return self._external_port_wiring[PortDirection.Input]
-
-    @property
-    def output_wires(self) -> WireDict:
-        return self._external_port_wiring[PortDirection.Output]
-
-    def _verify_unique_inputs(self, input_names: Iterable[IOName]) -> None:
-        input_port_declarations = {
-            name: port_declaration
-            for name, port_declaration in self._port_declarations.items()
-            if port_declaration.direction.is_input
-        }
-        if not input_port_declarations.keys().isdisjoint(input_names):
-            raise ClassiqWiringError(_SAME_INPUT_NAME_ERROR_MSG)
-
-    def _verify_no_inputs_as_outputs(self, output_qregs: Iterable[QReg]) -> None:
-        for qreg in output_qregs:
-            if any(
-                qreg.isoverlapping(gen_qreg)
-                for gen_qreg in self._generated_qregs.values()
-            ):
-                raise ClassiqWiringError(f"{_INPUT_AS_OUTPUT_ERROR_MSG} {qreg}")
-
-    @staticmethod
-    def _parse_control_states(
-        control_states: Optional[Union[ControlState, Iterable[ControlState]]] = None
-    ) -> List[ControlState]:
-        if control_states is None:
-            return list()
-        elif isinstance(control_states, ControlState):
-            return [control_states]
-        return list(control_states)
-
-    def create_inputs(
-        self,
-        inputs: Mapping[IOName, QRegGenericAlias],
-    ) -> Dict[IOName, QReg]:
-        self._verify_unique_inputs(inputs.keys())
-        qregs_dict = {
-            name: self._create_input_with_identity(name, qreg_type)
-            for name, qreg_type in inputs.items()
-        }
-        self._generated_qregs.update(qregs_dict)
-        return qregs_dict
-
-    def _create_input_with_identity(
-        self, name: IOName, qreg_type: QRegGenericAlias
-    ) -> QReg:
-        qreg = qreg_type()
-        self._handle_io_with_identity(PortDirection.Input, name, qreg)
-        return qreg
-
-    def set_outputs(self, outputs: Mapping[IOName, QReg]) -> None:
-        for name, qreg in outputs.items():
-            self._set_output_with_identity(name, qreg)
-
-    def _set_output_with_identity(self, name: IOName, qreg: QReg) -> None:
-        self._handle_io_with_identity(PortDirection.Output, name, qreg)
-
-    def _handle_io_with_identity(
-        self, port_direction: PortDirection, name: IOName, qreg: QReg
-    ) -> None:
-        # We need to add an Identity call on each input/output of the logic flow,
-        # since function input/output pins don't support "pin slicing".
-        # (Which means we cannot use QRegs in the wiring directly - because it gets
-        # decomposed into 1 bit wirings).
-        # Adding the identity also indirectly adds support for slicing on IOs
-        # (via the QReg slicing).
-        rui = qreg.to_register_user_input(name)
-        identity_call = SynthesisQuantumFunctionCall(
-            name=_get_identity_call_name(name, port_direction),
-            function_params=Identity(arguments=[rui]),
-        )
-        self._body.append(identity_call)
-        wire_name = logic_flow_change_handler.handle_io_connection(
-            port_direction, identity_call, name
-        )
-        if port_direction == PortDirection.Input:
-            self._logic_flow_builder.connect_func_call_to_qreg(
-                identity_call, name, qreg
-            )
-        else:
-            self._logic_flow_builder.connect_qreg_to_func_call(
-                qreg, name, identity_call
-            )
-        declaration_direction = PortDeclarationDirection.from_port_direction(
-            port_direction
-        )
-        if (
-            name in self._port_declarations
-            and self._port_declarations[name].direction != declaration_direction
-        ):
-            declaration_direction = PortDeclarationDirection.Inout
-        self._port_declarations[name] = SynthesisPortDeclaration(
-            name=name,
-            size=rui.size,
-            direction=declaration_direction,
-        )
-        external_port_wiring_dict = dict(self._external_port_wiring[port_direction])
-        external_port_wiring_dict[name] = wire_name
-        self._external_port_wiring[port_direction] = external_port_wiring_dict
-
-    def apply(
-        self,
-        function_name: Union[
-            str,
-            SynthesisQuantumFunctionDeclaration,
-            QuantumFunction,
-        ],
-        in_wires: Optional[SupportedInputArgs] = None,
-        out_wires: Optional[SupportedInputArgs] = None,
-        is_inverse: bool = False,
-        strict_zero_ios: bool = True,
-        release_by_inverse: bool = False,
-        control_states: Optional[Union[ControlState, Iterable[ControlState]]] = None,
-        should_control: bool = True,
-        power: int = 1,
-        call_name: Optional[str] = None,
-    ) -> Dict[IOName, QReg]:
-        # if there's no function library, create one
-        if self._function_library is None:
-            self.create_library()
-
-        if isinstance(function_name, SynthesisQuantumFunctionDeclaration):
-            function_data = function_name
-        elif isinstance(function_name, QuantumFunction):
-            function_data = function_name.function_data
-        else:
-            function_data = None
-
-        if function_data:
-            if function_data.name not in self._function_library.function_dict:  # type: ignore[union-attr]
-                self._function_library.add_function(function_data)  # type: ignore[union-attr]
-
-            function_name = function_data.name
-
-        function_name = cast(str, function_name)
-        return self._add_function_call(
-            function_name,
-            self._function_library.get_function(function_name),  # type: ignore[union-attr]
-            in_wires=in_wires,
-            out_wires=out_wires,
-            is_inverse=is_inverse,
-            strict_zero_ios=strict_zero_ios,
-            release_by_inverse=release_by_inverse,
-            control_states=control_states,
-            should_control=should_control,
-            power=power,
-            call_name=call_name,
-        )
-
-    def release_qregs(self, qregs: Union[QReg, Collection[QReg]]) -> None:
-        if isinstance(qregs, QReg):
-            qregs = [qregs]
-        for qreg in qregs:
-            self._logic_flow_builder.connect_qreg_to_zero(qreg)
-
-    def _add_function_call(
-        self,
-        function: str,
-        params: function_params.FunctionParams,
-        control_states: Optional[Union[ControlState, Iterable[ControlState]]] = None,
-        in_wires: Optional[SupportedInputArgs] = None,
-        out_wires: Optional[SupportedInputArgs] = None,
-        is_inverse: bool = False,
-        release_by_inverse: bool = False,
-        should_control: bool = True,
-        power: int = 1,
-        call_name: Optional[str] = None,
-        strict_zero_ios: bool = True,
-    ) -> Dict[IOName, QReg]:
-        if function != type(params).__name__ and not isinstance(params, CustomFunction):
-            raise ClassiqValueError(
-                "The FunctionParams type does not match function name"
-            )
-
-        if (
-            isinstance(params, CustomFunction)
-            and self._function_library
-            and function not in self._function_library.function_dict
-        ):
-            raise ClassiqValueError(
-                "QuantumFunctionCall: The function is not found in included library."
-            )
-
-        call = SynthesisQuantumFunctionCall(
-            function=function,
-            function_params=params,
-            is_inverse=is_inverse,
-            release_by_inverse=release_by_inverse,
-            strict_zero_ios=strict_zero_ios,
-            control_states=self._parse_control_states(control_states),
-            should_control=should_control,
-            power=power,
-            name=call_name,
-        )
-
-        if in_wires is not None:
-            self._connect_in_qregs(call=call, in_wires=in_wires)
-
-        self._body.append(call)
-
-        return self._connect_out_qregs(call=call, out_wires=out_wires or {})
-
-    def _connect_in_qregs(
-        self,
-        call: SynthesisQuantumFunctionCall,
-        in_wires: SupportedInputArgs,
-    ) -> None:
-        if isinstance(in_wires, dict):
-            self._connect_named_in_qregs(call=call, in_wires=in_wires)
-        elif isinstance(in_wires, QReg):
-            self._connect_unnamed_in_qregs(call=call, in_wires=[in_wires])
-        elif isinstance(in_wires, collections.abc.Collection):
-            self._connect_unnamed_in_qregs(
-                # mypy doesn't recognize that `dict` wouldn't reach this point
-                call=call,
-                in_wires=in_wires,  # type: ignore[arg-type]
-            )
-        else:
-            raise ClassiqWiringError(
-                f"Invalid in_wires type: {type(in_wires).__name__}"
-            )
-
-    def _connect_unnamed_in_qregs(
-        self,
-        call: SynthesisQuantumFunctionCall,
-        in_wires: Collection[QReg],
-    ) -> None:
-        call_inputs = call.function_params.inputs_full(call.strict_zero_ios).keys()
-        self._connect_named_in_qregs(call, dict(zip(call_inputs, in_wires)))
-
-    def _connect_named_in_qregs(
-        self,
-        call: SynthesisQuantumFunctionCall,
-        in_wires: Dict[IOName, QReg],
-    ) -> None:
-        for input_name, in_qreg in in_wires.items():
-            pin_name, pin_indices = self._get_pin_name_and_indices(input_name, call)
-            if len(in_qreg) != len(pin_indices):
-                raise ClassiqWiringError(
-                    f"Incorrect size of input QReg: expected {len(pin_indices)}, actual {len(in_qreg)}"
-                )
-            self._logic_flow_builder.connect_qreg_to_func_call(
-                in_qreg, pin_name, call, pin_indices
-            )
-
-    @staticmethod
-    def _get_pin_name_and_indices(
-        input_name: IOName,
-        call: SynthesisQuantumFunctionCall,
-    ) -> Tuple[IOName, range]:
-        try:
-            name, slicing = parse_io_slicing(input_name)
-        except (AssertionError, ValueError) as e:
-            raise ClassiqWiringError(
-                f"{input_name} {ILLEGAL_INPUT_OR_SLICING_ERROR_MSG}"
-            ) from e
-        pin_info = call.input_regs_dict.get(name)
-        if pin_info is None:
-            raise ClassiqWiringError(
-                f"No register size information on input pin {name}"
-            )
-        indices = range(pin_info.size)[slicing]
-        return name, indices
-
-    def _connect_out_qregs(
-        self,
-        call: SynthesisQuantumFunctionCall,
-        out_wires: SupportedInputArgs,
-    ) -> Dict[IOName, QReg]:
-        if isinstance(out_wires, dict):
-            return self._connect_named_out_qregs(call, out_wires)
-        elif isinstance(out_wires, QReg):
-            return self._connect_unnamed_out_qregs(call, [out_wires])
-        elif isinstance(out_wires, collections.abc.Collection):
-            return self._connect_unnamed_out_qregs(
-                # mypy doesn't recognize that `dict` wouldn't reach this point
-                call,
-                out_wires,  # type: ignore[arg-type]
-            )
-        else:
-            raise ClassiqWiringError(
-                f"Invalid in_wires type: {type(out_wires).__name__}"
-            )
-
-    def _connect_unnamed_out_qregs(
-        self,
-        call: SynthesisQuantumFunctionCall,
-        out_wires: Collection[QReg],
-    ) -> Dict[IOName, QReg]:
-        call_outputs = call.function_params.outputs.keys()
-        return self._connect_named_out_qregs(call, dict(zip(call_outputs, out_wires)))
-
-    def _connect_named_out_qregs(
-        self,
-        call: SynthesisQuantumFunctionCall,
-        out_wires: Mapping[IOName, QReg],
-    ) -> Dict[IOName, QReg]:
-        if not all(output_name in call.output_regs_dict for output_name in out_wires):
-            raise ClassiqWiringError(ILLEGAL_OUTPUT_ERROR_MSG)
-        output_dict = {}
-        for output_name, reg_user_input in call.output_regs_dict.items():
-            if reg_user_input is None:
-                raise ClassiqValueError(
-                    f"No output register information for {output_name}"
-                )
-            qreg = out_wires.get(output_name) or QReg.from_arithmetic_info(
-                reg_user_input
-            )
-            self._logic_flow_builder.connect_func_call_to_qreg(call, output_name, qreg)
-            output_dict[output_name] = qreg
-        return output_dict
-
-    def __getattr__(self, item: str) -> Callable[..., Any]:
-        # This is added due to problematic behaviour in deepcopy.
-        # deepcopy approaches __getattr__ before __init__ is called,
-        # and therefore self._function_library doesn't exist.
-        # Thus, we treat _function_library differently.
-
-        if item == "_function_library":
-            raise AttributeError(
-                f"{self.__class__.__name__!r} has no attribute {item!r}"
-            )
-
-        is_builtin_function_name = any(
-            item == func.__name__
-            for func in function_param_list.function_param_library.param_list
-        )
-
-        if is_builtin_function_name:
-            return functools.partial(self._add_function_call, item)
-
-        is_user_function_name = (
-            self._function_library is not None
-            and item in self._function_library.function_names
-        )
-
-        if is_user_function_name:
-            return functools.partial(self.apply, item)
-
-        if (
-            self._function_library is not None
-            and item in self._function_library.function_factory_names
-        ):
-            return functools.partial(
-                self._function_library.get_function_factory(item),
-                add_method=functools.partial(
-                    self._function_library.add_function,
-                    override_existing_functions=True,
-                ),
-                apply_method=self.apply,
-            )
-
-        raise AttributeError(f"{self.__class__.__name__!r} has no attribute {item!r}")
-
-    def __dir__(self) -> List[str]:
-        builtin_func_name = [
-            func.__name__
-            for func in function_param_list.function_param_library.param_list
-        ]
-        user_func_names = (
-            list(self._function_library.function_names)
-            if self._function_library is not None
-            else list()
-        )
-        return list(super().__dir__()) + builtin_func_name + user_func_names
-
-    def include_library(self, library: FunctionLibrary) -> None:
-        """Includes a function library.
-
-        Args:
-            library (FunctionLibrary): The function library.
-        """
-        if self._function_library is not None:
-            raise ClassiqValueError("Another function library is already included.")
-
-        self._function_library = library
-
-    @property
-    @abc.abstractmethod
-    def _body(
-        self,
-    ) -> List[SynthesisQuantumFunctionCall]:
-        pass
-
-    @abc.abstractmethod
-    def create_library(self) -> None:
-        pass