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

classiq/interface/generator/arith/binary_ops.py

@@ -1,24 +1,29 @@
 import math
+from collections.abc import Iterable
 from typing import (
     Any,
     ClassVar,
-    Dict,
     Generic,
-    Iterable,
     Literal,
     Optional,
-    Tuple,
-    Type,
     TypeVar,
     Union,
 )
 
 import pydantic
-from pydantic.generics import GenericModel
+from pydantic import BaseModel
+from pydantic_core.core_schema import ValidationInfo
+from typing_extensions import Self
 
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith import argument_utils, number_utils
-from classiq.interface.generator.arith.argument_utils import RegisterOrConst
+from classiq.interface.generator.arith.argument_utils import (
+    RegisterOrConst,
+    as_arithmetic_info,
+)
 from classiq.interface.generator.arith.arithmetic_operations import (
+    MODULO_WITH_FRACTION_PLACES_ERROR_MSG,
     ArithmeticOperationParams,
 )
 from classiq.interface.generator.arith.ast_node_rewrite import (
@@ -28,9 +33,6 @@ from classiq.interface.generator.arith.register_user_input import RegisterArithm
 from classiq.interface.generator.arith.unary_ops import Negation
 from classiq.interface.generator.function_params import get_zero_input_name
 
-from classiq._internals.enum_utils import StrEnum
-from classiq.exceptions import ClassiqValueError
-
 LeftDataT = TypeVar("LeftDataT")
 RightDataT = TypeVar("RightDataT")
 _NumericArgumentInplaceErrorMessage: str = "Cannot inplace the numeric argument {}"
@@ -51,23 +53,24 @@ class ArgToInplace(StrEnum):
 
 
 class BinaryOpParams(
-    ArithmeticOperationParams, GenericModel, Generic[LeftDataT, RightDataT]
+    ArithmeticOperationParams, BaseModel, Generic[LeftDataT, RightDataT]
 ):
     left_arg: LeftDataT
     right_arg: RightDataT
     left_arg_name: ClassVar[str] = DEFAULT_LEFT_ARG_NAME
     right_arg_name: ClassVar[str] = DEFAULT_RIGHT_ARG_NAME
 
-    @pydantic.root_validator(pre=True)
-    def _validate_one_is_register(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        left_arg = values.get("left_arg")
-        right_arg = values.get("right_arg")
-        if isinstance(left_arg, Numeric) and isinstance(right_arg, Numeric):
-            raise ClassiqValueError("One argument must be a register")
-        if left_arg is right_arg and isinstance(left_arg, pydantic.BaseModel):
-            # In case both arguments refer to the same object, copy it.
-            # This prevents changes performed on one argument to affect the other.
-            values["right_arg"] = left_arg.copy(deep=True)
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _clone_repeated_arg(cls, values: Any) -> dict[str, Any]:
+        if isinstance(values, dict):
+            left_arg = values.get("left_arg")
+            right_arg = values.get("right_arg")
+
+            if left_arg is right_arg and isinstance(left_arg, pydantic.BaseModel):
+                # In case both arguments refer to the same object, copy it.
+                # This prevents changes performed on one argument to affect the other.
+                values["right_arg"] = left_arg.model_copy(deep=True)
         return values
 
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
@@ -105,19 +108,21 @@ class InplacableBinaryOpParams(
 ):
     inplace_arg: Optional[ArgToInplace] = None
 
-    @pydantic.root_validator(pre=True)
-    def _validate_inplace_arg(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        left_arg = values.get("left_arg")
-        right_arg = values.get("right_arg")
-        inplace_arg: Optional[ArgToInplace] = values.get("inplace_arg")
-        if inplace_arg == ArgToInplace.RIGHT and isinstance(right_arg, Numeric):
-            raise ClassiqValueError(
-                _NumericArgumentInplaceErrorMessage.format(right_arg)
-            )
-        elif inplace_arg == ArgToInplace.LEFT and isinstance(left_arg, Numeric):
-            raise ClassiqValueError(
-                _NumericArgumentInplaceErrorMessage.format(left_arg)
-            )
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_inplace_arg(cls, values: Any) -> dict[str, Any]:
+        if isinstance(values, dict):
+            left_arg = values.get("left_arg")
+            right_arg = values.get("right_arg")
+            inplace_arg: Optional[ArgToInplace] = values.get("inplace_arg")
+            if inplace_arg == ArgToInplace.RIGHT and isinstance(right_arg, Numeric):
+                raise ClassiqValueError(
+                    _NumericArgumentInplaceErrorMessage.format(right_arg)
+                )
+            elif inplace_arg == ArgToInplace.LEFT and isinstance(left_arg, Numeric):
+                raise ClassiqValueError(
+                    _NumericArgumentInplaceErrorMessage.format(left_arg)
+                )
         return values
 
     def _create_ios(self) -> None:
@@ -154,9 +159,13 @@ class InplacableBinaryOpParams(
         if self.inplace_arg is None:
             return 0
         arg = self.left_arg if self.inplace_arg == ArgToInplace.LEFT else self.right_arg
-        return max(0, arg.integer_part_size - self.result_register.integer_part_size)  # type: ignore[attr-defined]
+        return max(
+            0, arg.integer_part_size - self.result_register.integer_part_size  # type: ignore[attr-defined]
+        ) + max(
+            0, arg.fraction_places - self.result_register.fraction_places  # type: ignore[attr-defined]
+        )
 
-    def _carried_arguments(self) -> Tuple[Optional[LeftDataT], Optional[RightDataT]]:
+    def _carried_arguments(self) -> tuple[Optional[LeftDataT], Optional[RightDataT]]:
         if self.inplace_arg == ArgToInplace.RIGHT and isinstance(
             self.left_arg, RegisterArithmeticInfo
         ):
@@ -187,28 +196,28 @@ class InplacableBinaryOpParams(
             yield ArgToInplace.LEFT
 
     def get_params_inplace_options(self) -> Iterable["InplacableBinaryOpParams"]:
-        params_kwargs = self.copy().__dict__
+        params_kwargs = self.model_copy().__dict__
         for inplace_arg in self._get_binary_op_inplace_options():
             params_kwargs["inplace_arg"] = inplace_arg
             yield self.__class__(**params_kwargs)
 
 
 class BinaryOpWithIntInputs(BinaryOpParams[RegisterOrInt, RegisterOrInt]):
-    @pydantic.root_validator()
-    def validate_int_registers(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        left_arg = values.get("left_arg")
+    @pydantic.model_validator(mode="after")
+    def validate_int_registers(self) -> Self:
+        left_arg = self.left_arg
         is_left_arg_float_register = (
             isinstance(left_arg, RegisterArithmeticInfo)
             and left_arg.fraction_places > 0
         )
-        right_arg = values.get("right_arg")
+        right_arg = self.right_arg
         is_right_arg_float_register = (
             isinstance(right_arg, RegisterArithmeticInfo)
             and right_arg.fraction_places > 0
         )
         if is_left_arg_float_register or is_right_arg_float_register:
             raise ClassiqValueError(BOOLEAN_OP_WITH_FRACTIONS_ERROR)
-        return values
+        return self
 
     @staticmethod
     def _is_signed(arg: Union[int, RegisterArithmeticInfo]) -> bool:
@@ -259,15 +268,21 @@ class Adder(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
     output_name = "sum"
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        lb = argument_utils.lower_bound(self.left_arg) + argument_utils.lower_bound(
-            self.right_arg
+        left_arg = argument_utils.limit_fraction_places(
+            self.left_arg, self.machine_precision
+        )
+        right_arg = argument_utils.limit_fraction_places(
+            self.right_arg, self.machine_precision
+        )
+        lb = argument_utils.lower_bound(left_arg) + argument_utils.lower_bound(
+            right_arg
         )
-        ub = argument_utils.upper_bound(self.left_arg) + argument_utils.upper_bound(
-            self.right_arg
+        ub = argument_utils.upper_bound(left_arg) + argument_utils.upper_bound(
+            right_arg
         )
         fraction_places = max(
-            argument_utils.fraction_places(self.left_arg),
-            argument_utils.fraction_places(self.right_arg),
+            argument_utils.fraction_places(left_arg),
+            argument_utils.fraction_places(right_arg),
         )
         return RegisterArithmeticInfo(
             size=self.output_size or self._get_output_size(ub, lb, fraction_places),
@@ -278,8 +293,9 @@ class Adder(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
 
     def _get_output_size(self, ub: float, lb: float, fraction_places: int) -> int:
         if isinstance(self.left_arg, float) and self.left_arg == 0.0:
-            assert isinstance(self.right_arg, RegisterArithmeticInfo)
-            return self.right_arg.size
+            if isinstance(self.right_arg, RegisterArithmeticInfo):
+                return self.right_arg.size
+            return as_arithmetic_info(self.right_arg).size
         elif isinstance(self.right_arg, float) and self.right_arg == 0.0:
             assert isinstance(self.left_arg, RegisterArithmeticInfo)
             return self.left_arg.size
@@ -291,60 +307,121 @@ class Adder(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
 class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
     output_name = "difference"
 
+    @staticmethod
+    def _get_effective_arg(
+        arg: RegisterOrConst, machine_precision: int
+    ) -> RegisterOrConst:
+        return argument_utils.limit_fraction_places(arg, machine_precision)
+
+    @property
+    def effective_left_arg(self) -> RegisterOrConst:
+        return self._get_effective_arg(self.left_arg, self.machine_precision)
+
+    @property
+    def effective_right_arg(self) -> RegisterOrConst:
+        return self._get_effective_arg(self.right_arg, self.machine_precision)
+
+    @staticmethod
+    def _is_arg_trimmed_register(arg: RegisterOrConst, machine_precision: int) -> bool:
+        return (
+            isinstance(arg, RegisterArithmeticInfo)
+            and arg.fraction_places > machine_precision
+        )
+
+    @property
+    def left_arg_is_trimmed_register(self) -> bool:
+        return self._is_arg_trimmed_register(self.left_arg, self.machine_precision)
+
+    @property
+    def right_arg_is_trimmed_register(self) -> bool:
+        return self._is_arg_trimmed_register(self.right_arg, self.machine_precision)
+
     def _get_result_register(self) -> RegisterArithmeticInfo:
         bounds = (
-            argument_utils.lower_bound(self.left_arg)
-            - argument_utils.upper_bound(self.right_arg),
-            argument_utils.upper_bound(self.left_arg)
-            - argument_utils.lower_bound(self.right_arg),
+            argument_utils.lower_bound(self.effective_left_arg)
+            - argument_utils.upper_bound(self.effective_right_arg),
+            argument_utils.upper_bound(self.effective_left_arg)
+            - argument_utils.lower_bound(self.effective_right_arg),
         )
         fraction_places = max(
-            argument_utils.fraction_places(self.left_arg),
-            argument_utils.fraction_places(self.right_arg),
+            argument_utils.fraction_places(self.effective_left_arg),
+            argument_utils.fraction_places(self.effective_right_arg),
         )
 
+        size = self.output_size or self._get_output_size(bounds, fraction_places)
+        is_signed = self._include_sign and min(bounds) < 0
         return RegisterArithmeticInfo(
-            size=self.output_size or self._get_output_size(bounds, fraction_places),
+            size=size,
             fraction_places=fraction_places,
-            is_signed=self._include_sign and min(bounds) < 0,
-            bounds=self._legal_bounds(bounds),
+            is_signed=is_signed,
+            bounds=self._legal_bounds(
+                bounds,
+                RegisterArithmeticInfo.get_maximal_bounds(
+                    size=size, is_signed=is_signed, fraction_places=fraction_places
+                ),
+            ),
         )
 
     def _get_output_size(
-        self, bounds: Tuple[float, float], fraction_places: int
+        self, bounds: tuple[float, float], fraction_places: int
     ) -> int:
-        if isinstance(self.right_arg, float) and self.right_arg == 0:
-            assert isinstance(self.left_arg, RegisterArithmeticInfo)
-            return self.left_arg.size
+        if isinstance(self.right_arg, float) and self.effective_right_arg == 0:
+            assert isinstance(self.effective_left_arg, RegisterArithmeticInfo)
+            return self.effective_left_arg.size
         integer_part_size = number_utils.bounds_to_integer_part_size(*bounds)
         size_needed = integer_part_size + fraction_places
         return size_needed
 
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
-        if not isinstance(self.right_arg, RegisterArithmeticInfo):
+        if (
+            not self.left_arg_is_trimmed_register
+            and not self.right_arg_is_trimmed_register
+        ):
+            return self._untrimmed_garbage_output_size()
+        if not self.is_inplaced():
+            return 0
+        inplace_arg_name = (
+            self.left_arg_name
+            if self.inplace_arg == ArgToInplace.LEFT
+            else self.right_arg_name
+        )
+        return max(
+            0,
+            self._inputs[inplace_arg_name].fraction_places
+            - self.result_register.fraction_places,
+        )
+
+    def _untrimmed_garbage_output_size(self) -> pydantic.NonNegativeInt:
+        if not isinstance(self.effective_right_arg, RegisterArithmeticInfo):
             adder_params = Adder(
-                left_arg=self.left_arg,
-                right_arg=-self.right_arg,
+                left_arg=self.effective_left_arg,
+                right_arg=-self.effective_right_arg,
                 output_size=self.output_size,
                 inplace_arg=self.inplace_arg,
             )
             return adder_params.garbage_output_size()
 
         negation_params = Negation(
-            arg=self.right_arg,
+            arg=self.effective_right_arg,
             output_size=self.negation_output_size,
             inplace=self.should_inplace_negation,
+            bypass_bounds_validation=True,
         )
         negation_result = negation_params.result_register
-        if self.output_size is None and max(self.right_arg.bounds) > 0:
-            negation_result = negation_result.copy(
-                update=dict(
-                    is_signed=True,
-                    bounds=(-max(self.right_arg.bounds), -min(self.right_arg.bounds)),
-                )
+        if self.output_size is None and max(self.effective_right_arg.bounds) > 0:
+            bounds = (
+                -max(self.effective_right_arg.bounds),
+                -min(self.effective_right_arg.bounds),
+            )
+            negation_result = RegisterArithmeticInfo(
+                size=negation_result.size,
+                fraction_places=negation_result.fraction_places,
+                is_signed=True,
+                bounds=bounds,
+                bypass_bounds_validation=True,
             )
         adder_params = Adder(
-            left_arg=self.left_arg,
+            left_arg=self.effective_left_arg,
             right_arg=negation_result,
             output_size=self.output_size,
             inplace_arg=self.arg_to_inplace_adder,
@@ -359,10 +436,10 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
         return self.inplace_arg == ArgToInplace.LEFT
 
     def _expected_negation_output_size(self) -> int:
-        return argument_utils.fraction_places(self.right_arg) + min(
+        return argument_utils.fraction_places(self.effective_right_arg) + min(
             self.result_register.integer_part_size,
             number_utils.bounds_to_integer_part_size(
-                *(-bound for bound in argument_utils.bounds(self.right_arg))
+                *(-bound for bound in argument_utils.bounds(self.effective_right_arg))
             ),
         )
 
@@ -390,54 +467,61 @@ class Multiplier(BinaryOpWithFloatInputs):
 
     def expected_fraction_places(self) -> int:
         return argument_utils.fraction_places(
-            argument_utils.limit_fraction_places(
-                self.left_arg, machine_precision=self.machine_precision
-            )
+            argument_utils.limit_fraction_places(self.left_arg, self.machine_precision)
         ) + argument_utils.fraction_places(
-            argument_utils.limit_fraction_places(
-                self.right_arg, machine_precision=self.machine_precision
-            )
+            argument_utils.limit_fraction_places(self.right_arg, self.machine_precision)
         )
 
     @staticmethod
     def _get_bounds(
-        args: Tuple[RegisterOrConst, RegisterOrConst], machine_precision: int
-    ) -> Tuple[float, float]:
+        args: tuple[RegisterOrConst, RegisterOrConst], machine_precision: int
+    ) -> tuple[float, float]:
         extremal_values = [
             left * right
             for left in argument_utils.bounds(args[0])
             for right in argument_utils.bounds(args[1])
         ]
         return (
-            number_utils.limit_fraction_places(
-                min(extremal_values), machine_precision=machine_precision
-            ),
-            number_utils.limit_fraction_places(
-                max(extremal_values), machine_precision=machine_precision
-            ),
+            number_utils.limit_fraction_places(min(extremal_values), machine_precision),
+            number_utils.limit_fraction_places(max(extremal_values), machine_precision),
         )
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
         fraction_places = min(self.machine_precision, self.expected_fraction_places())
         left_arg = argument_utils.limit_fraction_places(
-            self.left_arg, machine_precision=self.machine_precision
+            self.left_arg, self.machine_precision
         )
         right_arg = argument_utils.limit_fraction_places(
-            self.right_arg, machine_precision=self.machine_precision
+            self.right_arg, self.machine_precision
         )
         bounds = self._get_bounds((left_arg, right_arg), self.machine_precision)
+        if self.output_size:
+            if fraction_places:
+                raise ValueError(MODULO_WITH_FRACTION_PLACES_ERROR_MSG)
+            max_bounds = RegisterArithmeticInfo.get_maximal_bounds(
+                size=self.output_size, is_signed=False, fraction_places=0
+            )
+            bounds = number_utils.bounds_cut(bounds, max_bounds)
 
+        size = self.output_size or self._get_output_size(
+            bounds, fraction_places, left_arg, right_arg
+        )
+        is_signed = self._include_sign and min(bounds) < 0
         return RegisterArithmeticInfo(
-            size=self.output_size
-            or self._get_output_size(bounds, fraction_places, left_arg, right_arg),
+            size=size,
             fraction_places=fraction_places,
-            is_signed=self._include_sign and min(bounds) < 0,
-            bounds=self._legal_bounds(bounds),
+            is_signed=is_signed,
+            bounds=self._legal_bounds(
+                bounds,
+                RegisterArithmeticInfo.get_maximal_bounds(
+                    size=size, is_signed=is_signed, fraction_places=fraction_places
+                ),
+            ),
         )
 
     @staticmethod
     def _get_output_size(
-        bounds: Tuple[float, float],
+        bounds: tuple[float, float],
         fraction_places: int,
         left_arg: Union[RegisterArithmeticInfo, float],
         right_arg: Union[RegisterArithmeticInfo, float],
@@ -497,7 +581,8 @@ class LessEqual(Comparator):
 class Power(BinaryOpParams[RegisterArithmeticInfo, pydantic.PositiveInt]):
     output_name = "powered"
 
-    @pydantic.validator("right_arg", pre=True)
+    @pydantic.field_validator("right_arg", mode="before")
+    @classmethod
     def _validate_legal_power(cls, right_arg: Any) -> pydantic.PositiveInt:
         if not float(right_arg).is_integer():
             raise ClassiqValueError("Power must be an integer")
@@ -509,13 +594,13 @@ class Power(BinaryOpParams[RegisterArithmeticInfo, pydantic.PositiveInt]):
         return (
             argument_utils.fraction_places(
                 argument_utils.limit_fraction_places(
-                    self.left_arg, machine_precision=self.machine_precision
+                    self.left_arg, self.machine_precision
                 )
             )
             * self.right_arg
         )
 
-    def _get_result_bounds(self) -> Tuple[float, float]:
+    def _get_result_bounds(self) -> tuple[float, float]:
         bounds = [
             number_utils.limit_fraction_places(
                 bound, machine_precision=self.machine_precision
@@ -556,11 +641,11 @@ class Power(BinaryOpParams[RegisterArithmeticInfo, pydantic.PositiveInt]):
 
     def _get_inner_action_garbage_size(
         self,
-        action_type: Union[Type["Power"], Type[Multiplier]],
+        action_type: Union[type["Power"], type[Multiplier]],
         *,
         arg: RegisterArithmeticInfo,
         action_right_arg: RegisterOrConst,
-        compute_power: int
+        compute_power: int,
     ) -> pydantic.NonNegativeInt:
         inner_compute_power_params = Power(
             left_arg=arg,
@@ -609,19 +694,19 @@ class LShift(EffectiveUnaryOpParams[pydantic.NonNegativeInt]):
     output_name = "left_shifted"
     inplace_arg: Optional[ArgToInplace] = ArgToInplace.LEFT
 
-    @pydantic.root_validator()
-    def _validate_legal_modulo(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        output_size = values.get("output_size")
+    @pydantic.model_validator(mode="after")
+    def _validate_legal_modulo(self) -> Self:
+        output_size = self.output_size
         if output_size is None:
-            return values
-        arg = values.get("left_arg")
-        shift = values.get("right_arg")
+            return self
+        arg = self.left_arg
+        shift = self.right_arg
         if not isinstance(arg, RegisterArithmeticInfo):
             raise ClassiqValueError("left arg must be a RegisterArithmeticInfo")
         if not isinstance(shift, int):
             raise ClassiqValueError("Shift must be an integer")
         assert arg.fraction_places - shift <= 0, _FLOATING_POINT_MODULO_ERROR_MESSAGE
-        return values
+        return self
 
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
         if self.inplace_arg is None or self.output_size is None:
@@ -650,21 +735,21 @@ class RShift(EffectiveUnaryOpParams[pydantic.NonNegativeInt]):
     def _shifted_fraction_places(*, arg: RegisterArithmeticInfo, shift: int) -> int:
         return arg.fraction_places * int(arg.is_signed or shift < arg.size)
 
-    @pydantic.root_validator()
-    def _validate_legal_modulo(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        output_size = values.get("output_size")
+    @pydantic.model_validator(mode="after")
+    def _validate_legal_modulo(self) -> Self:
+        output_size = self.output_size
         if output_size is None:
-            return values
-        arg = values.get("left_arg")
-        shift = values.get("right_arg")
+            return self
+        arg = self.left_arg
+        shift = self.right_arg
         if not isinstance(arg, RegisterArithmeticInfo):
             raise ClassiqValueError("left arg must be a RegisterArithmeticInfo")
         if not isinstance(shift, int):
             raise ClassiqValueError("Shift must be an integer")
         assert (
-            cls._shifted_fraction_places(arg=arg, shift=shift) == 0
+            self._shifted_fraction_places(arg=arg, shift=shift) == 0
         ), _FLOATING_POINT_MODULO_ERROR_MESSAGE
-        return values
+        return self
 
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
         if self.inplace_arg is None:
@@ -694,16 +779,16 @@ class CyclicShift(EffectiveUnaryOpParams[int]):
     output_name = "cyclic_shifted"
     inplace_arg: Optional[ArgToInplace] = ArgToInplace.LEFT
 
-    @pydantic.root_validator()
-    def _validate_legal_modulo(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        output_size = values.get("output_size")
+    @pydantic.model_validator(mode="after")
+    def _validate_legal_modulo(self) -> Self:
+        output_size = self.output_size
         if output_size is None:
-            return values
-        arg = values.get("left_arg")
+            return self
+        arg = self.left_arg
         if not isinstance(arg, RegisterArithmeticInfo):
             raise ClassiqValueError("left arg must be a RegisterArithmeticInfo")
         assert arg.fraction_places == 0, _FLOATING_POINT_MODULO_ERROR_MESSAGE
-        return values
+        return self
 
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
         if self.inplace_arg is None:
@@ -722,27 +807,30 @@ class Modulo(EffectiveUnaryOpParams[int]):
     output_name = "modulus"
     inplace_arg: Optional[ArgToInplace] = ArgToInplace.LEFT
 
-    @pydantic.validator("left_arg")
+    @pydantic.field_validator("left_arg", mode="before")
+    @classmethod
     def _validate_left_arg_is_integer(
         cls, left_arg: RegisterArithmeticInfo
     ) -> RegisterArithmeticInfo:
         assert left_arg.fraction_places == 0, _FLOATING_POINT_MODULO_ERROR_MESSAGE
         return left_arg
 
-    @pydantic.validator("right_arg")
+    @pydantic.field_validator("right_arg", mode="before")
+    @classmethod
     def _validate_right_arg_is_a_power_of_two(
-        cls, right_arg: int, values: Dict[str, Any]
+        cls, right_arg: int, info: ValidationInfo
     ) -> int:
         repr_qubits_float = math.log2(right_arg)
         repr_qubits = round(repr_qubits_float)
         assert abs(repr_qubits - repr_qubits_float) < 10**-8, NOT_POWER_OF_TWO_ERROR_MSG
-        output_size = values.get("output_size")
+        output_size = info.data.get("output_size")
         if output_size is not None:
             repr_qubits = min(repr_qubits, output_size)
-        values["output_size"] = None
+        info.data["output_size"] = None
         return 2 ** (repr_qubits)
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        return RegisterArithmeticInfo(
-            size=round(math.log2(self.right_arg)), is_signed=False, fraction_places=0
-        )
+        size = round(math.log2(self.right_arg))
+        if size <= 0:
+            raise ClassiqValueError("Cannot use a quantum expression with zero size")
+        return RegisterArithmeticInfo(size=size, is_signed=False, fraction_places=0)

classiq/interface/generator/arith/endianness.py

@@ -1,4 +1,4 @@
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
 
 
 class Endianness(StrEnum):