classiq 0.94.2__py3-none-any.whl → 0.96.0__py3-none-any.whl

classiq/_internals/api_wrapper.py

@@ -12,15 +12,6 @@ from classiq.interface.analyzer.analysis_params import AnalysisRBParams
 from classiq.interface.analyzer.result import GraphStatus, QmodCode
 from classiq.interface.enum_utils import StrEnum
 from classiq.interface.exceptions import ClassiqAPIError, ClassiqValueError
-from classiq.interface.execution.iqcc import (
-    IQCCAuthItemsDetails,
-    IQCCInitAuthData,
-    IQCCInitAuthResponse,
-    IQCCListAuthMethods,
-    IQCCListAuthTargets,
-    IQCCProbeAuthData,
-    IQCCProbeAuthResponse,
-)
 from classiq.interface.execution.primitives import PrimitivesInput
 from classiq.interface.executor import execution_request
 from classiq.interface.executor.quantum_program_params import (
@@ -488,80 +479,6 @@ class ApiWrapper:
             raise ClassiqAPIError(f"Unexpected value: {data}")
         return [HardwareInformation.model_validate(info) for info in data]
 
-    @classmethod
-    async def call_iqcc_init_auth(
-        cls,
-        data: IQCCInitAuthData,
-        http_client: httpx.AsyncClient | None = None,
-    ) -> IQCCInitAuthResponse:
-        response = await cls._call_task_pydantic(
-            http_method=HTTPMethod.PUT,
-            url=f"{routes.IQCC_INIT_AUTH_FULL_PATH}",
-            model=data,
-            http_client=http_client,
-        )
-        return IQCCInitAuthResponse.model_validate(response)
-
-    @classmethod
-    async def call_iqcc_probe_auth(
-        cls,
-        data: IQCCProbeAuthData,
-        http_client: httpx.AsyncClient | None = None,
-    ) -> IQCCProbeAuthResponse | None:
-        try:
-            response = await cls._call_task_pydantic(
-                http_method=HTTPMethod.PUT,
-                url=f"{routes.IQCC_PROBE_AUTH_FULL_PATH}",
-                model=data,
-                http_client=http_client,
-            )
-        except ClassiqAPIError as ex:
-            if ex.status_code == 418:
-                return None
-            raise
-
-        return IQCCProbeAuthResponse.model_validate(response)
-
-    @classmethod
-    async def call_iqcc_list_auth_scopes(
-        cls,
-        http_client: httpx.AsyncClient | None = None,
-    ) -> IQCCAuthItemsDetails:
-        response = await cls._call_task(
-            http_method=HTTPMethod.GET,
-            url=routes.IQCC_LIST_AUTH_SCOPES_FULL_PATH,
-            http_client=http_client,
-        )
-        return IQCCAuthItemsDetails.model_validate(response)
-
-    @classmethod
-    async def call_iqcc_list_auth_methods(
-        cls,
-        data: IQCCListAuthMethods,
-        http_client: httpx.AsyncClient | None = None,
-    ) -> IQCCAuthItemsDetails:
-        response = await cls._call_task_pydantic(
-            http_method=HTTPMethod.PUT,
-            url=routes.IQCC_LIST_AUTH_METHODS_FULL_PATH,
-            model=data,
-            http_client=http_client,
-        )
-        return IQCCAuthItemsDetails.model_validate(response)
-
-    @classmethod
-    async def call_iqcc_list_auth_targets(
-        cls,
-        data: IQCCListAuthTargets,
-        http_client: httpx.AsyncClient | None = None,
-    ) -> IQCCAuthItemsDetails:
-        response = await cls._call_task_pydantic(
-            http_method=HTTPMethod.PUT,
-            url=routes.IQCC_LIST_AUTH_TARGETS_FULL_PATH,
-            model=data,
-            http_client=http_client,
-        )
-        return IQCCAuthItemsDetails.model_validate(response)
-
     @classmethod
     async def call_get_all_budgets(cls) -> list[UserBudget]:
         data = await client().call_api(

classiq/_internals/authentication/auth0.py

@@ -1,4 +1,5 @@
 import urllib.parse
+import warnings
 from dataclasses import dataclass
 from typing import Any
 
@@ -20,6 +21,7 @@ class AuthSettings(BaseSettings):
         default="f6721qMOVoDAOVkzrv8YaWassRKSFX6Y",
         validation_alias="CLASSIQ_AUTH_CLIENT_ID",
     )
+    organization: str = Field(default="", validation_alias="CLASSIQ_AUTH_ORGANIZATION")
 
     model_config = SettingsConfigDict(extra="allow")
 
@@ -53,6 +55,10 @@ class Auth0:
     def _client_id(self) -> str:
         return self._auth_settings.client_id
 
+    @property
+    def _organization(self) -> str:
+        return self._auth_settings.organization
+
     async def _make_request(
         self,
         url: str,
@@ -76,13 +82,20 @@ class Auth0:
             f"Request to Auth0 failed with error code {code}: {data.get('error')}"
         )
 
-    async def get_device_data(self, get_refresh_token: bool = True) -> dict[str, Any]:
+    async def get_device_data(
+        self, require_refresh_token: bool = True
+    ) -> dict[str, Any]:
         payload = {
-            "client_id": self._auth_settings.client_id,
+            "client_id": self._client_id,
             "audience": self._auth_settings.audience,
         }
-        if get_refresh_token:
+        if require_refresh_token:
             payload["scope"] = "offline_access"
+        if self._organization:
+            warnings.warn(
+                "Organizations are not supported in device auth flow.",
+                stacklevel=1,
+            )
 
         return await self._make_request(
             url="/oauth/device/code",
@@ -102,6 +115,22 @@ class Auth0:
             allow_error=codes.FORBIDDEN,
         )
 
+    def get_authorize_url(
+        self, redirect_uri: str, require_refresh_token: bool = True
+    ) -> str:
+        params = {
+            "client_id": self._client_id,
+            "response_type": "code",
+            "audience": self._auth_settings.audience,
+            "redirect_uri": redirect_uri,
+        }
+        if require_refresh_token:
+            params["scope"] = "offline_access"
+        if self._organization:
+            # Otherwise, let the Auth0 handle
+            params["organization"] = self._organization
+        return f"{self._base_url}/authorize?{urllib.parse.urlencode(params)}"
+
     async def refresh_access_token(self, refresh_token: str) -> Tokens:
         # TODO handle failure
         payload = {

classiq/_internals/authentication/authorization_code.py

@@ -0,0 +1,9 @@
+from classiq._internals.authentication.authorization_flow import AuthorizationFlow
+
+
+class AuthorizationCodeFlow(AuthorizationFlow):
+    async def authorize(self, redirect_uri: str) -> None:
+        auth_url = self.auth0_client.get_authorize_url(
+            redirect_uri, self.require_refresh_token
+        )
+        self.open_url(auth_url)

classiq/_internals/authentication/authorization_flow.py

@@ -0,0 +1,41 @@
+import webbrowser
+from typing import Any
+
+from classiq.interface.exceptions import ClassiqAuthenticationError
+
+from classiq._internals.authentication.auth0 import Auth0, Tokens
+
+
+class AuthorizationFlow:
+    def __init__(self, require_refresh_token: bool = True, text_only: bool = False):
+        self.require_refresh_token = require_refresh_token
+        self.text_only = text_only
+        self.auth0_client = Auth0()
+
+    async def get_tokens(self) -> Tokens:
+        raise NotImplementedError
+
+    def handle_ready_data(self, data: dict[str, Any]) -> Tokens:
+        access_token: str | None = data.get("access_token") or None
+        # If refresh token was not requested, this would be None
+        refresh_token: str | None = data.get("refresh_token") or None
+
+        if access_token is None or (
+            self.require_refresh_token is True and refresh_token is None
+        ):
+            raise ClassiqAuthenticationError(
+                "Token generation failed for unknown reason (missing access token or refresh token)."
+            )
+
+        return Tokens(access_token=access_token, refresh_token=refresh_token)
+
+    def open_url(self, url: str) -> None:
+        if self.text_only:
+            print(  # noqa: T201
+                f"Please visit this URL from any trusted device to authenticate: {url}"
+            )
+        else:
+            webbrowser.open(url)
+            print(  # noqa: T201
+                f"If a browser doesn't automatically open, please visit this URL from any trusted device to authenticate: {url}"
+            )

classiq/_internals/authentication/device.py

@@ -1,6 +1,6 @@
 import asyncio
-import webbrowser
 from collections.abc import Iterable
+from dataclasses import dataclass
 from datetime import timedelta
 from typing import Any, TypeVar
 
@@ -10,74 +10,55 @@ from classiq.interface.exceptions import (
 )
 
 from classiq._internals.async_utils import poll_for
-from classiq._internals.authentication.auth0 import Auth0, Tokens
+from classiq._internals.authentication.auth0 import Tokens
+from classiq._internals.authentication.authorization_flow import AuthorizationFlow
 
 T = TypeVar("T")
 
 
-class DeviceRegistrar:
+@dataclass
+class DeviceData:
+    user_code: str
+    device_code: str
+    interval: float
+    expires_in: float
+    verification_uri: str
+    verification_uri_complete: str
+
+
+class DeviceCodeFlow(AuthorizationFlow):
     _TIMEOUT_ERROR = (
         "Device registration timed out. Please re-initiate the flow and "
         "authorize the device within the timeout."
     )
     _TIMEOUT_SEC: float = timedelta(minutes=15).total_seconds()
 
-    @classmethod
-    async def register(
-        cls, get_refresh_token: bool = True, text_only: bool = False
-    ) -> Tokens:
-        auth0_client = Auth0()
-        data: dict[str, Any] = await auth0_client.get_device_data(
-            get_refresh_token=get_refresh_token
+    async def get_device_data(self) -> DeviceData:
+        device_data: dict[str, Any] = await self.auth0_client.get_device_data(
+            require_refresh_token=self.require_refresh_token
         )
+        return DeviceData(**device_data)
 
-        print(f"Your user code: {data['user_code']}")  # noqa: T201
-        verification_url = data["verification_uri_complete"]
-        print(  # noqa: T201
-            f"If a browser doesn't automatically open, please visit this URL from any trusted device: {verification_url}"
-        )
-        if not text_only:
-            webbrowser.open(verification_url)
-        timeout = min(data["expires_in"], cls._TIMEOUT_SEC)
-        return await cls._poll_tokens(
-            auth0_client=auth0_client,
-            device_code=data["device_code"],
-            interval=data["interval"],
+    async def poll_tokens(self, device_data: DeviceData) -> Tokens:
+        interval = device_data.interval
+        timeout = min(device_data.expires_in, self._TIMEOUT_SEC)
+        return await self._poll_tokens(
+            device_code=device_data.device_code,
+            interval=interval,
             timeout=timeout,
-            get_refresh_token=get_refresh_token,
         )
 
-    @classmethod
-    def _handle_ready_data(
-        cls, data: dict[str, Any], get_refresh_token: bool
-    ) -> Tokens:
-        access_token: str | None = data.get("access_token")
-        # If refresh token was not requested, this would be None
-        refresh_token: str | None = data.get("refresh_token")
-
-        if access_token is None or (
-            get_refresh_token is True and refresh_token is None
-        ):
-            raise ClassiqAuthenticationError(
-                "Token generation failed for unknown reason."
-            )
-
-        return Tokens(access_token=access_token, refresh_token=refresh_token)
-
-    @classmethod
     async def _poll_tokens(
-        cls,
-        auth0_client: Auth0,
+        self,
         device_code: str,
-        interval: int,
+        interval: float,
         timeout: float,
-        get_refresh_token: bool = True,
     ) -> Tokens:
         async def poller() -> dict[str, Any]:
             nonlocal device_code
-            return await auth0_client.poll_tokens(device_code=device_code)
+            return await self.auth0_client.poll_tokens(device_code=device_code)
 
-        def interval_coro() -> Iterable[int]:
+        def interval_coro() -> Iterable[float]:
             nonlocal interval
             while True:
                 yield interval
@@ -88,14 +69,14 @@ class DeviceRegistrar:
         ):
             error_code: str | None = data.get("error")
             if error_code is None:
-                return cls._handle_ready_data(data, get_refresh_token)
+                return self.handle_ready_data(data)
             elif error_code == "authorization_pending":
                 pass
             elif error_code == "slow_down":
                 # This value is used by poll_for via interval_coro
                 interval *= 2
             elif error_code == "expired_token":
-                raise ClassiqExpiredTokenError(cls._TIMEOUT_ERROR)
+                raise ClassiqExpiredTokenError(self._TIMEOUT_ERROR)
             elif error_code == "access_denied":
                 error_description = data.get("error_description")
                 if error_description is None:
@@ -109,4 +90,4 @@ class DeviceRegistrar:
                     f"Device registration failed with an unknown error: {error_code}."
                 )
         else:
-            raise ClassiqAuthenticationError(cls._TIMEOUT_ERROR)
+            raise ClassiqAuthenticationError(self._TIMEOUT_ERROR)

classiq/_internals/authentication/hybrid_flow.py

@@ -0,0 +1,19 @@
+from classiq._internals.authentication.auth0 import Tokens
+from classiq._internals.authentication.authorization_code import AuthorizationCodeFlow
+from classiq._internals.authentication.authorization_flow import AuthorizationFlow
+from classiq._internals.authentication.device import DeviceCodeFlow
+
+
+class HybridFlow(AuthorizationFlow):
+    def __init__(
+        self, require_refresh_token: bool = True, text_only: bool = False
+    ) -> None:
+        super().__init__(require_refresh_token, text_only)
+        self.device_flow = DeviceCodeFlow(require_refresh_token, text_only)
+        self.auth_code_flow = AuthorizationCodeFlow(require_refresh_token, text_only)
+
+    async def get_tokens(self) -> Tokens:
+        device_data = await self.device_flow.get_device_data()
+        await self.auth_code_flow.authorize(device_data.verification_uri_complete)
+        print(f"Your user code: {device_data.user_code}")  # noqa: T201
+        return await self.device_flow.poll_tokens(device_data)

classiq/_internals/authentication/token_manager.py

@@ -10,8 +10,8 @@ from classiq.interface.exceptions import (
 )
 
 from classiq._internals.authentication import password_manager as pm
-from classiq._internals.authentication.auth0 import Auth0
-from classiq._internals.authentication.device import DeviceRegistrar, Tokens
+from classiq._internals.authentication.auth0 import Auth0, Tokens
+from classiq._internals.authentication.hybrid_flow import HybridFlow
 from classiq._internals.config import Configuration
 
 PASSWORD_MANAGERS: Sequence[type[pm.PasswordManager]] = [
@@ -126,7 +126,8 @@ class TokenManager:
     async def _authentication_helper(self) -> None:
         # TODO: consider using refresh token rotation
         #  (https://auth0.com/docs/tokens/refresh-tokens/refresh-token-rotation)
-        tokens = await DeviceRegistrar.register(
-            get_refresh_token=True, text_only=self._config.text_only
+        authorization_flow = HybridFlow(
+            require_refresh_token=True, text_only=self._config.text_only
         )
+        tokens = await authorization_flow.get_tokens()
         self._save_tokens(tokens, force_override_refresh_token=True)

classiq/applications/__init__.py

@@ -1,6 +1,6 @@
-from classiq.applications import chemistry, combinatorial_optimization, qsp, qsvm
+from classiq.applications import chemistry, combinatorial_optimization, qsp
 
-__all__ = ["chemistry", "combinatorial_optimization", "qsp", "qsvm"]
+__all__ = ["chemistry", "combinatorial_optimization", "qsp"]
 
 
 _NON_IMPORTED_PUBLIC_SUBMODULES = ["qnn"]

classiq/applications/iqae/iqae.py

@@ -20,8 +20,10 @@ from classiq.qmod import (
     QCallable,
 )
 from classiq.qmod.builtins import Z, allocate, bind, within_apply
+from classiq.qmod.builtins.functions.allocation import drop
 from classiq.qmod.create_model_function import create_model
-from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qfunc import qfunc, qperm
+from classiq.qmod.qmod_variable import Const
 from classiq.synthesis import synthesize
 
 
@@ -83,8 +85,8 @@ class IQAE:
         def space_transform(est_reg: QArray) -> None:
             state_prep_op(est_reg[0 : est_reg.len - 1], est_reg[est_reg.len - 1])
 
-        @qfunc
-        def oracle(est_reg: QArray) -> None:
+        @qperm
+        def oracle(est_reg: Const[QArray]) -> None:
             Z(est_reg[est_reg.len - 1])
 
         @qfunc
@@ -105,6 +107,7 @@ class IQAE:
                     est_reg,
                 ),
             )
+            drop(problem_vars)
 
         if self._model is None:
             self._model = create_model(

classiq/applications/qnn/gradients/simple_quantum_gradient.py

@@ -59,7 +59,7 @@ def _differentiate_tensor(
     # The minus comes from the way pytorch defines diff
     #   it diffs the second object minus the first
     #     where we want the first minus the second
-    diff = -tensor.diff(axis=axis).squeeze(axis)  # type: ignore[call-arg] # torch does accept `axis` keyword
+    diff = -tensor.diff(axis=axis).squeeze(axis)
     return diff / (2 * epsilon)
 
 

classiq/applications/qnn/qlayer.py

@@ -104,7 +104,7 @@ class QLayerFunction(torch.autograd.Function):
         )
 
     @staticmethod
-    def backward(  # type: ignore[override]
+    def backward(
         ctx: Any, grad_output: Tensor
     ) -> tuple[Tensor | None, Tensor | None, None, None, None, None]:
         """

classiq/applications/qnn/torch_utils.py

@@ -23,7 +23,7 @@ def get_shape_second_dimension(shape: torch.Size) -> int:
     if len(shape) == 1:
         return 1
     elif len(shape) == 2:
-        return shape[1]
+        return shape[1]  # type: ignore[index]
     else:
         raise ClassiqValueError("Invalid shape dimension - must be 1D or 2D")
 
@@ -33,7 +33,7 @@ def get_shape_first_dimension(shape: torch.Size) -> int:
         raise ClassiqValueError("Invalid shape type - must have `__len__`")
 
     if len(shape) in (1, 2):
-        return shape[0]
+        return shape[0]  # type: ignore[index]
     else:
         raise ClassiqValueError("Invalid shape dimension - must be 1D or 2D")
 

classiq/applications/qsp/qsp.py

@@ -50,7 +50,7 @@ def qsvt_phases(
 ) -> np.ndarray:
     r"""
     Get QSVT phases that will generate the given Chebyshev polynomial.
-    The phases are ready to be used in `qsvt` and `qsvt_lcu` functions in the classiq library. The convetion
+    The phases are ready to be used in `qsvt` and `qsvt_lcu` functions in the classiq library. The convention
     is the reflection signal operator, and the measurement basis is the hadamard basis (see https://arxiv.org/abs/2105.02859
     APPENDIX A.).
     The current implementation is using the pyqsp package, based on techniques in https://arxiv.org/abs/2003.02831.
@@ -118,7 +118,7 @@ def qsvt_phases(
 
 def _plot_qsp_approx(
     poly_cheb: np.ndarray,
-    f_target: Callable[[np.ndarray], np.ndarray],
+    f_target: Callable[[float], complex],
     interval: tuple[float, float] = (-1, 1),
 ) -> None:
     from matplotlib import pyplot as plt
@@ -126,7 +126,7 @@ def _plot_qsp_approx(
     grid_full = np.linspace(-1, 1, 3000)
     grid_interval = np.linspace(interval[0], interval[1], 3000)
 
-    y_target = f_target(grid_interval)
+    y_target = np.vectorize(f_target, otypes=[float])(grid_interval)
     y_approx = np.polynomial.Chebyshev(poly_cheb)(grid_full)
 
     # Plot
@@ -153,7 +153,7 @@ def _plot_qsp_approx(
 
 
 def qsp_approximate(
-    f_target: Callable[[np.ndarray], np.ndarray],
+    f_target: Callable[[float], complex],
     degree: int,
     parity: int | None = None,
     interval: tuple[float, float] = (-1, 1),
@@ -193,7 +193,8 @@ def qsp_approximate(
     # Select grid points for the objective in [w_min, w_max]
     xj_obj = xj_full[(xj_full >= interval[0]) & (xj_full <= interval[1])]
 
-    yj_obj = f_target(xj_obj)
+    yj_obj = np.vectorize(f_target, otypes=[float])(xj_obj)
+
     # heuristic verification
     bound = min(1, bound)
     assert (

classiq/evaluators/qmod_node_evaluators/classical_function_evaluation.py

@@ -7,6 +7,7 @@ import sympy
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
+    ClassiqValueError,
 )
 from classiq.interface.generator.functions.classical_function_declaration import (
     ClassicalFunctionDeclaration,
@@ -208,6 +209,15 @@ def try_eval_sympy_function(
 
 def try_eval_builtin_function(
     expr_val: QmodAnnotatedExpression, node: ast.Call, func_name: str
+) -> bool:
+    try:
+        return _try_eval_builtin_function(expr_val, node, func_name)
+    except ValueError as e:
+        raise ClassiqValueError(str(e)) from e
+
+
+def _try_eval_builtin_function(
+    expr_val: QmodAnnotatedExpression, node: ast.Call, func_name: str
 ) -> bool:
     args_are_int = all(isinstance(expr_val.get_type(arg), Integer) for arg in node.args)
     args_are_real = all(

classiq/execution/__init__.py

@@ -8,7 +8,6 @@ from ..interface.executor.execution_preferences import __all__ as _ep_all
 from ..interface.executor.result import ExecutionDetails
 from ..interface.executor.vqe_result import VQESolverResult
 from .execution_session import ExecutionSession
-from .iqcc import generate_iqcc_token, generate_iqcc_token_async
 from .jobs import ExecutionJob, get_execution_jobs, get_execution_jobs_async
 from .qnn import execute_qnn
 from .user_budgets import (
@@ -33,8 +32,6 @@ __all__ = (
         "get_execution_jobs_async",
         "ExecutionSession",
         "execute_qnn",
-        "generate_iqcc_token",
-        "generate_iqcc_token_async",
         "get_budget",
         "get_budget_async",
         "set_budget_limit",

classiq/execution/user_budgets.py

@@ -14,7 +14,6 @@ PROVIDER_MAPPER = {
     ProviderVendor.OQC: "OQC",
     ProviderVendor.INTEL: "INTEL",
     ProviderVendor.AQT: "AQT",
-    ProviderVendor.IQCC: "IQCC",
     ProviderVendor.CLASSIQ: "CLASSIQ",
 }
 

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

classiq/interface/backend/backend_preferences.py

@@ -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,9 +194,13 @@ class AwsBackendPreferences(BackendPreferences):
     backend_service_provider: ProviderTypeVendor.AMAZON_BRAKET = pydantic.Field(
         default=ProviderVendor.AMAZON_BRAKET
     )
-    aws_role_arn: str | None = 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: str | None = pydantic.Field(
         default=None, description="S3 Bucket Name"
@@ -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",