classiq 0.88.0__py3-none-any.whl → 0.90.0__py3-none-any.whl

classiq/evaluators/qmod_node_evaluators/classical_function_evaluation.py

@@ -1,5 +1,5 @@
 import ast
-from typing import Any, Callable, Optional, Union, cast
+from typing import Callable, Union, cast
 
 import sympy
 
@@ -184,37 +184,25 @@ def try_eval_sympy_function(
     if not isinstance(sympy_func, sympy.FunctionClass):
         return False
     _validate_no_kwargs(node)
-    args: Optional[list[Any]] = None
-    sympy_ret_val: Any = None
-    if all(expr_val.has_value(arg) for arg in node.args):
-        args = [expr_val.get_value(arg) for arg in node.args]
-        sympy_ret_val = sympy_func(*args)
-        if not isinstance(sympy_ret_val, sympy.Expr):
-            raise ClassiqInternalExpansionError
     ret_type: QmodType
-    ret_val: Any = None
     if hasattr(sympy_func, "is_Boolean") and sympy_func.is_Boolean:
         ret_type = Bool()
-        if args is not None:
-            ret_val = bool(sympy_ret_val)
     elif (
         hasattr(sympy_func, "is_Integer") and sympy_func.is_Integer
     ) or func_name in INTEGER_FUNCTION_OVERRIDE:
         ret_type = Integer()
-        if args is not None:
-            ret_val = int(sympy_ret_val)
     else:
         ret_type = Real()
-        if sympy_ret_val is not None:
-            if sympy_ret_val.is_imaginary:
-                ret_val = complex(sympy_ret_val)
-            elif sympy_ret_val.is_real:
-                ret_val = float(sympy_ret_val)
-            else:
-                raise ClassiqInternalExpansionError
     expr_val.set_type(node, ret_type)
-    if ret_val is not None:
-        expr_val.set_value(node, ret_val)
+
+    if any(not expr_val.has_value(arg) for arg in node.args):
+        return True
+
+    args = [expr_val.get_value(arg) for arg in node.args]
+    sympy_ret_val = sympy_func(*args)
+    if not isinstance(sympy_ret_val, sympy.Basic):
+        raise ClassiqInternalExpansionError
+    expr_val.set_value(node, sympy_ret_val)
     return True
 
 
@@ -265,14 +253,7 @@ def try_eval_builtin_function(
             sympy_val = sympy.mod_inverse(
                 *[expr_val.get_value(arg) for arg in node.args]
             )
-            ret_val: Any
-            if isinstance(sympy_val, sympy.Expr) and sympy_val.is_imaginary:
-                ret_val = complex(sympy_val)
-            elif args_are_int:
-                ret_val = int(sympy_val)
-            else:
-                ret_val = float(sympy_val)
-            expr_val.set_value(node, ret_val)
+            expr_val.set_value(node, sympy_val)
         return True
 
     if func_name == "sum":
@@ -293,13 +274,7 @@ def try_eval_builtin_function(
         expr_val.set_type(node, Real())
         if args_have_values:
             sympy_val = sympy.sqrt(*[expr_val.get_value(arg) for arg in node.args])
-            if isinstance(sympy_val, sympy.Expr) and sympy_val.is_imaginary:
-                ret_val = complex(sympy_val)
-            elif float(sympy_val) == int(sympy_val):
-                ret_val = int(sympy_val)
-            else:
-                ret_val = float(sympy_val)
-            expr_val.set_value(node, ret_val)
+            expr_val.set_value(node, sympy_val)
         return True
 
     if func_name == "abs":

classiq/evaluators/qmod_node_evaluators/constant_evaluation.py

@@ -16,7 +16,11 @@ from classiq.interface.generator.functions.classical_type import (
 from classiq.interface.generator.functions.type_name import Enum
 
 from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
-from classiq.evaluators.qmod_node_evaluators.utils import SYMPY_SYMBOLS, QmodType
+from classiq.evaluators.qmod_node_evaluators.utils import (
+    SYMPY_SYMBOLS,
+    QmodType,
+    get_sympy_type,
+)
 
 QMOD_LITERALS: dict[str, tuple[ClassicalType, Any]] = {
     "false": (Bool(), False),
@@ -68,22 +72,9 @@ def try_eval_qmod_literal(expr_val: QmodAnnotatedExpression, node: ast.Name) ->
 
 def try_eval_sympy_constant(expr_val: QmodAnnotatedExpression, node: ast.Name) -> bool:
     sympy_val = SYMPY_SYMBOLS.get(node.id)
-    if not isinstance(sympy_val, sympy.Expr) or not sympy_val.is_constant():
+    if not isinstance(sympy_val, sympy.Basic) or len(sympy_val.free_symbols) > 0:
         return False
-    constant_type: QmodType
-    constant_value: Any
-    if sympy_val.is_Integer:
-        constant_type = Integer()
-        constant_value = int(sympy_val)
-    elif sympy_val.is_Boolean:
-        constant_type = Bool()
-        constant_value = bool(sympy_val)
-    elif sympy_val.is_imaginary:
-        constant_type = Real()
-        constant_value = complex(sympy_val)
-    else:
-        constant_type = Real()
-        constant_value = float(sympy_val)
+    constant_type = get_sympy_type(sympy_val)
     expr_val.set_type(node, constant_type)
-    expr_val.set_value(node, constant_value)
+    expr_val.set_value(node, sympy_val)
     return True

classiq/evaluators/qmod_node_evaluators/measurement_evaluation.py

@@ -21,5 +21,5 @@ def eval_measurement(expr_val: QmodAnnotatedExpression, node: ast.Call) -> None:
     if is_classical_type(arg_type):
         raise ClassiqExpansionError("'measure' expects a quantum input")
     if not isinstance(arg_type, QuantumBit):
-        raise ClassiqExpansionError("Currently, 'measure' only supports quantum bits")
+        raise ClassiqExpansionError("'measure' only supports QBits")
     expr_val.set_type(node, Bool())

classiq/evaluators/qmod_node_evaluators/min_max_evaluation.py

@@ -1,5 +1,7 @@
 import ast
 
+import sympy
+
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
@@ -84,7 +86,11 @@ def eval_min_max_op(
 
     if all(expr_val.has_value(arg) for arg in node.args):
         values = [expr_val.get_value(arg) for arg in node.args]
-        if not all(isinstance(value, (int, float)) for value in values):
+        if not all(
+            isinstance(value, (int, float))
+            or (isinstance(value, sympy.Expr) and value.is_real)
+            for value in values
+        ):
             raise ClassiqExpansionError(f"Invalid argument for function {func_name!r}")
 
         if func_name == "min":

classiq/evaluators/qmod_node_evaluators/name_evaluation.py

@@ -22,7 +22,6 @@ from classiq.evaluators.qmod_type_inference.classical_type_inference import (
 
 
 def eval_name(expr_val: QmodAnnotatedExpression, node: ast.Name, value: Any) -> None:
-    # FIXME: Remove sympy compatibility (CLS-3214)
     if isinstance(
         value, (bool, int, float, complex, list, QmodStructInstance, sympy.Basic)
     ):

classiq/evaluators/qmod_node_evaluators/numeric_attrs_utils.py

@@ -1,12 +1,18 @@
 import ast
 from typing import TYPE_CHECKING, Optional
 
+import sympy
+
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.functions.classical_type import Bool
 from classiq.interface.model.quantum_type import QuantumScalar
 
 from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
-from classiq.evaluators.qmod_node_evaluators.utils import QmodType, is_classical_type
+from classiq.evaluators.qmod_node_evaluators.utils import (
+    QmodType,
+    get_sympy_val,
+    is_classical_type,
+)
 from classiq.model_expansions.arithmetic import NumericAttributes
 
 
@@ -46,6 +52,8 @@ def get_classical_value_for_arithmetic(
         return None
 
     value = expr_val.get_value(node)
+    if isinstance(value, sympy.Basic):
+        value = get_sympy_val(value)
     if not isinstance(value, (int, float)):
         if treat_qnum_as_float and isinstance(value, complex):
             return None

classiq/evaluators/qmod_node_evaluators/utils.py

@@ -4,6 +4,7 @@ import sympy
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.functions.classical_type import (
+    Bool,
     ClassicalArray,
     ClassicalTuple,
     ClassicalType,
@@ -100,3 +101,35 @@ def is_classical_integer(qmod_type: QmodType) -> bool:
     return isinstance(qmod_type, Integer) or (
         isinstance(qmod_type, TypeName) and qmod_type.is_enum
     )
+
+
+def get_sympy_val(val: sympy.Basic) -> Union[bool, int, float, complex]:
+    if hasattr(val, "is_Boolean") and val.is_Boolean:
+        return bool(val)
+    if (hasattr(val, "is_integer") and val.is_integer) or (
+        hasattr(val, "is_Integer") and val.is_Integer
+    ):
+        return int(val)
+    if hasattr(val, "is_real") and val.is_real:
+        return float(val)
+    if (hasattr(val, "is_complex") and val.is_complex) or (
+        hasattr(val, "is_imaginary") and val.is_imaginary
+    ):
+        return complex(val)
+    raise ClassiqInternalExpansionError("Unidentified sympy value")
+
+
+def get_sympy_type(val: sympy.Basic) -> ClassicalType:
+    if hasattr(val, "is_Boolean") and val.is_Boolean:
+        return Bool()
+    if (hasattr(val, "is_integer") and val.is_integer) or (
+        hasattr(val, "is_Integer") and val.is_Integer
+    ):
+        return Integer()
+    if (
+        (hasattr(val, "is_real") and val.is_real)
+        or (hasattr(val, "is_complex") and val.is_complex)
+        or (hasattr(val, "is_imaginary") and val.is_imaginary)
+    ):
+        return Real()
+    raise ClassiqInternalExpansionError("Unidentified sympy value")

classiq/evaluators/qmod_type_inference/classical_type_inference.py

@@ -20,6 +20,8 @@ from classiq.interface.generator.functions.type_name import Enum, Struct, TypeNa
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
 from classiq.interface.helpers.backward_compatibility import zip_strict
 
+from classiq.evaluators.qmod_node_evaluators.utils import get_sympy_type
+
 
 def _copy_generative_flag(
     from_type: ClassicalType, to_type: Optional[ClassicalType]
@@ -57,13 +59,8 @@ def infer_classical_type(value: Any) -> ClassicalType:
             )
         )
         return classical_type
-    # FIXME: Remove sympy compatibility (CLS-3214)
-    if (
-        isinstance(value, sympy.Basic)
-        and len(value.free_symbols) == 0
-        and value.is_complex
-    ):
-        return Real()
+    if isinstance(value, sympy.Basic):
+        return get_sympy_type(value)
     raise ClassiqInternalExpansionError
 
 

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.88.0'
+SEMVER_VERSION = '0.90.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/analyzer/analysis_params.py

@@ -1,12 +1,9 @@
 from typing import Annotated, Optional
 
-import numpy
 import pydantic
-from pydantic import ConfigDict, Field, StringConstraints
+from pydantic import Field, StringConstraints
 
 from classiq.interface.backend.quantum_backend_providers import AnalyzerProviderVendor
-from classiq.interface.chemistry.ground_state_problem import MoleculeProblem
-from classiq.interface.executor.optimizer_preferences import OptimizerPreferences
 from classiq.interface.generator.hardware.hardware_data import SynthesisHardwareData
 from classiq.interface.generator.model.preferences.preferences import (
     TranspilationOption,
@@ -80,7 +77,7 @@ class AnalysisHardwareListParams(AnalysisParams, HardwareListParams):
 
 
 class HardwareParams(pydantic.BaseModel):
-    device: PydanticNonEmptyString = pydantic.Field(default=None, description="Devices")
+    device: PydanticNonEmptyString = pydantic.Field(default=None, description="Devices")  # type: ignore[assignment]
     provider: AnalyzerProviderVendor
 
 
@@ -103,24 +100,3 @@ class AnalysisRBParams(pydantic.BaseModel):
     num_clifford: list[
         Annotated[int, Annotated[int, Field(strict=True, gt=0, le=MAX_NUM_CLIFFORD)]]
     ]
-
-
-class ChemistryGenerationParams(pydantic.BaseModel):
-    model_config = ConfigDict(title="Chemistry")
-
-    molecule: MoleculeProblem = pydantic.Field(
-        title="Molecule",
-        default=...,
-        description="The molecule to generate the VQE ansatz for",
-    )
-    optimizer_preferences: OptimizerPreferences = pydantic.Field(
-        default=..., description="Execution options for the classical Optimizer"
-    )
-
-    def initial_point(self) -> Optional[numpy.ndarray]:
-        if self.optimizer_preferences.initial_point is not None:
-            return numpy.ndarray(
-                self.optimizer_preferences.initial_point  # type: ignore[arg-type]
-            )
-        else:
-            return None

classiq/interface/analyzer/result.py

@@ -40,6 +40,10 @@ class QasmCode(pydantic.BaseModel):
     code: str = Field(..., max_length=MAX_FILE_LENGTH)
 
 
+class QmodCode(VersionedModel):
+    code: str = Field(..., max_length=MAX_FILE_LENGTH)
+
+
 class AnalysisStatus(StrEnum):
     NONE = "none"
     SUCCESS = "success"

classiq/interface/backend/backend_preferences.py

@@ -274,7 +274,7 @@ class AzureCredential(BaseSettings):
 
     def __init__(self, **data: Any) -> None:
         initial_data = {
-            field: data[field] for field in data if field in self.model_fields
+            field: data[field] for field in data if field in self.__class__.model_fields
         }
         super().__init__(**data)
         for field, value in initial_data.items():

classiq/interface/chemistry/ground_state_problem.py

@@ -1,4 +1,5 @@
-from typing import Annotated, Literal, Optional, Union, cast
+import warnings
+from typing import Annotated, Any, Literal, Optional, Union, cast
 
 import pydantic
 from pydantic import ConfigDict, Field
@@ -7,7 +8,7 @@ from pydantic_core.core_schema import ValidationInfo
 from classiq.interface.chemistry.fermionic_operator import SummedFermionicOperator
 from classiq.interface.chemistry.molecule import Molecule
 from classiq.interface.enum_utils import StrEnum
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqValueError
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
@@ -52,6 +53,19 @@ class GroundStateProblem(HashablePydanticBaseModel):
     )
     num_qubits: Optional[int] = pydantic.Field(default=None)
 
+    def __init__(self, /, **data: Any) -> None:
+        warnings.warn(
+            (
+                f"The class `{self.__class__.__name__}` is deprecated and will no "
+                "longer be supported starting on 2025-09-18 at the earliest. "
+                "For more information on Classiq's chemistry application, see "
+                "https://docs.classiq.io/latest/explore/applications/chemistry/classiq_chemistry_application/classiq_chemistry_application/."
+            ),
+            category=ClassiqDeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(**data)
+
     @pydantic.field_validator("z2_symmetries")
     @classmethod
     def _validate_z2_symmetries(cls, z2_symmetries: bool, info: ValidationInfo) -> bool:

classiq/interface/executor/optimizer_preferences.py

@@ -1,12 +1,4 @@
-from typing import Optional
-
-import pydantic
-from pydantic import BaseModel
-from pydantic_core.core_schema import ValidationInfo
-
 from classiq.interface.enum_utils import StrEnum
-from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.helpers.custom_pydantic_types import PydanticAlphaParamCVAR
 
 
 class CostType(StrEnum):
@@ -22,107 +14,3 @@ class OptimizerType(StrEnum):
     NELDER_MEAD = "NELDER_MEAD"
     ADAM = "ADAM"
     SLSQP = "SLSQP"
-
-
-class OptimizerPreferences(BaseModel):
-    name: OptimizerType = pydantic.Field(
-        default=OptimizerType.COBYLA, description="Classical optimization algorithm."
-    )
-    num_shots: Optional[pydantic.PositiveInt] = pydantic.Field(
-        default=None,
-        description="Number of repetitions of the quantum ansatz.",
-    )
-    max_iteration: pydantic.PositiveInt = pydantic.Field(
-        default=100, description="Maximal number of optimizer iterations"
-    )
-    tolerance: Optional[pydantic.PositiveFloat] = pydantic.Field(
-        default=None, description="Final accuracy in the optimization"
-    )
-    step_size: Optional[pydantic.PositiveFloat] = pydantic.Field(
-        default=None,
-        description="step size for numerically " "calculating the gradient",
-    )
-    random_seed: Optional[int] = pydantic.Field(
-        default=None,
-        description="The random seed used for the generation",
-    )
-    initial_point: Optional[list[float]] = pydantic.Field(
-        default=None,
-        description="Initial values for the ansatz parameters",
-    )
-    skip_compute_variance: bool = pydantic.Field(
-        default=False,
-        description="If True, the optimizer will not compute the variance of the ansatz.",
-    )
-
-    @pydantic.field_validator("tolerance", mode="before")
-    @classmethod
-    def check_tolerance(
-        cls, tolerance: Optional[pydantic.PositiveFloat], info: ValidationInfo
-    ) -> Optional[pydantic.PositiveFloat]:
-        optimizer_type = info.data.get("type")
-        if tolerance is not None and optimizer_type == OptimizerType.SPSA:
-            raise ClassiqValueError("No tolerance param for SPSA optimizer")
-
-        if tolerance is None and optimizer_type != OptimizerType.SPSA:
-            tolerance = pydantic.PositiveFloat(0.001)
-
-        return tolerance
-
-    @pydantic.field_validator("step_size", mode="before")
-    @classmethod
-    def check_step_size(
-        cls, step_size: Optional[pydantic.PositiveFloat], info: ValidationInfo
-    ) -> Optional[pydantic.PositiveFloat]:
-        optimizer_type = info.data.get("name")
-        if step_size is not None and optimizer_type not in (
-            OptimizerType.L_BFGS_B,
-            OptimizerType.ADAM,
-        ):
-            raise ClassiqValueError(
-                "Use step_size only for L_BFGS_B or ADAM optimizers."
-            )
-
-        if step_size is None and optimizer_type in (
-            OptimizerType.L_BFGS_B,
-            OptimizerType.ADAM,
-        ):
-            step_size = pydantic.PositiveFloat(0.05)
-
-        return step_size
-
-
-class GroundStateOptimizer(OptimizerPreferences):
-    pass
-
-
-class CombinatorialOptimizer(OptimizerPreferences):
-    cost_type: CostType = pydantic.Field(
-        default=CostType.CVAR,
-        description="Summarizing method of the measured bit strings",
-    )
-    alpha_cvar: Optional[PydanticAlphaParamCVAR] = pydantic.Field(
-        default=None, description="Parameter for the CVAR summarizing method"
-    )
-    is_maximization: bool = pydantic.Field(
-        default=False,
-        description="Whether the optimization goal is to maximize",
-    )
-    should_check_valid_solutions: bool = pydantic.Field(
-        default=False,
-        description="Whether to check if all the solutions satisfy the constraints",
-    )
-
-    @pydantic.field_validator("alpha_cvar", mode="before")
-    @classmethod
-    def check_alpha_cvar(
-        cls, alpha_cvar: Optional[PydanticAlphaParamCVAR], info: ValidationInfo
-    ) -> Optional[PydanticAlphaParamCVAR]:
-        cost_type = info.data.get("cost_type")
-        if alpha_cvar is not None and cost_type != CostType.CVAR:
-            raise ClassiqValueError("Use CVAR params only for CostType.CVAR.")
-
-        if alpha_cvar is None and cost_type == CostType.CVAR:
-            alpha_cvar = PydanticAlphaParamCVAR(0.2)
-
-        return alpha_cvar

classiq/interface/generator/application_apis/chemistry_declarations.py

@@ -20,7 +20,9 @@ FOCK_HAMILTONIAN_PROBLEM_PARAM = ClassicalParameterDeclaration(
     name="fock_hamiltonian_problem",
     classical_type=Struct(name="FockHamiltonianProblem"),
 )
-FOCK_HAMILTONIAN_SIZE = "get_field(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'), 'len')"
+FOCK_HAMILTONIAN_SIZE = (
+    "fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0].pauli.len"
+)
 
 
 class ChemistryProblemType(Enum):

classiq/interface/generator/arith/arithmetic_expression_validator.py

@@ -88,13 +88,8 @@ class ExpressionValidator(ast.NodeVisitor):
             ast_expr = ast.parse(adjusted_expression, filename="", mode=self._mode)
         except SyntaxError as e:
             raise ClassiqValueError(f"Failed to parse expression {expression!r}") from e
-        try:
-            self._ast_obj = self.rewrite_ast(ast_expr)
-            self.visit(self._ast_obj)
-        except RecursionError as e:
-            raise ClassiqValueError(
-                f"Failed to parse expression since it is too long: {expression}"
-            ) from e
+        self._ast_obj = self.rewrite_ast(ast_expr)
+        self.visit(self._ast_obj)
 
     @staticmethod
     def _get_adjusted_expression(expression: str) -> str:

classiq/interface/generator/arith/register_user_input.py

@@ -19,7 +19,7 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
     is_signed: bool = pydantic.Field(default=False)
     fraction_places: pydantic.NonNegativeInt = pydantic.Field(default=0)
     bypass_bounds_validation: bool = pydantic.Field(default=False)
-    bounds: PydanticFloatTuple = pydantic.Field(
+    bounds: PydanticFloatTuple = pydantic.Field(  # type: ignore[assignment]
         default=None,
         validate_default=True,
     )

classiq/interface/generator/expressions/evaluated_expression.py

@@ -10,10 +10,11 @@ from classiq.interface.backend.pydantic_backend import EXECUTION_PARAMETER_PATTE
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression_types import (
     ExpressionValue,
-    QmodStructInstance,
     RuntimeConstant,
 )
-from classiq.interface.generator.expressions.handle_identifier import HandleIdentifier
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    QmodStructInstance,
+)
 
 
 @dataclass(frozen=True)
@@ -21,9 +22,6 @@ class EvaluatedExpression:
     value: ExpressionValue
 
     def is_constant(self, constant_type: Optional[type] = None) -> bool:
-        if self.value is None:
-            return False
-
         return isinstance(
             self.value,
             get_args(RuntimeConstant) if constant_type is None else constant_type,
@@ -49,14 +47,6 @@ class EvaluatedExpression:
     def to_list(self) -> list:
         return self.as_constant_type(list)
 
-    def to_handle(self) -> HandleIdentifier:
-        if not isinstance(self.value, HandleIdentifier):
-            raise ClassiqValueError(
-                f"Invalid access to expression {self.value} as HandleIdentifier"
-            )
-
-        return self.value
-
     def to_struct_dict(self) -> Mapping[str, Any]:
         if not isinstance(self.value, QmodStructInstance):
             raise ClassiqValueError(

classiq/interface/generator/expressions/expression_types.py

@@ -1,35 +1,21 @@
-from typing import Union
+from typing import TYPE_CHECKING, Union
 
-from sympy import Basic
-from sympy.logic.boolalg import Boolean
+import sympy
 
-from classiq.interface.generator.expressions.handle_identifier import HandleIdentifier
-from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
-    AnyClassicalValue,
-)
-from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
-    ClassicalProxy,
-)
 from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
-from classiq.interface.generator.expressions.proxies.quantum.qmod_sized_proxy import (
-    QmodSizedProxy,
-)
-from classiq.interface.generator.expressions.type_proxy import TypeProxy
+
+if TYPE_CHECKING:
+    from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 
 RuntimeConstant = Union[
     int,
     float,
     list,
     bool,
+    complex,
     QmodStructInstance,
-    TypeProxy,
-    HandleIdentifier,
-]
-Proxies = Union[
-    QmodSizedProxy,
-    ClassicalProxy,
+    sympy.Basic,
 ]
-RuntimeExpression = Union[AnyClassicalValue, Basic, Boolean]
-ExpressionValue = Union[RuntimeConstant, Proxies, RuntimeExpression]
+ExpressionValue = Union[RuntimeConstant, "QmodAnnotatedExpression"]

classiq/interface/generator/expressions/proxies/classical/classical_proxy.py

@@ -1,5 +1,5 @@
 from collections.abc import Mapping
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
     from classiq.interface.generator.expressions.expression_types import ExpressionValue
@@ -18,7 +18,7 @@ class ClassicalProxy:
         return str(self.handle)
 
     @property
-    def fields(self) -> Mapping[str, "ExpressionValue"]:
+    def fields(self) -> Mapping[str, Union["ExpressionValue", "ClassicalProxy"]]:
         raise NotImplementedError
 
     @property

classiq/interface/generator/expressions/proxies/classical/classical_struct_proxy.py

@@ -8,7 +8,6 @@ from classiq.interface.generator.expressions.proxies.classical.classical_proxy i
 from classiq.interface.model.handle_binding import FieldHandleBinding, HandleBinding
 
 if TYPE_CHECKING:
-    from classiq.interface.generator.expressions.expression_types import ExpressionValue
     from classiq.interface.generator.types.struct_declaration import StructDeclaration
 
 
@@ -22,7 +21,7 @@ class ClassicalStructProxy(NonSymbolicExpr, ClassicalProxy):
         return self._decl
 
     @property
-    def fields(self) -> Mapping[str, "ExpressionValue"]:
+    def fields(self) -> Mapping[str, ClassicalProxy]:
         return {
             field_name: field_type.get_classical_proxy(
                 FieldHandleBinding(base_handle=self.handle, field=field_name)