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

classiq/interface/generator/function_params.py

@@ -1,41 +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
-from classiq.exceptions import ClassiqValueError
-
 FunctionParamsDiscriminator = str
 
 IOName = PydanticNonEmptyString
-ArithmeticIODict = Dict[IOName, RegisterArithmeticInfo]
+ArithmeticIODict = dict[IOName, RegisterArithmeticInfo]
 
 DEFAULT_ZERO_NAME = "zero"
 DEFAULT_OUTPUT_NAME = "OUT"
@@ -112,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()
@@ -127,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"
@@ -176,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:
@@ -202,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)
@@ -239,7 +232,7 @@ 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:
@@ -258,7 +251,7 @@ class FunctionParams(HashablePydanticBaseModel):
         if total_inputs_size != total_outputs_size:
             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 []
 
@@ -266,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
@@ -311,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 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):

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
-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()

classiq/interface/generator/functions/classical_type.py

@@ -1,43 +1,31 @@
-from abc import abstractmethod
-from typing import Any, Dict, List, Literal, Union
+from typing import TYPE_CHECKING, Any, Literal, Union
 
 import pydantic
-from pydantic import Extra, Field
+from pydantic import ConfigDict
 from sympy import IndexedBase, Symbol
-from typing_extensions import Annotated
 
-from classiq.interface.generator.expressions.enums.ladder_operator import (
-    LadderOperator as LadderOperatorEnum,
-)
-from classiq.interface.generator.expressions.enums.pauli import Pauli as PauliEnum
+from classiq.interface.ast_node import HashableASTNode
 from classiq.interface.generator.expressions.expression_types import RuntimeExpression
-from classiq.interface.helpers.hashable_pydantic_base_model import (
-    HashablePydanticBaseModel,
-)
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 
+if TYPE_CHECKING:
+    from classiq.interface.generator.functions.concrete_types import (
+        ConcreteClassicalType,
+    )
+
+CLASSICAL_ATTRIBUTES = {"len", "size", "is_signed", "fraction_digits"}
+
 NamedSymbol = Union[IndexedBase, Symbol]
 
 
-class ClassicalType(HashablePydanticBaseModel):
-    def as_symbolic(self, name: str) -> Union[NamedSymbol, List[NamedSymbol]]:
+class ClassicalType(HashableASTNode):
+    def as_symbolic(self, name: str) -> Union[NamedSymbol, list[NamedSymbol]]:
         return Symbol(name)
 
-    @property
-    @abstractmethod
-    def default_value(self) -> Any:
-        raise NotImplementedError(
-            f"{self.__class__.__name__} type has no default value"
-        )
+    model_config = ConfigDict(extra="forbid")
 
-    @property
-    def python_type(self) -> type:
-        raise NotImplementedError(
-            f"{self.__class__.__name__!r} has no Python SDK equivalent"
-        )
-
-    class Config:
-        extra = Extra.forbid
+    def __str__(self) -> str:
+        return str(type(self).__name__)
 
 
 class Integer(ClassicalType):
@@ -46,18 +34,11 @@ class Integer(ClassicalType):
     def as_symbolic(self, name: str) -> Symbol:
         return Symbol(name, integer=True)
 
-    @property
-    def default_value(self) -> int:
-        return 0
-
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "int")
 
-    @property
-    def python_type(self) -> type:
-        return int
-
 
 class Real(ClassicalType):
     kind: Literal["real"]
@@ -65,34 +46,20 @@ class Real(ClassicalType):
     def as_symbolic(self, name: str) -> Symbol:
         return Symbol(name, real=True)
 
-    @property
-    def default_value(self) -> float:
-        return 0
-
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "real")
 
-    @property
-    def python_type(self) -> type:
-        return float
-
 
 class Bool(ClassicalType):
     kind: Literal["bool"]
 
-    @property
-    def default_value(self) -> bool:
-        return False
-
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "bool")
 
-    @property
-    def python_type(self) -> type:
-        return bool
-
 
 class ClassicalList(ClassicalType):
     kind: Literal["list"]
@@ -101,68 +68,21 @@ class ClassicalList(ClassicalType):
     def as_symbolic(self, name: str) -> Symbol:
         return IndexedBase(name)
 
-    @property
-    def default_value(self) -> List:
-        return []
-
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "list")
 
-    @property
-    def python_type(self) -> type:
-        return List[self.element_type.python_type]  # type:ignore[name-defined]
-
-
-class Pauli(ClassicalType):
-    kind: Literal["pauli"]
-
-    @property
-    def default_value(self) -> PauliEnum:
-        return PauliEnum.I
-
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(values, "kind", "pauli")
-
-    @property
-    def python_type(self) -> type:
-        return int
-
 
 class StructMetaType(ClassicalType):
     kind: Literal["type_proxy"]
 
-    @property
-    def default_value(self) -> Any:
-        return super().default_value
-
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "type_proxy")
 
 
-class QStructBase:  # marker for Qmod structs in the Python SDK
-    pass
-
-
-class Struct(ClassicalType):
-    kind: Literal["struct_instance"]
-    name: str = pydantic.Field(description="The struct type of the instance")
-
-    @property
-    def default_value(self) -> Any:
-        return super().default_value
-
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(values, "kind", "struct_instance")
-
-    @property
-    def python_type(self) -> type:
-        return type(self.name, (QStructBase,), dict())
-
-
 class ClassicalArray(ClassicalType):
     kind: Literal["array"]
     element_type: "ConcreteClassicalType"
@@ -171,92 +91,53 @@ class ClassicalArray(ClassicalType):
     def as_symbolic(self, name: str) -> list:
         return [self.element_type.as_symbolic(f"{name}_{i}") for i in range(self.size)]
 
-    @property
-    def default_value(self) -> Any:
-        return super().default_value
-
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "array")
 
 
 class OpaqueHandle(ClassicalType):
-    @property
-    def default_value(self) -> int:
-        return 0
+    pass
 
 
 class VQEResult(OpaqueHandle):
     kind: Literal["vqe_result"]
 
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "vqe_result")
 
 
 class Histogram(OpaqueHandle):
     kind: Literal["histogram"]
 
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "histogram")
 
 
 class Estimation(OpaqueHandle):
     kind: Literal["estimation_result"]
 
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "estimation_result")
 
 
 class IQAERes(OpaqueHandle):
     kind: Literal["iqae_result"]
 
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "iqae_result")
 
 
-class LadderOperator(ClassicalType):
-    kind: Literal["ladder_operator"]
-
-    @property
-    def default_value(self) -> LadderOperatorEnum:
-        return LadderOperatorEnum.PLUS
-
-    @pydantic.root_validator(pre=True)
-    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(values, "kind", "ladder_operator")
-
-    @property
-    def python_type(self) -> type:
-        return int
-
-
-ConcreteClassicalType = Annotated[
-    Union[
-        Integer,
-        Real,
-        Bool,
-        ClassicalList,
-        Pauli,
-        StructMetaType,
-        Struct,
-        ClassicalArray,
-        VQEResult,
-        Histogram,
-        Estimation,
-        LadderOperator,
-        IQAERes,
-    ],
-    Field(discriminator="kind"),
-]
-ClassicalList.update_forward_refs()
-ClassicalArray.update_forward_refs()
-
-
-def as_symbolic(symbols: Dict[str, ClassicalType]) -> Dict[str, RuntimeExpression]:
+def as_symbolic(symbols: dict[str, ClassicalType]) -> dict[str, RuntimeExpression]:
     return {
         param_name: param_type.as_symbolic(param_name)
         for param_name, param_type in symbols.items()

classiq/interface/generator/functions/concrete_types.py

@@ -0,0 +1,55 @@
+from typing import Annotated, Union
+
+from pydantic import Field
+
+from classiq.interface.generator.functions.classical_type import (
+    Bool,
+    ClassicalArray,
+    ClassicalList,
+    Estimation,
+    Histogram,
+    Integer,
+    IQAERes,
+    Real,
+    StructMetaType,
+    VQEResult,
+)
+from classiq.interface.generator.functions.type_name import Enum, TypeName
+from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
+from classiq.interface.model.quantum_type import (
+    QuantumBit,
+    QuantumBitvector,
+    QuantumNumeric,
+    RegisterQuantumType,
+)
+
+ConcreteClassicalType = Annotated[
+    Union[
+        Integer,
+        Real,
+        Bool,
+        ClassicalList,
+        StructMetaType,
+        TypeName,
+        ClassicalArray,
+        VQEResult,
+        Histogram,
+        Estimation,
+        IQAERes,
+    ],
+    Field(discriminator="kind"),
+]
+ClassicalList.model_rebuild()
+ClassicalArray.model_rebuild()
+
+NativePythonClassicalTypes = (int, float, bool, list)
+PythonClassicalPydanticTypes = (Enum,)
+
+ConcreteQuantumType = Annotated[
+    Union[QuantumBit, QuantumBitvector, QuantumNumeric, TypeName],
+    Field(discriminator="kind", default_factory=QuantumBitvector),
+]
+QuantumBitvector.model_rebuild()
+TypeName.model_rebuild()
+QStructDeclaration.model_rebuild()
+RegisterQuantumType.model_rebuild()