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

classiq/interface/applications/qsvm.py

@@ -1,20 +1,18 @@
 from collections.abc import Sequence
 from typing import (
-    TYPE_CHECKING,
     Any,
     Iterable as IterableType,
     List,
     Optional,
     Tuple,
+    Type,
     Union,
 )
 
 import numpy as np
 import pydantic
 from numpy.typing import ArrayLike
-
-if TYPE_CHECKING:
-    from pydantic.typing import AnyClassMethod
+from pydantic import ConfigDict, field_validator
 
 from classiq.interface.helpers.versioned_model import VersionedModel
 
@@ -33,8 +31,12 @@ def listify(obj: Union[IterableType, ArrayLike]) -> list:
         return list(obj)  # type: ignore[arg-type]
 
 
-def validate_array_to_list(name: str) -> "AnyClassMethod":
-    return pydantic.validator(name, pre=True, allow_reuse=True)(listify)
+def validate_array_to_list(name: str) -> Any:
+    @field_validator(name, mode="before")
+    def _listify(cls: Type[pydantic.BaseModel], value: Any) -> Any:
+        return listify(value)
+
+    return _listify
 
 
 Shape = Tuple[int, ...]
@@ -89,16 +91,15 @@ class QSVMData(VersionedModel):
     data: DataList
     labels: Optional[LabelsInt] = None
     internal_state: Optional[QSVMInternalState] = None
+    model_config = ConfigDict(extra="forbid")
 
-    class Config:
-        smart_union = True
-        extra = "forbid"
-
-    @pydantic.validator("data", pre=True)
+    @pydantic.field_validator("data", mode="before")
+    @classmethod
     def set_data(cls, data: Union[IterableType, ArrayLike]) -> list:
         return listify(data)
 
-    @pydantic.validator("labels", pre=True)
+    @pydantic.field_validator("labels", mode="before")
+    @classmethod
     def set_labels(
         cls, labels: Optional[Union[IterableType, ArrayLike]]
     ) -> Optional[list]:

classiq/interface/backend/backend_preferences.py

@@ -3,7 +3,8 @@ from __future__ import annotations
 from typing import Any, Dict, Iterable, List, Optional, Union
 
 import pydantic
-from pydantic import BaseModel, validator
+from pydantic import BaseModel
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 from classiq.interface.backend import pydantic_backend
 from classiq.interface.backend.quantum_backend_providers import (
@@ -21,7 +22,6 @@ from classiq.interface.backend.quantum_backend_providers import (
 )
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.hardware import Provider
-from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 
 
 class BackendPreferences(BaseModel):
@@ -36,10 +36,7 @@ class BackendPreferences(BaseModel):
         backend_name (str): Name of the requested backend or target.
     """
 
-    # Due to the way the field is currently implemented, i.e. it redefined with different types
-    # in the subclass, it shouldn't be dumped with exclude_unset. This causes this field not to appear.
-    # For example: don't use obj.dict(exclude_unset=True).
-    backend_service_provider: str = pydantic.Field(
+    backend_service_provider: ProviderVendor = pydantic.Field(
         ..., description="Provider company or cloud for the requested backend."
     )
     backend_name: str = pydantic.Field(
@@ -50,12 +47,6 @@ class BackendPreferences(BaseModel):
     def hw_provider(self) -> Provider:
         return Provider(self.backend_service_provider)
 
-    @pydantic.validator("backend_service_provider", pre=True)
-    def validate_backend_service_provider(
-        cls, backend_service_provider: Any
-    ) -> Provider:
-        return validate_backend_service_provider(backend_service_provider)
-
     @classmethod
     def batch_preferences(
         cls, *, backend_names: Iterable[str], **kwargs: Any
@@ -110,7 +101,9 @@ class AliceBobBackendPreferences(BackendPreferences):
     For more details, refer to the [Alice&Bob Backend Documentation](https://docs.classiq.io/latest/reference-manual/executor/cloud-providers/alice-and-bob-backends/).
     """
 
-    backend_service_provider: ProviderTypeVendor.ALICE_BOB
+    backend_service_provider: ProviderTypeVendor.ALICE_BOB = pydantic.Field(
+        default=ProviderVendor.ALICE_AND_BOB
+    )
     distance: Optional[int] = pydantic.Field(
         default=None, description="Repetition code distance"
     )
@@ -127,12 +120,6 @@ class AliceBobBackendPreferences(BackendPreferences):
         ..., description="AliceBob API key"
     )
 
-    @pydantic.root_validator(pre=True)
-    def _set_backend_service_provider(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(
-            values, "backend_service_provider", ProviderVendor.ALICE_AND_BOB
-        )
-
     @property
     def parameters(self) -> Dict[str, Any]:
         parameters = {
@@ -154,13 +141,9 @@ class ClassiqBackendPreferences(BackendPreferences):
     For more details, refer to the [Classiq Backend Documentation](https://docs.classiq.io/latest/reference-manual/executor/cloud-providers/classiq-backends/).
     """
 
-    backend_service_provider: ProviderTypeVendor.CLASSIQ
-
-    @pydantic.root_validator(pre=True)
-    def _set_backend_service_provider(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(
-            values, "backend_service_provider", ProviderVendor.CLASSIQ
-        )
+    backend_service_provider: ProviderTypeVendor.CLASSIQ = pydantic.Field(
+        default=ProviderVendor.CLASSIQ
+    )
 
     def is_nvidia_backend(self) -> bool:
         return self.backend_name in list(ClassiqNvidiaBackendNames)
@@ -197,7 +180,9 @@ class AwsBackendPreferences(BackendPreferences):
     [AwsBackendPreferences examples](https://docs.classiq.io/latest/reference-manual/executor/cloud-providers/amazon-backends/?h=awsbackend#usage)
     """
 
-    backend_service_provider: ProviderTypeVendor.AMAZON_BRAKET
+    backend_service_provider: ProviderTypeVendor.AMAZON_BRAKET = pydantic.Field(
+        default=ProviderVendor.AMAZON_BRAKET
+    )
     aws_role_arn: pydantic_backend.PydanticAwsRoleArn = pydantic.Field(
         description="ARN of the role to be assumed for execution on your Braket account."
     )
@@ -206,21 +191,14 @@ class AwsBackendPreferences(BackendPreferences):
         description="S3 Folder Path Within The S3 Bucket"
     )
 
-    @validator("s3_bucket_name")
-    def _validate_s3_bucket_name(
-        cls, s3_bucket_name: str, values: Dict[str, Any]
-    ) -> str:
+    @pydantic.field_validator("s3_bucket_name", mode="before")
+    @classmethod
+    def _validate_s3_bucket_name(cls, s3_bucket_name: str) -> str:
         s3_bucket_name = s3_bucket_name.strip()
         if not s3_bucket_name.startswith("amazon-braket-"):
             raise ClassiqValueError('S3 bucket name should start with "amazon-braket-"')
         return s3_bucket_name
 
-    @pydantic.root_validator(pre=True)
-    def _set_backend_service_provider(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(
-            values, "backend_service_provider", ProviderVendor.AMAZON_BRAKET
-        )
-
 
 class IBMBackendProvider(BaseModel):
     """
@@ -255,7 +233,9 @@ class IBMBackendPreferences(BackendPreferences):
     See examples in the [IBM Quantum Backend Documentation](https://docs.classiq.io/latest/reference-manual/executor/cloud-providers/ibm-backends/?h=).
     """
 
-    backend_service_provider: ProviderTypeVendor.IBM_QUANTUM
+    backend_service_provider: ProviderTypeVendor.IBM_QUANTUM = pydantic.Field(
+        default=ProviderVendor.IBM_QUANTUM
+    )
     access_token: Optional[str] = pydantic.Field(
         default=None,
         description="IBM Quantum access token to be used"
@@ -270,14 +250,8 @@ class IBMBackendPreferences(BackendPreferences):
         description="QCTRL API key to access QCTRL optimization abilities",
     )
 
-    @pydantic.root_validator(pre=True)
-    def _set_backend_service_provider(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(
-            values, "backend_service_provider", ProviderVendor.IBM_QUANTUM
-        )
 
-
-class AzureCredential(pydantic.BaseSettings):
+class AzureCredential(BaseSettings):
     """
     Represents the credentials and configuration required to authenticate with Azure services.
 
@@ -296,11 +270,20 @@ class AzureCredential(pydantic.BaseSettings):
         description="Azure Resource ID (including Azure subscription ID, resource "
         "group and workspace), for personal resource",
     )
+    model_config = SettingsConfigDict(
+        title="Azure Service Principal Credential",
+        env_prefix="AZURE_",
+        case_sensitive=False,
+        extra="allow",
+    )
 
-    class Config:
-        title = "Azure Service Principal Credential"
-        env_prefix = "AZURE_"
-        case_sensitive = False
+    def __init__(self, **data: Any) -> None:
+        initial_data = {
+            field: data[field] for field in data if field in self.model_fields
+        }
+        super().__init__(**data)
+        for field, value in initial_data.items():
+            setattr(self, field, value)
 
 
 class AzureBackendPreferences(BackendPreferences):
@@ -317,7 +300,9 @@ class AzureBackendPreferences(BackendPreferences):
 
     """
 
-    backend_service_provider: ProviderTypeVendor.AZURE_QUANTUM
+    backend_service_provider: ProviderTypeVendor.AZURE_QUANTUM = pydantic.Field(
+        default=ProviderVendor.AZURE_QUANTUM
+    )
 
     location: str = pydantic.Field(
         default="East US", description="Azure personal resource region"
@@ -343,12 +328,6 @@ class AzureBackendPreferences(BackendPreferences):
         """
         return self.credentials is None
 
-    @pydantic.root_validator(pre=True)
-    def _set_backend_service_provider(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(
-            values, "backend_service_provider", ProviderVendor.AZURE_QUANTUM
-        )
-
 
 class IonqBackendPreferences(BackendPreferences):
     """
@@ -365,7 +344,9 @@ class IonqBackendPreferences(BackendPreferences):
     See examples in the [IonQ Backend Documentation](https://docs.classiq.io/latest/reference-manual/executor/cloud-providers/ionq-backends/?h=).
     """
 
-    backend_service_provider: ProviderTypeVendor.IONQ
+    backend_service_provider: ProviderTypeVendor.IONQ = pydantic.Field(
+        default=ProviderVendor.IONQ
+    )
     api_key: pydantic_backend.PydanticIonQApiKeyType = pydantic.Field(
         ..., description="IonQ API key"
     )
@@ -374,12 +355,6 @@ class IonqBackendPreferences(BackendPreferences):
         description="Error mitigation configuration.",
     )
 
-    @pydantic.root_validator(pre=True)
-    def _set_backend_service_provider(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(
-            values, "backend_service_provider", ProviderVendor.IONQ
-        )
-
 
 class GCPBackendPreferences(BackendPreferences):
     """
@@ -394,13 +369,9 @@ class GCPBackendPreferences(BackendPreferences):
     See examples in the [Google Cloud Backend Documentation](https://docs.classiq.io/latest/reference-manual/executor/cloud-providers/google-backends/?h=).
     """
 
-    backend_service_provider: ProviderTypeVendor.GOOGLE
-
-    @pydantic.root_validator(pre=True)
-    def _set_backend_service_provider(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(
-            values, "backend_service_provider", ProviderVendor.GOOGLE
-        )
+    backend_service_provider: ProviderTypeVendor.GOOGLE = pydantic.Field(
+        default=ProviderVendor.GOOGLE
+    )
 
     def is_nvidia_backend(self) -> bool:
         return True
@@ -417,16 +388,12 @@ class OQCBackendPreferences(BackendPreferences):
         password (str): OQC password
     """
 
-    backend_service_provider: ProviderTypeVendor.OQC
+    backend_service_provider: ProviderTypeVendor.OQC = pydantic.Field(
+        default=ProviderVendor.OQC
+    )
     username: str = pydantic.Field(description="OQC username")
     password: str = pydantic.Field(description="OQC password")
 
-    @pydantic.root_validator(pre=True)
-    def _set_backend_service_provider(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(
-            values, "backend_service_provider", ProviderVendor.OQC
-        )
-
 
 class IntelBackendPreferences(BackendPreferences):
     """
@@ -438,13 +405,9 @@ class IntelBackendPreferences(BackendPreferences):
     For more details, refer to the [Classiq Backend Documentation](https://docs.classiq.io/latest/reference-manual/executor/cloud-providers/classiq-backends/).
     """
 
-    backend_service_provider: ProviderTypeVendor.INTEL
-
-    @pydantic.root_validator(pre=True)
-    def _set_backend_service_provider(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(
-            values, "backend_service_provider", ProviderVendor.INTEL
-        )
+    backend_service_provider: ProviderTypeVendor.INTEL = pydantic.Field(
+        default=ProviderVendor.INTEL
+    )
 
 
 class AQTBackendPreferences(BackendPreferences):
@@ -458,17 +421,38 @@ class AQTBackendPreferences(BackendPreferences):
         workspace: The AQT workspace where the simulator/hardware is located.
     """
 
-    # TODO[pydantic]: Add a default value
-    backend_service_provider: ProviderTypeVendor.AQT
+    backend_service_provider: ProviderTypeVendor.AQT = pydantic.Field(
+        default=ProviderVendor.AQT
+    )
     api_key: str = pydantic.Field(description="AQT API key")
     workspace: str = pydantic.Field(description="AQT workspace")
 
-    # TODO[pydantic]: Remove this validator
-    @pydantic.root_validator(pre=True)
-    def _set_backend_service_provider(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        return values_with_discriminator(
-            values, "backend_service_provider", ProviderVendor.AQT
-        )
+
+class IQCCBackendPreferences(BackendPreferences):
+    """
+    NOTE: This is a work in progress and is subject to change.
+
+    Represents the backend preferences specific to IQCC (Israeli Quantum Computing
+    Center).
+
+    Attributes:
+        auth_token: The authorization token generated by calling `generate_iqcc_token`.
+        target_id: The target ID of the login node.
+        target_scope_id: The scope ID of the specified target.
+        ssh_user_name: The user name to use when connecting to the SSH server on the login node.
+        ssh_key: The private key to use when connecting to the SSH server on the login node.
+        slurm_account: The account to use when initiating SLURM jobs.
+    """
+
+    backend_service_provider: ProviderTypeVendor.IQCC = pydantic.Field(
+        default=ProviderVendor.IQCC
+    )
+    auth_token: str
+    target_id: str
+    target_scope_id: str
+    ssh_user_name: str
+    ssh_key: str
+    slurm_account: str
 
 
 def is_exact_simulator(backend_preferences: BackendPreferences) -> bool:
@@ -502,6 +486,7 @@ BackendPreferencesTypes = Union[
     OQCBackendPreferences,
     IntelBackendPreferences,
     AQTBackendPreferences,
+    IQCCBackendPreferences,
 ]
 
 __all__ = [
@@ -525,17 +510,5 @@ __all__ = [
     "OQCBackendNames",
     "IntelBackendPreferences",
     "AQTBackendPreferences",
+    "IQCCBackendPreferences",
 ]
-
-
-def validate_backend_service_provider(backend_service_provider: Any) -> Provider:
-    if isinstance(backend_service_provider, Provider):
-        return backend_service_provider
-    if isinstance(backend_service_provider, str):
-        for member in Provider:
-            if member.lower() == backend_service_provider.lower():
-                return Provider(member)
-    raise ClassiqValueError(
-        f"""Vendor {backend_service_provider} is not supported.
-    The supported providers are {', '.join(Provider)}."""
-    )

classiq/interface/backend/ionq/ionq_quantum_program.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, List, Optional
 
-import pydantic
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict, Field
+from typing_extensions import Annotated
 
 # This file is based on autogenerated code from: https://static.ionq.co/schemas/circuit-v0.json using
 # https://pydantic-docs.helpmanual.io/datamodel_code_generator/
@@ -12,10 +12,13 @@ from pydantic import BaseModel
 if TYPE_CHECKING:
     PydanticGateName = str
 else:
-    PydanticGateName = pydantic.constr(
-        regex=r"^\w+$",
-        min_length=1,
-    )
+    PydanticGateName = Annotated[
+        str,
+        Field(
+            pattern=r"^\w+$",
+            min_length=1,
+        ),
+    ]
 
 
 class Gate(BaseModel):
@@ -24,23 +27,13 @@ class Gate(BaseModel):
     control: Optional[int] = None
     targets: Optional[List[int]] = None
     controls: Optional[List[int]] = None
-
-    # Ionq changes format sometimes.
-    #   One example is that `IonqQauntumCircuit` got a field name "gateset" with the value "qis"
-    #   Another is that `Gate` got a field named "rotation"
-    class Config:
-        extra = pydantic.Extra.allow
+    model_config = ConfigDict(extra="allow")
 
 
 class IonqQuantumCircuit(BaseModel):
     qubits: int
     circuit: List[Gate]
-
-    # Ionq changes format sometimes.
-    #   One example is that `IonqQuantumCircuit` got a field name "gateset" with the value "qis"
-    #   Another is that `Gate` got a field named "rotation"
-    class Config:
-        extra = pydantic.Extra.allow
+    model_config = ConfigDict(extra="allow")
 
     @classmethod
     def from_string(cls, code: str) -> IonqQuantumCircuit:
@@ -48,4 +41,4 @@ class IonqQuantumCircuit(BaseModel):
         commentless_code = "\n".join(
             line for line in code_lines if not line.startswith("//")
         )
-        return cls.parse_raw(commentless_code)
+        return cls.model_validate_json(commentless_code)

classiq/interface/backend/pydantic_backend.py

@@ -1,6 +1,7 @@
 from typing import TYPE_CHECKING
 
-import pydantic
+from pydantic import Field, StrictStr, constr
+from typing_extensions import Annotated
 
 AZURE_QUANTUM_RESOURCE_ID_REGEX = r"^/subscriptions/([a-fA-F0-9-]*)/resourceGroups/([^\s/]*)/providers/Microsoft\.Quantum/Workspaces/([^\s/]*)$"
 
@@ -25,20 +26,31 @@ if TYPE_CHECKING:
 else:
     # TODO Simplify regular expressions in this file
 
-    PydanticAwsRoleArn = pydantic.constr(
-        strip_whitespace=True,
-    )
+    PydanticAwsRoleArn = Annotated[
+        StrictStr,
+        constr(
+            strip_whitespace=True,
+        ),
+    ]
 
-    PydanticS3BucketKey = pydantic.constr(strip_whitespace=True, min_length=1)
+    PydanticS3BucketKey = Annotated[
+        StrictStr, constr(strip_whitespace=True, min_length=1)
+    ]
 
-    PydanticAzureResourceIDType = pydantic.constr(regex=AZURE_QUANTUM_RESOURCE_ID_REGEX)
+    PydanticAzureResourceIDType = Annotated[
+        str, Field(pattern=AZURE_QUANTUM_RESOURCE_ID_REGEX)
+    ]
 
-    PydanticIonQApiKeyType = pydantic.constr(
-        regex=f"[A-Za-z0-9]{{{_IONQ_API_KEY_LENGTH}}}"
-    )
+    PydanticIonQApiKeyType = Annotated[
+        str, Field(pattern=f"[A-Za-z0-9]{{{_IONQ_API_KEY_LENGTH}}}")
+    ]
 
-    PydanticAliceBobApiKeyType = pydantic.constr(min_length=1, strip_whitespace=True)
+    PydanticAliceBobApiKeyType = Annotated[
+        StrictStr, constr(min_length=1, strip_whitespace=True)
+    ]
 
-    PydanticArgumentNameType = pydantic.constr(regex="[_a-zA-Z][_a-zA-Z0-9]*")
+    PydanticArgumentNameType = Annotated[str, Field(pattern="[_a-zA-Z][_a-zA-Z0-9]*")]
 
-    PydanticExecutionParameter = pydantic.constr(regex=EXECUTION_PARAMETER_PATTERN)
+    PydanticExecutionParameter = Annotated[
+        str, Field(pattern=EXECUTION_PARAMETER_PATTERN)
+    ]

classiq/interface/backend/quantum_backend_providers.py

@@ -20,6 +20,7 @@ class ProviderVendor(StrEnum):
     OQC = "OQC"
     INTEL = "Intel"
     AQT = "AQT"
+    IQCC = "IQCC"
 
 
 class ProviderTypeVendor:
@@ -33,6 +34,7 @@ class ProviderTypeVendor:
     OQC = Literal[ProviderVendor.OQC]
     INTEL = Literal[ProviderVendor.INTEL]
     AQT = Literal[ProviderVendor.AQT]
+    IQCC = Literal[ProviderVendor.IQCC]
 
 
 class ClassiqSimulatorBackendNames(StrEnum):

classiq/interface/chemistry/fermionic_operator.py

@@ -5,6 +5,7 @@ from typing import Set, Tuple, Union
 
 import numpy as np
 import pydantic
+from pydantic import ConfigDict
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.helpers.hashable_pydantic_base_model import (
@@ -75,7 +76,8 @@ class FermionicOperator(HashablePydanticBaseModel):
 
         return (op_symbol, op_index)
 
-    @pydantic.validator("op_list")
+    @pydantic.field_validator("op_list")
+    @classmethod
     def _validate_op_list(cls, op_list: list) -> list:
         return list(map(cls._validate_single_op, op_list))
 
@@ -99,8 +101,7 @@ class FermionicOperator(HashablePydanticBaseModel):
             "FermionicOperator can be summed together only with type FermionicOperator or SummedFermionicOperator"
         )
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
     @staticmethod
     def _to_ladder_op(char: str) -> str:
@@ -135,9 +136,7 @@ class SummedFermionicOperator(HashablePydanticBaseModel):
     op_list: list = pydantic.Field(
         description="A list of tuples each containing a FermionicOperator and a coefficient.",
     )
-
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
     @staticmethod
     def _validate_single_op(op: tuple) -> FermionicOperatorTuple:
@@ -166,7 +165,8 @@ class SummedFermionicOperator(HashablePydanticBaseModel):
 
         return op  # type: ignore[return-value] # mypy thinks that it is `Tuple[Any, ...]`, though the asserts here tell otherwise..
 
-    @pydantic.validator("op_list")
+    @pydantic.field_validator("op_list")
+    @classmethod
     def _validate_op_list(cls, op_list: list) -> list:
         return list(map(cls._validate_single_op, op_list))
 

classiq/interface/chemistry/ground_state_problem.py

@@ -1,7 +1,8 @@
-from typing import Any, Dict, List, Literal, Optional, Tuple, Union
+from typing import List, Literal, Optional, Tuple, Union, cast
 
 import pydantic
-from pydantic import Field
+from pydantic import ConfigDict, Field
+from pydantic_core.core_schema import ValidationInfo
 from typing_extensions import Annotated
 
 from classiq.interface.chemistry.fermionic_operator import SummedFermionicOperator
@@ -52,18 +53,19 @@ class GroundStateProblem(HashablePydanticBaseModel):
     )
     num_qubits: Optional[int] = pydantic.Field(default=None)
 
-    @pydantic.validator("z2_symmetries")
-    def _validate_z2_symmetries(
-        cls, z2_symmetries: bool, values: Dict[str, Any]
-    ) -> bool:
-        if z2_symmetries and values.get("mapping") == FermionMapping.FAST_BRAVYI_KITAEV:
+    @pydantic.field_validator("z2_symmetries")
+    @classmethod
+    def _validate_z2_symmetries(cls, z2_symmetries: bool, info: ValidationInfo) -> bool:
+        if (
+            z2_symmetries
+            and info.data.get("mapping") == FermionMapping.FAST_BRAVYI_KITAEV
+        ):
             raise ClassiqValueError(
                 "z2 symmetries reduction can not be used for fast_bravyi_kitaev mapping"
             )
         return z2_symmetries
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 class MoleculeProblem(GroundStateProblem):
@@ -87,20 +89,23 @@ class HamiltonianProblem(GroundStateProblem):
         description="Tuple containing the numbers of alpha particles and beta particles"
     )
 
-    @pydantic.validator("num_particles")
-    def _validate_num_particles(cls, num_particles: List[int]) -> List[int]:
-        assert isinstance(num_particles, list)
+    @pydantic.field_validator("num_particles", mode="before")
+    @classmethod
+    def _validate_num_particles(
+        cls,
+        num_particles: Union[
+            List[Union[int, float]], Tuple[Union[int, float], Union[int, float]]
+        ],
+    ) -> List[int]:
+        assert isinstance(num_particles, (list, tuple))
         assert len(num_particles) == 2
 
-        # This probably will never happen, since pydantic automatically converts
-        #   floats to ints
-        assert isinstance(num_particles[0], int)
-        assert num_particles[0] >= 1
+        num_particles = [int(x) for x in num_particles]
 
-        assert isinstance(num_particles[1], int)
+        assert num_particles[0] >= 1
         assert num_particles[1] >= 1
 
-        return num_particles
+        return cast(List[int], num_particles)
 
 
 CHEMISTRY_PROBLEMS = (MoleculeProblem, HamiltonianProblem)