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

classiq/interface/executor/aws_execution_cost.py

@@ -1,11 +1,12 @@
+import datetime
 from datetime import date
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 
 import pydantic
-from pydantic import validator
+from pydantic import BaseModel, ConfigDict, Field
+from pydantic_core.core_schema import ValidationInfo
 
 from classiq.interface.enum_utils import StrEnum
-from classiq.interface.exceptions import ClassiqValueError
 
 
 class Granularity(StrEnum):
@@ -19,30 +20,44 @@ class CostScope(StrEnum):
     organization = "organization"
 
 
-class ExecutionCostForTimePeriod(pydantic.BaseModel):
-    start: date = pydantic.Field(
-        description="The beginning of the time period for tasks usage and cost ("
-        "inclusive).",
+class ExecutionCostForTimePeriod(BaseModel):
+    start: date = Field(
+        description="The beginning of the time period for tasks usage and cost (inclusive)."
     )
-    end: date = pydantic.Field(
-        description="The end of the time period for tasks usage and cost (exclusive).",
+    end: date = Field(
+        description="The end of the time period for tasks usage and cost (exclusive)."
     )
-    granularity: Granularity = pydantic.Field(
+    granularity: Granularity = Field(
         description="Either MONTHLY or DAILY, or HOURLY.", default=Granularity.daily
     )
-    cost_scope: CostScope = pydantic.Field(
+    cost_scope: CostScope = Field(
         description="Either user or organization", default=CostScope.user
     )
 
-    class Config:
-        json_encoders = {date: lambda v: v.strftime("%Y-%m-%d")}
-
-    @validator("end")
-    def date_order(cls, v: date, values: Dict[str, Any], **kwargs: Any) -> date:
-        if "start" in values and v <= values["start"]:
-            raise ClassiqValueError('"end" date should be after "start" date')
+    @pydantic.field_validator("start", mode="before")
+    @classmethod
+    def validate_start_date(cls, start_date: Union[datetime.datetime, date]) -> date:
+        if isinstance(start_date, datetime.datetime):
+            return start_date.date()
+        return start_date
+
+    @pydantic.field_validator("end", mode="before")
+    @classmethod
+    def validate_date_and_date_order(
+        cls, v: Union[date, datetime.datetime], info: ValidationInfo
+    ) -> date:
+        if isinstance(v, datetime.datetime):
+            v = v.date()
+        if "start" in info.data and v <= info.data["start"]:
+            raise ValueError('"end" date should be after "start" date')
         return v
 
+    def dict(self, **kwargs: Any) -> Dict[str, Any]:
+        data = super().model_dump(**kwargs)
+        data["start"] = self.start.strftime("%Y-%m-%d")
+        data["end"] = self.end.strftime("%Y-%m-%d")
+        return data
+
 
 """The following models describe the aws response model and based on this schema:
 https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/ce.html#CostExplorer.Client.get_cost_and_usage"""
@@ -65,8 +80,10 @@ class Total(pydantic.BaseModel):
 class ExecutedTaskForPeriodItem(pydantic.BaseModel):
     TimePeriod: TimePeriod
     Total: Total
-    Groups: Optional[List]
-    Estimated: Optional[bool]
+    Groups: Optional[List] = None
+    Estimated: Optional[bool] = None
+
+    model_config = ConfigDict(extra="forbid")
 
 
 class ExecutionCostForTimePeriodResponse(pydantic.BaseModel):

classiq/interface/executor/execution_preferences.py

@@ -59,8 +59,7 @@ class ExecutionPreferences(pydantic.BaseModel):
         title="Transpilation Option",
     )
     job_name: Optional[str] = pydantic.Field(
-        min_length=1,
-        description="The job name",
+        min_length=1, description="The job name", default=None
     )
 
 

classiq/interface/executor/execution_request.py

@@ -57,9 +57,9 @@ class ExecutionJobDetails(VersionedModel):
     status: JobStatus
 
     num_shots: Optional[int]
-    program_id: Optional[str]
+    program_id: Optional[str] = Field(default=None)
 
-    error: Optional[str]
+    error: Optional[str] = Field(default=None)
 
 
 class ExecutionJobsQueryResults(VersionedModel):

classiq/interface/executor/execution_result.py

@@ -1,6 +1,6 @@
 from typing import Any, List, Literal, Union
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
 from typing_extensions import Annotated, TypeAlias
 
 from classiq.interface.enum_utils import StrEnum
@@ -85,7 +85,7 @@ class TaggedIQAEResult(BaseModel):
 class TaggedUnstructured(BaseModel):
     value_type: Literal[SavedResultValueType.Unstructured]
     name: str
-    value: Any
+    value: Any = None
 
 
 SavedResult = Annotated[
@@ -109,3 +109,5 @@ ResultsCollection: TypeAlias = List[SavedResult]
 
 class ExecuteGeneratedCircuitResults(VersionedModel):
     results: ResultsCollection
+
+    model_config = ConfigDict(extra="forbid")

classiq/interface/executor/iqae_result.py

@@ -14,6 +14,6 @@ class IQAEIterationData(BaseModel):
 
 class IQAEResult(VersionedModel, QmodPyObject):
     estimation: float
-    confidence_interval: List[float] = Field(min_items=2, max_items=2)
+    confidence_interval: List[float] = Field(min_length=2, max_length=2)
     iterations_data: List[IQAEIterationData]
     warnings: List[str]

classiq/interface/executor/optimizer_preferences.py

@@ -1,7 +1,8 @@
-from typing import Any, Dict, List, Optional
+from typing import List, 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
@@ -53,11 +54,12 @@ class OptimizerPreferences(BaseModel):
         description="If True, the optimizer will not compute the variance of the ansatz.",
     )
 
-    @pydantic.validator("tolerance", pre=True, always=True)
+    @pydantic.field_validator("tolerance", mode="before")
+    @classmethod
     def check_tolerance(
-        cls, tolerance: Optional[pydantic.PositiveFloat], values: Dict[str, Any]
+        cls, tolerance: Optional[pydantic.PositiveFloat], info: ValidationInfo
     ) -> Optional[pydantic.PositiveFloat]:
-        optimizer_type = values.get("type")
+        optimizer_type = info.data.get("type")
         if tolerance is not None and optimizer_type == OptimizerType.SPSA:
             raise ClassiqValueError("No tolerance param for SPSA optimizer")
 
@@ -66,11 +68,12 @@ class OptimizerPreferences(BaseModel):
 
         return tolerance
 
-    @pydantic.validator("step_size", pre=True, always=True)
+    @pydantic.field_validator("step_size", mode="before")
+    @classmethod
     def check_step_size(
-        cls, step_size: Optional[pydantic.PositiveFloat], values: Dict[str, Any]
+        cls, step_size: Optional[pydantic.PositiveFloat], info: ValidationInfo
     ) -> Optional[pydantic.PositiveFloat]:
-        optimizer_type = values.get("name")
+        optimizer_type = info.data.get("name")
         if step_size is not None and optimizer_type not in (
             OptimizerType.L_BFGS_B,
             OptimizerType.ADAM,
@@ -109,11 +112,12 @@ class CombinatorialOptimizer(OptimizerPreferences):
         description="Whether to check if all the solutions satisfy the constraints",
     )
 
-    @pydantic.validator("alpha_cvar", pre=True, always=True)
+    @pydantic.field_validator("alpha_cvar", mode="before")
+    @classmethod
     def check_alpha_cvar(
-        cls, alpha_cvar: Optional[PydanticAlphaParamCVAR], values: Dict[str, Any]
+        cls, alpha_cvar: Optional[PydanticAlphaParamCVAR], info: ValidationInfo
     ) -> Optional[PydanticAlphaParamCVAR]:
-        cost_type = values.get("cost_type")
+        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.")
 

classiq/interface/executor/quantum_code.py

@@ -4,7 +4,8 @@ from pathlib import Path
 from typing import Any, Dict, Optional, Tuple, Union
 
 import pydantic
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict
+from pydantic_core.core_schema import ValidationInfo
 
 from classiq.interface.backend.ionq.ionq_quantum_program import IonqQuantumCircuit
 from classiq.interface.backend.pydantic_backend import PydanticArgumentNameType
@@ -31,17 +32,18 @@ class QuantumBaseCode(BaseModel):
         ..., description="The textual representation of the program"
     )
 
-    @pydantic.validator("code")
+    @pydantic.field_validator("code")
+    @classmethod
     def load_quantum_program(
-        cls, code: Union[CodeType, IonqQuantumCircuit], values: Dict[str, Any]
+        cls, code: Union[CodeType, IonqQuantumCircuit], values: ValidationInfo
     ) -> CodeType:
-        syntax = values.get("syntax")
+        syntax = values.data.get("syntax")
         if isinstance(code, IonqQuantumCircuit):
             if syntax != QuantumInstructionSet.IONQ:
                 raise ClassiqValueError(
                     f"Invalid code type {type(code)} for syntax: {syntax}"
                 )
-            return code.json()
+            return code.model_dump_json()
 
         return code
 
@@ -56,41 +58,44 @@ class QuantumCode(QuantumBaseCode):
         description="The map of outputs to their qubits in the circuit.",
     )
     registers_initialization: Optional[RegistersInitialization] = pydantic.Field(
-        default_factory=None,
+        default=None,
         description="Initial conditions for the different registers in the circuit.",
     )
     synthesis_execution_data: Optional[ExecutionData] = pydantic.Field(default=None)
     synthesis_execution_arguments: Arguments = pydantic.Field(default_factory=dict)
+    model_config = ConfigDict(validate_assignment=True)
 
-    class Config:
-        validate_assignment = True
-
-    @pydantic.validator("arguments")
+    @pydantic.field_validator("arguments", mode="before")
+    @classmethod
     def validate_arguments(
-        cls, arguments: MultipleArguments, values: Dict[str, Any]
+        cls, arguments: MultipleArguments, info: ValidationInfo
     ) -> MultipleArguments:
-        if arguments and values.get("syntax") not in (
+        if arguments and info.data.get("syntax") not in (
             QuantumInstructionSet.QSHARP,
             QuantumInstructionSet.QASM,
         ):
             raise ClassiqValueError("Only QASM or Q# programs support arguments")
 
-        if values.get("syntax") == QuantumInstructionSet.QSHARP and len(arguments) > 1:
+        if (
+            info.data.get("syntax") == QuantumInstructionSet.QSHARP
+            and len(arguments) > 1
+        ):
             raise ClassiqValueError(
                 f"Q# programs supports only one group of arguments. {len(arguments)} given"
             )
 
         return arguments
 
-    @pydantic.validator("synthesis_execution_data")
+    @pydantic.field_validator("synthesis_execution_data")
+    @classmethod
     def validate_synthesis_execution_data(
         cls,
         synthesis_execution_data: Optional[ExecutionData],
-        values: Dict[str, Any],
+        values: ValidationInfo,
     ) -> Optional[ExecutionData]:
         if (
             synthesis_execution_data is not None
-            and values.get("syntax") is not QuantumInstructionSet.QASM
+            and values.data.get("syntax") is not QuantumInstructionSet.QASM
         ):
             raise ClassiqValueError("Only QASM supports the requested configuration")
 

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
@@ -24,6 +24,7 @@ from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.complex_type import Complex
 from classiq.interface.generator.functions.classical_type import QmodPyObject
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonNegIntTuple
+from classiq.interface.helpers.dotdict import get_recursive_dotdict
 from classiq.interface.helpers.versioned_model import VersionedModel
 
 _ILLEGAL_QUBIT_ERROR_MSG: str = "Illegal qubit index requested"
@@ -37,16 +38,26 @@ 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]]
+
+if TYPE_CHECKING:
+    DotAccessParsedState = Mapping[Name, Any]
+else:
+    DotAccessParsedState = ParsedState
 
 
 class SampledState(BaseModel):
-    state: ParsedState
+    state: DotAccessParsedState
     shots: MeasuredShots
 
     def __repr__(self) -> str:
         return f"{self.state}: {self.shots}"
 
+    @pydantic.field_validator("state", mode="after")
+    @classmethod
+    def _convert_state_to_dotdict(cls, state: ParsedState) -> DotAccessParsedState:
+        return {name: get_recursive_dotdict(value) for name, value in state.items()}
+
 
 ParsedCounts: TypeAlias = List[SampledState]
 
@@ -60,7 +71,7 @@ class SimulatedState(BaseModel):
         return self.state[item]
 
 
-SimulatedState.update_forward_refs(RegisterValue=RegisterValue)
+SimulatedState.model_rebuild()
 ParsedStateVector: TypeAlias = List[SimulatedState]
 
 
@@ -170,7 +181,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 +193,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 +217,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 +311,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