classiq 0.38.0__py3-none-any.whl → 0.65.4__py3-none-any.whl

classiq/__init__.py

@@ -1,8 +1,5 @@
 """Classiq SDK."""
 
-import sys
-from typing import List
-
 from classiq.interface._version import VERSION as _VERSION
 from classiq.interface.generator.application_apis import *  # noqa: F403
 from classiq.interface.generator.arith.register_user_input import (
@@ -10,21 +7,13 @@ from classiq.interface.generator.arith.register_user_input import (
     RegisterUserInput,
 )
 from classiq.interface.generator.control_state import ControlState
-from classiq.interface.generator.expressions.enums.pauli import Pauli
 from classiq.interface.generator.functions import *  # noqa: F403
-from classiq.interface.generator.functions import __all__ as _ifunc_all
+from classiq.interface.generator.model import *  # noqa: F403
+from classiq.interface.generator.model import __all__ as _md_all
 from classiq.interface.generator.quantum_program import QuantumProgram
-from classiq.interface.ide.show import show
 
-from classiq import (
-    applications,
-    builtin_functions,
-    exceptions,
-    execution,
-    model,
-    synthesis,
-)
-from classiq._internals import _qfunc_ext, logger
+from classiq import applications, execution, synthesis
+from classiq._internals import logger
 from classiq._internals.async_utils import (
     enable_jupyter_notebook,
     is_notebook as _is_notebook,
@@ -34,31 +23,56 @@ from classiq._internals.client import configure
 from classiq._internals.config import Configuration
 from classiq._internals.help import open_help
 from classiq.analyzer import Analyzer
-from classiq.applications_model_constructors import *  # noqa: F403
-from classiq.applications_model_constructors import (
-    __all__ as _application_constructors_all,
+from classiq.applications.chemistry import (
+    construct_chemistry_model,
+    molecule_problem_to_qmod,
+)
+from classiq.applications.combinatorial_optimization import (
+    CombinatorialProblem,
+    compute_qaoa_initial_point,
+    construct_combinatorial_optimization_model,
+    execute_qaoa,
+    pyo_model_to_hamiltonian,
 )
+from classiq.applications.finance import construct_finance_model
+from classiq.applications.grover import construct_grover_model
+from classiq.applications.hamiltonian.pauli_decomposition import (
+    hamiltonian_to_matrix,
+    matrix_to_hamiltonian,
+)
+from classiq.applications.qsvm import construct_qsvm_model
 from classiq.executor import (
     execute,
     execute_async,
     set_quantum_program_execution_preferences,
 )
-from classiq.model import *  # noqa: F403
-from classiq.model import __all__ as _md_all
+from classiq.open_library import *  # noqa: F403
+from classiq.open_library import __all__ as _open_library_all
 from classiq.qmod import *  # noqa: F403
 from classiq.qmod import __all__ as _qmod_all
-from classiq.quantum_functions import *  # noqa: F403
-from classiq.quantum_functions import __all__ as _qfuncs_all
-from classiq.quantum_register import *  # noqa: F403
-from classiq.quantum_register import __all__ as _qregs_all
 from classiq.synthesis import (
+    quantum_program_from_qasm,
+    quantum_program_from_qasm_async,
     set_constraints,
     set_execution_preferences,
     set_preferences,
+    show,
     synthesize,
     synthesize_async,
+    update_constraints,
+    update_execution_preferences,
+    update_preferences,
 )
 
+_application_constructors_all = [
+    "construct_qsvm_model",
+    "construct_combinatorial_optimization_model",
+    "construct_chemistry_model",
+    "construct_finance_model",
+    "construct_grover_model",
+    "molecule_problem_to_qmod",
+]
+
 __version__ = _VERSION
 
 if _is_notebook():
@@ -67,10 +81,7 @@ if _is_notebook():
 _sub_modules = [
     "analyzer",
     "applications",
-    "builtin_functions",
-    "exceptions",
     "execution",
-    "model",
     "open_help",
     "qmod",
     "synthesis",
@@ -91,19 +102,23 @@ __all__ = (
         "set_preferences",
         "set_constraints",
         "set_execution_preferences",
+        "update_preferences",
+        "update_constraints",
+        "update_execution_preferences",
         "set_quantum_program_execution_preferences",
         "show",
-        "Pauli",
+        "hamiltonian_to_matrix",
+        "matrix_to_hamiltonian",
+        "quantum_program_from_qasm",
+        "quantum_program_from_qasm_async",
     ]
-    + _qregs_all
-    + _qfuncs_all
     + _md_all
-    + _ifunc_all
     + _sub_modules
     + _application_constructors_all
     + _qmod_all
+    + _open_library_all
 )
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/_analyzer_extras/_ipywidgets_async_extension.py

@@ -1,6 +1,7 @@
 import asyncio
+from collections.abc import Awaitable
 from functools import wraps
-from typing import TYPE_CHECKING, Awaitable, Callable
+from typing import TYPE_CHECKING, Callable
 
 from ipywidgets import widgets  # type: ignore[import]
 

classiq/_internals/api_wrapper.py

@@ -1,39 +1,39 @@
 import json
-from typing import Dict, Optional, Protocol, Type, TypeVar
+from typing import Any, Optional, Protocol, TypeVar
 
+import httpx
 import pydantic
 
 import classiq.interface.executor.execution_result
 import classiq.interface.pyomo_extension
 from classiq.interface.analyzer import analysis_params, result as analysis_result
 from classiq.interface.analyzer.analysis_params import AnalysisRBParams
+from classiq.interface.analyzer.result import GraphStatus
 from classiq.interface.chemistry import ground_state_problem, operator
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqAPIError, ClassiqValueError
+from classiq.interface.execution.iqcc import (
+    IQCCInitAuthData,
+    IQCCInitAuthResponse,
+    IQCCProbeAuthData,
+    IQCCProbeAuthResponse,
+)
 from classiq.interface.execution.jobs import (
     ExecutionJobDetailsV1,
     ExecutionJobsQueryResultsV1,
 )
-from classiq.interface.executor import execution_request, result as execute_result
+from classiq.interface.execution.primitives import PrimitivesInput
+from classiq.interface.executor import execution_request
 from classiq.interface.generator import quantum_program as generator_result
-from classiq.interface.jobs import (
-    JobDescriptionBase,
-    JobDescriptionFailure,
-    JobDescriptionSuccess,
-    JobID,
-    JSONObject,
-)
-from classiq.interface.model.common_model_types import ModelInput
+from classiq.interface.hardware import HardwareInformation, Provider
+from classiq.interface.jobs import JobDescription, JobID, JSONObject
+from classiq.interface.model.model import Model
 from classiq.interface.server import routes
 
 from classiq._internals.client import client
-from classiq._internals.enum_utils import StrEnum
 from classiq._internals.jobs import JobPoller
-from classiq.exceptions import ClassiqAPIError, ClassiqValueError
 
 ResultType = TypeVar("ResultType", bound=pydantic.BaseModel)
-CLASSIQ_ACCEPT_HEADER = "X-Classiq-Accept-Version"
-
-_ACCEPT_HEADER = "X-Classiq-Accept-Version"
-_CONTENT_TYPE_HEADER = "X-Classiq-Content-Type-Version"
 
 
 class HTTPMethod(StrEnum):
@@ -41,6 +41,7 @@ class HTTPMethod(StrEnum):
     GET = "GET"
     POST = "POST"
     PATCH = "PATCH"
+    PUT = "PUT"
 
 
 class StatusType(Protocol):
@@ -48,13 +49,13 @@ class StatusType(Protocol):
 
 
 def _parse_job_response(
-    job_result: JobDescriptionBase[JSONObject],
-    output_type: Type[ResultType],
+    job_result: JobDescription[JSONObject],
+    output_type: type[ResultType],
 ) -> ResultType:
-    if isinstance(job_result, JobDescriptionSuccess):
-        return output_type.parse_obj(job_result.description)
-    if isinstance(job_result, JobDescriptionFailure):
-        raise ClassiqAPIError(job_result.description.details)
+    if job_result.result is not None:
+        return output_type.model_validate(job_result.result)
+    if job_result.failure_details:
+        raise ClassiqAPIError(job_result.failure_details)
 
     raise ClassiqAPIError("Unexpected response from server")
 
@@ -67,13 +68,18 @@ class ApiWrapper:
         url: str,
         model: pydantic.BaseModel,
         use_versioned_url: bool = True,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> dict:
         # TODO: we can't use model.dict() - it doesn't serialize complex class.
         # This was added because JSON serializer doesn't serialize complex type, and pydantic does.
         # We should add support for smarter json serialization.
-        body = json.loads(model.json())
+        body = json.loads(model.model_dump_json())
         return await cls._call_task(
-            http_method, url, body, use_versioned_url=use_versioned_url
+            http_method,
+            url,
+            body,
+            use_versioned_url=use_versioned_url,
+            http_client=http_client,
         )
 
     @classmethod
@@ -81,80 +87,121 @@ class ApiWrapper:
         cls,
         http_method: str,
         url: str,
-        body: Optional[Dict] = None,
-        params: Optional[Dict] = None,
+        body: Optional[dict] = None,
+        params: Optional[dict] = None,
         use_versioned_url: bool = True,
-        headers: Optional[Dict[str, str]] = None,
+        headers: Optional[dict[str, str]] = None,
+        allow_none: bool = False,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> dict:
-        res = await client().call_api(
+        res: Any = await client().call_api(
             http_method=http_method,
             url=url,
             body=body,
             headers=headers,
             params=params,
             use_versioned_url=use_versioned_url,
+            http_client=http_client,
         )
+        if allow_none and res is None:
+            return {}
         if not isinstance(res, dict):
             raise ClassiqValueError(f"Unexpected returned value: {res}")
         return res
 
     @classmethod
     async def call_generation_task(
-        cls, model: ModelInput
+        cls,
+        model: Model,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> generator_result.QuantumProgram:
         poller = JobPoller(base_url=routes.TASKS_GENERATE_FULL_PATH)
-        result = await poller.run_pydantic(model, timeout_sec=None)
+        result = await poller.run_pydantic(
+            model, timeout_sec=None, http_client=http_client
+        )
         return _parse_job_response(result, generator_result.QuantumProgram)
 
     @classmethod
-    async def call_execute_generated_circuit(
-        cls, circuit: generator_result.QuantumProgram
+    async def call_create_execution_session(
+        cls,
+        circuit: generator_result.QuantumProgram,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> str:
+        raw_result = await cls._call_task_pydantic(
+            http_method=HTTPMethod.POST,
+            url=routes.EXECUTION_SESSIONS_PREFIX,
+            model=circuit,
+            http_client=http_client,
+        )
+        return raw_result["id"]
+
+    @classmethod
+    async def call_create_session_job(
+        cls,
+        session_id: str,
+        primitives_input: PrimitivesInput,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> execution_request.ExecutionJobDetails:
-        execution_input = await cls._call_task_pydantic(
+        data = await cls._call_task_pydantic(
+            http_method=HTTPMethod.POST,
+            url=routes.EXECUTION_SESSIONS_PREFIX + f"/{session_id}",
+            model=primitives_input,
+            http_client=http_client,
+        )
+        return execution_request.ExecutionJobDetails.model_validate(data)
+
+    @classmethod
+    async def call_convert_quantum_program(
+        cls,
+        circuit: generator_result.QuantumProgram,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> dict:
+        return await cls._call_task_pydantic(
             http_method=HTTPMethod.POST,
             url=routes.CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_FULL,
             model=circuit,
+            http_client=http_client,
         )
-        headers = {
-            _ACCEPT_HEADER: "v1",
-            _CONTENT_TYPE_HEADER: execution_input["version"],
-        }
+
+    @classmethod
+    async def call_execute_execution_input(
+        cls,
+        execution_input: dict,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> execution_request.ExecutionJobDetails:
         data = await cls._call_task(
             http_method=HTTPMethod.POST,
-            headers=headers,
-            url=routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH,
+            url=routes.EXECUTION_JOBS_FULL_PATH,
             body=execution_input,
-            use_versioned_url=False,
+            http_client=http_client,
         )
-        return execution_request.ExecutionJobDetails.parse_obj(data)
+        return execution_request.ExecutionJobDetails.model_validate(data)
 
     @classmethod
     async def call_get_execution_job_details(
         cls,
         job_id: JobID,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> execution_request.ExecutionJobDetails:
-        headers = {_ACCEPT_HEADER: "v1"}
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
-            headers=headers,
-            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}/{job_id.job_id}",
-            use_versioned_url=False,
+            url=f"{routes.EXECUTION_JOBS_FULL_PATH}/{job_id.job_id}",
+            http_client=http_client,
         )
-        return execution_request.ExecutionJobDetails.parse_obj(data)
+        return execution_request.ExecutionJobDetails.model_validate(data)
 
     @classmethod
     async def call_get_execution_job_result(
         cls,
         job_id: JobID,
-        version: str,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> classiq.interface.executor.execution_result.ExecuteGeneratedCircuitResults:
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
-            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}/{job_id.job_id}/result",
-            use_versioned_url=False,
-            headers={CLASSIQ_ACCEPT_HEADER: version},
+            url=f"{routes.EXECUTION_JOBS_FULL_PATH}/{job_id.job_id}/result",
+            http_client=http_client,
         )
-        return classiq.interface.executor.execution_result.ExecuteGeneratedCircuitResults.parse_obj(
+        return classiq.interface.executor.execution_result.ExecuteGeneratedCircuitResults.model_validate(
             data
         )
 
@@ -163,147 +210,238 @@ class ApiWrapper:
         cls,
         job_id: JobID,
         name: str,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> ExecutionJobDetailsV1:
         data = await cls._call_task(
             http_method=HTTPMethod.PATCH,
-            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}/{job_id.job_id}",
+            url=f"{routes.EXECUTION_JOBS_FULL_PATH}/{job_id.job_id}",
             params={
                 "name": name,
             },
-            use_versioned_url=False,
+            http_client=http_client,
+        )
+        return ExecutionJobDetailsV1.model_validate(data)
+
+    @classmethod
+    async def call_cancel_execution_job(
+        cls,
+        job_id: JobID,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> None:
+        await cls._call_task(
+            http_method=HTTPMethod.PUT,
+            url=f"{routes.EXECUTION_JOBS_FULL_PATH}/{job_id.job_id}/cancel",
+            allow_none=True,
+            http_client=http_client,
         )
-        return ExecutionJobDetailsV1.parse_obj(data)
 
     @classmethod
     async def call_query_execution_jobs(
         cls,
         offset: int,
         limit: int,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> ExecutionJobsQueryResultsV1:
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
-            url=f"{routes.EXECUTION_JOBS_NON_VERSIONED_FULL_PATH}",
+            url=f"{routes.EXECUTION_JOBS_FULL_PATH}",
             params={
                 "offset": offset,
                 "limit": limit,
             },
-            use_versioned_url=False,
+            http_client=http_client,
         )
-        return ExecutionJobsQueryResultsV1.parse_obj(data)
-
-    @classmethod
-    async def call_execute_estimate(
-        cls, request: execution_request.ExecutionRequest
-    ) -> execute_result.EstimationResults:
-        poller = JobPoller(base_url=routes.EXECUTE_ESTIMATE_FULL_PATH)
-        result = await poller.run_pydantic(request, timeout_sec=None)
-        return _parse_job_response(result, execute_result.EstimationResults)
-
-    @classmethod
-    async def call_execute_quantum_program(
-        cls, request: execution_request.ExecutionRequest
-    ) -> execute_result.MultipleExecutionDetails:
-        poller = JobPoller(
-            base_url=routes.EXECUTE_QUANTUM_PROGRAM_FULL_PATH,
-        )
-        result = await poller.run_pydantic(request, timeout_sec=None)
-        return _parse_job_response(result, execute_result.MultipleExecutionDetails)
+        return ExecutionJobsQueryResultsV1.model_validate(data)
 
     @classmethod
     async def call_analysis_task(
-        cls, params: analysis_params.AnalysisParams
+        cls,
+        params: analysis_params.AnalysisParams,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> analysis_result.Analysis:
         data = await cls._call_task_pydantic(
             http_method=HTTPMethod.POST,
             url=routes.ANALYZER_FULL_PATH,
             model=params,
+            http_client=http_client,
         )
 
-        return analysis_result.Analysis.parse_obj(data)
+        return analysis_result.Analysis.model_validate(data)
 
     @classmethod
     async def call_analyzer_app(
-        cls, params: generator_result.QuantumProgram
+        cls,
+        params: generator_result.QuantumProgram,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> analysis_result.DataID:
         data = await cls._call_task_pydantic(
             http_method=HTTPMethod.POST,
             url=routes.ANALYZER_DATA_FULL_PATH,
             model=params,
+            http_client=http_client,
         )
-        return analysis_result.DataID.parse_obj(data)
+        return analysis_result.DataID.model_validate(data)
 
     @classmethod
     async def get_generated_circuit_from_qasm(
-        cls, params: analysis_result.QasmCode
+        cls,
+        params: analysis_result.QasmCode,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> generator_result.QuantumProgram:
         data = await cls._call_task_pydantic(
             http_method=HTTPMethod.POST,
             url=routes.IDE_QASM_FULL_PATH,
             model=params,
+            http_client=http_client,
         )
-        return generator_result.QuantumProgram.parse_obj(data)
+        return generator_result.QuantumProgram.model_validate(data)
 
     @classmethod
     async def get_analyzer_app_data(
-        cls, params: analysis_result.DataID
+        cls,
+        params: analysis_result.DataID,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> generator_result.QuantumProgram:
         data = await cls._call_task(
             http_method=HTTPMethod.GET,
             url=f"{routes.ANALYZER_DATA_FULL_PATH}/{params.id}",
+            http_client=http_client,
         )
-        return generator_result.QuantumProgram.parse_obj(data)
+        return generator_result.QuantumProgram.model_validate(data)
 
     @classmethod
     async def call_rb_analysis_task(
-        cls, params: AnalysisRBParams
+        cls,
+        params: AnalysisRBParams,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> analysis_result.RbResults:
         data = await cls._call_task(
             http_method=HTTPMethod.POST,
             url=routes.ANALYZER_RB_FULL_PATH,
-            body=params.dict(),
+            body=params.model_dump(),
+            http_client=http_client,
         )
 
-        return analysis_result.RbResults.parse_obj(data)
+        return analysis_result.RbResults.model_validate(data)
 
     @classmethod
     async def call_hardware_connectivity_task(
-        cls, params: analysis_params.AnalysisHardwareParams
+        cls,
+        params: analysis_params.AnalysisHardwareParams,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> analysis_result.GraphResult:
         data = await cls._call_task_pydantic(
             http_method=HTTPMethod.POST,
             url=routes.ANALYZER_HC_GRAPH_FULL_PATH,
             model=params,
+            http_client=http_client,
         )
-        return analysis_result.GraphResult.parse_obj(data)
+        return analysis_result.GraphResult.model_validate(data)
 
     @classmethod
     async def call_table_graphs_task(
         cls,
         params: analysis_params.AnalysisHardwareListParams,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> analysis_result.GraphResult:
         poller = JobPoller(base_url=routes.ANALYZER_HC_TABLE_GRAPH_FULL_PATH)
-        result = await poller.run_pydantic(params, timeout_sec=None)
+        result = await poller.run_pydantic(
+            params, timeout_sec=None, http_client=http_client
+        )
         return _parse_job_response(result, analysis_result.GraphResult)
 
     @classmethod
     async def call_available_devices_task(
         cls,
         params: analysis_params.AnalysisOptionalDevicesParams,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> analysis_result.DevicesResult:
-        data = await cls._call_task(
-            http_method=HTTPMethod.POST,
-            url=routes.ANALYZER_OPTIONAL_DEVICES_FULL_PATH,
-            body=params.dict(),
+        hardware_info = await cls.call_get_all_hardware_devices(http_client=http_client)
+        return cls._get_devices_from_hardware_info(hardware_info, params)
+
+    @staticmethod
+    def _get_devices_from_hardware_info(
+        hardware_info: list[HardwareInformation],
+        params: analysis_params.AnalysisOptionalDevicesParams,
+    ) -> analysis_result.DevicesResult:
+        available_hardware: dict[Provider, dict[str, bool]] = {
+            Provider.IBM_QUANTUM: {},
+            Provider.AMAZON_BRAKET: {},
+            Provider.AZURE_QUANTUM: {},
+        }
+        for info in hardware_info:
+            if info.provider not in available_hardware:
+                continue
+            is_available = info.number_of_qubits >= params.qubit_count
+            available_hardware[info.provider][info.display_name] = is_available
+        return analysis_result.DevicesResult(
+            devices=analysis_result.AvailableHardware(
+                ibm_quantum=available_hardware[Provider.IBM_QUANTUM],
+                azure_quantum=available_hardware[Provider.AZURE_QUANTUM],
+                amazon_braket=available_hardware[Provider.AMAZON_BRAKET],
+            ),
+            status=GraphStatus.SUCCESS,
         )
-        return analysis_result.DevicesResult.parse_obj(data)
+
+    @classmethod
+    async def call_get_all_hardware_devices(
+        cls,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> list[HardwareInformation]:
+        data = await client().call_api(
+            http_method=HTTPMethod.GET,
+            url="/hardware-catalog/v1/hardwares",
+            use_versioned_url=False,
+            http_client=http_client,
+        )
+        if not isinstance(data, list):
+            raise ClassiqAPIError(f"Unexpected value: {data}")
+        return [HardwareInformation.model_validate(info) for info in data]
 
     @classmethod
     async def call_generate_hamiltonian_task(
-        cls, problem: ground_state_problem.CHEMISTRY_PROBLEMS_TYPE
+        cls,
+        problem: ground_state_problem.CHEMISTRY_PROBLEMS_TYPE,
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> operator.PauliOperator:
         poller = JobPoller(
             base_url=routes.GENERATE_HAMILTONIAN_FULL_PATH,
-            use_versioned_url=False,
         )
-        result = await poller.run_pydantic(problem, timeout_sec=None)
+        result = await poller.run_pydantic(
+            problem, timeout_sec=None, http_client=http_client
+        )
         return _parse_job_response(result, operator.PauliOperator)
+
+    @classmethod
+    async def call_iqcc_init_auth(
+        cls,
+        data: IQCCInitAuthData,
+        http_client: Optional[httpx.AsyncClient] = 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: Optional[httpx.AsyncClient] = None,
+    ) -> Optional[IQCCProbeAuthResponse]:
+        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)