classiq 0.93.0__py3-none-any.whl → 0.94.0__py3-none-any.whl

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -1,12 +1,7 @@
 SUPPORTED_PYTHON_BUILTIN_FUNCTIONS = {"len", "sum", "print"}
 
 CLASSIQ_BUILTIN_CLASSICAL_FUNCTIONS = {
-    "hypercube_entangler_graph",
-    "grid_entangler_graph",
     "qft_const_adder_phase",
-    "molecule_problem_to_hamiltonian",
-    "fock_hamiltonian_problem_to_hamiltonian",
-    "molecule_ground_state_solution_post_process",
 }
 
 CLASSIQ_EXPR_FUNCTIONS = {

classiq/interface/generator/expressions/evaluated_expression.py

@@ -1,10 +1,9 @@
 import re
 from collections.abc import Mapping
 from dataclasses import dataclass
-from typing import Any, Optional
+from typing import Any, get_args
 
 from sympy import Expr
-from typing_extensions import get_args
 
 from classiq.interface.backend.pydantic_backend import EXECUTION_PARAMETER_PATTERN
 from classiq.interface.exceptions import ClassiqValueError
@@ -21,7 +20,7 @@ from classiq.interface.generator.expressions.proxies.classical.qmod_struct_insta
 class EvaluatedExpression:
     value: ExpressionValue
 
-    def is_constant(self, constant_type: Optional[type] = None) -> bool:
+    def is_constant(self, constant_type: type | None = None) -> bool:
         return isinstance(
             self.value,
             get_args(RuntimeConstant) if constant_type is None else constant_type,

classiq/interface/generator/expressions/expression.py

@@ -1,6 +1,6 @@
 import ast
 from collections.abc import Mapping
-from typing import Any, Optional
+from typing import Any
 
 import pydantic
 from pydantic import ConfigDict, PrivateAttr
@@ -24,7 +24,7 @@ from classiq.interface.generator.function_params import validate_expression_str
 
 class Expression(HashableASTNode):
     expr: str
-    _evaluated_expr: Optional[EvaluatedExpression] = PrivateAttr(default=None)
+    _evaluated_expr: EvaluatedExpression | None = PrivateAttr(default=None)
 
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)

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

@@ -1,9 +1,8 @@
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any, Optional, TypeGuard
 
 import sympy
 from sympy import Integer
-from typing_extensions import TypeGuard
 
 from classiq.interface.exceptions import ClassiqIndexError
 from classiq.interface.generator.expressions.expression import Expression
@@ -24,7 +23,7 @@ if TYPE_CHECKING:
     )
 
 
-def _is_int(val: Any) -> TypeGuard[Union[int, sympy.Basic]]:
+def _is_int(val: Any) -> TypeGuard[int | sympy.Basic]:
     if isinstance(val, sympy.Basic):
         return val.is_Number
     return isinstance(val, int)
@@ -47,7 +46,7 @@ class ClassicalSequenceProxy(NonSymbolicExpr, ClassicalProxy):
         raise NotImplementedError
 
     def __getitem__(
-        self, key: Union[slice, int, Integer, ClassicalProxy]
+        self, key: slice | int | Integer | ClassicalProxy
     ) -> ClassicalProxy:
         return (
             self._get_slice(key) if isinstance(key, slice) else self._get_subscript(key)
@@ -68,9 +67,7 @@ class ClassicalSequenceProxy(NonSymbolicExpr, ClassicalProxy):
     def get_slice_at(self, start: Any, stop: Any) -> ClassicalProxy:
         raise NotImplementedError
 
-    def _get_subscript(
-        self, index_: Union[int, Integer, ClassicalProxy]
-    ) -> ClassicalProxy:
+    def _get_subscript(self, index_: int | Integer | ClassicalProxy) -> ClassicalProxy:
         if _is_int(index_):
             index = int(index_)
             if index < 0:

classiq/interface/generator/function_param_list.py

@@ -7,7 +7,6 @@ from classiq.interface.generator.arith.binary_ops import (
     BitwiseAnd,
     BitwiseOr,
     BitwiseXor,
-    CyclicShift,
     Equal,
     GreaterEqual,
     GreaterThan,
@@ -28,11 +27,6 @@ from classiq.interface.generator.commuting_pauli_exponentiation import (
     CommutingPauliExponentiation,
 )
 from classiq.interface.generator.copy import Copy
-from classiq.interface.generator.entangler_params import (
-    GridEntangler,
-    HypercubeEntangler,
-    TwoDimensionalEntangler,
-)
 from classiq.interface.generator.function_param_library import FunctionParamLibrary
 from classiq.interface.generator.hadamard_transform import HadamardTransform
 from classiq.interface.generator.hamiltonian_evolution.exponentiation import (
@@ -45,13 +39,9 @@ from classiq.interface.generator.hamiltonian_evolution.suzuki_trotter import (
 from classiq.interface.generator.hardware_efficient_ansatz import (
     HardwareEfficientAnsatz,
 )
-from classiq.interface.generator.hartree_fock import HartreeFock
-from classiq.interface.generator.hva import HVA
 from classiq.interface.generator.identity import Identity
-from classiq.interface.generator.linear_pauli_rotations import LinearPauliRotations
 from classiq.interface.generator.mcu import Mcu
 from classiq.interface.generator.mcx import Mcx
-from classiq.interface.generator.qft import QFT
 from classiq.interface.generator.qsvm import QSVMFeatureMap
 from classiq.interface.generator.randomized_benchmarking import RandomizedBenchmarking
 from classiq.interface.generator.reset import Reset
@@ -68,7 +58,6 @@ from classiq.interface.generator.state_preparation import (
     UniformDistributionStatePreparation,
     WStatePreparation,
 )
-from classiq.interface.generator.ucc import UCC
 from classiq.interface.generator.unitary_gate import UnitaryGate
 from classiq.interface.generator.user_defined_function_params import CustomFunction
 
@@ -82,7 +71,6 @@ function_param_library: FunctionParamLibrary = FunctionParamLibrary(
             GHZStatePreparation,
             WStatePreparation,
             ExponentialStatePreparation,
-            QFT,
             BitwiseAnd,
             BitwiseOr,
             BitwiseXor,
@@ -102,21 +90,14 @@ function_param_library: FunctionParamLibrary = FunctionParamLibrary(
             Subtractor,
             RShift,
             LShift,
-            CyclicShift,
             Modulo,
-            TwoDimensionalEntangler,
-            HypercubeEntangler,
-            GridEntangler,
             Mcx,
             Mcu,
             CustomFunction,
             HardwareEfficientAnsatz,
             UnitaryGate,
-            LinearPauliRotations,
             Multiplier,
             Power,
-            HartreeFock,
-            UCC,
             Min,
             Max,
             Exponentiation,
@@ -125,7 +106,6 @@ function_param_library: FunctionParamLibrary = FunctionParamLibrary(
             QDrift,
             Identity,
             RandomizedBenchmarking,
-            HVA,
             UGate,
             AmplitudeLoading,
             QSVMFeatureMap,

classiq/interface/generator/function_params.py

@@ -5,7 +5,6 @@ from collections.abc import Collection, Iterable, Mapping
 from typing import (
     Annotated,
     Any,
-    Optional,
     Union,
     get_args,
 )
@@ -108,7 +107,7 @@ GenerationExpressionSupportedNodeTypes = Union[
 
 
 def validate_expression_str(
-    expr_str: str, supported_functions: Optional[set[str]] = None
+    expr_str: str, supported_functions: set[str] | None = None
 ) -> None:
     # By default, no functions are allowed.
     supported_functions = supported_functions or set()
@@ -219,7 +218,7 @@ class FunctionParams(HashablePydanticBaseModel):
             and (len(output_names - input_names) <= 1)
         )
 
-    def get_power_order(self) -> Optional[int]:
+    def get_power_order(self) -> int | None:
         return None
 
     def _create_ios(self) -> None:
@@ -227,7 +226,7 @@ class FunctionParams(HashablePydanticBaseModel):
 
     @staticmethod
     def _get_size_of_ios(
-        registers: Collection[Optional[RegisterArithmeticInfo]],
+        registers: Collection[RegisterArithmeticInfo | None],
     ) -> int:
         return sum(reg.size if reg is not None else 0 for reg in registers)
 
@@ -265,11 +264,11 @@ class FunctionParams(HashablePydanticBaseModel):
 def parse_function_params(
     *,
     params: Any,
-    discriminator: Optional[Any],
+    discriminator: Any | None,
     param_classes: Collection[type[FunctionParams]],
     no_discriminator_error: Exception,
     bad_function_error: Exception,
-    default_parser_class: Optional[type[FunctionParams]] = None,
+    default_parser_class: type[FunctionParams] | None = None,
 ) -> FunctionParams:  # Any is for use in pydantic validators.
     if not discriminator:
         raise no_discriminator_error

classiq/interface/generator/functions/classical_function_declaration.py

@@ -1,5 +1,5 @@
 from collections.abc import Sequence
-from typing import ClassVar, Optional
+from typing import ClassVar
 
 import pydantic
 
@@ -23,7 +23,7 @@ class ClassicalFunctionDeclaration(FunctionDeclaration):
         default_factory=list,
     )
 
-    return_type: Optional[ConcreteClassicalType] = pydantic.Field(
+    return_type: ConcreteClassicalType | None = pydantic.Field(
         description="The type of the classical value that is returned by the function (for classical functions)",
         default=None,
     )

classiq/interface/generator/functions/classical_type.py

@@ -1,5 +1,5 @@
 from itertools import chain
-from typing import TYPE_CHECKING, Any, Literal, Optional
+from typing import TYPE_CHECKING, Any, Literal
 
 import pydantic
 from pydantic import PrivateAttr
@@ -131,7 +131,7 @@ class StructMetaType(ClassicalType):
 class ClassicalArray(ClassicalType):
     kind: Literal["array"]
     element_type: "ConcreteClassicalType"
-    length: Optional[Expression] = None
+    length: Expression | None = None
 
     @pydantic.model_validator(mode="before")
     @classmethod
@@ -160,7 +160,7 @@ class ClassicalArray(ClassicalType):
         return self.length.to_int_value()
 
     def get_classical_proxy(self, handle: HandleBinding) -> ClassicalProxy:
-        length: Optional[ExpressionValue]
+        length: ExpressionValue | None
         if self.length is None:
             length = None
         elif not self.length.is_evaluated():

classiq/interface/generator/functions/type_modifier.py

@@ -1,5 +1,4 @@
 from classiq.interface.enum_utils import StrEnum
-from classiq.interface.exceptions import ClassiqInternalExpansionError
 
 
 class TypeModifier(StrEnum):
@@ -7,16 +6,3 @@ class TypeModifier(StrEnum):
     Permutable = "permutable"
     Mutable = "mutable"
     Inferred = "inferred"
-
-    @staticmethod
-    def and_(first: "TypeModifier", second: "TypeModifier") -> "TypeModifier":
-        if second is TypeModifier.Inferred:
-            raise ClassiqInternalExpansionError
-        if first is TypeModifier.Mutable or second is TypeModifier.Mutable:
-            return TypeModifier.Mutable
-        elif first is TypeModifier.Permutable or second is TypeModifier.Permutable:
-            return TypeModifier.Permutable
-        else:
-            if first is not TypeModifier.Const and second is not TypeModifier.Const:
-                raise ClassiqInternalExpansionError("Unexpected type modifiers")
-            return TypeModifier.Const

classiq/interface/generator/functions/type_name.py

@@ -35,8 +35,8 @@ if TYPE_CHECKING:
 class TypeName(ClassicalType, QuantumType):
     kind: Literal["struct_instance"]
     name: str = pydantic.Field(description="The type name of the instance")
-    _assigned_fields: Optional[Mapping[str, "ConcreteQuantumType"]] = (
-        pydantic.PrivateAttr(default=None)
+    _assigned_fields: Mapping[str, "ConcreteQuantumType"] | None = pydantic.PrivateAttr(
+        default=None
     )
     _classical_struct_decl: Optional["StructDeclaration"] = pydantic.PrivateAttr(
         default=None

classiq/interface/generator/generated_circuit_data.py

@@ -1,11 +1,10 @@
 import logging
 import re
-from typing import Literal, Optional, Union
+from typing import Literal, Optional, TypeAlias
 from uuid import UUID
 
 import pydantic
 from pydantic import ConfigDict, Field
-from typing_extensions import TypeAlias
 
 from classiq.interface.debug_info.back_ref_util import is_allocate_or_free_by_backref
 from classiq.interface.enum_utils import StrEnum
@@ -87,12 +86,12 @@ class GeneratedFunction(pydantic.BaseModel):
     name: str
     control_states: list[ControlState]
     registers: list[GeneratedRegister] = list()
-    depth: Optional[int] = pydantic.Field(default=None)
-    width: Optional[int] = pydantic.Field(default=None)
+    depth: int | None = pydantic.Field(default=None)
+    width: int | None = pydantic.Field(default=None)
     dangling_inputs: dict[str, GeneratedRegister] = dict()
     dangling_outputs: dict[str, GeneratedRegister] = dict()
 
-    def __getitem__(self, key: Union[int, str]) -> GeneratedRegister:
+    def __getitem__(self, key: int | str) -> GeneratedRegister:
         if isinstance(key, int):
             return self.registers[key]
         if isinstance(key, str):
@@ -101,7 +100,7 @@ class GeneratedFunction(pydantic.BaseModel):
                     return register
         raise KeyError(key)
 
-    def get(self, key: Union[int, str]) -> Optional[GeneratedRegister]:
+    def get(self, key: int | str) -> GeneratedRegister | None:
         try:
             return self.__getitem__(key)
         except KeyError:
@@ -119,7 +118,7 @@ class GeneratedCircuitData(pydantic.BaseModel):
     width: int
     circuit_parameters: list[ParameterName] = pydantic.Field(default_factory=list)
     qubit_mapping: QubitMapping = pydantic.Field(default_factory=QubitMapping)
-    execution_data: Optional[ExecutionData] = pydantic.Field(default=None)
+    execution_data: ExecutionData | None = pydantic.Field(default=None)
 
     @classmethod
     def from_empty_logic_flow(cls) -> "GeneratedCircuitData":
@@ -176,15 +175,15 @@ STATEMENTS_NAME: dict[str, StatementType] = {
 
 
 class FunctionDebugInfoInterface(pydantic.BaseModel):
-    generated_function: Optional[GeneratedFunction] = Field(default=None)
+    generated_function: GeneratedFunction | None = Field(default=None)
     children: list["FunctionDebugInfoInterface"]
     relative_qubits: tuple[int, ...]
-    absolute_qubits: Optional[tuple[int, ...]] = Field(default=None)
-    control_variable: Optional[str] = Field(default=None)
-    is_basis_gate: Optional[bool] = Field(default=None)
+    absolute_qubits: tuple[int, ...] | None = Field(default=None)
+    control_variable: str | None = Field(default=None)
+    is_basis_gate: bool | None = Field(default=None)
     is_inverse: bool = Field(default=False)
     is_unitary: bool = Field(default=True, exclude=True)
-    uuid: Optional[UUID] = Field(default=None, exclude=True)
+    uuid: UUID | None = Field(default=None, exclude=True)
     port_to_passed_variable_map: dict[str, str] = Field(default={})
     back_refs: StatementBlock = Field(default_factory=list)
 
@@ -229,7 +228,7 @@ class FunctionDebugInfoInterface(pydantic.BaseModel):
         return f"{name}{suffix}"
 
     @property
-    def first_back_ref(self) -> Optional[ConcreteQuantumStatement]:
+    def first_back_ref(self) -> ConcreteQuantumStatement | None:
         return self.back_refs[0] if self.back_refs else None
 
     @property

classiq/interface/generator/hamiltonian_evolution/exponentiation.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 import pydantic
 
 from classiq.interface.chemistry import operator
@@ -16,10 +14,10 @@ class ExponentiationOptimization(StrEnum):
 
 
 class ExponentiationConstraints(pydantic.BaseModel):
-    max_depth: Optional[pydantic.PositiveInt] = pydantic.Field(
+    max_depth: pydantic.PositiveInt | None = pydantic.Field(
         default=None, description="Maximum depth of the exponentiation circuit."
     )
-    max_error: Optional[pydantic.PositiveFloat] = pydantic.Field(
+    max_error: pydantic.PositiveFloat | None = pydantic.Field(
         default=None,
         description="Maximum approximation error of the exponentiation circuit.",
     )

classiq/interface/generator/hardware/hardware_data.py

@@ -1,7 +1,7 @@
 import itertools
 from collections import defaultdict
 from collections.abc import MutableSet
-from typing import Any, Optional
+from typing import Any
 
 import pydantic
 from typing_extensions import Self
@@ -50,7 +50,7 @@ class HardwareData(pydantic.BaseModel):
         f"If no connectivity map is given or the connectivity map is symmetric - {sorted(DEFAULT_BASIS_GATES)}. "
         f"If a non-symmetric connectivity map is given - {sorted(DEFAULT_ROUTING_BASIS_GATES)}. ",
     )
-    connectivity_map: Optional[ConnectivityMap] = pydantic.Field(
+    connectivity_map: ConnectivityMap | None = pydantic.Field(
         default=None,
         description="Qubit connectivity map, in the form [ [q0, q1], [q1, q2],...]. "
         "If none given, assume the hardware is fully connected",
@@ -65,8 +65,8 @@ class HardwareData(pydantic.BaseModel):
     @pydantic.field_validator("connectivity_map")
     @classmethod
     def _validate_connectivity_map(
-        cls, connectivity_map: Optional[ConnectivityMap]
-    ) -> Optional[ConnectivityMap]:
+        cls, connectivity_map: ConnectivityMap | None
+    ) -> ConnectivityMap | None:
         if connectivity_map is None:
             return connectivity_map
         if not connectivity_map:
@@ -128,7 +128,7 @@ class CustomHardwareSettings(HardwareData):
 
     """
 
-    _width: Optional[int] = pydantic.PrivateAttr(default=None)
+    _width: int | None = pydantic.PrivateAttr(default=None)
 
     @pydantic.field_validator("basis_gates", mode="after")
     @classmethod
@@ -144,14 +144,14 @@ class CustomHardwareSettings(HardwareData):
 
     def __init__(self, **kwargs: Any) -> None:
         super().__init__(**kwargs)
-        self._width: Optional[int] = (
+        self._width: int | None = (
             len(set(itertools.chain.from_iterable(self.connectivity_map)))
             if self.connectivity_map
             else None
         )
 
     @property
-    def width(self) -> Optional[int]:
+    def width(self) -> int | None:
         return self._width
 
 
@@ -221,4 +221,4 @@ class SynthesisHardwareData(HardwareData):
             Defaults to `None`.
     """
 
-    backend_data: Optional[BackendPreferences] = pydantic.Field(default=None)
+    backend_data: BackendPreferences | None = pydantic.Field(default=None)

classiq/interface/generator/hardware_efficient_ansatz.py

@@ -1,5 +1,5 @@
 import itertools
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING, Union
 
 import pydantic
 from pydantic_core.core_schema import ValidationInfo
@@ -51,11 +51,11 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
         default=1, description="Number of layers in the Ansatz"
     )
 
-    one_qubit_gates: Union[str, list[str]] = pydantic.Field(
+    one_qubit_gates: str | list[str] = pydantic.Field(
         default=["x", "ry"],
         description='List of gates for the one qubit gates layer, e.g. ["x", "ry"]',
     )
-    two_qubit_gates: Union[str, list[str]] = pydantic.Field(
+    two_qubit_gates: str | list[str] = pydantic.Field(
         default=["cx"],
         description='List of gates for the two qubit gates entangling layer, e.g. ["cx", "cry"]',
     )
@@ -67,7 +67,7 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
     @pydantic.field_validator("num_qubits", mode="before")
     @classmethod
     def validate_num_qubits(
-        cls, num_qubits: Optional[pydantic.PositiveInt], info: ValidationInfo
+        cls, num_qubits: pydantic.PositiveInt | None, info: ValidationInfo
     ) -> pydantic.PositiveInt:
         connectivity_map = info.data.get("connectivity_map")
         conn_map_is_not_list = (
@@ -107,8 +107,8 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
     @pydantic.field_validator("one_qubit_gates")
     @classmethod
     def validate_one_qubit_gates(
-        cls, one_qubit_gates: Union[str, list[str]]
-    ) -> Union[str, list[str]]:
+        cls, one_qubit_gates: str | list[str]
+    ) -> str | list[str]:
         one_qubit_gates_list = (
             [one_qubit_gates] if isinstance(one_qubit_gates, str) else one_qubit_gates
         )
@@ -120,8 +120,8 @@ class HardwareEfficientAnsatz(function_params.FunctionParams):
     @pydantic.field_validator("two_qubit_gates")
     @classmethod
     def validate_two_qubit_gates(
-        cls, two_qubit_gates: Union[str, list[str]]
-    ) -> Union[str, list[str]]:
+        cls, two_qubit_gates: str | list[str]
+    ) -> str | list[str]:
         two_qubit_gates_list = (
             [two_qubit_gates] if isinstance(two_qubit_gates, str) else two_qubit_gates
         )

classiq/interface/generator/mcu.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional, cast
+from typing import Any, cast
 
 import pydantic
 
@@ -44,10 +44,10 @@ class Mcu(FunctionParams):
         default=0, description="gam radian angle."
     )
 
-    num_ctrl_qubits: Optional[pydantic.PositiveInt] = pydantic.Field(
+    num_ctrl_qubits: pydantic.PositiveInt | None = pydantic.Field(
         default=None, description="The number of control qubits."
     )
-    ctrl_state: Optional[str] = pydantic.Field(
+    ctrl_state: str | None = pydantic.Field(
         default=None, description="string of the control state"
     )
 

classiq/interface/generator/mcx.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional
+from typing import Any
 
 import pydantic
 from pydantic_core.core_schema import ValidationInfo
@@ -20,7 +20,7 @@ class Mcx(FunctionParams):
     arguments: list[RegisterUserInput] = pydantic.Field(
         default_factory=list, description="registers describing the state (ordered)"
     )
-    num_ctrl_qubits: Optional[pydantic.PositiveInt] = pydantic.Field(
+    num_ctrl_qubits: pydantic.PositiveInt | None = pydantic.Field(
         description="number of control qubits",
         default=None,
     )
@@ -33,7 +33,7 @@ class Mcx(FunctionParams):
     def _validate_argument_names(
         cls, arguments: list[RegisterUserInput]
     ) -> list[RegisterUserInput]:
-        register_name_list: list[Optional[str]] = [arg.name for arg in arguments]
+        register_name_list: list[str | None] = [arg.name for arg in arguments]
         if None in register_name_list:
             raise ClassiqValueError("All registers must be named")
         if len(set(register_name_list)) != len(register_name_list):

classiq/interface/generator/model/constraints.py

@@ -1,11 +1,12 @@
+import warnings
 from collections import defaultdict
-from typing import Optional, Union
+from typing import TypeVar, Union
 
 import pydantic
 from pydantic import BaseModel, ConfigDict
 
 from classiq.interface.enum_utils import StrEnum
-from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqDeprecationWarning, ClassiqValueError
 from classiq.interface.generator.transpiler_basis_gates import TranspilerBasisGates
 
 UNCONSTRAINED = -1
@@ -19,6 +20,8 @@ class OptimizationParameter(StrEnum):
 
 OptimizationParameterType = Union[OptimizationParameter, TranspilerBasisGates]
 
+T = TypeVar("T")
+
 
 def optimization_parameter_type_from_string(param: str) -> OptimizationParameterType:
     for enum_ in (OptimizationParameter, TranspilerBasisGates):
@@ -53,14 +56,18 @@ class Constraints(BaseModel):
 
     model_config = ConfigDict(extra="forbid")
 
-    max_width: Optional[pydantic.PositiveInt] = pydantic.Field(
+    max_width: pydantic.PositiveInt | None = pydantic.Field(
         default=None,
         description="Maximum number of qubits in generated quantum circuit",
     )
-    max_depth: Optional[pydantic.PositiveInt] = None
+    max_depth: pydantic.PositiveInt | None = pydantic.Field(
+        default=None,
+    )
 
     max_gate_count: dict[TranspilerBasisGates, pydantic.NonNegativeInt] = (
-        pydantic.Field(default_factory=lambda: defaultdict(int))
+        pydantic.Field(
+            default_factory=lambda: defaultdict(int),
+        )
     )
 
     optimization_parameter: OptimizationParameterType = pydantic.Field(
@@ -68,3 +75,25 @@ class Constraints(BaseModel):
         description="If set, the synthesis engine optimizes the solution"
         " according to that chosen parameter",
     )
+
+    @pydantic.field_validator("max_depth", mode="before")
+    @classmethod
+    def deprecate_max_depth(cls, value: T) -> T:
+        if value is not None:
+            warnings.warn(
+                "max_depth is deprecated and will no longer be supported starting on 2025-10-27 at the earliest.",
+                ClassiqDeprecationWarning,
+                stacklevel=1,
+            )
+        return value
+
+    @pydantic.field_validator("max_gate_count", mode="before")
+    @classmethod
+    def deprecate_max_gate_count(cls, value: T) -> T:
+        if value:
+            warnings.warn(
+                "max_gate_count is deprecated and will no longer be supported starting on 2025-10-27 at the earliest.",
+                ClassiqDeprecationWarning,
+                stacklevel=1,
+            )
+        return value