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

classiq/_internals/authentication/password_manager.py

@@ -5,7 +5,7 @@ import os
 import pathlib
 import platform
 import stat
-from typing import Any, Optional
+from typing import Any
 
 import keyring
 from keyring.backends import fail
@@ -42,27 +42,27 @@ class PasswordManager(abc.ABC):
         self._settings = PasswordManagerSettings()
 
     @property
-    def access_token(self) -> Optional[str]:
+    def access_token(self) -> str | None:
         return self._get(key=self._settings.ACCESS_TOKEN_KEY)
 
     @access_token.setter
-    def access_token(self, access_token: Optional[str]) -> None:
+    def access_token(self, access_token: str | None) -> None:
         self._set(key=self._settings.ACCESS_TOKEN_KEY, value=access_token)
 
     @property
-    def refresh_token(self) -> Optional[str]:
+    def refresh_token(self) -> str | None:
         return self._get(key=self._settings.REFRESH_TOKEN_KEY)
 
     @refresh_token.setter
-    def refresh_token(self, refresh_token: Optional[str]) -> None:
+    def refresh_token(self, refresh_token: str | None) -> None:
         self._set(key=self._settings.REFRESH_TOKEN_KEY, value=refresh_token)
 
     @abc.abstractmethod
-    def _get(self, key: str) -> Optional[str]:
+    def _get(self, key: str) -> str | None:
         pass
 
     @abc.abstractmethod
-    def _set(self, key: str, value: Optional[str]) -> None:
+    def _set(self, key: str, value: str | None) -> None:
         pass
 
     @abc.abstractmethod
@@ -76,10 +76,10 @@ class PasswordManager(abc.ABC):
 
 
 class KeyringPasswordManager(PasswordManager):
-    def _get(self, key: str) -> Optional[str]:
+    def _get(self, key: str) -> str | None:
         return keyring.get_password(service_name=self._SERVICE_NAME, username=key)
 
-    def _set(self, key: str, value: Optional[str]) -> None:
+    def _set(self, key: str, value: str | None) -> None:
         if value is None:
             self._clear(key)
             return
@@ -101,10 +101,10 @@ class KeyringPasswordManager(PasswordManager):
 
 
 class DummyPasswordManager(PasswordManager):
-    def _get(self, key: str) -> Optional[str]:
+    def _get(self, key: str) -> str | None:
         return None
 
-    def _set(self, key: str, value: Optional[str]) -> None:
+    def _set(self, key: str, value: str | None) -> None:
         return
 
     def _clear(self, key: str) -> None:
@@ -134,13 +134,13 @@ class FilePasswordManager(PasswordManager):
             return json.loads(self.credentials_file.read_text())
         return {}
 
-    def _get(self, key: str) -> Optional[str]:
+    def _get(self, key: str) -> str | None:
         token_dict = self._get_token_dict()
         if key in token_dict:
             return token_dict[key]
         return None
 
-    def _set(self, key: str, value: Optional[str]) -> None:
+    def _set(self, key: str, value: str | None) -> None:
         token_dict = self._get_token_dict()
         token_dict[key] = value
         self._update_file(token_dict)

classiq/_internals/authentication/token_manager.py

@@ -3,7 +3,6 @@ import logging
 import threading
 import warnings
 from collections.abc import Sequence
-from typing import Optional
 
 from classiq.interface.exceptions import (
     ClassiqAuthenticationError,
@@ -26,7 +25,7 @@ class TokenManager:
     def __init__(
         self,
         config: Configuration,
-        password_manager: Optional[pm.PasswordManager] = None,
+        password_manager: pm.PasswordManager | None = None,
     ) -> None:
         self._config = config
         if password_manager is None:
@@ -35,8 +34,8 @@ class TokenManager:
         # to a specific event loop, which is undesirable
         self._lock = threading.Lock()
         self._password_manager: pm.PasswordManager = password_manager
-        self._access_token: Optional[str] = self._password_manager.access_token
-        self._refresh_token: Optional[str] = self._password_manager.refresh_token
+        self._access_token: str | None = self._password_manager.access_token
+        self._refresh_token: str | None = self._password_manager.refresh_token
         if self._access_token is None and self._refresh_token is not None:
             _logger.info(
                 "Inconsistent state, access token is absent and refresh token is present."
@@ -67,7 +66,7 @@ class TokenManager:
             "Password Manager not found, we could not store your credentials securely. Please contact support@classiq.io"
         )
 
-    def get_access_token(self) -> Optional[str]:
+    def get_access_token(self) -> str | None:
         return self._access_token
 
     async def _refresh(self) -> None:

classiq/_internals/client.py

@@ -7,9 +7,8 @@ import os
 import platform
 import sys
 import time
-from collections.abc import Awaitable
-from types import TracebackType
-from typing import Any, Callable, NoReturn, Optional, TypeVar, Union
+from collections.abc import Awaitable, Callable
+from typing import Any, NoReturn, TypeVar
 
 import httpx
 from typing_extensions import ParamSpec
@@ -146,27 +145,6 @@ def try_again_on_failure(
     return wrapper
 
 
-class _AsyncNullContext(contextlib.AbstractAsyncContextManager):
-    """
-    This class is meant to replace `contextlib.nullcontext`, which hadn't supported
-    async context manager until python 3.10.
-    """
-
-    def __init__(self, enter_result: Any = None) -> None:
-        self._enter_result = enter_result
-
-    async def __aenter__(self) -> Any:
-        return self._enter_result
-
-    async def __aexit__(
-        self,
-        exc_type: Optional[type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> None:
-        pass
-
-
 class Client:
     _UNKNOWN_VERSION = HostChecker._UNKNOWN_VERSION
     _SESSION_HEADER = "Classiq-Session"
@@ -177,7 +155,7 @@ class Client:
         self._config = conf
         self._token_manager = token_manager.TokenManager(config=self._config)
         self._api_prefix = self._make_api_prefix()
-        self._session_id: Optional[str] = None
+        self._session_id: str | None = None
 
     @staticmethod
     def _make_api_prefix() -> str:
@@ -229,9 +207,9 @@ class Client:
         http_client: httpx.AsyncClient,
         method: str,
         url: str,
-        json: Optional[dict] = None,
-        params: Optional[dict] = None,
-        headers: Optional[dict[str, str]] = None,
+        json: dict | None = None,
+        params: dict | None = None,
+        headers: dict[str, str] | None = None,
     ) -> httpx.Response:
         http_client.headers.update(self._get_headers())
 
@@ -265,12 +243,12 @@ class Client:
         self,
         http_method: str,
         url: str,
-        body: Optional[dict] = None,
-        params: Optional[dict] = None,
+        body: dict | None = None,
+        params: dict | None = None,
         use_versioned_url: bool = True,
-        headers: Optional[dict[str, str]] = None,
-        http_client: Optional[httpx.AsyncClient] = None,
-    ) -> Union[dict, list, str]:
+        headers: dict[str, str] | None = None,
+        http_client: httpx.AsyncClient | None = None,
+    ) -> dict | list | str:
         if use_versioned_url:
             url = self.make_versioned_url(url)
         async with self.use_client_or_create(http_client) as async_client:
@@ -285,26 +263,21 @@ class Client:
             return response.json()
 
     def use_client_or_create(
-        self, http_client: Optional[httpx.AsyncClient]
+        self, http_client: httpx.AsyncClient | None
     ) -> contextlib.AbstractAsyncContextManager[httpx.AsyncClient]:
         if http_client is None:
             return self.async_client()
         else:
-            if sys.version_info[0:2] < (3, 10):
-                # remove this `if` and the `_AsyncNullContext` class when we stop
-                # supporting python 3.9
-                return _AsyncNullContext(enter_result=http_client)
-            else:
-                return contextlib.nullcontext(enter_result=http_client)
+            return contextlib.nullcontext(enter_result=http_client)
 
     def sync_call_api(
         self,
         http_method: str,
         url: str,
-        body: Optional[dict] = None,
-        headers: Optional[dict] = None,
+        body: dict | None = None,
+        headers: dict | None = None,
         use_versioned_url: bool = True,
-    ) -> Union[dict, str]:
+    ) -> dict | str:
         if use_versioned_url:
             url = self.make_versioned_url(url)
         with httpx.Client(**self._make_client_args()) as sync_client:
@@ -356,7 +329,7 @@ class Client:
         return self._config
 
 
-DEFAULT_CLIENT: Optional[Client] = None
+DEFAULT_CLIENT: Client | None = None
 
 
 def client() -> Client:

classiq/_internals/config.py

@@ -2,7 +2,6 @@
 
 import os
 import pathlib
-from typing import Optional, Union
 
 import configargparse  # type: ignore[import]
 import pydantic
@@ -53,7 +52,7 @@ if os.name == "posix":
     ] + _DEFAULT_CONFIG_FILES
 
 
-def init(args: Optional[Union[str, list[str]]] = None) -> Configuration:
+def init(args: str | list[str] | None = None) -> Configuration:
     """Initialize the configuration object.
 
     Args:

classiq/_internals/help.py

@@ -1,12 +1,11 @@
 import webbrowser
-from typing import Optional
 
 from classiq.interface._version import SEMVER_VERSION
 
 DOCS_BASE_URL = "https://docs.classiq.io/"
 
 
-def open_help(version: Optional[str] = None) -> None:
+def open_help(version: str | None = None) -> None:
     if version is None:
         version = SEMVER_VERSION
     if version == "0.0.0":

classiq/_internals/host_checker.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 import warnings
 from datetime import datetime
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 import httpx
 import pydantic
@@ -38,7 +38,7 @@ class HostChecker:
         self._client_version = client_version
         self._interface_version = interface_version
 
-    def _get_interface_version(self) -> Optional[str]:
+    def _get_interface_version(self) -> str | None:
         global_interfaces = GlobalVersions.model_validate(
             self._client.sync_call_api(
                 "get", "/interface_versions", use_versioned_url=False
@@ -52,7 +52,7 @@ class HostChecker:
         )
         return host.classiq_interface
 
-    def _get_deprecation_info(self) -> Optional[DeprecationInfo]:
+    def _get_deprecation_info(self) -> DeprecationInfo | None:
         global_versions = GlobalVersions.model_validate(
             self._client.sync_call_api("get", "/versions", use_versioned_url=False)
         )

classiq/_internals/jobs.py

@@ -1,7 +1,7 @@
 import json
 import logging
-from collections.abc import Iterable
-from typing import Callable, Optional, TypeVar
+from collections.abc import Callable, Iterable
+from typing import TypeVar
 
 import httpx
 import pydantic
@@ -37,7 +37,7 @@ def _join_url_path(*parts: str) -> str:
 
 def _general_job_description_parser(
     json_response: JSONObject,
-) -> Optional[GeneralJobDescription]:
+) -> GeneralJobDescription | None:
     job_description = GeneralJobDescription.model_validate(json_response)
     if job_description.status.is_final():
         return job_description
@@ -54,7 +54,7 @@ class JobPoller:
         self,
         base_url: str,
         use_versioned_url: bool = True,
-        additional_headers: Optional[dict[str, str]] = None,
+        additional_headers: dict[str, str] | None = None,
     ) -> None:
         self._additional_headers = additional_headers
         client_instance = client()
@@ -80,7 +80,7 @@ class JobPoller:
         http_client: httpx.AsyncClient,
         http_method: str,
         url: str,
-        body: Optional[dict] = None,
+        body: dict | None = None,
     ) -> httpx.Response:
         return await client().request(
             http_client=http_client,
@@ -111,8 +111,8 @@ class JobPoller:
         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]
+        timeout_sec: float | None,
+        response_parser: Callable[[JSONObject], T | None] = _general_job_description_parser,  # type: ignore[assignment]
     ) -> T:
         async def poller() -> JSONObject:
             nonlocal self, poll_url
@@ -132,9 +132,9 @@ class JobPoller:
     async def poll(
         self,
         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,
+        timeout_sec: float | None,
+        response_parser: Callable[[JSONObject], T | None] = _general_job_description_parser,  # type: ignore[assignment]
+        http_client: httpx.AsyncClient | None = None,
     ) -> T:
         poll_url = self._make_poll_url(job_id=job_id)
         async with client().use_client_or_create(http_client) as async_client:
@@ -153,8 +153,8 @@ class JobPoller:
     async def run(
         self,
         body: dict,
-        timeout_sec: Optional[float],
-        http_client: Optional[httpx.AsyncClient] = None,
+        timeout_sec: float | None,
+        http_client: httpx.AsyncClient | None = None,
     ) -> GeneralJobDescription:
         async with client().use_client_or_create(http_client) as async_client:
             submit_response = await self._submit(http_client=async_client, body=body)
@@ -173,8 +173,8 @@ class JobPoller:
     async def run_pydantic(
         self,
         model: pydantic.BaseModel,
-        timeout_sec: Optional[float],
-        http_client: Optional[httpx.AsyncClient] = None,
+        timeout_sec: float | None,
+        http_client: httpx.AsyncClient | None = 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 and UUID,

classiq/_internals/type_validation.py

@@ -1,4 +1,4 @@
-from typing import Any, TypeVar, Union, overload
+from typing import Any, TypeVar, overload
 
 T = TypeVar("T")
 U = TypeVar("U")
@@ -20,7 +20,7 @@ def validate_type(
     expected_type: tuple[type[T], type[U]],
     operation: str,
     exception_type: type[Exception],
-) -> Union[T, U]: ...
+) -> T | U: ...
 
 
 @overload
@@ -34,7 +34,7 @@ def validate_type(
 
 def validate_type(
     obj: Any,
-    expected_type: Union[tuple[type, ...], type],
+    expected_type: tuple[type, ...] | type,
     operation: str,
     exception_type: type[Exception],
 ) -> Any:

classiq/analyzer/analyzer.py

@@ -4,9 +4,7 @@ import json
 import webbrowser
 from collections.abc import Sequence
 from importlib.util import find_spec
-from typing import Any, Optional, Union
-
-import plotly.graph_objects as go
+from typing import TYPE_CHECKING, Optional
 
 from classiq.interface.analyzer import analysis_params
 from classiq.interface.backend.quantum_backend_providers import AnalyzerProviderVendor
@@ -21,12 +19,12 @@ from classiq.analyzer.analyzer_utilities import (
     ProviderNameEnum,
 )
 
-find_ipywidgets = find_spec("ipywidgets")
-VBox = Any
+if TYPE_CHECKING:
+    import plotly.graph_objects as go
+    from ipywidgets import VBox  # type: ignore[import]
 
+find_ipywidgets = find_spec("ipywidgets")
 if find_ipywidgets is not None:
-    from ipywidgets import VBox  # type: ignore[import, no-redef]
-
     from classiq._analyzer_extras.interactive_hardware import InteractiveHardware
 
 
@@ -53,7 +51,7 @@ class Analyzer(AnalyzerUtilities):
             hardware_graphs=dict(),
         )
 
-        self.hardware_comparison_table: Optional[go.Figure] = None
+        self.hardware_comparison_table: Optional["go.Figure"] = None
 
         self.transpilation_params = analysis_params.AnalysisHardwareTranspilationParams(
             hardware_data=self.circuit.hardware_data,
@@ -62,7 +60,7 @@ class Analyzer(AnalyzerUtilities):
         )
 
     def get_available_devices(
-        self, providers: Optional[list[ProviderNameEnum]] = None
+        self, providers: list[ProviderNameEnum] | None = None
     ) -> dict[ProviderNameEnum, list[DeviceName]]:
         """Deprecated. Use get_all_hardware_devices instead.
 
@@ -85,9 +83,9 @@ class Analyzer(AnalyzerUtilities):
 
     def plot_hardware_connectivity(
         self,
-        provider: Optional[ProviderNameEnum] = None,
-        device: Optional[DeviceName] = None,
-    ) -> VBox:
+        provider: ProviderNameEnum | None = None,
+        device: DeviceName | None = None,
+    ) -> "VBox":
         """plot the hardware_connectivity graph. It is required to required  install the
         analyzer_sdk extra.
 
@@ -115,8 +113,8 @@ class Analyzer(AnalyzerUtilities):
 
     def get_hardware_comparison_table(
         self,
-        providers: Optional[Sequence[Union[str, AnalyzerProviderVendor]]] = None,
-        devices: Optional[list[str]] = None,
+        providers: Sequence[str | AnalyzerProviderVendor] | None = None,
+        devices: list[str] | None = 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.
@@ -129,6 +127,8 @@ class Analyzer(AnalyzerUtilities):
         Returns:
             None.
         """
+        import plotly.graph_objects as go
+
         if providers is None:
             providers = list(AnalyzerProviderVendor)
         params = analysis_params.AnalysisHardwareListParams(
@@ -142,8 +142,8 @@ class Analyzer(AnalyzerUtilities):
 
     def plot_hardware_comparison_table(
         self,
-        providers: Optional[list[Union[str, AnalyzerProviderVendor]]] = None,
-        devices: Optional[list[str]] = None,
+        providers: list[str | AnalyzerProviderVendor] | None = None,
+        devices: list[str] | None = None,
     ) -> None:
         """plot the comparison table. if it has not been created it, it first creates the table using all the
         available hardware.
@@ -156,8 +156,8 @@ class Analyzer(AnalyzerUtilities):
 
     def _hardware_comparison_condition(
         self,
-        providers: Optional[Sequence[Union[str, AnalyzerProviderVendor]]] = None,
-        devices: Optional[list[str]] = None,
+        providers: Sequence[str | AnalyzerProviderVendor] | None = None,
+        devices: list[str] | None = None,
     ) -> None:
         if (
             providers is not None

classiq/analyzer/rb.py

@@ -1,10 +1,7 @@
 from enum import Enum as PythonEnum
-from typing import Optional, Union
+from typing import TYPE_CHECKING, Optional
 
-import matplotlib.pyplot as plt
 import numpy as np
-import pandas as pd
-import plotly.graph_objects as go
 
 from classiq.interface.analyzer.analysis_params import AnalysisRBParams
 from classiq.interface.analyzer.result import RbResults
@@ -13,6 +10,11 @@ from classiq.interface.exceptions import ClassiqAnalyzerError
 from classiq._internals.api_wrapper import ApiWrapper
 from classiq.executor import BackendPreferencesAndResult
 
+if TYPE_CHECKING:
+    import matplotlib.pyplot as plt
+    import pandas as pd
+    import plotly.graph_objects as go
+
 
 class RBAnalysis:
     def __init__(self, experiments_data: list[AnalysisRBParams]) -> None:
@@ -21,6 +23,7 @@ class RBAnalysis:
         Args:
             experiments_data: List of results from varius RB experiments.
         """
+        import pandas as pd
 
         self.experiments_data = experiments_data
         self._total_results: pd.DataFrame = pd.DataFrame()
@@ -43,12 +46,14 @@ class RBAnalysis:
         _, rb_result_keys = temp_res.popitem()
         return list(rb_result_keys.__dict__.keys())
 
-    async def show_multiple_hardware_data_async(self) -> pd.DataFrame:
+    async def show_multiple_hardware_data_async(self) -> "pd.DataFrame":
         """Run the RB analysis.
 
         Returns:
             The RB result.
         """
+        import pandas as pd
+
         results = await self._get_multiple_hardware_results_async()
         indices = RBAnalysis._get_df_indices(results)
         result_df = pd.DataFrame(index=indices)
@@ -57,12 +62,14 @@ class RBAnalysis:
         self._total_results = result_df
         return result_df
 
-    def plot_multiple_hardware_results(self) -> go.Figure:
+    def plot_multiple_hardware_results(self) -> "go.Figure":
         """Plot Bar graph of the results.
 
         Returns:
             None.
         """
+        import plotly.graph_objects as go
+
         df = self._total_results.loc[["mean_fidelity", "average_error"]].transpose()
         hardware = list(df.index)
         params = list(df.columns)
@@ -78,7 +85,7 @@ class RBAnalysis:
         return fig
 
 
-def _strict_string(arg: Union[PythonEnum, str]) -> str:
+def _strict_string(arg: PythonEnum | str) -> str:
     if isinstance(arg, PythonEnum):
         return arg.value
     return arg
@@ -110,8 +117,10 @@ 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:
+    import matplotlib.pyplot as plt
+
     if ax is None:
         plt.figure()
         ax = plt.gca()

classiq/applications/chemistry/__init__.py

@@ -1,38 +1,8 @@
-from classiq.interface.chemistry.fermionic_operator import (
-    FermionicOperator,
-    SummedFermionicOperator,
-)
-from classiq.interface.chemistry.ground_state_problem import (
-    GroundStateProblem,
-    HamiltonianProblem,
-    MoleculeProblem,
-)
-from classiq.interface.chemistry.molecule import Molecule
 from classiq.interface.chemistry.operator import PauliOperator, PauliOperators
 
-from . import ground_state_problem
-from .ansatz_parameters import HEAParameters, HVAParameters, UCCParameters
-from .chemistry_execution_parameters import ChemistryExecutionParameters
-from .chemistry_model_constructor import (
-    construct_chemistry_model,
-    molecule_problem_to_qmod,
-)
-
 __all__ = [
-    "ChemistryExecutionParameters",
-    "FermionicOperator",
-    "GroundStateProblem",
-    "HEAParameters",
-    "HVAParameters",
-    "HamiltonianProblem",
-    "Molecule",
-    "MoleculeProblem",
     "PauliOperator",
     "PauliOperators",
-    "SummedFermionicOperator",
-    "UCCParameters",
-    "construct_chemistry_model",
-    "molecule_problem_to_qmod",
 ]
 
 

classiq/applications/chemistry/op_utils.py

@@ -1,4 +1,4 @@
-from typing import Optional, cast
+from typing import cast
 
 import numpy as np
 from openfermion.ops.operators.qubit_operator import QubitOperator
@@ -10,7 +10,7 @@ from classiq.qmod.builtins.enums import Pauli
 from classiq.qmod.builtins.structs import IndexedPauli, SparsePauliOp, SparsePauliTerm
 
 
-def _get_n_qubits(qubit_op: QubitOperator, n_qubits: Optional[int]) -> int:
+def _get_n_qubits(qubit_op: QubitOperator, n_qubits: int | None) -> int:
     min_n_qubits = cast(int, count_qubits(qubit_op))
     if n_qubits is None:
         return min_n_qubits
@@ -23,7 +23,7 @@ def _get_n_qubits(qubit_op: QubitOperator, n_qubits: Optional[int]) -> int:
 
 
 def qubit_op_to_pauli_terms(
-    qubit_op: QubitOperator, n_qubits: Optional[int] = None
+    qubit_op: QubitOperator, n_qubits: int | None = None
 ) -> SparsePauliOp:
     n_qubits = _get_n_qubits(qubit_op, n_qubits)
     return SparsePauliOp(
@@ -49,7 +49,7 @@ _XZ_TO_PAULIS = {(0, 0): "I", (1, 0): "X", (0, 1): "Z", (1, 1): "Y"}
 
 
 def qubit_op_to_xz_matrix(
-    qubit_op: QubitOperator, n_qubits: Optional[int] = None
+    qubit_op: QubitOperator, n_qubits: int | None = None
 ) -> np.ndarray:
     n_qubits = _get_n_qubits(qubit_op, n_qubits)
     xz_mat = np.zeros((len(qubit_op.terms), 2 * n_qubits), dtype=np.int8)