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

classiq/execution/jobs.py

@@ -1,7 +1,7 @@
 import warnings
 import webbrowser
 from datetime import datetime
-from typing import Any, Optional, Union
+from typing import Any
 from urllib.parse import urljoin
 
 import httpx
@@ -39,7 +39,7 @@ class ClassiqExecutionResultError(ClassiqError):
 
 class ExecutionJob:
     _details: ExecutionJobDetails
-    _result: Optional[ResultsCollection]
+    _result: ResultsCollection | None
 
     def __init__(self, details: ExecutionJobDetails) -> None:
         self._details = details
@@ -50,7 +50,7 @@ class ExecutionJob:
         return self._details.id
 
     @property
-    def name(self) -> Optional[str]:
+    def name(self) -> str | None:
         return self._details.name
 
     @property
@@ -58,15 +58,15 @@ class ExecutionJob:
         return self._details.start_time
 
     @property
-    def end_time(self) -> Optional[datetime]:
+    def end_time(self) -> datetime | None:
         return self._details.end_time
 
     @property
-    def provider(self) -> Optional[str]:
+    def provider(self) -> str | None:
         return self._details.provider
 
     @property
-    def backend_name(self) -> Optional[str]:
+    def backend_name(self) -> str | None:
         return self._details.backend_name
 
     @property
@@ -74,15 +74,15 @@ class ExecutionJob:
         return self._details.status
 
     @property
-    def num_shots(self) -> Optional[int]:
+    def num_shots(self) -> int | None:
         return self._details.num_shots
 
     @property
-    def program_id(self) -> Optional[str]:
+    def program_id(self) -> str | None:
         return self._details.program_id
 
     @property
-    def error(self) -> Optional[str]:
+    def error(self) -> str | None:
         return self._details.error
 
     def __repr__(self) -> str:
@@ -92,7 +92,7 @@ class ExecutionJob:
         else:
             return f"{class_name}(name={self.name!r}, id={self.id!r})"
 
-    def cost(self, *, verbose: bool = False) -> Union[str, JobCost]:
+    def cost(self, *, verbose: bool = False) -> str | JobCost:
         if self._details.cost is None:
             self._details.cost = JobCost()
         if verbose:
@@ -103,7 +103,7 @@ class ExecutionJob:
     async def from_id_async(
         cls,
         id: str,
-        _http_client: Optional[httpx.AsyncClient] = None,
+        _http_client: httpx.AsyncClient | None = None,
     ) -> "ExecutionJob":
         details = await ApiWrapper.call_get_execution_job_details(
             JobID(job_id=id), http_client=_http_client
@@ -116,7 +116,7 @@ class ExecutionJob:
     def from_id(
         cls,
         id: str,
-        _http_client: Optional[httpx.AsyncClient] = None,
+        _http_client: httpx.AsyncClient | None = None,
     ) -> "ExecutionJob":
         return syncify_function(cls.from_id_async)(id, _http_client=_http_client)
 
@@ -126,8 +126,8 @@ class ExecutionJob:
 
     async def result_async(
         self,
-        timeout_sec: Optional[float] = None,
-        _http_client: Optional[httpx.AsyncClient] = None,
+        timeout_sec: float | None = None,
+        _http_client: httpx.AsyncClient | None = None,
     ) -> ResultsCollection:
         await self.poll_async(timeout_sec=timeout_sec, _http_client=_http_client)
 
@@ -151,7 +151,7 @@ class ExecutionJob:
         return self.result(*args, **kwargs)[0].value
 
     def get_sample_result(
-        self, _http_client: Optional[httpx.AsyncClient] = None
+        self, _http_client: httpx.AsyncClient | None = None
     ) -> ExecutionDetails:
         """
         Returns the job's result as a single sample result after validation. If the result is not yet available, waits for it.
@@ -177,7 +177,7 @@ class ExecutionJob:
         return result
 
     def get_batch_sample_result(
-        self, _http_client: Optional[httpx.AsyncClient] = None
+        self, _http_client: httpx.AsyncClient | None = None
     ) -> list[ExecutionDetails]:
         """
         Returns the job's result as a single batch_sample result after validation. If the result is not yet available, waits for it.
@@ -209,7 +209,7 @@ class ExecutionJob:
         return result_list
 
     def get_estimate_result(
-        self, _http_client: Optional[httpx.AsyncClient] = None
+        self, _http_client: httpx.AsyncClient | None = None
     ) -> EstimationResult:
         """
         Returns the job's result as a single estimate result after validation. If the result is not yet available, waits for it.
@@ -233,7 +233,7 @@ class ExecutionJob:
         raise ClassiqExecutionResultError("estimate")
 
     def get_batch_estimate_result(
-        self, _http_client: Optional[httpx.AsyncClient] = None
+        self, _http_client: httpx.AsyncClient | None = None
     ) -> list[EstimationResult]:
         """
         Returns the job's result as a single batch_estimate result after validation. If the result is not yet available, waits for it.
@@ -258,7 +258,7 @@ class ExecutionJob:
         raise ClassiqExecutionResultError("batch_estimate")
 
     def get_minimization_result(
-        self, _http_client: Optional[httpx.AsyncClient] = None
+        self, _http_client: httpx.AsyncClient | None = None
     ) -> TaggedMinimizeResult:
         """
         Returns the job's result as a single minimization result after validation. If the result is not yet available, waits for it.
@@ -281,8 +281,8 @@ class ExecutionJob:
 
     async def poll_async(
         self,
-        timeout_sec: Optional[float] = None,
-        _http_client: Optional[httpx.AsyncClient] = None,
+        timeout_sec: float | None = None,
+        _http_client: httpx.AsyncClient | None = None,
     ) -> None:
         if not self.status.is_final():
             await self._poll_job(timeout_sec=timeout_sec, _http_client=_http_client)
@@ -291,10 +291,10 @@ class ExecutionJob:
 
     async def _poll_job(
         self,
-        timeout_sec: Optional[float] = None,
-        _http_client: Optional[httpx.AsyncClient] = None,
+        timeout_sec: float | None = None,
+        _http_client: httpx.AsyncClient | None = None,
     ) -> None:
-        def response_parser(json_response: JSONObject) -> Optional[bool]:
+        def response_parser(json_response: JSONObject) -> bool | None:
             self._details = ExecutionJobDetails.model_validate(json_response)
             if self.status.is_final():
                 return True
@@ -313,7 +313,7 @@ class ExecutionJob:
     async def rename_async(
         self,
         name: str,
-        _http_client: Optional[httpx.AsyncClient] = None,
+        _http_client: httpx.AsyncClient | None = None,
     ) -> None:
         self._details = await ApiWrapper.call_patch_execution_job(
             self._job_id,
@@ -325,7 +325,7 @@ class ExecutionJob:
 
     async def cancel_async(
         self,
-        _http_client: Optional[httpx.AsyncClient] = None,
+        _http_client: httpx.AsyncClient | None = None,
     ) -> None:
         """
         Cancels the execution job. This implies the cancellation of any ongoing jobs

classiq/execution/qnn.py

@@ -1,5 +1,4 @@
 import functools
-from typing import Optional
 
 import more_itertools
 
@@ -60,7 +59,7 @@ def _execute_qnn_sample(
 def execute_qnn(
     quantum_program: QuantumProgram,
     arguments: MultipleArguments,
-    observable: Optional[PauliOperator] = None,
+    observable: PauliOperator | None = None,
 ) -> ResultsCollection:
     with ExecutionSession(quantum_program) as session:
         if observable:

classiq/execution/user_budgets.py

@@ -1,77 +1,111 @@
-from typing import Optional
-
-from classiq.interface.backend.quantum_backend_providers import ProviderVendor
+from classiq.interface.backend.quantum_backend_providers import (
+    PROVIDER_NAME_MAPPER,
+    ProviderVendor,
+)
 from classiq.interface.executor.user_budget import UserBudgets
 
 from classiq._internals.api_wrapper import ApiWrapper
 from classiq._internals.async_utils import syncify_function
 
-PROVIDER_MAPPER = {
-    ProviderVendor.IONQ: "IONQ",
-    ProviderVendor.IBM_QUANTUM: "IBM_CLOUD",
-    ProviderVendor.AZURE_QUANTUM: "AZURE",
-    ProviderVendor.AMAZON_BRAKET: "AMAZON",
-    ProviderVendor.GOOGLE: "GOOGLE",
-    ProviderVendor.ALICE_AND_BOB: "ALICE_AND_BOB",
-    ProviderVendor.OQC: "OQC",
-    ProviderVendor.INTEL: "INTEL",
-    ProviderVendor.AQT: "AQT",
-    ProviderVendor.IQCC: "IQCC",
-    ProviderVendor.CLASSIQ: "CLASSIQ",
-}
-
 
 async def get_budget_async(
-    provider_vendor: Optional[ProviderVendor] = None,
+    provider: ProviderVendor | None = None,
 ) -> UserBudgets:
 
     budgets_list = await ApiWrapper().call_get_all_budgets()
-    if provider_vendor:
-        provider = PROVIDER_MAPPER.get(provider_vendor, None)
+    if provider:
+        _provider = PROVIDER_NAME_MAPPER.get(provider, None)
         budgets_list = [
-            budget for budget in budgets_list if budget.provider == provider
+            budget for budget in budgets_list if budget.provider == _provider
         ]
 
     return UserBudgets(budgets=budgets_list)
 
 
-get_budget = syncify_function(get_budget_async)
+def get_budget(
+    provider: ProviderVendor | None = None,
+) -> UserBudgets:
+    """
+    Retrieve the user's budget information for quantum computing resources.
+
+    Args:
+        provider:
+            (Optional) The quantum backend provider to filter budgets by.
+            If not provided, budgets for all providers will be returned.
+
+    Returns:
+        UserBudgets: An object containing the user's budget information.
+    """
+    return syncify_function(get_budget_async)(provider)
 
 
 async def set_budget_limit_async(
-    provider_vendor: ProviderVendor,
+    provider: ProviderVendor,
     limit: float,
 ) -> UserBudgets:
-    provider = PROVIDER_MAPPER.get(provider_vendor, None)
-    if not provider:
-        raise ValueError(f"Unsupported provider: {provider_vendor}")
+    _provider = PROVIDER_NAME_MAPPER.get(provider, None)
+    if not _provider:
+        raise ValueError(f"Unsupported provider: {provider}")
 
-    budget = get_budget(provider_vendor)
+    budget = await get_budget_async(provider)
     if budget is None:
-        raise ValueError(f"No budget found for provider: {provider_vendor}")
+        raise ValueError(f"No budget found for provider: {provider}")
 
     if limit <= 0:
         raise ValueError("Budget limit must be greater than zero.")
 
     if limit > budget.budgets[0].available_budget:
         print(  # noqa: T201
-            f"Budget limit {limit} exceeds available budget {budget.budgets[0].available_budget} for provider {provider_vendor}.\n"
+            f"Budget limit {limit} exceeds available budget {budget.budgets[0].available_budget} for provider {provider}.\n"
             "Setting budget limit to the maximum available budget."
         )
-    budgets_list = await ApiWrapper().call_set_budget_limit(provider, limit)
+    budgets_list = await ApiWrapper().call_set_budget_limit(_provider, limit)
     return UserBudgets(budgets=[budgets_list])
 
 
-set_budget_limit = syncify_function(set_budget_limit_async)
+def set_budget_limit(
+    provider: ProviderVendor,
+    limit: float,
+) -> UserBudgets:
+    """
+    Set a budget limit for a specific quantum backend provider.
 
+    Args:
+        provider:
+            The quantum backend provider for which to set the budget limit.
+        limit:
+            The budget limit to set. Must be greater than zero and not exceed the available budget.
 
-async def clear_budget_limit_async(provider_vendor: ProviderVendor) -> UserBudgets:
-    provider = PROVIDER_MAPPER.get(provider_vendor, None)
-    if not provider:
-        raise ValueError(f"Unsupported provider: {provider_vendor}")
+    Returns:
+        UserBudgets: An object containing the updated budget information.
 
-    budgets_list = await ApiWrapper().call_clear_budget_limit(provider)
+    Raises:
+        ValueError: If the provider is unsupported, no budget is found, or the limit is invalid.
+    """
+    return syncify_function(set_budget_limit_async)(provider, limit)
+
+
+async def clear_budget_limit_async(provider: ProviderVendor) -> UserBudgets:
+    _provider = PROVIDER_NAME_MAPPER.get(provider, None)
+    if not _provider:
+        raise ValueError(f"Unsupported provider: {provider}")
+
+    budgets_list = await ApiWrapper().call_clear_budget_limit(_provider)
     return UserBudgets(budgets=[budgets_list])
 
 
-clear_budget_limit = syncify_function(clear_budget_limit_async)
+def clear_budget_limit(provider: ProviderVendor) -> UserBudgets:
+    """
+    Clear the budget limit for a specific quantum backend provider.
+
+    Args:
+        provider:
+            The quantum backend provider for which to clear the budget limit.
+
+    Returns:
+        UserBudgets: An object containing the updated budget information.
+
+    Raises:
+        ValueError: If the provider is unsupported.
+    """
+    return syncify_function(clear_budget_limit_async)(provider)

classiq/executor.py

@@ -1,8 +1,6 @@
 """Executor module, implementing facilities for executing quantum programs using Classiq platform."""
 
-from typing import Union
-
-from typing_extensions import TypeAlias
+from typing import TypeAlias, Union
 
 from classiq.interface.backend.backend_preferences import BackendPreferencesTypes
 from classiq.interface.executor.estimation import OperatorsEstimation

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.93.0'
+SEMVER_VERSION = '0.100.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/analyzer/analysis_params.py

@@ -1,4 +1,4 @@
-from typing import Annotated, Optional
+from typing import Annotated
 
 import pydantic
 from pydantic import Field, StringConstraints
@@ -26,7 +26,7 @@ class AnalysisParams(pydantic.BaseModel):
 
 
 class HardwareListParams(pydantic.BaseModel):
-    devices: Optional[list[PydanticNonEmptyString]] = pydantic.Field(
+    devices: list[PydanticNonEmptyString] | None = pydantic.Field(
         default=None, description="Devices"
     )
     providers: list[Provider]
@@ -35,7 +35,7 @@ class HardwareListParams(pydantic.BaseModel):
     @pydantic.field_validator("providers")
     @classmethod
     def set_default_providers(
-        cls, providers: Optional[list[AnalyzerProviderVendor]]
+        cls, providers: list[AnalyzerProviderVendor] | None
     ) -> list[AnalyzerProviderVendor]:
         if providers is None:
             providers = list(AnalyzerProviderVendor)
@@ -67,7 +67,7 @@ class LatexParams(AnalysisParams):
 
 
 class AnalysisHardwareTranspilationParams(pydantic.BaseModel):
-    hardware_data: Optional[SynthesisHardwareData] = None
+    hardware_data: SynthesisHardwareData | None = None
     random_seed: int
     transpilation_option: TranspilationOption
 

classiq/interface/analyzer/cytoscape_graph.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional
+from typing import Any
 
 import pydantic
 
@@ -42,7 +42,7 @@ class CytoScapeNode(pydantic.BaseModel):
         default=...,
         description="Data of the Node, such as label, and color, can be of free form",
     )
-    position: Optional[CytoScapePosition] = pydantic.Field(
+    position: CytoScapePosition | None = pydantic.Field(
         default=..., description="Position of the Node to be rendered in Cytocape"
     )
 
@@ -66,7 +66,7 @@ class ConnectivityErrors(StrEnum):
 
 
 class HardwareConnectivityGraphResult(VersionedModel):
-    graph: Optional[CytoScapeGraph] = pydantic.Field(
+    graph: CytoScapeGraph | None = pydantic.Field(
         default=...,
         description="The Cytoscape graph in the desired Structure for the FE",
     )

classiq/interface/analyzer/result.py

@@ -1,4 +1,4 @@
-from typing import Annotated, Literal, Optional, Union
+from typing import Annotated, Literal, Union
 
 import pydantic
 from pydantic import Field
@@ -125,15 +125,15 @@ class HardwareComparisonDataColumns(pydantic.BaseModel):
 
 
 class AvailableHardware(pydantic.BaseModel):
-    ibm_quantum: Optional[dict[PydanticNonEmptyString, bool]] = pydantic.Field(
+    ibm_quantum: dict[PydanticNonEmptyString, bool] | None = pydantic.Field(
         default=None,
         description="available IBM Quantum devices with boolean indicates if a given device has enough qubits.",
     )
-    azure_quantum: Optional[dict[PydanticNonEmptyString, bool]] = pydantic.Field(
+    azure_quantum: dict[PydanticNonEmptyString, bool] | None = pydantic.Field(
         default=None,
         description="available Azure Quantum devices with boolean indicates if a given device has enough qubits.",
     )
-    amazon_braket: Optional[dict[PydanticNonEmptyString, bool]] = pydantic.Field(
+    amazon_braket: dict[PydanticNonEmptyString, bool] | None = pydantic.Field(
         default=None,
         description="available Amazon Braket devices with boolean indicates if a given device has enough qubits.",
     )

classiq/interface/ast_node.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional, TypeVar
+from typing import Any, TypeVar
 from uuid import UUID
 
 import pydantic
@@ -13,8 +13,8 @@ ASTNodeType = TypeVar("ASTNodeType", bound="ASTNode")
 
 
 class ASTNode(HashablePydanticBaseModel):
-    source_ref: Optional[SourceReference] = pydantic.Field(default=None)
-    back_ref: Optional[UUID] = pydantic.Field(default=None)
+    source_ref: SourceReference | None = pydantic.Field(default=None)
+    back_ref: UUID | None = pydantic.Field(default=None)
 
     def _as_back_ref(self: Self) -> Self:
         return self

classiq/interface/backend/backend_preferences.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import warnings
 from collections.abc import Iterable
-from typing import Any, Optional, Union
+from typing import Any, Union
 
 import pydantic
 from pydantic import BaseModel
@@ -103,19 +103,19 @@ class AliceBobBackendPreferences(BackendPreferences):
     backend_service_provider: ProviderTypeVendor.ALICE_BOB = pydantic.Field(
         default=ProviderVendor.ALICE_AND_BOB
     )
-    distance: Optional[int] = pydantic.Field(
+    distance: int | None = pydantic.Field(
         default=None, description="Repetition code distance"
     )
-    kappa_1: Optional[float] = pydantic.Field(
+    kappa_1: float | None = pydantic.Field(
         default=None, description="One-photon dissipation rate (Hz)"
     )
-    kappa_2: Optional[float] = pydantic.Field(
+    kappa_2: float | None = pydantic.Field(
         default=None, description="Two-photon dissipation rate (Hz)"
     )
-    average_nb_photons: Optional[float] = pydantic.Field(
+    average_nb_photons: float | None = pydantic.Field(
         default=None, description="Average number of photons"
     )
-    api_key: Optional[pydantic_backend.PydanticAliceBobApiKeyType] = pydantic.Field(
+    api_key: pydantic_backend.PydanticAliceBobApiKeyType | None = pydantic.Field(
         default=None, description="AliceBob API key"
     )
 
@@ -131,7 +131,7 @@ class AliceBobBackendPreferences(BackendPreferences):
 
     @pydantic.field_validator("api_key", mode="after")
     @classmethod
-    def _validate_api_key(cls, api_key: Optional[str]) -> Optional[str]:
+    def _validate_api_key(cls, api_key: str | None) -> str | None:
         if api_key is not None:
             warnings.warn(
                 "API key is no longer required for Alice&Bob backends.",
@@ -172,10 +172,11 @@ class AwsBackendPreferences(BackendPreferences):
         backend_service_provider (ProviderTypeVendor.AMAZON_BRAKET):
             The service provider for the backend, which is Amazon Braket.
 
-        aws_role_arn (pydantic_backend.PydanticAwsRoleArn):
-            The Amazon Resource Name (ARN) of the role that will be assumed for execution
-            on your Braket account. This is a required field and should be provided to allow
-            secure and authorized access to AWS resources.
+        aws_access_key_id (str):
+            The access key id of AWS user with full braket access
+
+        aws_secret_access_key (str):
+            The secret key assigned to the access key id for the user with full braket access.
 
         s3_bucket_name (str):
             The name of the S3 bucket where results and other related data will be stored.
@@ -193,14 +194,18 @@ class AwsBackendPreferences(BackendPreferences):
     backend_service_provider: ProviderTypeVendor.AMAZON_BRAKET = pydantic.Field(
         default=ProviderVendor.AMAZON_BRAKET
     )
-    aws_role_arn: Optional[str] = pydantic.Field(
+    aws_access_key_id: str | None = pydantic.Field(
+        default=None,
+        description="Key id assigned to user with credentials to access Braket service",
+    )
+    aws_secret_access_key: str | None = pydantic.Field(
         default=None,
-        description="ARN of the role to be assumed for execution on your Braket account.",
+        description="Secret access key assigned to user with credentials to access Braket service",
     )
-    s3_bucket_name: Optional[str] = pydantic.Field(
+    s3_bucket_name: str | None = pydantic.Field(
         default=None, description="S3 Bucket Name"
     )
-    s3_folder: Optional[str] = pydantic.Field(
+    s3_folder: str | None = pydantic.Field(
         default=None, description="S3 Folder Path Within The S3 Bucket"
     )
     run_through_classiq: bool = pydantic.Field(
@@ -229,15 +234,15 @@ class IBMBackendPreferences(BackendPreferences):
     backend_service_provider: ProviderTypeVendor.IBM_CLOUD = pydantic.Field(
         default=ProviderVendor.IBM_QUANTUM
     )
-    access_token: Optional[str] = pydantic.Field(
+    access_token: str | None = pydantic.Field(
         default=None,
         description="IBM Cloud access token to be used"
         " with IBM Quantum hosted backends",
     )
-    channel: Optional[str] = pydantic.Field(
+    channel: str | None = pydantic.Field(
         default=None, description="Channel to use for IBM cloud backends."
     )
-    instance_crn: Optional[str] = pydantic.Field(
+    instance_crn: str | None = pydantic.Field(
         default=None, description="IBM Cloud instance CRN."
     )
     run_through_classiq: bool = pydantic.Field(
@@ -303,12 +308,12 @@ class AzureBackendPreferences(BackendPreferences):
         default="East US", description="Azure personal resource region"
     )
 
-    credentials: Optional[AzureCredential] = pydantic.Field(
+    credentials: AzureCredential | None = pydantic.Field(
         default=None,
         description="The service principal credential to access personal quantum workspace",
     )
 
-    ionq_error_mitigation_flag: Optional[bool] = pydantic.Field(
+    ionq_error_mitigation_flag: bool | None = pydantic.Field(
         default=False,
         description="Error mitigation configuration upon running on IonQ through Azure.",
     )
@@ -343,7 +348,7 @@ class IonqBackendPreferences(BackendPreferences):
     backend_service_provider: ProviderTypeVendor.IONQ = pydantic.Field(
         default=ProviderVendor.IONQ
     )
-    api_key: Optional[pydantic_backend.PydanticIonQApiKeyType] = pydantic.Field(
+    api_key: pydantic_backend.PydanticIonQApiKeyType | None = pydantic.Field(
         default=None, description="IonQ API key"
     )
     error_mitigation: bool = pydantic.Field(
@@ -428,33 +433,6 @@ class AQTBackendPreferences(BackendPreferences):
     workspace: str = pydantic.Field(description="AQT workspace")
 
 
-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
-
-
 class CINECABackendPreferences(BackendPreferences):
     """
     Represents the backend preferences specific to CINECA.
@@ -507,7 +485,6 @@ BackendPreferencesTypes = Union[
     OQCBackendPreferences,
     IntelBackendPreferences,
     AQTBackendPreferences,
-    IQCCBackendPreferences,
     CINECABackendPreferences,
 ]
 
@@ -525,7 +502,6 @@ __all__ = [
     "ClassiqSimulatorBackendNames",
     "GCPBackendPreferences",
     "IBMBackendPreferences",
-    "IQCCBackendPreferences",
     "IntelBackendNames",
     "IntelBackendPreferences",
     "IonqBackendNames",

classiq/interface/backend/ionq/ionq_quantum_program.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Annotated, Optional
+from typing import TYPE_CHECKING, Annotated
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -22,10 +22,10 @@ else:
 
 class Gate(BaseModel):
     gate: PydanticGateName
-    target: Optional[int] = None
-    control: Optional[int] = None
-    targets: Optional[list[int]] = None
-    controls: Optional[list[int]] = None
+    target: int | None = None
+    control: int | None = None
+    targets: list[int] | None = None
+    controls: list[int] | None = None
     model_config = ConfigDict(extra="allow")