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

classiq/model/model.py

@@ -1,229 +0,0 @@
-"""Model module, implementing facilities for designing models and generating circuits using Classiq platform."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any, Dict, List, Mapping, Optional, 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.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__)
-
-# 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
-    )
-
-
-DEFAULT_RESULT_NAME = "result"
-DEFAULT_AMPLITUDE_ESTIMATION_RESULT_NAME = "estimation"
-
-
-class Model(function_handler.FunctionHandler):
-    """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
-from classiq.quantum_functions.function_library import (
-    QASM3_INTRO,
-    QASM_INTRO,
-    FunctionLibrary,
-    QuantumFunction,
-    QuantumFunctionFactory,
-)
-
-__all__ = [
-    "quantum_function",
-    "QASM_INTRO",
-    "QASM3_INTRO",
-    "FunctionLibrary",
-    "QuantumFunction",
-    "QuantumFunctionFactory",
-]

classiq/quantum_functions/annotation_parser.py

@@ -1,205 +0,0 @@
-# type: ignore  # noqa: PGH003
-# 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) and 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) and 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

classiq/quantum_functions/decorators.py

@@ -1,22 +0,0 @@
-from typing import Callable, Optional, Union, overload
-
-from classiq.quantum_functions.quantum_function import QuantumFunction
-
-
-@overload
-def quantum_function(func: None = None, name: Optional[str] = None) -> Callable: ...
-
-
-@overload
-def quantum_function(func: Callable, name: Optional[str] = None) -> QuantumFunction: ...
-
-
-def quantum_function(
-    func: Optional[Callable] = None, name: Optional[str] = None
-) -> Union[QuantumFunction, Callable]:
-    if func is None:
-        return lambda func: quantum_function(func, name)
-    else:
-        qf = QuantumFunction()
-        qf.add_implementation(func, name)
-        return qf

classiq/quantum_functions/function_library.py

@@ -1,181 +0,0 @@
-"""Function library module, implementing facilities for adding user defined functions to the Classiq platform."""
-
-from typing import Any, Dict, List, Tuple, Type, Union
-
-from more_itertools import locate
-
-from classiq.interface.generator.functions import (
-    SynthesisForeignFunctionDefinition,
-    SynthesisNativeFunctionDefinition,
-    SynthesisQuantumFunctionDeclaration,
-)
-from classiq.interface.generator.model.model import (
-    MAIN_FUNCTION_NAME,
-    ConcreteFunctionDefinition,
-)
-from classiq.interface.generator.user_defined_function_params import CustomFunction
-from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
-
-from classiq.exceptions import ClassiqValueError
-from classiq.quantum_functions.quantum_function import (
-    QuantumFunction,
-    QuantumFunctionFactory,
-)
-
-QASM_INTRO = 'OPENQASM 2.0;\ninclude "qelib1.inc";\n'
-QASM3_INTRO = 'OPENQASM 3.0;\ninclude "stdgates.inc";\n'
-
-_INVALID_FUNCTION_LIBRARY_ARGUMENT_ERROR_MSG: str = (
-    "Argument is not a valid FunctionLibrary object"
-)
-
-
-class FunctionLibrary:
-    """Facility to manage functions."""
-
-    def __init__(
-        self,
-        *functions: Union[
-            SynthesisQuantumFunctionDeclaration,
-            QuantumFunction,
-            Type[QuantumFunctionFactory],
-        ],
-    ) -> None:
-        """
-        Args:
-            name (:obj:`str`, optional): The name of the function library.
-            *functions (:obj:`SynthesisQuantumFunctionDeclaration`, optional): A list of functions to initialize the object.
-        """
-        self._data: List[ConcreteFunctionDefinition] = list()
-        self._params: Dict[str, CustomFunction] = dict()
-        self._func_factories: Dict[str, Type[QuantumFunctionFactory]] = dict()
-
-        for f in functions:
-            self.add_function(f)
-
-        if MAIN_FUNCTION_NAME not in self.function_dict:
-            self.add_function(
-                SynthesisNativeFunctionDefinition(name=MAIN_FUNCTION_NAME)
-            )
-
-    def get_function(self, function_name: str) -> CustomFunction:
-        return self._params[function_name]
-
-    def get_function_factory(
-        self, function_factory_name: str
-    ) -> Type[QuantumFunctionFactory]:
-        return self._func_factories[function_factory_name]
-
-    def __getitem__(self, key: Any) -> CustomFunction:
-        if isinstance(key, str):
-            return self.get_function(key)
-        else:
-            raise ClassiqValueError("Invalid key")
-
-    def add_function(
-        self,
-        function_data: Union[
-            SynthesisQuantumFunctionDeclaration,
-            QuantumFunction,
-            Type[QuantumFunctionFactory],
-        ],
-        override_existing_functions: bool = False,
-    ) -> None:
-        """Adds a function to the function library.
-
-        Args:
-            function_data (SynthesisQuantumFunctionDeclaration): The function data object.
-            override_existing_functions (:obj:`bool`, optional): Defaults to False.
-
-        Returns:
-            None
-        """
-        if isinstance(function_data, type) and issubclass(
-            function_data, QuantumFunctionFactory
-        ):
-            self._func_factories[function_data.__name__] = function_data
-            return
-        if isinstance(function_data, QuantumFunction):
-            function_data = function_data.function_data
-
-        if not isinstance(
-            function_data,
-            (SynthesisForeignFunctionDefinition, SynthesisNativeFunctionDefinition),
-        ):
-            raise ClassiqValueError(
-                f"Concrete function definition object expected, got {function_data.__class__.__name__}"
-            )
-
-        function_name = function_data.name
-        if not override_existing_functions and function_name in self.function_dict:
-            raise ClassiqValueError("Cannot override existing functions.")
-
-        if isinstance(function_data, SynthesisNativeFunctionDefinition):
-            for call in filter(
-                lambda i: isinstance(i.function_params, CustomFunction),
-                function_data.body,
-            ):
-                if self._data and call.function not in self.function_dict:
-                    raise ClassiqValueError(
-                        "FunctionLibrary: The function is not found in included library."
-                    )
-
-        self._data.append(function_data)
-        self._params[function_name] = self._to_params(function_data)
-
-    @property
-    def function_names(self) -> Tuple[str, ...]:
-        """Get a tuple of the names of the functions in the library.
-
-        Returns:
-            The names of the functions in the library.
-        """
-        return tuple(self.function_dict.keys())
-
-    @property
-    def function_factory_names(self) -> Tuple[str, ...]:
-        return tuple(self._func_factories.keys())
-
-    @property
-    def functions(self) -> List[ConcreteFunctionDefinition]:
-        return list(self._data)
-
-    @property
-    def function_dict(self) -> Dict[str, SynthesisQuantumFunctionDeclaration]:
-        return nameables_to_dict(self._data)
-
-    def remove_function_definition(self, name: str) -> None:
-        idx = list(locate(self.functions, lambda func: func.name == name))
-        assert len(idx) == 1
-        self._data.pop(idx[0])
-
-    @staticmethod
-    def _to_params(data: SynthesisQuantumFunctionDeclaration) -> CustomFunction:
-        params = CustomFunction(
-            input_decls=data.inputs,
-            output_decls=data.outputs,
-        )
-        return params
-
-    def __add__(self, other: "FunctionLibrary") -> "FunctionLibrary":
-        if not isinstance(other, FunctionLibrary):
-            raise ClassiqValueError(_INVALID_FUNCTION_LIBRARY_ARGUMENT_ERROR_MSG)
-        joint_library = FunctionLibrary()
-        for library in (self, other):
-            for func in library.functions:
-                if (
-                    func.name == MAIN_FUNCTION_NAME
-                    or func.name in joint_library.function_names
-                ):
-                    continue
-                joint_library.add_function(func)
-        return joint_library
-
-    def __iadd__(self, other: "FunctionLibrary") -> "FunctionLibrary":
-        if not isinstance(other, FunctionLibrary):
-            raise ClassiqValueError(_INVALID_FUNCTION_LIBRARY_ARGUMENT_ERROR_MSG)
-        for func in other.functions:
-            if func.name == MAIN_FUNCTION_NAME or func.name in self.function_names:
-                continue
-            self.add_function(func)
-        return self