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

classiq/_internals/jobs.py

@@ -1,24 +1,20 @@
 import json
 import logging
-from typing import Callable, Dict, Iterable, Optional, Set, TypeVar
+from collections.abc import Iterable
+from typing import Callable, Optional, TypeVar
 
 import httpx
 import pydantic
 
-from classiq.interface.jobs import (
-    JobDescriptionBase,
-    JobDescriptionUnion,
-    JobID,
-    JSONObject,
-)
+from classiq.interface.exceptions import ClassiqAPIError
+from classiq.interface.jobs import JobDescription, JobID, JSONObject
 
 from classiq._internals.async_utils import poll_for
-from classiq._internals.client import client, try_again_on_failure
+from classiq._internals.client import client
 from classiq._internals.config import SDKMode
-from classiq.exceptions import ClassiqAPIError
 
 _URL_PATH_SEP = "/"
-GeneralJobDescription = JobDescriptionBase[JSONObject]
+GeneralJobDescription = JobDescription[JSONObject]
 _logger = logging.getLogger(__name__)
 T = TypeVar("T")
 
@@ -42,26 +38,24 @@ def _join_url_path(*parts: str) -> str:
 def _general_job_description_parser(
     json_response: JSONObject,
 ) -> Optional[GeneralJobDescription]:
-    job_description = JobDescriptionUnion[JSONObject].parse_obj(json_response)
-    if job_description.__root__.status.is_final():
-        return job_description.__root__
+    job_description = GeneralJobDescription.model_validate(json_response)
+    if job_description.status.is_final():
+        return job_description
     return None
 
 
 class JobPoller:
-    INITIAL_INTERVAL_SEC = 1
-    INTERVAL_FACTOR = 2
-    FINAL_INTERVAL_SEC = INITIAL_INTERVAL_SEC * INTERVAL_FACTOR**5  # 32 secs
+    INITIAL_INTERVAL_SEC = 0.1
+    INTERVAL_FACTOR = 1.5
+    FINAL_INTERVAL_SEC = 25
     DEV_INTERVAL = 0.05
 
     def __init__(
         self,
         base_url: str,
-        required_headers: Optional[Set[str]] = None,
         use_versioned_url: bool = True,
-        additional_headers: Optional[Dict[str, str]] = None,
+        additional_headers: Optional[dict[str, str]] = None,
     ) -> None:
-        self._required_headers = required_headers or set()
         self._additional_headers = additional_headers
         client_instance = client()
         self._base_url = (
@@ -69,11 +63,10 @@ class JobPoller:
             if use_versioned_url
             else base_url
         )
-        self._async_client = client_instance.async_client()
         self._mode = client_instance.config.mode
 
     def _parse_job_id_response(self, response: httpx.Response) -> JobID:
-        return JobID.parse_obj(response.json())
+        return JobID.model_validate(response.json())
 
     def _make_poll_url(self, job_id: JobID) -> str:
         return _join_url_path(self._base_url, job_id.job_id)
@@ -82,37 +75,33 @@ class JobPoller:
     def _make_cancel_url(poll_url: str) -> str:
         return _join_url_path(poll_url, "cancel")
 
-    def _update_headers(self, response: httpx.Response) -> None:
-        for header in self._required_headers:
-            try:
-                self._async_client.headers[header] = response.headers[header]
-            except KeyError as exc:
-                raise ClassiqAPIError(
-                    f"Response to {self._base_url} is missing header {header}"
-                ) from exc
-
-    @try_again_on_failure
     async def _request(
-        self, http_method: str, url: str, body: Optional[Dict] = None
+        self,
+        http_client: httpx.AsyncClient,
+        http_method: str,
+        url: str,
+        body: Optional[dict] = None,
     ) -> httpx.Response:
-        # Update headers in case they change
-        self._async_client.headers.update(client().get_headers())
-        response = await self._async_client.request(
-            method=http_method, url=url, json=body, headers=self._additional_headers
+        return await client().request(
+            http_client=http_client,
+            method=http_method,
+            url=url,
+            json=body,
+            headers=self._additional_headers,
         )
-        client().handle_response(response)
-        return response
 
-    async def _submit(self, body: Dict) -> httpx.Response:
-        return await self._request(http_method="POST", url=self._base_url, body=body)
+    async def _submit(
+        self, http_client: httpx.AsyncClient, body: dict
+    ) -> httpx.Response:
+        return await self._request(
+            http_client=http_client, http_method="POST", url=self._base_url, body=body
+        )
 
     def _interval_sec(self) -> Iterable[float]:
         if self._mode == SDKMode.DEV:
             while True:
                 yield self.DEV_INTERVAL
         else:
-            for _ in range(10):
-                yield self.INITIAL_INTERVAL_SEC
             interval = self.INITIAL_INTERVAL_SEC
             while True:
                 yield interval
@@ -120,13 +109,16 @@ class JobPoller:
 
     async def _poll(
         self,
+        http_client: httpx.AsyncClient,
         poll_url: str,
         timeout_sec: Optional[float],
         response_parser: Callable[[JSONObject], Optional[T]] = _general_job_description_parser,  # type: ignore[assignment]
     ) -> T:
         async def poller() -> JSONObject:
             nonlocal self, poll_url
-            raw_response = await self._request(http_method="GET", url=poll_url)
+            raw_response = await self._request(
+                http_client=http_client, http_method="GET", url=poll_url
+            )
             return raw_response.json()
 
         async for json_response in poll_for(
@@ -142,39 +134,50 @@ class JobPoller:
         job_id: JobID,
         timeout_sec: Optional[float],
         response_parser: Callable[[JSONObject], Optional[T]] = _general_job_description_parser,  # type: ignore[assignment]
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> T:
         poll_url = self._make_poll_url(job_id=job_id)
-        async with self._async_client:
+        async with client().use_client_or_create(http_client) as async_client:
             return await self._poll(
+                http_client=async_client,
                 poll_url=poll_url,
                 response_parser=response_parser,
                 timeout_sec=timeout_sec,
             )
 
-    async def _cancel(self, poll_url: str) -> None:
+    async def _cancel(self, http_client: httpx.AsyncClient, poll_url: str) -> None:
         _logger.info("Cancelling job %s", poll_url, exc_info=True)
         cancel_url = self._make_cancel_url(poll_url)
-        await self._request(http_method="PUT", url=cancel_url)
+        await self._request(http_client=http_client, http_method="PUT", url=cancel_url)
 
     async def run(
-        self, body: Dict, timeout_sec: Optional[float]
+        self,
+        body: dict,
+        timeout_sec: Optional[float],
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> GeneralJobDescription:
-        async with self._async_client:
-            submit_response = await self._submit(body=body)
+        async with client().use_client_or_create(http_client) as async_client:
+            submit_response = await self._submit(http_client=async_client, body=body)
             job_id = self._parse_job_id_response(response=submit_response)
             poll_url = self._make_poll_url(job_id=job_id)
-            self._update_headers(response=submit_response)
             try:
-                return await self._poll(poll_url=poll_url, timeout_sec=timeout_sec)
+                return await self._poll(
+                    http_client=async_client,
+                    poll_url=poll_url,
+                    timeout_sec=timeout_sec,
+                )
             except Exception:
-                await self._cancel(poll_url=poll_url)
+                await self._cancel(http_client=async_client, poll_url=poll_url)
                 raise
 
     async def run_pydantic(
-        self, model: pydantic.BaseModel, timeout_sec: Optional[float]
+        self,
+        model: pydantic.BaseModel,
+        timeout_sec: Optional[float],
+        http_client: Optional[httpx.AsyncClient] = None,
     ) -> GeneralJobDescription:
         # 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())
-        return await self.run(body, timeout_sec)
+        # This was added because JSON serializer doesn't serialize complex and UUID,
+        # while pydantic does. We should add support for smarter json serialization.
+        body = json.loads(model.model_dump_json())
+        return await self.run(body, timeout_sec, http_client=http_client)

classiq/_internals/type_validation.py

@@ -1,4 +1,4 @@
-from typing import Any, Tuple, Type, TypeVar, Union, overload
+from typing import Any, TypeVar, Union, overload
 
 T = TypeVar("T")
 U = TypeVar("U")
@@ -10,37 +10,37 @@ U = TypeVar("U")
 
 @overload
 def validate_type(
-    obj: Any, expected_type: Type[T], operation: str, exception_type: Type[Exception]
+    obj: Any, expected_type: type[T], operation: str, exception_type: type[Exception]
 ) -> T: ...
 
 
 @overload
 def validate_type(
     obj: Any,
-    expected_type: Tuple[Type[T], Type[U]],
+    expected_type: tuple[type[T], type[U]],
     operation: str,
-    exception_type: Type[Exception],
+    exception_type: type[Exception],
 ) -> Union[T, U]: ...
 
 
 @overload
 def validate_type(
     obj: Any,
-    expected_type: Tuple[Type[T], ...],
+    expected_type: tuple[type[T], ...],
     operation: str,
-    exception_type: Type[Exception],
+    exception_type: type[Exception],
 ) -> Any: ...
 
 
 def validate_type(
     obj: Any,
-    expected_type: Union[Tuple[type, ...], type],
+    expected_type: Union[tuple[type, ...], type],
     operation: str,
-    exception_type: Type[Exception],
+    exception_type: type[Exception],
 ) -> Any:
     operation = operation[0].upper() + operation[1:]
     if not isinstance(obj, expected_type):
-        expected_types: Tuple[type, ...]
+        expected_types: tuple[type, ...]
         if isinstance(expected_type, type):
             expected_types = (expected_type,)
         else:

classiq/analyzer/__init__.py

@@ -1,5 +1,3 @@
-from typing import List
-
 import classiq.analyzer.show_interactive_hack
 from classiq.analyzer.analyzer import Analyzer
 
@@ -8,5 +6,5 @@ from ..analyzer import rb
 __all__ = ["rb"]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return ["rb"]

classiq/analyzer/analyzer.py

@@ -2,14 +2,16 @@
 
 import json
 import webbrowser
+from collections.abc import Sequence
 from importlib.util import find_spec
-from typing import Any, Dict, List, Optional, Sequence, Union
+from typing import Any, Optional, Union
 from urllib.parse import urljoin
 
 import plotly.graph_objects as go
 
 from classiq.interface.analyzer import analysis_params
 from classiq.interface.backend.quantum_backend_providers import AnalyzerProviderVendor
+from classiq.interface.exceptions import ClassiqAnalyzerError
 from classiq.interface.generator import quantum_program as generator_result
 
 from classiq._internals import async_utils, client
@@ -20,7 +22,6 @@ from classiq.analyzer.analyzer_utilities import (
     ProviderNameEnum,
 )
 from classiq.analyzer.url_utils import circuit_page_uri, client_ide_base_url
-from classiq.exceptions import ClassiqAnalyzerError
 
 find_ipywidgets = find_spec("ipywidgets")
 VBox = Any
@@ -38,7 +39,7 @@ class Analyzer(AnalyzerUtilities):
         """Init self.
 
         Args:
-            circuit (): The circuit to be analyzed.
+            circuit: The circuit to be analyzed.
         """
         if circuit.qasm is None:
             raise ClassiqAnalyzerError(
@@ -79,16 +80,18 @@ class Analyzer(AnalyzerUtilities):
         )
 
     def get_available_devices(
-        self, providers: Optional[List[ProviderNameEnum]] = None
-    ) -> Dict[ProviderNameEnum, List[DeviceName]]:
-        """Returns dict of the available devices by the providers. only devices
+        self, providers: Optional[list[ProviderNameEnum]] = None
+    ) -> dict[ProviderNameEnum, list[DeviceName]]:
+        """Deprecated. Use get_all_hardware_devices instead.
+
+        Returns dict of the available devices by the providers. only devices
         with sufficient number of qubits are returns
 
-        Args: providers (): List of providers (string or `AnalyzerProviderVendor`).
+        Args: providers: List of providers.
         if None, the table include all the available hardware.
 
         Returns:
-            available devices (): dict of the available devices (Dict[str,List[str]]).
+            available devices: dict of the available devices.
         """
         if providers is None:
             providers = list(AnalyzerProviderVendor)
@@ -107,10 +110,10 @@ class Analyzer(AnalyzerUtilities):
         analyzer_sdk extra.
 
         Args:
-            provider (): provider name (optional - string or `AnalyzerProviderVendor`).
-            device (): device name (optional - string).
+            provider: provider name.
+            device: device name.
         Returns:
-         hardware_connectivity_graph (): interactive graph.
+         hardware_connectivity_graph: interactive graph.
         """
 
         self._validate_analyzer_extra()
@@ -131,16 +134,18 @@ class Analyzer(AnalyzerUtilities):
     def get_hardware_comparison_table(
         self,
         providers: Optional[Sequence[Union[str, AnalyzerProviderVendor]]] = None,
-        devices: Optional[List[str]] = None,
+        devices: Optional[list[str]] = None,
     ) -> None:
         """create a comparison table between the transpiled circuits result on different hardware.
         The  comparison table included the depth, multi qubit gates count,and total gates count of the circuits.
 
-        Args: providers (): List of providers (string or `AnalyzerProviderVendor`). if None, the table include all
-        the available hardware.
-        devices (): List of devices (string). if None, the table include all the available devices of the selected
+        Args:
+            providers: List of providers. if None, the table include all the available hardware.
+            devices: List of devices. if None, the table include all the available devices of the selected
         providers.
-        Returns: None.
+
+        Returns:
+            None.
         """
         if providers is None:
             providers = list(AnalyzerProviderVendor)
@@ -155,8 +160,8 @@ class Analyzer(AnalyzerUtilities):
 
     def plot_hardware_comparison_table(
         self,
-        providers: Optional[List[Union[str, AnalyzerProviderVendor]]] = None,
-        devices: Optional[List[str]] = None,
+        providers: Optional[list[Union[str, AnalyzerProviderVendor]]] = None,
+        devices: Optional[list[str]] = None,
     ) -> None:
         """plot the comparison table. if it has not been created it, it first creates the table using all the
         available hardware.
@@ -170,7 +175,7 @@ class Analyzer(AnalyzerUtilities):
     def _hardware_comparison_condition(
         self,
         providers: Optional[Sequence[Union[str, AnalyzerProviderVendor]]] = None,
-        devices: Optional[List[str]] = None,
+        devices: Optional[list[str]] = None,
     ) -> None:
         if (
             providers is not None

classiq/analyzer/analyzer_utilities.py

@@ -1,11 +1,11 @@
-from typing import Dict, List, Union
+from typing import Union
 
 from classiq.interface.analyzer import analysis_params
 from classiq.interface.backend.quantum_backend_providers import AnalyzerProviderVendor
+from classiq.interface.exceptions import ClassiqAnalyzerError
 from classiq.interface.generator.quantum_program import QuantumProgram
 
 from classiq._internals.api_wrapper import ApiWrapper
-from classiq.exceptions import ClassiqAnalyzerError
 
 DeviceName = str
 ProviderName = str
@@ -13,9 +13,9 @@ ProviderLowerName = str
 HardwareGraphJson = str
 Availability = bool
 ProviderNameEnum = Union[ProviderName, AnalyzerProviderVendor]
-AvailableDevices = Dict[DeviceName, Availability]
-ProviderAvailableDevices = Dict[ProviderLowerName, AvailableDevices]
-HardwareGraphs = Dict[DeviceName, HardwareGraphJson]
+AvailableDevices = dict[DeviceName, Availability]
+ProviderAvailableDevices = dict[ProviderLowerName, AvailableDevices]
+HardwareGraphs = dict[DeviceName, HardwareGraphJson]
 
 
 class AnalyzerUtilities:
@@ -32,7 +32,7 @@ class AnalyzerUtilities:
         self.hardware_graphs = hardware_graphs
 
     async def _request_available_devices_async(
-        self, providers: List[ProviderNameEnum]
+        self, providers: list[ProviderNameEnum]
     ) -> None:
         requested_providers = self._requested_providers_filter(providers)
         if not requested_providers:
@@ -41,7 +41,7 @@ class AnalyzerUtilities:
             qubit_count=self.circuit.data.width, providers=requested_providers
         )
         result = await ApiWrapper.call_available_devices_task(params=params)
-        self.available_devices.update(result.devices.dict())
+        self.available_devices.update(result.devices.model_dump())
 
     async def request_hardware_connectivity_async(
         self, provider: ProviderNameEnum, device: DeviceName
@@ -69,8 +69,8 @@ class AnalyzerUtilities:
             )
 
     def _requested_providers_filter(
-        self, providers: List[ProviderNameEnum]
-    ) -> List[ProviderNameEnum]:
+        self, providers: list[ProviderNameEnum]
+    ) -> list[ProviderNameEnum]:
         return list(
             filter(
                 lambda provider: self.available_devices.get(_to_lower_case(provider))
@@ -81,7 +81,7 @@ class AnalyzerUtilities:
 
     def _filter_devices_by_qubits_count(
         self, provider: ProviderNameEnum
-    ) -> List[DeviceName]:
+    ) -> list[DeviceName]:
         device_avail_dict = self.available_devices[_to_lower_case(provider)]
         return list(
             filter(lambda device: device_avail_dict[device], device_avail_dict.keys())

classiq/analyzer/rb.py

@@ -1,5 +1,5 @@
-from enum import Enum
-from typing import Dict, List, Optional, Set, Union
+from enum import Enum as PythonEnum
+from typing import Optional, Union
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -8,14 +8,14 @@ import plotly.graph_objects as go
 
 from classiq.interface.analyzer.analysis_params import AnalysisRBParams
 from classiq.interface.analyzer.result import RbResults
+from classiq.interface.exceptions import ClassiqAnalyzerError
 
 from classiq._internals.api_wrapper import ApiWrapper
-from classiq.exceptions import ClassiqAnalyzerError
 from classiq.executor import BackendPreferencesAndResult
 
 
 class RBAnalysis:
-    def __init__(self, experiments_data: List[AnalysisRBParams]) -> None:
+    def __init__(self, experiments_data: list[AnalysisRBParams]) -> None:
         """Init self.
 
         Args:
@@ -25,8 +25,8 @@ class RBAnalysis:
         self.experiments_data = experiments_data
         self._total_results: pd.DataFrame = pd.DataFrame()
 
-    async def _get_multiple_hardware_results_async(self) -> Dict[str, RbResults]:
-        total_result: Dict[str, RbResults] = {}
+    async def _get_multiple_hardware_results_async(self) -> dict[str, RbResults]:
+        total_result: dict[str, RbResults] = {}
         for batch in self.experiments_data:
             if len(batch.num_clifford) < 5:
                 raise ClassiqAnalyzerError(
@@ -38,7 +38,7 @@ class RBAnalysis:
         return total_result
 
     @staticmethod
-    def _get_df_indices(results: Dict[str, RbResults]) -> List[str]:
+    def _get_df_indices(results: dict[str, RbResults]) -> list[str]:
         temp_res = results.copy()
         _, rb_result_keys = temp_res.popitem()
         return list(rb_result_keys.__dict__.keys())
@@ -78,22 +78,22 @@ class RBAnalysis:
         return fig
 
 
-def _strict_string(arg: Union[Enum, str]) -> str:
-    if isinstance(arg, Enum):
+def _strict_string(arg: Union[PythonEnum, str]) -> str:
+    if isinstance(arg, PythonEnum):
         return arg.value
     return arg
 
 
 def order_executor_data_by_hardware(
-    mixed_data: List[BackendPreferencesAndResult],
-) -> List[AnalysisRBParams]:
-    hardware_names: Set[str] = {
+    mixed_data: list[BackendPreferencesAndResult],
+) -> list[AnalysisRBParams]:
+    hardware_names: set[str] = {
         _strict_string(hardware.backend_name) for hardware, _, _ in mixed_data
     }
-    counts_dicts: Dict[str, List[Dict[str, int]]] = {
+    counts_dicts: dict[str, list[dict[str, int]]] = {
         name: list() for name in hardware_names
     }
-    cliffords_dicts: Dict[str, List[int]] = {name: list() for name in hardware_names}
+    cliffords_dicts: dict[str, list[int]] = {name: list() for name in hardware_names}
     for hardware, num_clifford, result in mixed_data:
         hw_name: str = _strict_string(hardware.backend_name)
         counts_dicts[hw_name].append(result.counts)  # type: ignore[union-attr]
@@ -110,7 +110,7 @@ def order_executor_data_by_hardware(
 
 
 def fit_to_exponential_function(
-    result: RbResults, num_clifford: List[int], ax: Optional[plt.Axes] = None
+    result: RbResults, num_clifford: list[int], ax: Optional[plt.Axes] = None
 ) -> None:
     if ax is None:
         plt.figure()

classiq/analyzer/show_interactive_hack.py

@@ -1,6 +1,8 @@
 import webbrowser
 from urllib.parse import urljoin
 
+from classiq.interface.exceptions import ClassiqAnalyzerVisualizationError
+from classiq.interface.generator.model.preferences.preferences import QuantumFormat
 from classiq.interface.generator.quantum_program import QuantumProgram
 
 from classiq._internals.api_wrapper import ApiWrapper
@@ -8,18 +10,39 @@ from classiq._internals.async_utils import syncify_function
 from classiq.analyzer.url_utils import circuit_page_uri, client_ide_base_url
 
 
-async def handle_remote_app(circuit: QuantumProgram) -> None:
+async def handle_remote_app(circuit: QuantumProgram, display_url: bool = True) -> None:
+    if circuit.outputs.get(QuantumFormat.QASM) is None:
+        raise ClassiqAnalyzerVisualizationError(
+            "Missing QASM transpilation: visualization is only supported "
+            "for QASM programs. Try adding QASM to the output formats "
+            "synthesis preferences"
+        )
     circuit_dataid = await ApiWrapper.call_analyzer_app(circuit)
     app_url = urljoin(
         client_ide_base_url(),
         circuit_page_uri(circuit_id=circuit_dataid.id, circuit_version=circuit.version),
     )
-    print(f"Opening: {app_url}")  # noqa: T201
+
+    if display_url:
+        print(f"Opening: {app_url}")  # noqa: T201
+
     webbrowser.open_new_tab(app_url)
 
 
-async def _show_interactive(self: QuantumProgram) -> None:
-    await handle_remote_app(circuit=self)
+async def _show_interactive(self: QuantumProgram, display_url: bool = True) -> None:
+    """
+    Displays the interactive representation of the quantum program in the Classiq IDE.
+
+    Args:
+        self:
+            The serialized quantum program to be displayed.
+        display_url:
+            Whether to print the url
+
+    Links:
+        [Visualization tool](https://docs.classiq.io/latest/reference-manual/analyzer/quantum-program-visualization-tool/)
+    """
+    await handle_remote_app(self, display_url)
 
 
 QuantumProgram.show = syncify_function(_show_interactive)  # type: ignore[attr-defined]

classiq/analyzer/url_utils.py

@@ -1,6 +1,5 @@
 import urllib
 from urllib.parse import urljoin
-from uuid import UUID
 
 from classiq.interface.server import routes
 
@@ -21,7 +20,7 @@ def versioned_url_params(circuit_version: str) -> str:
     )
 
 
-def circuit_page_uri(circuit_id: UUID, circuit_version: str) -> str:
-    url = urljoin(f"{routes.ANALYZER_CIRCUIT_PAGE}/", str(circuit_id))
+def circuit_page_uri(circuit_id: str, circuit_version: str) -> str:
+    url = urljoin(f"{routes.ANALYZER_CIRCUIT_PAGE}/", circuit_id)
     url += versioned_url_params(circuit_version=circuit_version)
     return url

classiq/applications/__init__.py

@@ -1,17 +1,8 @@
-from typing import List
-
-from classiq.applications import (
-    benchmarking,
-    chemistry,
-    combinatorial_optimization,
-    finance,
-    qsvm,
-)
+from classiq.applications import chemistry, combinatorial_optimization, finance, qsvm
 
 __all__ = [
-    "benchmarking",
-    "combinatorial_optimization",
     "chemistry",
+    "combinatorial_optimization",
     "finance",
     "qsvm",
 ]
@@ -20,5 +11,5 @@ __all__ = [
 _NON_IMPORTED_PUBLIC_SUBMODULES = ["qnn"]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__ + _NON_IMPORTED_PUBLIC_SUBMODULES