classiq 0.52.0__py3-none-any.whl → 0.54.0__py3-none-any.whl

classiq/applications/qsvm/qsvm_data_generation.py

@@ -1,6 +1,6 @@
 import logging
 from collections import defaultdict
-from typing import Dict, Optional, Tuple
+from typing import Optional
 
 import numpy as np
 
@@ -15,7 +15,7 @@ def generate_data(
     range_max: float = 2 * np.pi,
     std: float = 0.5,
     sources: Optional[np.ndarray] = None,
-) -> Dict[int, np.ndarray]:
+) -> dict[int, np.ndarray]:
     if sources is None:
         sources = np.random.uniform(
             range_min, range_max, (amount_of_sources, dimension)
@@ -36,7 +36,7 @@ def generate_data(
     return results
 
 
-def data_dict_to_data_and_labels(data_dict: dict) -> Tuple[np.ndarray, np.ndarray]:
+def data_dict_to_data_and_labels(data_dict: dict) -> tuple[np.ndarray, np.ndarray]:
     data = []
     labels = []
     for k, v in data_dict.items():

classiq/applications/qsvm/qsvm_model_constructor.py

@@ -1,4 +1,4 @@
-from typing import Any, List, Tuple
+from typing import Any
 
 from classiq.interface.applications.qsvm import DataList, LabelsInt
 from classiq.interface.exceptions import ClassiqValueError
@@ -22,19 +22,19 @@ _OUTPUT_VARIABLE_NAME = "qsvm_results"
 
 def _bloch_sphere_feature_map_function_params(
     bloch_feature_dimension: int,
-) -> Tuple[List[Expression], str]:
+) -> tuple[list[Expression], str]:
     return [
         Expression(expr=f"{bloch_feature_dimension}")
     ], f"ceiling({bloch_feature_dimension}/2)"
 
 
 def _pauli_feature_map_function_params(
-    paulis: List[List[Pauli]],
+    paulis: list[list[Pauli]],
     entanglement: QSVMFeatureMapEntanglement,
     alpha: int,
     reps: int,
     feature_dimension: int,
-) -> Tuple[List[Expression], str]:
+) -> tuple[list[Expression], str]:
     paulis_str = (
         "["
         + ",".join(
@@ -61,7 +61,7 @@ def _pauli_feature_map_function_params(
 
 def get_qsvm_qmain_body(
     feature_map_function_name: str, **kwargs: Any
-) -> List[QuantumFunctionCall]:
+) -> list[QuantumFunctionCall]:
     if feature_map_function_name == "bloch_sphere_feature_map":
         params, size_expr = _bloch_sphere_feature_map_function_params(**kwargs)
     elif feature_map_function_name == "pauli_feature_map":

classiq/execution/__init__.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from ..executor import *  # noqa: F403
 from ..executor import __all__ as _exec_all
 from ..interface.backend.backend_preferences import *  # noqa: F403
@@ -12,6 +10,7 @@ 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 .qaoa import execute_qaoa
 from .qnn import execute_qnn
 
 __all__ = (
@@ -26,6 +25,7 @@ __all__ = (
         "get_execution_jobs",
         "get_execution_jobs_async",
         "ExecutionSession",
+        "execute_qaoa",
         "execute_qnn",
         "generate_iqcc_token",
         "generate_iqcc_token_async",
@@ -33,5 +33,5 @@ __all__ = (
 )
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/execution/all_hardware_devices.py

@@ -1,12 +1,10 @@
-from typing import List
-
 from classiq.interface.hardware import HardwareInformation
 
 from classiq._internals import async_utils
 from classiq._internals.api_wrapper import ApiWrapper
 
 
-def get_all_hardware_devices() -> List[HardwareInformation]:
+def get_all_hardware_devices() -> list[HardwareInformation]:
     """
     Returns a list of all hardware devices known to Classiq.
     """

classiq/execution/execution_session.py

@@ -1,5 +1,7 @@
 import json
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union, cast
+from typing import Any, Callable, Optional, Union, cast
+
+import numpy as np
 
 from classiq.interface.chemistry.operator import PauliOperator, pauli_integers_to_str
 from classiq.interface.exceptions import ClassiqValueError
@@ -8,6 +10,7 @@ from classiq.interface.executor.execution_preferences import ExecutionPreference
 from classiq.interface.executor.result import (
     EstimationResult,
     ExecutionDetails,
+    ParsedState,
 )
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
 from classiq.interface.generator.quantum_program import QuantumProgram
@@ -25,12 +28,12 @@ from classiq.qmod.builtins.classical_execution_primitives import (
 )
 from classiq.synthesis import SerializedQuantumProgram
 
-Hamiltonian = Union[List[QmodPyStruct], List[PauliTerm]]
+Hamiltonian = Union[list[QmodPyStruct], list[PauliTerm]]
 Program = Union[SerializedQuantumProgram, QuantumProgram]
-ParsedExecutionParams = Dict[str, Union[float, int]]
-ExecutionParameters = Optional[Union[ExecutionParams, List[ExecutionParams]]]
+ParsedExecutionParams = dict[str, Union[float, int]]
+ExecutionParameters = Optional[Union[ExecutionParams, list[ExecutionParams]]]
 ParsedExecutionParameters = Optional[
-    Union[ParsedExecutionParams, List[ParsedExecutionParams]]
+    Union[ParsedExecutionParams, list[ParsedExecutionParams]]
 ]
 
 
@@ -52,11 +55,11 @@ def _deserialize_program(program: Program) -> QuantumProgram:
     )
 
 
-def hamiltonian_to_pauli_terms(hamiltonian: Hamiltonian) -> List[PauliTerm]:
+def hamiltonian_to_pauli_terms(hamiltonian: Hamiltonian) -> list[PauliTerm]:
     if isinstance(hamiltonian[0], PauliTerm):
-        return cast(List[PauliTerm], hamiltonian)
+        return cast(list[PauliTerm], hamiltonian)
     else:
-        return _pauli_dict_to_pauli_terms(cast(List[QmodPyStruct], hamiltonian))
+        return _pauli_dict_to_pauli_terms(cast(list[QmodPyStruct], hamiltonian))
 
 
 def to_hamiltonian_str(hamiltonian: Hamiltonian) -> str:
@@ -75,8 +78,8 @@ def _hamiltonian_to_pauli_operator(hamiltonian: Hamiltonian) -> PauliOperator:
 
 
 def serialize(
-    item: Union[float, int, Tuple[int, ...], Tuple[float, ...]]
-) -> Union[str, List]:
+    item: Union[float, int, tuple[int, ...], tuple[float, ...]]
+) -> Union[str, list]:
     if isinstance(item, tuple):
         return list(item)
     return str(item)
@@ -123,7 +126,7 @@ def create_sample_execution_code(operation: str, **kwargs: Any) -> str:
     return f"\nresult = {operation}({parameters})" + SAVE_RESULT
 
 
-operation_handlers: Dict[str, Callable[[str], str]] = {
+operation_handlers: dict[str, Callable[[str], str]] = {
     "estimate": create_estimate_execution_code,
     "batch_estimate": create_estimate_execution_code,
     "sample": create_sample_execution_code,
@@ -215,7 +218,7 @@ class ExecutionSession:
         )
         return execute(SerializedQuantumProgram(self.qprog))
 
-    def batch_sample(self, parameters: List[ExecutionParams]) -> List[ExecutionDetails]:
+    def batch_sample(self, parameters: list[ExecutionParams]) -> list[ExecutionDetails]:
         """
         Samples the quantum program multiple times with the given parameters for each iteration. The number of samples is determined by the length of the parameters list.
 
@@ -228,7 +231,7 @@ class ExecutionSession:
         job = self.submit_batch_sample(parameters=parameters)
         return job.get_batch_sample_result()
 
-    def submit_batch_sample(self, parameters: List[ExecutionParams]) -> ExecutionJob:
+    def submit_batch_sample(self, parameters: list[ExecutionParams]) -> ExecutionJob:
         """
         Initiates an execution job with the `batch_sample` primitive.
 
@@ -297,8 +300,8 @@ class ExecutionSession:
         return execute(SerializedQuantumProgram(self.qprog))
 
     def batch_estimate(
-        self, hamiltonian: Hamiltonian, parameters: List[ExecutionParams]
-    ) -> List[EstimationResult]:
+        self, hamiltonian: Hamiltonian, parameters: list[ExecutionParams]
+    ) -> list[EstimationResult]:
         """
         Estimates the expectation value of the given Hamiltonian multiple times using the quantum program, with the given parameters for each iteration. The number of estimations is determined by the length of the parameters list.
 
@@ -313,7 +316,7 @@ class ExecutionSession:
         return job.get_batch_estimate_result()
 
     def submit_batch_estimate(
-        self, hamiltonian: Hamiltonian, parameters: List[ExecutionParams]
+        self, hamiltonian: Hamiltonian, parameters: list[ExecutionParams]
     ) -> ExecutionJob:
         """
         Initiates an execution job with the `batch_estimate` primitive.
@@ -340,3 +343,41 @@ class ExecutionSession:
             )
         )
         return execute(SerializedQuantumProgram(self.qprog))
+
+    def estimate_cost(
+        self,
+        cost_func: Callable[[ParsedState], float],
+        parameters: Optional[ExecutionParams] = None,
+        quantile: float = 1.0,
+    ) -> float:
+        """
+        Estimates circuit cost using a classical cost function.
+
+        Args:
+            cost_func: classical circuit sample cost function
+            parameters: execution parameters sent to 'sample'
+            quantile: drop cost values outside the specified quantile
+
+        Returns:
+            cost estimation
+
+        See Also:
+            sample
+        """
+        if quantile < 0 or quantile > 1:
+            raise ClassiqValueError("'quantile' must be between 0 and 1")
+        res = self.sample(parameters)
+
+        counts = np.array(res.parsed_counts)
+        costs = np.vectorize(lambda sample: cost_func(sample.state))(counts)
+        shots = np.vectorize(lambda sample: sample.shots)(counts)
+
+        if quantile == 1:
+            return float(np.average(costs, weights=shots))
+        costs = np.repeat(costs, shots)
+        sort_idx = costs.argsort()
+        sort_idx = sort_idx[: int(quantile * len(costs))]
+        costs = costs[sort_idx]
+        if costs.size == 0:
+            return np.nan
+        return float(np.average(costs))

classiq/execution/iqcc.py

@@ -51,7 +51,7 @@ async def generate_iqcc_token_async(
                 token_id=initiate_response.token_id,
             )
         )
-        if probe_response.auth_token is not None:
+        if probe_response is not None:
             return probe_response.auth_token
 
         if time.monotonic() - start_time > timeout:

classiq/execution/jobs.py

@@ -1,6 +1,6 @@
 import webbrowser
 from datetime import datetime
-from typing import Any, List, Optional, Union
+from typing import Any, Optional, Union
 from urllib.parse import urljoin
 
 from classiq.interface.exceptions import (
@@ -150,7 +150,7 @@ class ExecutionJob:
             return result.details[0]
         raise ClassiqExecutionResultError("sample")
 
-    def get_batch_sample_result(self) -> List[ExecutionDetails]:
+    def get_batch_sample_result(self) -> list[ExecutionDetails]:
         """
         Returns the job's result as a single batch_sample result after validation. If the result is not yet available, waits for it.
 
@@ -195,7 +195,7 @@ class ExecutionJob:
             return result.results[0]
         raise ClassiqExecutionResultError("estimate")
 
-    def get_batch_estimate_result(self) -> List[EstimationResult]:
+    def get_batch_estimate_result(self) -> list[EstimationResult]:
         """
         Returns the job's result as a single batch_estimate result after validation. If the result is not yet available, waits for it.
 
@@ -271,7 +271,7 @@ class ExecutionJob:
 
 async def get_execution_jobs_async(
     offset: int = 0, limit: int = 50
-) -> List[ExecutionJob]:
+) -> list[ExecutionJob]:
     result = await ApiWrapper().call_query_execution_jobs(offset=offset, limit=limit)
     return [ExecutionJob(details) for details in result.results]
 

classiq/execution/qaoa.py

@@ -0,0 +1,84 @@
+import math
+from typing import Callable, Optional
+
+import numpy as np
+import scipy
+
+from classiq.interface.executor.execution_preferences import ExecutionPreferences
+from classiq.interface.executor.result import ExecutionDetails
+from classiq.interface.model.model import SerializedModel
+
+from classiq.execution import ExecutionSession
+from classiq.qmod.builtins.functions import (
+    RX,
+    allocate,
+    apply_to_all,
+    hadamard_transform,
+)
+from classiq.qmod.builtins.operations import phase, repeat
+from classiq.qmod.cparam import CReal
+from classiq.qmod.create_model_function import create_model
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_parameter import CArray
+from classiq.qmod.qmod_variable import Output, QVar
+from classiq.synthesis import SerializedQuantumProgram, synthesize
+
+
+def execute_qaoa(
+    problem_vars: type[QVar],
+    cost_func: Callable,
+    num_layers: int,
+    maxiter: int,
+    execution_preferences: Optional[ExecutionPreferences] = None,
+) -> tuple[SerializedModel, SerializedQuantumProgram, ExecutionDetails]:
+    """
+    Implements a simple QAOA algorithm, including the creation and synthesis of the QAOA
+    ansatz and the classical optimization loop.
+
+    Args:
+        problem_vars: the quantum type (scalar, array, or struct) of the problem variable(s)
+        cost_func: the arithmetic expression that evaluates the cost given an instance of the problem_vars type
+        num_layers: the number of layers of the QAOA ansatz
+        maxiter: the maximum number of iterations for the classical optimization loop
+        execution_preferences: the execution settings for running the QAOA ansatz
+
+    Returns:
+        a tuple containing the model of the QAOA ansatz, the corresponding synthesized quantum program,
+        and the result of the execution with the optimized parameters
+    """
+
+    @qfunc
+    def main(
+        params: CArray[CReal, num_layers * 2],  # type:ignore[valid-type]
+        v: Output[problem_vars],  # type:ignore[valid-type]
+    ) -> None:
+        allocate(v.size, v)  # type:ignore[attr-defined]
+        hadamard_transform(v)
+        repeat(
+            num_layers,
+            lambda i: [  # type:ignore[arg-type]
+                phase(-cost_func(v), params[i]),  # type:ignore[func-returns-value]
+                apply_to_all(lambda q: RX(params[num_layers + i], q), v),
+            ],
+        )
+
+    model = create_model(main)
+    qprog = synthesize(model)
+
+    es = ExecutionSession(qprog, execution_preferences)
+    initial_params = (
+        np.concatenate((np.linspace(0, 1, num_layers), np.linspace(1, 0, num_layers)))
+        * math.pi
+    )
+    final_params = scipy.optimize.minimize(
+        lambda params: es.estimate_cost(
+            lambda state: cost_func(state["v"]),
+            {"params": params.tolist()},
+        ),
+        x0=initial_params,
+        method="COBYLA",
+        options={"maxiter": maxiter},
+    ).x.tolist()
+    result = es.sample({"params": final_params})
+
+    return model, qprog, result

classiq/execution/qnn.py

@@ -1,5 +1,5 @@
 import functools
-from typing import List, Optional
+from typing import Optional
 
 import more_itertools
 
@@ -24,7 +24,7 @@ _MAX_ARGUMENTS_SIZE = 1024
 
 def _execute_qnn_estimate(
     session: ExecutionSession,
-    arguments: List[Arguments],
+    arguments: list[Arguments],
     observable: PauliOperator,
 ) -> ResultsCollection:
     hamiltonian = pauli_operator_to_hamiltonian(observable.pauli_list)
@@ -42,7 +42,7 @@ def _execute_qnn_estimate(
 
 def _execute_qnn_sample(
     session: ExecutionSession,
-    arguments: List[Arguments],
+    arguments: list[Arguments],
 ) -> ResultsCollection:
     return [
         TaggedExecutionDetails(

classiq/executor.py

@@ -1,6 +1,6 @@
 """Executor module, implementing facilities for executing quantum programs using Classiq platform."""
 
-from typing import Tuple, Union
+from typing import Union
 
 from typing_extensions import TypeAlias
 
@@ -18,8 +18,8 @@ from classiq.execution.jobs import ExecutionJob
 from classiq.synthesis import SerializedQuantumProgram
 
 BatchExecutionResult: TypeAlias = Union[ExecutionDetails, BaseException]
-ProgramAndResult: TypeAlias = Tuple[QuantumCode, BatchExecutionResult]
-BackendPreferencesAndResult: TypeAlias = Tuple[
+ProgramAndResult: TypeAlias = tuple[QuantumCode, BatchExecutionResult]
+BackendPreferencesAndResult: TypeAlias = tuple[
     BackendPreferencesTypes, int, BatchExecutionResult
 ]
 
@@ -46,7 +46,7 @@ def execute(quantum_program: SerializedQuantumProgram) -> ExecutionJob:
     Returns:
         ExecutionJob: The result of the execution.
 
-    For examples please see [Execution Documentation](https://docs.classiq.io/latest/reference-manual/executor/)
+    For examples please see [Execution Documentation](https://docs.classiq.io/latest/user-guide/executor/)
     """
     return async_utils.run(execute_async(quantum_program))
 

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

classiq/interface/analyzer/analysis_params.py

@@ -1,9 +1,8 @@
-from typing import Dict, List, Optional
+from typing import Annotated, Optional
 
 import numpy
 import pydantic
 from pydantic import ConfigDict, Field, StringConstraints
-from typing_extensions import Annotated
 
 from classiq.interface.backend.quantum_backend_providers import AnalyzerProviderVendor
 from classiq.interface.chemistry.ground_state_problem import MoleculeProblem
@@ -30,17 +29,17 @@ class AnalysisParams(pydantic.BaseModel):
 
 
 class HardwareListParams(pydantic.BaseModel):
-    devices: Optional[List[PydanticNonEmptyString]] = pydantic.Field(
+    devices: Optional[list[PydanticNonEmptyString]] = pydantic.Field(
         default=None, description="Devices"
     )
-    providers: List[Provider]
+    providers: list[Provider]
     from_ide: bool = Field(default=False)
 
     @pydantic.field_validator("providers")
     @classmethod
     def set_default_providers(
-        cls, providers: Optional[List[AnalyzerProviderVendor]]
-    ) -> List[AnalyzerProviderVendor]:
+        cls, providers: Optional[list[AnalyzerProviderVendor]]
+    ) -> list[AnalyzerProviderVendor]:
         if providers is None:
             providers = list(AnalyzerProviderVendor)
         return providers
@@ -65,7 +64,7 @@ class GateNamsMapping(pydantic.BaseModel):
 
 
 class LatexParams(AnalysisParams):
-    gate_names: List[GateNamsMapping] = pydantic.Field(
+    gate_names: list[GateNamsMapping] = pydantic.Field(
         default=..., description="List of gate names as apper in the qasm"
     )
 
@@ -96,12 +95,12 @@ class CircuitAnalysisHardwareParams(AnalysisParams):
 
 class AnalysisRBParams(pydantic.BaseModel):
     hardware: str
-    counts: List[
-        Dict[
+    counts: list[
+        dict[
             str, Annotated[int, Annotated[int, Field(strict=True, gt=0, le=MAX_COUNTS)]]
         ]
     ]
-    num_clifford: List[
+    num_clifford: list[
         Annotated[int, Annotated[int, Field(strict=True, gt=0, le=MAX_NUM_CLIFFORD)]]
     ]
 

classiq/interface/analyzer/cytoscape_graph.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 
 import pydantic
 
@@ -25,7 +25,7 @@ class CytoScapeEdgeData(pydantic.BaseModel):
 
     @pydantic.model_validator(mode="before")
     @classmethod
-    def _validate_values(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    def _validate_values(cls, values: dict[str, Any]) -> dict[str, Any]:
         values["source"] = str(values["source"]) or " "
         values["target"] = str(values["target"]) or " "
         return values
@@ -38,7 +38,7 @@ class CytoScapeEdge(pydantic.BaseModel):
 
 
 class CytoScapeNode(pydantic.BaseModel):
-    data: Dict[str, Any] = pydantic.Field(
+    data: dict[str, Any] = pydantic.Field(
         default=...,
         description="Data of the Node, such as label, and color, can be of free form",
     )
@@ -48,11 +48,11 @@ class CytoScapeNode(pydantic.BaseModel):
 
 
 class CytoScapeGraph(pydantic.BaseModel):
-    nodes: List[CytoScapeNode] = pydantic.Field(
+    nodes: list[CytoScapeNode] = pydantic.Field(
         default_factory=list,
         description="Nodes of the Graph",
     )
-    edges: List[CytoScapeEdge] = pydantic.Field(
+    edges: list[CytoScapeEdge] = pydantic.Field(
         default_factory=list,
         description="Edges of the Graph",
     )

classiq/interface/analyzer/result.py

@@ -1,9 +1,9 @@
-from typing import Dict, List, Literal, Optional, Set, Tuple, Union
+from typing import Annotated, Literal, Optional, Union
 from uuid import UUID
 
 import pydantic
 from pydantic import Field
-from typing_extensions import Annotated, Self
+from typing_extensions import Self
 
 from classiq.interface.analyzer.analysis_params import MAX_FILE_LENGTH
 from classiq.interface.enum_utils import StrEnum
@@ -11,7 +11,7 @@ from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
 from classiq.interface.helpers.versioned_model import VersionedModel
 
-Match = List[List[int]]
+Match = list[list[int]]
 
 
 class GraphStatus(StrEnum):
@@ -29,8 +29,8 @@ class RbResults(VersionedModel):
     average_error: float
     A: float
     B: float
-    success_probability: List[float]
-    parameters_error: Tuple[float, ...]
+    success_probability: list[float]
+    parameters_error: tuple[float, ...]
 
 
 class DataID(pydantic.BaseModel):
@@ -58,19 +58,19 @@ class BasisGates(StrEnum):
 
 
 class HardwareComparisonInformation(pydantic.BaseModel):
-    devices: List[str] = pydantic.Field(
+    devices: list[str] = pydantic.Field(
         default=..., description="Device which is used for the transpilation."
     )
-    providers: List[str] = pydantic.Field(
+    providers: list[str] = pydantic.Field(
         default=..., description="Provider cloud of the device."
     )
-    depth: List[pydantic.NonNegativeInt] = pydantic.Field(
+    depth: list[pydantic.NonNegativeInt] = pydantic.Field(
         default=..., description="Circuit depth."
     )
-    multi_qubit_gate_count: List[pydantic.NonNegativeInt] = pydantic.Field(
+    multi_qubit_gate_count: list[pydantic.NonNegativeInt] = pydantic.Field(
         default=..., description="Number of multi qubit gates."
     )
-    total_gate_count: List[pydantic.NonNegativeInt] = pydantic.Field(
+    total_gate_count: list[pydantic.NonNegativeInt] = pydantic.Field(
         default=..., description="Number of total gates."
     )
 
@@ -105,32 +105,32 @@ class SingleHardwareInformation(pydantic.BaseModel):
 
 class HardwareComparisonData(VersionedModel):
     kind: Literal["hardware_comparison"] = Field(default="hardware_comparison")
-    data: List[SingleHardwareInformation]
+    data: list[SingleHardwareInformation]
 
 
 HardwareComparisonGraphType = Annotated[
     Union[HardwareComparisonData, GraphResult], Field(discriminator="kind")
 ]
 
-_HARDWARE_COMPARISON_TABLE_COLUMNS_NAMES: Dict[str, str] = {
+_HARDWARE_COMPARISON_TABLE_COLUMNS_NAMES: dict[str, str] = {
     s.upper(): s.capitalize() for s in SingleHardwareInformation.model_fields
 }
 
 
 class HardwareComparisonDataColumns(pydantic.BaseModel):
-    columns: Dict[str, str] = _HARDWARE_COMPARISON_TABLE_COLUMNS_NAMES
+    columns: dict[str, str] = _HARDWARE_COMPARISON_TABLE_COLUMNS_NAMES
 
 
 class AvailableHardware(pydantic.BaseModel):
-    ibm_quantum: Optional[Dict[PydanticNonEmptyString, bool]] = pydantic.Field(
+    ibm_quantum: Optional[dict[PydanticNonEmptyString, bool]] = pydantic.Field(
         default=None,
         description="available IBM Quantum devices with boolean indicates if a given device has enough qubits.",
     )
-    azure_quantum: Optional[Dict[PydanticNonEmptyString, bool]] = pydantic.Field(
+    azure_quantum: Optional[dict[PydanticNonEmptyString, bool]] = pydantic.Field(
         default=None,
         description="available Azure Quantum devices with boolean indicates if a given device has enough qubits.",
     )
-    amazon_braket: Optional[Dict[PydanticNonEmptyString, bool]] = pydantic.Field(
+    amazon_braket: Optional[dict[PydanticNonEmptyString, bool]] = pydantic.Field(
         default=None,
         description="available Amazon Braket devices with boolean indicates if a given device has enough qubits.",
     )
@@ -163,7 +163,7 @@ class QuantumCircuitProperties(pydantic.BaseModel):
 
 
 class NativeQuantumCircuitProperties(QuantumCircuitProperties):
-    native_gates: Set[BasisGates] = pydantic.Field(
+    native_gates: set[BasisGates] = pydantic.Field(
         default=..., description="Native gates used for decomposition"
     )