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

classiq/execution/qaoa.py

@@ -0,0 +1,84 @@
+import math
+from typing import Callable, Optional, Tuple, Type
+
+import numpy as np
+import scipy
+
+from classiq.interface.executor.execution_preferences import ExecutionPreferences
+from classiq.interface.executor.result import ExecutionDetails
+from classiq.interface.model.model import SerializedModel
+
+from classiq.execution import ExecutionSession
+from classiq.qmod.builtins.functions import (
+    RX,
+    allocate,
+    apply_to_all,
+    hadamard_transform,
+)
+from classiq.qmod.builtins.operations import phase, repeat
+from classiq.qmod.cparam import CReal
+from classiq.qmod.create_model_function import create_model
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_parameter import CArray
+from classiq.qmod.qmod_variable import Output, QVar
+from classiq.synthesis import SerializedQuantumProgram, synthesize
+
+
+def execute_qaoa(
+    problem_vars: Type[QVar],
+    cost_func: Callable,
+    num_layers: int,
+    maxiter: int,
+    execution_preferences: Optional[ExecutionPreferences] = None,
+) -> Tuple[SerializedModel, SerializedQuantumProgram, ExecutionDetails]:
+    """
+    Implements a simple QAOA algorithm, including the creation and synthesis of the QAOA
+    ansatz and the classical optimization loop.
+
+    Args:
+        problem_vars: the quantum type (scalar, array, or struct) of the problem variable(s)
+        cost_func: the arithmetic expression that evaluates the cost given an instance of the problem_vars type
+        num_layers: the number of layers of the QAOA ansatz
+        maxiter: the maximum number of iterations for the classical optimization loop
+        execution_preferences: the execution settings for running the QAOA ansatz
+
+    Returns:
+        a tuple containing the model of the QAOA ansatz, the corresponding synthesized quantum program,
+        and the result of the execution with the optimized parameters
+    """
+
+    @qfunc
+    def main(
+        params: CArray[CReal, num_layers * 2],  # type:ignore[valid-type]
+        v: Output[problem_vars],  # type:ignore[valid-type]
+    ) -> None:
+        allocate(v.size, v)  # type:ignore[attr-defined]
+        hadamard_transform(v)
+        repeat(
+            num_layers,
+            lambda i: [  # type:ignore[arg-type]
+                phase(-cost_func(v), params[i]),  # type:ignore[func-returns-value]
+                apply_to_all(lambda q: RX(params[num_layers + i], q), v),
+            ],
+        )
+
+    model = create_model(main)
+    qprog = synthesize(model)
+
+    es = ExecutionSession(qprog, execution_preferences)
+    initial_params = (
+        np.concatenate((np.linspace(0, 1, num_layers), np.linspace(1, 0, num_layers)))
+        * math.pi
+    )
+    final_params = scipy.optimize.minimize(
+        lambda params: es.estimate_cost(
+            lambda state: cost_func(state["v"]),
+            {"params": params.tolist()},
+        ),
+        x0=initial_params,
+        method="COBYLA",
+        options={"maxiter": maxiter},
+    ).x.tolist()
+    result = es.sample({"params": final_params})
+
+    return model, qprog, result

classiq/executor.py

@@ -27,7 +27,7 @@ BackendPreferencesAndResult: TypeAlias = Tuple[
 def _parse_serialized_qprog(
     quantum_program: SerializedQuantumProgram,
 ) -> QuantumProgram:
-    return QuantumProgram.parse_raw(quantum_program)
+    return QuantumProgram.model_validate_json(quantum_program)
 
 
 async def execute_async(quantum_program: SerializedQuantumProgram) -> ExecutionJob:
@@ -46,7 +46,7 @@ def execute(quantum_program: SerializedQuantumProgram) -> ExecutionJob:
     Returns:
         ExecutionJob: The result of the execution.
 
-    For examples please see [Execution Documentation](https://docs.classiq.io/latest/reference-manual/executor/)
+    For examples please see [Execution Documentation](https://docs.classiq.io/latest/user-guide/executor/)
     """
     return async_utils.run(execute_async(quantum_program))
 
@@ -57,7 +57,7 @@ def set_quantum_program_execution_preferences(
 ) -> SerializedQuantumProgram:
     circuit = _parse_serialized_qprog(quantum_program)
     circuit.model.execution_preferences = preferences
-    return SerializedQuantumProgram(circuit.json())
+    return SerializedQuantumProgram(circuit.model_dump_json())
 
 
 __all__ = [

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.51.1'
+SEMVER_VERSION = '0.53.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/analyzer/analysis_params.py

@@ -2,7 +2,7 @@ from typing import Dict, List, Optional
 
 import numpy
 import pydantic
-from pydantic import Field, conint, constr
+from pydantic import ConfigDict, Field, StringConstraints
 from typing_extensions import Annotated
 
 from classiq.interface.backend.quantum_backend_providers import AnalyzerProviderVendor
@@ -36,7 +36,8 @@ class HardwareListParams(pydantic.BaseModel):
     providers: List[Provider]
     from_ide: bool = Field(default=False)
 
-    @pydantic.validator("providers", always=True)
+    @pydantic.field_validator("providers")
+    @classmethod
     def set_default_providers(
         cls, providers: Optional[List[AnalyzerProviderVendor]]
     ) -> List[AnalyzerProviderVendor]:
@@ -55,8 +56,12 @@ class AnalysisOptionalDevicesParams(HardwareListParams):
 
 
 class GateNamsMapping(pydantic.BaseModel):
-    qasm_name: Annotated[str, constr(max_length=MAX_NAME_LENGTH)]
-    display_name: Annotated[str, constr(max_length=MAX_NAME_LENGTH)]
+    qasm_name: Annotated[
+        str, Annotated[str, StringConstraints(max_length=MAX_NAME_LENGTH)]
+    ]
+    display_name: Annotated[
+        str, Annotated[str, StringConstraints(max_length=MAX_NAME_LENGTH)]
+    ]
 
 
 class LatexParams(AnalysisParams):
@@ -66,7 +71,7 @@ class LatexParams(AnalysisParams):
 
 
 class AnalysisHardwareTranspilationParams(pydantic.BaseModel):
-    hardware_data: Optional[SynthesisHardwareData]
+    hardware_data: Optional[SynthesisHardwareData] = None
     random_seed: int
     transpilation_option: TranspilationOption
 
@@ -91,13 +96,18 @@ class CircuitAnalysisHardwareParams(AnalysisParams):
 
 class AnalysisRBParams(pydantic.BaseModel):
     hardware: str
-    counts: List[Dict[str, Annotated[int, conint(strict=True, gt=0, le=MAX_COUNTS)]]]
-    num_clifford: List[Annotated[int, conint(strict=True, gt=0, le=MAX_NUM_CLIFFORD)]]
+    counts: List[
+        Dict[
+            str, Annotated[int, Annotated[int, Field(strict=True, gt=0, le=MAX_COUNTS)]]
+        ]
+    ]
+    num_clifford: List[
+        Annotated[int, Annotated[int, Field(strict=True, gt=0, le=MAX_NUM_CLIFFORD)]]
+    ]
 
 
 class ChemistryGenerationParams(pydantic.BaseModel):
-    class Config:
-        title = "Chemistry"
+    model_config = ConfigDict(title="Chemistry")
 
     molecule: MoleculeProblem = pydantic.Field(
         title="Molecule",

classiq/interface/analyzer/cytoscape_graph.py

@@ -17,16 +17,23 @@ class CytoScapePosition(pydantic.BaseModel):
 
 class CytoScapeEdgeData(pydantic.BaseModel):
     source: str = pydantic.Field(
-        default=..., description="the Id of the Node that is the Source of the edge"
+        default=" ", description="the Id of the Node that is the Source of the edge"
     )
     target: str = pydantic.Field(
-        default=..., description="the Id of the Node that is the Target the edge"
+        default=" ", description="the Id of the Node that is the Target the edge"
     )
 
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_values(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        values["source"] = str(values["source"]) or " "
+        values["target"] = str(values["target"]) or " "
+        return values
+
 
 class CytoScapeEdge(pydantic.BaseModel):
     data: CytoScapeEdgeData = pydantic.Field(
-        default=..., description="Edge's Data, mainly the source and target of the Edge"
+        description="Edge's Data, mainly the source and target of the Edge"
     )
 
 

classiq/interface/analyzer/result.py

@@ -3,7 +3,7 @@ from uuid import UUID
 
 import pydantic
 from pydantic import Field
-from typing_extensions import Annotated
+from typing_extensions import Annotated, Self
 
 from classiq.interface.analyzer.analysis_params import MAX_FILE_LENGTH
 from classiq.interface.enum_utils import StrEnum
@@ -74,12 +74,13 @@ class HardwareComparisonInformation(pydantic.BaseModel):
         default=..., description="Number of total gates."
     )
 
-    @pydantic.root_validator
-    def validate_equal_length(cls, values: Dict[str, list]) -> Dict[str, list]:
+    @pydantic.model_validator(mode="after")
+    def validate_equal_length(self) -> Self:
+        values = self.model_dump()
         lengths = list(map(len, values.values()))
         if len(set(lengths)) != 1:
             raise ClassiqValueError("All lists should have the same length")
-        return values
+        return self
 
 
 # TODO: copy the types for `devices` & `providers` from `HardwareComparisonInformation`
@@ -112,7 +113,7 @@ HardwareComparisonGraphType = Annotated[
 ]
 
 _HARDWARE_COMPARISON_TABLE_COLUMNS_NAMES: Dict[str, str] = {
-    s.upper(): s.capitalize() for s in SingleHardwareInformation.__fields__
+    s.upper(): s.capitalize() for s in SingleHardwareInformation.model_fields
 }
 
 

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)}."""
-    )