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

classiq/qmod/qmod_struct.py

@@ -1,37 +0,0 @@
-import dataclasses
-from typing import Any, List, Type
-
-from typing_extensions import dataclass_transform
-
-from classiq.interface.generator.functions.classical_type import QStructBase
-
-
-def _qmod_val_to_expr_str(val: Any) -> str:
-    if dataclasses.is_dataclass(type(val)):
-        kwargs_str = ", ".join(
-            [
-                f"{field.name}={_qmod_val_to_expr_str(vars(val)[field.name])}"
-                for field in dataclasses.fields(val)
-            ]
-        )
-        return f"struct_literal({type(val).__name__}, {kwargs_str})"
-
-    if isinstance(val, List):
-        elements_str = ", ".join([_qmod_val_to_expr_str(elem) for elem in val])
-        return f"[{elements_str}]"
-
-    return str(val)
-
-
-@dataclass_transform()
-def QStruct(user_class: Type) -> Type:  # noqa: N802 - for consistency with 'QFunc'
-    def _new_repr(self: Any) -> str:
-        return _qmod_val_to_expr_str(self)
-
-    user_dataclass = type(
-        user_class.__name__,
-        (QStructBase, dataclasses.dataclass(user_class)),
-        dict(),
-    )
-    user_dataclass.__repr__ = _new_repr  # type:ignore[assignment]
-    return user_dataclass

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

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

classiq/quantum_functions/function_parser.py

@@ -1,74 +0,0 @@
-import sys
-from types import FunctionType, MethodType
-from typing import Any, Callable, Tuple, _GenericAlias  # type: ignore[attr-defined]
-
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-else:
-    GenericAlias = _GenericAlias
-
-
-from classiq.exceptions import ClassiqQFuncError
-
-
-class FunctionParser:
-    def __init__(self, func: FunctionType) -> None:
-        self._func = func
-
-    @staticmethod
-    def _extract_function_output_by_execution(func: FunctionType) -> Any:
-        # Todo: Parse the type (annotations) of the arguments, and remove only those inheriting from QReg
-        if func.__code__.co_kwonlyargcount:
-            raise ClassiqQFuncError("kw only args are not supported")
-
-        arg_count = func.__code__.co_argcount - ("self" in func.__code__.co_varnames)
-        nones = [None] * arg_count
-        return func(*nones)
-
-    def extract_function_output(self) -> Any:
-        output = self._extract_function_output_by_execution(func=self._func)
-
-        self._validate_function_output(output)
-
-        return output
-
-    @staticmethod
-    def _validate_function_output(output: Any) -> None:
-        # Todo: validate QASM
-
-        if type(output) is not str:
-            raise ClassiqQFuncError(
-                "Invalid output. Please return a string of OpenQASM2.0."
-            )
-
-
-def _convert_class_to_function(cls: type) -> Tuple[FunctionType, str]:
-    # Create instance
-    try:
-        inst = cls()
-    except TypeError as exc:
-        raise ClassiqQFuncError("Unable to initialize class") from exc
-
-    return inst.__call__, inst.__class__.__name__
-
-
-def convert_callable_to_function(func: Callable) -> Tuple[FunctionType, str]:
-    # There's a story to be told here:
-    # Functions vs Methods.
-    # It's a centuries old fight, which won't end soon..
-    # Functions, being functions, always have a way of telling us about their functionality
-    #   This is done using `func.__code__`
-    # Methods, being the heigher form of functions, are too proud to have a `__code__` attribute.
-    #   Thus, `"__code__" in method` is false
-    #   However, `method.__code__` exists
-    #   Since it is inherited from the class that initialized the instance who owns the method
-    # Thus, we reach the important conclusion:
-    # Methods are shy functions. They are functions, but they don't like telling us that they're functions.
-    if not callable(func):
-        raise ClassiqQFuncError("Invalid callable given.")
-
-    if isinstance(func, (FunctionType, MethodType)):
-        return func, func.__name__  # type: ignore[return-value]
-
-    # Assuming `func` is an instance of some class
-    return _convert_class_to_function(func)  # type: ignore[arg-type]