classiq 0.51.1__py3-none-any.whl → 0.52.0__py3-none-any.whl

classiq/interface/executor/register_initialization.py

@@ -1,6 +1,7 @@
-from typing import Any, Dict, List
+from typing import List
 
 import pydantic
+from typing_extensions import Self
 
 from classiq.interface.exceptions import ClassiqStateInitializationError
 from classiq.interface.generator.arith import number_utils
@@ -15,19 +16,18 @@ class RegisterInitialization(pydantic.BaseModel):
     qubits: List[int]
     initial_condition: pydantic.NonNegativeInt
 
-    @pydantic.validator("initial_condition", pre=True)
+    @pydantic.field_validator("initial_condition", mode="before")
+    @classmethod
     def _validate_initial_condition(cls, value: int) -> int:
         if not isinstance(value, int) or value < 0:
             raise ClassiqStateInitializationError(_NON_INTEGER_INITIALIZATION_ERROR_MSG)
         return value
 
-    @pydantic.root_validator()
-    def _validate_register_initialization(
-        cls, values: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        qubits: List[int] = values.get("qubits", list())
-        initial_condition: int = values.get("initial_condition", 0)
-        name: str = values.get("name", "")
+    @pydantic.model_validator(mode="after")
+    def _validate_register_initialization(self) -> Self:
+        qubits: List[int] = self.qubits or []
+        initial_condition: int = self.initial_condition or 0
+        name: str = self.name or ""
 
         initial_condition_length = number_utils.size(initial_condition)
         register_length = len(qubits)
@@ -35,4 +35,4 @@ class RegisterInitialization(pydantic.BaseModel):
             raise ClassiqStateInitializationError(
                 f"Register {name} has {register_length} qubits, which is not enough to represent the number {initial_condition}."
             )
-        return values
+        return self

classiq/interface/executor/result.py

@@ -16,7 +16,7 @@ from typing import (
 
 import pydantic
 from pydantic import BaseModel
-from typing_extensions import TypeAlias
+from typing_extensions import Self, TypeAlias
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.quantum_code import OutputQubitsMap, Qubits
@@ -37,7 +37,7 @@ MeasuredShots: TypeAlias = pydantic.NonNegativeInt
 ParsedState: TypeAlias = Mapping[Name, RegisterValue]
 ParsedStates: TypeAlias = Mapping[State, ParsedState]
 Counts: TypeAlias = Dict[State, MeasuredShots]
-StateVector: TypeAlias = Optional[Dict[str, Any]]
+StateVector: TypeAlias = Optional[Dict[str, Complex]]
 
 
 class SampledState(BaseModel):
@@ -60,7 +60,7 @@ class SimulatedState(BaseModel):
         return self.state[item]
 
 
-SimulatedState.update_forward_refs(RegisterValue=RegisterValue)
+SimulatedState.model_rebuild()
 ParsedStateVector: TypeAlias = List[SimulatedState]
 
 
@@ -170,7 +170,7 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         default=None,
         description="The state vector when executed on a simulator, with LSB right qubit order",
     )
-    parsed_state_vector_states: ParsedStates = pydantic.Field(
+    parsed_state_vector_states: Optional[ParsedStates] = pydantic.Field(
         default=None,
         description="A mapping between the raw states of the state vector (bitstrings) to their parsed states (registers' values)",
     )
@@ -182,22 +182,23 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         default=None, description="The total number of shots the circuit was executed"
     )
 
-    @pydantic.validator("counts", pre=True)
+    @pydantic.field_validator("counts", mode="after")
+    @classmethod
     def _clean_spaces_from_counts_keys(cls, v: Counts) -> Counts:
         if not v or " " not in list(v.keys())[0]:
             return v
         return {state.replace(" ", ""): v[state] for state in v}
 
-    @pydantic.validator("num_shots", always=True)
-    def _validate_num_shots(
-        cls, num_shots: Optional[int], values: Dict[str, Any]
-    ) -> Optional[int]:
-        if num_shots is not None:
-            return num_shots
-        counts = values.get("counts")
-        if not counts:
-            return None
-        return sum(shots for _, shots in counts.items())
+    @pydantic.model_validator(mode="after")
+    def _validate_num_shots(self) -> Self:
+        if isinstance(self, ExecutionDetails):
+            if self.num_shots is not None:
+                return self
+            counts = self.counts
+            if not counts:
+                return self
+            self.num_shots = sum(shots for _, shots in counts.items())
+        return self
 
     @property
     def parsed_counts(self) -> ParsedCounts:
@@ -205,6 +206,8 @@ class ExecutionDetails(BaseModel, QmodPyObject):
 
     @property
     def parsed_state_vector(self) -> Optional[ParsedStateVector]:
+        if TYPE_CHECKING:
+            assert self.parsed_state_vector_states is not None
         return prepare_parsed_state_vector(
             self.state_vector, self.parsed_state_vector_states
         )
@@ -297,7 +300,7 @@ class MultipleExecutionDetails(VersionedModel):
         return self.details[index]
 
 
-class EstimationMetadata(BaseModel, extra=pydantic.Extra.allow):
+class EstimationMetadata(BaseModel, extra="allow"):
     shots: Optional[pydantic.NonNegativeInt] = None
     remapped_qubits: bool = False
     input_qubit_map: Optional[List[PydanticNonNegIntTuple]] = None

classiq/interface/executor/vqe_result.py

@@ -19,7 +19,7 @@ class SolverResult(BaseModel):
     energy: float
     # TODO: add time units (like seconds)
     time: Optional[float] = None
-    solution: Optional[Solution]
+    solution: Optional[Solution] = None
 
 
 class SolutionData(BaseModel):

classiq/interface/finance/function_input.py

@@ -1,6 +1,8 @@
 from typing import Any, Dict, Optional, Union
 
 import pydantic
+from pydantic import ConfigDict
+from pydantic_core.core_schema import ValidationInfo
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.enums.finance_functions import (
@@ -20,9 +22,7 @@ class FunctionCondition(pydantic.BaseModel):
         default=False,
         description="When true, function is set when input is larger to threshold and otherwise 0. Default is False.",
     )
-
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 class FinanceFunctionInput(pydantic.BaseModel):
@@ -50,24 +50,33 @@ class FinanceFunctionInput(pydantic.BaseModel):
         description="The required probability on the tail of the distribution (1 - percentile)",
     )
 
-    @pydantic.validator("f", pre=True)
-    def _convert_f_if_str(cls, f: Any) -> "FinanceFunctionType":
-        # Keep this for backwards-compatible string support
-        if f in get_finance_function_dict():
-            return get_finance_function_dict()[f]
-        return f
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _convert_f_if_str(cls, values: Any, info: ValidationInfo) -> Dict[str, Any]:
+        if isinstance(values, dict):
+            f = values.get("f")
+        elif isinstance(values, FinanceFunctionInput):
+            f = values.f
+            values = values.model_dump()
+        else:
+            f = info.data.get("f")
+        if isinstance(f, str) and f in get_finance_function_dict():
+            values["f"] = get_finance_function_dict()[f]
+        return values
 
-    @pydantic.validator("use_chebyshev_polynomial_approximation")
+    @pydantic.field_validator("use_chebyshev_polynomial_approximation", mode="before")
+    @classmethod
     def _validate_polynomial_flag(
-        cls, use_chebyshev_flag: bool, values: Dict[str, Any]
+        cls, use_chebyshev_flag: bool, info: ValidationInfo
     ) -> bool:
-        if use_chebyshev_flag ^ (values.get("polynomial_degree") is None):
+        if use_chebyshev_flag ^ (info.data.get("polynomial_degree") is None):
             return use_chebyshev_flag
         raise ClassiqValueError(
             "Degree must be positive and use_chebyshev_polynomial_approximation set to True"
         )
 
-    @pydantic.validator("f")
+    @pydantic.field_validator("f", mode="before")
+    @classmethod
     def _validate_finance_function(
         cls, f: Union[int, str, "FinanceFunctionType"]
     ) -> FinanceFunctionType:
@@ -77,17 +86,17 @@ class FinanceFunctionInput(pydantic.BaseModel):
             return FinanceFunctionType(f)
         return get_finance_function_dict()[f]
 
-    @pydantic.validator("tail_probability", always=True)
+    @pydantic.field_validator("tail_probability", mode="before")
+    @classmethod
     def _validate_tail_probability_assignment_for_shortfall(
         cls,
         tail_probability: Optional[PydanticNonZeroProbabilityFloat],
-        values: Dict[str, Any],
+        info: ValidationInfo,
     ) -> Optional[PydanticNonZeroProbabilityFloat]:
-        if values.get("f") == FinanceFunctionType.SHORTFALL and not tail_probability:
+        if info.data.get("f") == FinanceFunctionType.SHORTFALL and not tail_probability:
             raise ClassiqValueError(
                 "Tail probability must be set for expected shortfall"
             )
         return tail_probability
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)

classiq/interface/finance/log_normal_model_input.py

@@ -2,6 +2,7 @@ from typing import Literal, Tuple
 
 import numpy as np
 import pydantic
+from pydantic import ConfigDict
 
 from classiq.interface.finance.model_input import FinanceModelInput
 
@@ -36,5 +37,4 @@ class LogNormalModelInput(FinanceModelInput):
     def num_output_qubits(self) -> int:
         return self.num_qubits
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)

classiq/interface/finance/model_input.py

@@ -1,6 +1,8 @@
 import abc
 from typing import Tuple
 
+from pydantic import ConfigDict
+
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
@@ -13,8 +15,7 @@ class FinanceModelInput(HashablePydanticBaseModel):
     def num_output_qubits(self) -> int:
         return 0
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
     @property
     @abc.abstractmethod

classiq/interface/generator/amplitude_loading.py

@@ -1,8 +1,9 @@
 import re
-from typing import Any, Dict, get_args
+from typing import get_args
 
 import pydantic
 import sympy
+from typing_extensions import Self
 
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import ClassiqValueError
@@ -50,7 +51,8 @@ class AmplitudeLoading(FunctionParams):
         description="Implementation options.",
     )
 
-    @pydantic.validator("expression", pre=True)
+    @pydantic.field_validator("expression", mode="before")
+    @classmethod
     def validate_coefficient(cls, expression: str) -> str:
         if isinstance(expression, str):
             # We validate the given value is legal and does not contain code that will be executed in our BE.
@@ -65,9 +67,9 @@ class AmplitudeLoading(FunctionParams):
             return str(expression)
         return expression
 
-    @pydantic.root_validator()
-    def check_all_variable_are_defined(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        expression = values.get("expression", "")
+    @pydantic.model_validator(mode="after")
+    def check_all_variable_are_defined(self) -> Self:
+        expression = self.expression or ""
         literals = set(re.findall(SUPPORTED_VAR_NAMES_REG, expression))
 
         not_allowed = literals.intersection(FORBIDDEN_LITERALS) - BOOLEAN_LITERALS
@@ -79,7 +81,7 @@ class AmplitudeLoading(FunctionParams):
 
         if len(variables) != 1:
             raise ClassiqValueError(f"{variables} must contain exactly single variable")
-        return values
+        return self
 
     def _create_ios(self) -> None:
         self._inputs = {

classiq/interface/generator/arith/argument_utils.py

@@ -1,6 +1,9 @@
 from typing import Tuple, Union
 
 from classiq.interface.generator.arith import number_utils
+from classiq.interface.generator.arith.number_utils import (
+    get_int_representation_and_fraction_places,
+)
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 
 RegisterOrConst = Union[RegisterArithmeticInfo, float]
@@ -73,3 +76,24 @@ def as_arithmetic_info(
         fraction_places=number_utils.fraction_places(arg),
         bounds=(arg, arg) if with_bounds else None,
     )
+
+
+def unsigned_integer_interpretation(
+    value: float, register: RegisterArithmeticInfo
+) -> int:
+    int_val, fraction_digits = get_int_representation_and_fraction_places(value)
+
+    # align fraction digits
+    fraction_digits_diff = register.fraction_places - fraction_digits
+    if fraction_digits_diff < 0:
+        int_val >>= -fraction_digits_diff
+    else:
+        int_val <<= fraction_digits_diff
+
+    # extend sign bit
+    if int(value) < 0:
+        bin_val = number_utils.binary_string(int_val)
+        bin_val += "1" * (register.size - len(bin_val))
+        int_val = number_utils.binary_to_int(bin_val[::-1])
+
+    return int_val

classiq/interface/generator/arith/arithmetic.py

@@ -2,6 +2,7 @@ from typing import Any, Dict, Final, Optional, Set
 
 import networkx as nx
 import pydantic
+from pydantic_core.core_schema import ValidationInfo
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith import arithmetic_expression_parser
@@ -31,11 +32,12 @@ class Arithmetic(ArithmeticExpressionABC):
     target: Optional[RegisterArithmeticInfo] = None
     inputs_to_save: Set[str] = pydantic.Field(default_factory=set)
 
-    @pydantic.validator("inputs_to_save", always=True)
+    @pydantic.field_validator("inputs_to_save")
+    @classmethod
     def _validate_inputs_to_save(
-        cls, inputs_to_save: Set[str], values: Dict[str, Any]
+        cls, inputs_to_save: Set[str], info: ValidationInfo
     ) -> Set[str]:
-        assert all(reg in values.get("definitions", {}) for reg in inputs_to_save)
+        assert all(reg in info.data.get("definitions", {}) for reg in inputs_to_save)
         return inputs_to_save
 
     @staticmethod

classiq/interface/generator/arith/arithmetic_expression_abc.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, Optional, Set, Tuple, Union
 
 import networkx as nx
 import pydantic
+from pydantic import TypeAdapter
 from typing_extensions import TypeAlias
 
 from classiq.interface.exceptions import ClassiqValueError
@@ -46,14 +47,10 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
     def _get_literal_set(self) -> Set[str]:
         return _extract_literals(self.expression)
 
-    @pydantic.validator("definitions")
+    @classmethod
     def _validate_expression_literals_and_definitions(
-        cls, definitions: Dict[str, ValidDefinitions], values: Dict[str, Any]
+        cls, definitions: Dict[str, ValidDefinitions], expression: PydanticExpressionStr
     ) -> Dict[str, ValidDefinitions]:
-        expression = values.get("expression")
-        if expression is None:
-            return definitions
-
         literals = _extract_literals(expression)
 
         forbidden = literals.intersection(FORBIDDEN_LITERALS)
@@ -70,12 +67,33 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
             raise ClassiqValueError(f"The following names are undefined: {undefined}")
         return definitions
 
-    @pydantic.root_validator
-    def _validate_expression(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        expression: Optional[str] = values.get("expression")
-        definitions: Optional[Dict[str, ValidDefinitions]] = values.get("definitions")
-        machine_precision: Optional[int] = values.get("machine_precision")
-        if expression is None or definitions is None or machine_precision is None:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_expression(cls, values: Any) -> Dict[str, Any]:
+        if not isinstance(values, dict):
+            return values
+        expression_adapter: TypeAdapter = TypeAdapter(Optional[PydanticExpressionStr])
+        expression = expression_adapter.validate_python(values.get("expression"))
+        definitions_adapter: TypeAdapter = TypeAdapter(
+            Optional[Dict[str, ValidDefinitions]]
+        )
+        definition_dict = values.get("definitions")
+        if (
+            isinstance(definition_dict, list)
+            and len(definition_dict) > 0
+            and isinstance(definition_dict[0], tuple)
+        ):
+            definition_dict = dict(definition_dict)
+        definitions = definitions_adapter.validate_python(definition_dict)
+        machine_precision: Optional[int] = values.get(
+            "machine_precision", DEFAULT_MACHINE_PRECISION
+        )
+        if (
+            expression is None
+            or expression == ""
+            or definitions is None
+            or machine_precision is None
+        ):
             return values
 
         try:
@@ -108,14 +126,18 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
             graph = parse_expression(expression)
             cls._validate_expression_graph(graph, values)
 
+        validated_defs = cls._validate_expression_literals_and_definitions(
+            definitions, expression
+        )
+
         validate_arithmetic_result_type(
             graph=graph,
-            definitions=definitions,
+            definitions=validated_defs,
             machine_precision=machine_precision,
         )
 
         new_expr, new_defs = cls._replace_const_definitions_in_expression(
-            expression, definitions, machine_precision
+            expression, validated_defs, machine_precision
         )
         values["expression"] = new_expr
         values["definitions"] = new_defs

classiq/interface/generator/arith/arithmetic_operations.py

@@ -16,7 +16,7 @@ MODULO_WITH_FRACTION_PLACES_ERROR_MSG: Final[str] = (
 
 
 class ArithmeticOperationParams(FunctionParams):
-    output_size: Optional[pydantic.PositiveInt]
+    output_size: Optional[pydantic.PositiveInt] = pydantic.Field(default=None)
     machine_precision: pydantic.PositiveInt = DEFAULT_MACHINE_PRECISION
     output_name: ClassVar[str]
     garbage_output_name: ClassVar[str] = DEFAULT_GARBAGE_OUT_NAME
@@ -43,9 +43,12 @@ class ArithmeticOperationParams(FunctionParams):
         return self.output_size is None
 
     def _legal_bounds(
-        self, suggested_bounds: Tuple[float, float]
+        self, suggested_bounds: Tuple[float, float], max_bounds: Tuple[float, float]
     ) -> Optional[Tuple[float, float]]:
-        if self._include_sign or min(suggested_bounds) >= 0:
+        if self.output_size is None or (
+            suggested_bounds[0] >= max_bounds[0]
+            and suggested_bounds[1] <= max_bounds[1]
+        ):
             return suggested_bounds
         return None