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

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]

classiq/quantum_functions/quantum_function.py

@@ -1,236 +0,0 @@
-import sys
-from abc import ABC, abstractmethod
-from types import FunctionType
-from typing import Callable, Dict, List, Optional, Sequence, Tuple
-
-from classiq.interface.generator.functions import (
-    FunctionImplementation,
-    Register,
-    RegisterMappingData,
-    SynthesisForeignFunctionDefinition,
-)
-from classiq.interface.generator.register_role import RegisterRole as Role
-
-from classiq.exceptions import ClassiqError
-
-# This line is ignored because the entire annotation_parser module is ignored by mypy
-from classiq.quantum_functions.annotation_parser import (  # type: ignore[attr-defined]
-    AnnotationParser,
-    get_annotation_role,
-)
-from classiq.quantum_functions.function_parser import (
-    FunctionParser,
-    convert_callable_to_function,
-)
-
-# isort: split
-from typing import _GenericAlias  # type: ignore[attr-defined]
-
-from classiq.quantum_register import QRegGenericAlias
-
-if sys.version_info >= (3, 9):
-    from types import GenericAlias
-else:
-    GenericAlias = _GenericAlias
-
-
-class QuantumFunction:
-    def __init__(self) -> None:
-        self._function_data: Optional[SynthesisForeignFunctionDefinition] = None
-
-    @staticmethod
-    def _generate_single_register(
-        first_qubit: int, name: str, obj: GenericAlias
-    ) -> Register:
-        qreg_size = obj.size
-
-        qubits = tuple(range(first_qubit, first_qubit + qreg_size))
-
-        return Register(
-            name=name,
-            qubits=qubits,
-        )
-
-    @classmethod
-    def _generate_registers(
-        cls,
-        input_names: Sequence[str],
-        input_values: Sequence[QRegGenericAlias],
-        output_values: Sequence[QRegGenericAlias],
-    ) -> Dict[Role, Tuple[Register, ...]]:
-        registers: Dict[Role, List[Register]] = {k: list() for k in Role}
-
-        qubit_counter = 0
-        for input_name, input_annotation in zip(input_names, input_values):
-            role = get_annotation_role(
-                annotation=input_annotation, default_role=Role.INPUT
-            )
-
-            registers[role].append(
-                cls._generate_single_register(
-                    first_qubit=qubit_counter,
-                    name=input_name,
-                    obj=input_annotation,
-                )
-            )
-
-            if input_annotation.size is None:
-                raise ClassiqError("Missing size in input annotation")
-
-            qubit_counter += input_annotation.size
-
-        qubit_counter = 0
-        for input_name, output_annotation in zip(input_names, output_values):
-            role = get_annotation_role(
-                annotation=output_annotation, default_role=Role.OUTPUT
-            )
-
-            if output_annotation.size is None:
-                raise ClassiqError("Missing size in input annotation")
-
-            if role == Role.AUXILIARY:
-                qubit_counter += output_annotation.size
-                continue
-
-            registers[role].append(
-                cls._generate_single_register(
-                    first_qubit=qubit_counter,
-                    name=input_name,
-                    obj=output_annotation,
-                )
-            )
-            qubit_counter += output_annotation.size
-
-        return {k: tuple(v) for k, v in registers.items()}
-
-    @classmethod
-    def _create_implementation_from_function(
-        cls,
-        func: FunctionType,
-        func_name: str,
-        auxiliary_registers: Tuple[Register, ...],
-    ) -> FunctionImplementation:
-        # Return value
-        fp = FunctionParser(func)
-        serialized_circuit = fp.extract_function_output()
-
-        implementation = FunctionImplementation(
-            name=func_name,
-            serialized_circuit=serialized_circuit,
-            auxiliary_registers=auxiliary_registers,
-        )
-        return implementation
-
-    def add_implementation(
-        self, func: Callable, name: Optional[str] = None
-    ) -> "QuantumFunction":
-        func, func_name = convert_callable_to_function(func=func)
-        func_name = name or func_name
-
-        # Annotations
-        ap = AnnotationParser(func)
-        ap.parse()
-
-        registers: Dict[Role, Tuple[Register, ...]] = self._generate_registers(
-            input_names=ap.input_names,
-            input_values=ap.input_values,
-            output_values=ap.output_values,
-        )
-
-        implementation = self._create_implementation_from_function(
-            func=func,
-            func_name=func_name,
-            auxiliary_registers=registers[Role.AUXILIARY],
-        )
-
-        if self._function_data is None:
-            self._function_data = SynthesisForeignFunctionDefinition(
-                name=func_name,
-                implementations=(implementation,),
-                register_mapping=RegisterMappingData.from_registers_dict(
-                    regs_dict=registers
-                ),
-            )
-        else:
-            self._function_data.register_mapping.validate_equal_mappings(
-                RegisterMappingData.from_registers_dict(regs_dict=registers)
-            )
-            current_implementations = self._function_data.implementations or tuple()
-            new_implementations = current_implementations + (implementation,)
-            implementation.validate_ranges_of_all_registers(
-                self._function_data.register_mapping
-            )
-            self._function_data = SynthesisForeignFunctionDefinition(
-                name=self._function_data.name,
-                register_mapping=self._function_data.register_mapping,
-                implementations=new_implementations,
-            )
-
-        return self
-
-    @property
-    def function_data(self) -> SynthesisForeignFunctionDefinition:
-        if self._function_data is None:
-            raise ClassiqError("Access to uninitialized function data")
-
-        return self._function_data
-
-    @function_data.setter
-    def function_data(
-        self, new_function_data: SynthesisForeignFunctionDefinition
-    ) -> None:
-        self._function_data = new_function_data
-
-
-class QuantumFunctionFactoryBadUsageError(Exception):
-    def __init__(self, msg: str) -> None:
-        self.message = f"{msg} Please call QuantumFunctionFactory.__init__ after initializing all user params."
-        super().__init__(self.message)
-
-
-class QuantumFunctionFactory(ABC):
-    """
-    Provides the capability of creating parametrized user-defined functions.
-    """
-
-    def __init__(self, add_method: Callable, apply_method: Callable) -> None:
-        self._apply_method = apply_method
-        try:
-            definition = self.definition
-        except AttributeError as e:
-            raise QuantumFunctionFactoryBadUsageError(
-                f"{self.__class__.__name__} instance definition parsing failed."
-            ) from e
-        definition.function_data = definition.function_data.renamed(str(self))
-        add_method(definition)
-
-    def __str__(self) -> str:
-        str_list = [self.__class__.__name__.lower()]
-        str_list.extend(
-            f"{k}_{abs(hash(str(v)))}"
-            for k, v in self.__dict__.items()
-            if k != "_apply_method"
-        )
-        return "_".join(str_list)
-
-    def __call__(self, *args, **kwargs):
-        try:
-            return self._apply_method(str(self), *args, **kwargs)
-        except AttributeError as e:
-            raise QuantumFunctionFactoryBadUsageError(
-                f"Could not call {self.__class__.__name__}."
-            ) from e
-
-    @property
-    @abstractmethod
-    def definition(self) -> QuantumFunction:
-        """
-        Abstract method for providing the definition of the user function.
-        The QuantumFunction object may be generated either directly, or using existing
-        helper tools such as the @qfunc decorator.
-        Instance attributes of the QuantumFunctionFactory may be used as parameters for the
-        definition.
-
-        Returns:
-            The user-defined QuantumFunction object.
-        """