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

classiq/interface/generator/finance.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Tuple, Union
+from typing import Union
 
 import pydantic
 
@@ -20,7 +20,7 @@ DEFAULT_POST_INPUT_NAME = "post_function_input"
 
 class Finance(function_params.FunctionParams):
     model: Union[GaussianModelInput, LogNormalModelInput] = pydantic.Field(
-        description="Load a financial model"
+        description="Load a financial model", discriminator="kind"
     )
     finance_function: FinanceFunctionInput = pydantic.Field(
         description="The finance function to solve the model"
@@ -90,7 +90,7 @@ class FinancePayoff(function_params.FunctionParams):
         description="The finance function to solve the model"
     )
     num_qubits: pydantic.PositiveInt
-    distribution_range: Tuple[float, float]
+    distribution_range: tuple[float, float]
 
     def _create_ios(self) -> None:
         self._inputs = {

classiq/interface/generator/function_param_library.py

@@ -1,19 +1,19 @@
-from typing import Iterable, Set, Type
+from collections.abc import Iterable
 
 from classiq.interface.generator.function_params import FunctionParams
 
 
 class FunctionParamLibrary:
-    def __init__(self, param_list: Iterable[Type[FunctionParams]]) -> None:
-        self._param_list: Set[Type[FunctionParams]] = set(param_list)
+    def __init__(self, param_list: Iterable[type[FunctionParams]]) -> None:
+        self._param_list: set[type[FunctionParams]] = set(param_list)
 
     @property
-    def param_list(self) -> Set[Type[FunctionParams]]:
+    def param_list(self) -> set[type[FunctionParams]]:
         return self._param_list.copy()
 
     # Private methods are for tests only
-    def _add(self, param: Type[FunctionParams]) -> None:
+    def _add(self, param: type[FunctionParams]) -> None:
         self._param_list.add(param)
 
-    def _remove(self, param: Type[FunctionParams]) -> None:
+    def _remove(self, param: type[FunctionParams]) -> None:
         self._param_list.discard(param)

classiq/interface/generator/function_param_list_without_self_reference.py

@@ -28,8 +28,7 @@ from classiq.interface.generator.arith.unary_ops import BitwiseInvert, Negation,
 from classiq.interface.generator.commuting_pauli_exponentiation import (
     CommutingPauliExponentiation,
 )
-from classiq.interface.generator.credit_risk_example.linear_gci import LinearGCI
-from classiq.interface.generator.credit_risk_example.weighted_adder import WeightedAdder
+from classiq.interface.generator.copy import Copy
 from classiq.interface.generator.entangler_params import (
     GridEntangler,
     HypercubeEntangler,
@@ -53,7 +52,6 @@ from classiq.interface.generator.hardware_efficient_ansatz import (
 from classiq.interface.generator.hartree_fock import HartreeFock
 from classiq.interface.generator.hva import HVA
 from classiq.interface.generator.identity import Identity
-from classiq.interface.generator.inequality_mixer import InequalityMixer
 from classiq.interface.generator.linear_pauli_rotations import LinearPauliRotations
 from classiq.interface.generator.mcu import Mcu
 from classiq.interface.generator.mcx import Mcx
@@ -67,7 +65,6 @@ from classiq.interface.generator.piecewise_linear_amplitude_loading import (
 from classiq.interface.generator.qft import QFT
 from classiq.interface.generator.qsvm import QSVMFeatureMap
 from classiq.interface.generator.randomized_benchmarking import RandomizedBenchmarking
-from classiq.interface.generator.range_mixer import RangeMixer
 from classiq.interface.generator.standard_gates.standard_gates_param_list import (
     standard_gate_function_param_library,
 )
@@ -81,7 +78,6 @@ from classiq.interface.generator.state_preparation import (
     UniformDistributionStatePreparation,
     WStatePreparation,
 )
-from classiq.interface.generator.state_propagator import StatePropagator
 from classiq.interface.generator.ucc import UCC
 from classiq.interface.generator.unitary_gate import UnitaryGate
 from classiq.interface.generator.user_defined_function_params import CustomFunction
@@ -97,7 +93,6 @@ function_param_library_without_self_reference: FunctionParamLibrary = (
                 GHZStatePreparation,
                 WStatePreparation,
                 ExponentialStatePreparation,
-                StatePropagator,
                 QFT,
                 BitwiseAnd,
                 BitwiseOr,
@@ -134,11 +129,9 @@ function_param_library_without_self_reference: FunctionParamLibrary = (
                 CustomFunction,
                 HardwareEfficientAnsatz,
                 UnitaryGate,
-                WeightedAdder,
                 LinearPauliRotations,
                 Multiplier,
                 Power,
-                LinearGCI,
                 HartreeFock,
                 UCC,
                 Min,
@@ -150,14 +143,13 @@ function_param_library_without_self_reference: FunctionParamLibrary = (
                 Identity,
                 RandomizedBenchmarking,
                 HVA,
-                InequalityMixer,
-                RangeMixer,
                 UGate,
                 AmplitudeLoading,
                 QSVMFeatureMap,
                 PiecewiseLinearAmplitudeLoading,
                 PiecewiseLinearRotationAmplitudeLoading,
                 HadamardTransform,
+                Copy,
             },
             standard_gate_function_param_library.param_list,
             oracle_function_param_library.param_list,

classiq/interface/generator/function_params.py

@@ -1,40 +1,35 @@
 import ast
 import itertools
 import re
+from collections.abc import Collection, Iterable, Mapping
 from typing import (
+    Annotated,
     Any,
-    Collection,
-    Dict,
-    Iterable,
-    List,
-    Mapping,
     Optional,
-    Set,
-    Type,
     Union,
     get_args,
 )
 
 import pydantic
 import sympy
-from pydantic.fields import ModelField
+from pydantic import BeforeValidator, ConfigDict
 
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.arithmetic_expression_validator import (
     validate_expression,
 )
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
-from classiq.interface.generator.expressions.enums import BUILTIN_ENUMS
+from classiq.interface.generator.parameters import ParameterFloatType
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
 
-from classiq._internals.enum_utils import StrEnum
-
 FunctionParamsDiscriminator = str
 
 IOName = PydanticNonEmptyString
-ArithmeticIODict = Dict[IOName, RegisterArithmeticInfo]
+ArithmeticIODict = dict[IOName, RegisterArithmeticInfo]
 
 DEFAULT_ZERO_NAME = "zero"
 DEFAULT_OUTPUT_NAME = "OUT"
@@ -84,7 +79,6 @@ ExecutionExpressionSupportedNodeTypes = Union[
 ]
 
 GenerationOnlyExpressionSupportedNodeTypes = Union[
-    ast.FloorDiv,
     ast.Pow,
     ast.List,
     ast.Subscript,
@@ -96,6 +90,7 @@ GenerationOnlyExpressionSupportedNodeTypes = Union[
     ast.Lt,
     ast.LtE,
     ast.Eq,
+    ast.NotEq,
     ast.Call,
     ast.Dict,
     ast.Slice,
@@ -111,11 +106,9 @@ GenerationExpressionSupportedNodeTypes = Union[
     ExecutionExpressionSupportedNodeTypes, GenerationOnlyExpressionSupportedNodeTypes
 ]
 
-GenerationExpressionSupportedAttrSymbols = set(BUILTIN_ENUMS.keys())
-
 
 def validate_expression_str(
-    expr_str: str, supported_functions: Optional[Set[str]] = None
+    expr_str: str, supported_functions: Optional[set[str]] = None
 ) -> None:
     # By default, no functions are allowed.
     supported_functions = supported_functions or set()
@@ -126,10 +119,25 @@ def validate_expression_str(
         supported_nodes=get_args(GenerationExpressionSupportedNodeTypes),
         expression_type="parameter",
         supported_functions=supported_functions,
-        supported_attr_values=GenerationExpressionSupportedAttrSymbols,
     )
 
 
+def validate_parameters(value: Any) -> Any:
+    if isinstance(value, str):
+        validate_expression_str(value)
+    elif isinstance(value, sympy.Expr):
+        return str(value)
+    try:
+        return float(value)
+    except ValueError:
+        return value
+
+
+FunctionParamsNumericParameter = Annotated[
+    ParameterFloatType, BeforeValidator(validate_parameters)
+]
+
+
 class PortDirection(StrEnum):
     Input = "input"
     Output = "output"
@@ -175,11 +183,11 @@ class FunctionParams(HashablePydanticBaseModel):
         return sum(reg.size for reg in self.outputs.values())
 
     @property
-    def _input_names(self) -> List[IOName]:
+    def _input_names(self) -> list[IOName]:
         return list(self._inputs.keys())
 
     @property
-    def _output_names(self) -> List[IOName]:
+    def _output_names(self) -> list[IOName]:
         return list(self._outputs.keys())
 
     def _create_zero_input_registers(self, names_and_sizes: Mapping[str, int]) -> None:
@@ -201,20 +209,6 @@ class FunctionParams(HashablePydanticBaseModel):
         if self.discriminator() not in _UNVALIDATED_FUNCTIONS:
             self._validate_total_io_sizes()
 
-    def is_field_param_type(self, name: str, param_type_signature: str) -> bool:
-        f = type(self).__fields__[name]
-        return isinstance(f, ModelField) and (
-            param_type_signature in f.field_info.extra
-        )
-
-    def is_field_gen_param(self, name: str) -> bool:
-        return self.is_field_param_type(
-            name, "is_gen_param"
-        ) or self.is_field_exec_param(name)
-
-    def is_field_exec_param(self, name: str) -> bool:
-        return self.is_field_param_type(name, "is_exec_param")
-
     def is_powerable(self, strict_zero_ios: bool = True) -> bool:
         input_names = set(self.inputs_full(strict_zero_ios))
         output_names = set(self._output_names)
@@ -238,12 +232,12 @@ class FunctionParams(HashablePydanticBaseModel):
         return sum(reg.size if reg is not None else 0 for reg in registers)
 
     def _validate_io_names(self) -> None:
-        error_msg: List[str] = []
+        error_msg: list[str] = []
         error_msg += self._get_error_msg(self._inputs, BAD_INPUT_REGISTER_ERROR_MSG)
         error_msg += self._get_error_msg(self._outputs, BAD_OUTPUT_REGISTER_ERROR_MSG)
         if error_msg:
             error_msg += [END_BAD_REGISTER_ERROR_MSG]
-            raise ValueError("\n".join(error_msg))
+            raise ClassiqValueError("\n".join(error_msg))
 
     @staticmethod
     def _sum_registers_sizes(registers: Iterable[RegisterArithmeticInfo]) -> int:
@@ -255,9 +249,9 @@ class FunctionParams(HashablePydanticBaseModel):
         )
         total_outputs_size = self._sum_registers_sizes(self._outputs.values())
         if total_inputs_size != total_outputs_size:
-            raise ValueError(REGISTER_SIZES_MISMATCH_ERROR_MSG)
+            raise ClassiqValueError(REGISTER_SIZES_MISMATCH_ERROR_MSG)
 
-    def _get_error_msg(self, names: Iterable[IOName], msg: str) -> List[str]:
+    def _get_error_msg(self, names: Iterable[IOName], msg: str) -> list[str]:
         bad_names = [name for name in names if re.fullmatch(NAME_REGEX, name) is None]
         return [f"{msg}: {bad_names}"] if bad_names else []
 
@@ -265,38 +259,17 @@ class FunctionParams(HashablePydanticBaseModel):
     def discriminator(cls) -> FunctionParamsDiscriminator:
         return cls.__name__
 
-    @property
-    def _params(self) -> List[str]:
-        return [
-            name
-            for name, field in self.__fields__.items()
-            if field.field_info.extra.get("is_exec_param", False)
-        ]
-
-    @pydantic.validator("*", pre=True)
-    def validate_parameters(cls, value: Any, field: pydantic.fields.ModelField) -> Any:
-        if (
-            "is_exec_param" in field.field_info.extra
-            or "is_gen_param" in field.field_info.extra
-        ):
-            if isinstance(value, str):
-                validate_expression_str(value)
-            elif isinstance(value, sympy.Expr):
-                return str(value)
-        return value
-
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True, extra="forbid")
 
 
 def parse_function_params(
     *,
     params: Any,
     discriminator: Optional[Any],
-    param_classes: Collection[Type[FunctionParams]],
+    param_classes: Collection[type[FunctionParams]],
     no_discriminator_error: Exception,
     bad_function_error: Exception,
-    default_parser_class: Optional[Type[FunctionParams]] = None,
+    default_parser_class: Optional[type[FunctionParams]] = None,
 ) -> FunctionParams:  # Any is for use in pydantic validators.
     if not discriminator:
         raise no_discriminator_error
@@ -310,21 +283,21 @@ def parse_function_params(
     if len(matching_classes) != 1:
         if default_parser_class is not None:
             try:
-                return default_parser_class.parse_obj(params)
+                return default_parser_class.model_validate(params)
             except Exception:
-                raise bad_function_error
+                raise bad_function_error from None
         raise bad_function_error
 
-    return matching_classes[0].parse_obj(params)
+    return matching_classes[0].model_validate(params)
 
 
 def parse_function_params_values(
     *,
-    values: Dict[str, Any],
+    values: dict[str, Any],
     params_key: str,
     discriminator_key: str,
-    param_classes: Collection[Type[FunctionParams]],
-    default_parser_class: Type[FunctionParams],
+    param_classes: Collection[type[FunctionParams]],
+    default_parser_class: type[FunctionParams],
 ) -> None:
     params = values.get(params_key, dict())
     if isinstance(params, FunctionParams):
@@ -335,10 +308,10 @@ def parse_function_params_values(
         params=params,
         discriminator=discriminator,
         param_classes=param_classes,
-        no_discriminator_error=ValueError(
+        no_discriminator_error=ClassiqValueError(
             f"The {discriminator_key} {NO_DISCRIMINATOR_ERROR_MSG} {params_key} type."
         ),
-        bad_function_error=ValueError(
+        bad_function_error=ClassiqValueError(
             f"{BAD_FUNCTION_ERROR_MSG} {discriminator_key}: {discriminator}"
         ),
         default_parser_class=default_parser_class,

classiq/interface/generator/functions/__init__.py

@@ -1,23 +1 @@
-from typing import List
-
-import classiq.interface.generator.functions.core_lib_declarations.quantum_functions
-import classiq.interface.generator.functions.core_lib_declarations.quantum_operators  # noqa: F401
-from classiq.interface.generator.functions.foreign_function_definition import *
-from classiq.interface.generator.functions.foreign_function_definition import (
-    SynthesisForeignFunctionDefinition as ForeignFunctionDefinition,
-)
 from classiq.interface.generator.functions.function_declaration import *
-from classiq.interface.generator.functions.function_implementation import *
-from classiq.interface.generator.functions.native_function_definition import *
-from classiq.interface.generator.functions.register import *
-
-__all__ = [  # noqa: F405
-    "ForeignFunctionDefinition",
-    "FunctionImplementation",
-    "Register",
-    "RegisterMappingData",
-]
-
-
-def __dir__() -> List[str]:
-    return __all__

classiq/interface/generator/functions/builtins/internal_operators.py

@@ -0,0 +1,16 @@
+CTRL_VAR_PREFIX = "ctrl__"
+CONTROL_OPERATOR_NAME = "control"
+INVERT_OPERATOR_NAME = "invert"
+REPEAT_OPERATOR_NAME = "iteration"
+POWER_OPERATOR_NAME = "power"
+UNCOMPUTE_OPERATOR_NAME = "uncompute"
+WITHIN_APPLY_NAME = "within_apply"
+
+All_BUILTINS_OPERATORS = {
+    CONTROL_OPERATOR_NAME,
+    INVERT_OPERATOR_NAME,
+    REPEAT_OPERATOR_NAME,
+    POWER_OPERATOR_NAME,
+    UNCOMPUTE_OPERATOR_NAME,
+    WITHIN_APPLY_NAME,
+}

classiq/interface/generator/functions/classical_function_declaration.py

@@ -1,11 +1,15 @@
-from typing import ClassVar, Dict, Mapping, Optional
+from collections.abc import Sequence
+from typing import ClassVar, Optional
 
 import pydantic
 
-from classiq.interface.generator.functions.classical_type import ConcreteClassicalType
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 from classiq.interface.generator.functions.function_declaration import (
     FunctionDeclaration,
 )
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 
 
 class ClassicalFunctionDeclaration(FunctionDeclaration):
@@ -13,23 +17,28 @@ class ClassicalFunctionDeclaration(FunctionDeclaration):
     Facilitates the creation of a common classical function interface object.
     """
 
+    name: str
+
+    positional_parameters: Sequence[ClassicalParameterDeclaration] = pydantic.Field(
+        default_factory=list,
+    )
+
     return_type: Optional[ConcreteClassicalType] = pydantic.Field(
         description="The type of the classical value that is returned by the function (for classical functions)",
         default=None,
     )
 
     BUILTIN_FUNCTION_DECLARATIONS: ClassVar[
-        Dict[str, "ClassicalFunctionDeclaration"]
+        dict[str, "ClassicalFunctionDeclaration"]
     ] = {}
 
     FOREIGN_FUNCTION_DECLARATIONS: ClassVar[
-        Dict[str, "ClassicalFunctionDeclaration"]
+        dict[str, "ClassicalFunctionDeclaration"]
     ] = {}
 
-    def update_logic_flow(
-        self, function_dict: Mapping[str, "ClassicalFunctionDeclaration"]
-    ) -> None:
-        pass
+    @property
+    def param_decls(self) -> Sequence[ClassicalParameterDeclaration]:
+        return self.positional_parameters
 
 
-ClassicalFunctionDeclaration.update_forward_refs()
+ClassicalFunctionDeclaration.model_rebuild()