classiq 0.37.1__py3-none-any.whl → 0.65.3__py3-none-any.whl

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,15 +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._internals.async_utils import Asyncify
-from classiq.exceptions import ClassiqAnalyzerError
 from classiq.executor import BackendPreferencesAndResult
 
 
-class RBAnalysis(metaclass=Asyncify):
-    def __init__(self, experiments_data: List[AnalysisRBParams]) -> None:
+class RBAnalysis:
+    def __init__(self, experiments_data: list[AnalysisRBParams]) -> None:
         """Init self.
 
         Args:
@@ -26,8 +25,8 @@ class RBAnalysis(metaclass=Asyncify):
         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(
@@ -39,7 +38,7 @@ class RBAnalysis(metaclass=Asyncify):
         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())
@@ -67,9 +66,9 @@ class RBAnalysis(metaclass=Asyncify):
         df = self._total_results.loc[["mean_fidelity", "average_error"]].transpose()
         hardware = list(df.index)
         params = list(df.columns)
-        data = []
-        for param in params:
-            data.append(go.Bar(name=param, x=hardware, y=df[param].values * 100))
+        data = [
+            go.Bar(name=param, x=hardware, y=df[param].values * 100) for param in params
+        ]
         fig = go.Figure(data).update_layout(
             title="RB hardware comparison",
             barmode="group",
@@ -79,22 +78,22 @@ class RBAnalysis(metaclass=Asyncify):
         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]
@@ -111,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,26 +1,49 @@
 import webbrowser
 from urllib.parse import urljoin
 
-from classiq.interface.generator.generated_circuit import GeneratedCircuit
+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
 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: GeneratedCircuit) -> 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}")
+
+    if display_url:
+        print(f"Opening: {app_url}")  # noqa: T201
+
     webbrowser.open_new_tab(app_url)
 
 
-async def _show_interactive(self: GeneratedCircuit) -> 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)
 
 
-GeneratedCircuit.show = syncify_function(_show_interactive)  # type: ignore[attr-defined]
-GeneratedCircuit.show_async = _show_interactive  # type: ignore[attr-defined]
+QuantumProgram.show = syncify_function(_show_interactive)  # type: ignore[attr-defined]
+QuantumProgram.show_async = _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

classiq/applications/chemistry/__init__.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from classiq.interface.chemistry.fermionic_operator import (
     FermionicOperator,
     SummedFermionicOperator,
@@ -15,22 +13,28 @@ 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__ = [
-    "Molecule",
-    "MoleculeProblem",
+    "ChemistryExecutionParameters",
+    "FermionicOperator",
     "GroundStateProblem",
+    "HEAParameters",
+    "HVAParameters",
     "HamiltonianProblem",
-    "PauliOperators",
+    "Molecule",
+    "MoleculeProblem",
     "PauliOperator",
-    "FermionicOperator",
+    "PauliOperators",
     "SummedFermionicOperator",
     "UCCParameters",
-    "HVAParameters",
-    "HEAParameters",
-    "ChemistryExecutionParameters",
+    "construct_chemistry_model",
+    "molecule_problem_to_qmod",
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/applications/chemistry/ansatz_parameters.py

@@ -1,5 +1,5 @@
 import dataclasses
-from typing import List, Tuple, Union
+from typing import Union
 
 from classiq.interface.generator.excitations import EXCITATIONS_TYPE_EXACT
 from classiq.interface.generator.ucc import default_excitation_factory
@@ -21,9 +21,9 @@ class HVAParameters:
 class HEAParameters:
     reps: int
     num_qubits: int
-    connectivity_map: List[Tuple[int, int]]
-    one_qubit_gates: List[str]
-    two_qubit_gates: List[str]
+    connectivity_map: list[tuple[int, int]]
+    one_qubit_gates: list[str]
+    two_qubit_gates: list[str]
 
 
 AnsatzParameters = Union[UCCParameters, HVAParameters, HEAParameters]