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

classiq/execution/execution_session.py

@@ -1,5 +1,5 @@
 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
 
@@ -28,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]]
 ]
 
 
@@ -55,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:
@@ -78,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)
@@ -126,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,
@@ -218,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.
 
@@ -231,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.
 
@@ -300,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.
 
@@ -316,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.

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

@@ -1,5 +1,5 @@
 import math
-from typing import Callable, Optional, Tuple, Type
+from typing import Callable, Optional
 
 import numpy as np
 import scipy
@@ -25,12 +25,12 @@ from classiq.synthesis import SerializedQuantumProgram, synthesize
 
 
 def execute_qaoa(
-    problem_vars: Type[QVar],
+    problem_vars: type[QVar],
     cost_func: Callable,
     num_layers: int,
     maxiter: int,
     execution_preferences: Optional[ExecutionPreferences] = None,
-) -> Tuple[SerializedModel, SerializedQuantumProgram, ExecutionDetails]:
+) -> tuple[SerializedModel, SerializedQuantumProgram, ExecutionDetails]:
     """
     Implements a simple QAOA algorithm, including the creation and synthesis of the QAOA
     ansatz and the classical optimization loop.

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
 ]
 

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.53.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"
     )
 

classiq/interface/applications/qsvm.py

@@ -1,11 +1,7 @@
-from collections.abc import Sequence
+from collections.abc import Iterable as IterableType, Sequence
 from typing import (
     Any,
-    Iterable as IterableType,
-    List,
     Optional,
-    Tuple,
-    Type,
     Union,
 )
 
@@ -16,8 +12,8 @@ from pydantic import ConfigDict, field_validator
 
 from classiq.interface.helpers.versioned_model import VersionedModel
 
-DataList = List[List[float]]
-LabelsInt = List[int]
+DataList = list[list[float]]
+LabelsInt = list[int]
 
 
 def listify(obj: Union[IterableType, ArrayLike]) -> list:
@@ -33,13 +29,13 @@ def listify(obj: Union[IterableType, ArrayLike]) -> list:
 
 def validate_array_to_list(name: str) -> Any:
     @field_validator(name, mode="before")
-    def _listify(cls: Type[pydantic.BaseModel], value: Any) -> Any:
+    def _listify(cls: type[pydantic.BaseModel], value: Any) -> Any:
         return listify(value)
 
     return _listify
 
 
-Shape = Tuple[int, ...]
+Shape = tuple[int, ...]
 
 
 class QSVMInternalState(VersionedModel):
@@ -118,4 +114,4 @@ class QSVMPredictResult(VersionedModel):
 
 
 Data = Union[DataList, np.ndarray]
-Labels = Union[List[Any], np.ndarray]
+Labels = Union[list[Any], np.ndarray]

classiq/interface/backend/backend_preferences.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import Any, Dict, Iterable, List, Optional, Union
+from collections.abc import Iterable
+from typing import Any, Optional, Union
 
 import pydantic
 from pydantic import BaseModel
@@ -50,7 +51,7 @@ class BackendPreferences(BaseModel):
     @classmethod
     def batch_preferences(
         cls, *, backend_names: Iterable[str], **kwargs: Any
-    ) -> List[BackendPreferences]:
+    ) -> list[BackendPreferences]:
         return [cls(backend_name=name, **kwargs) for name in backend_names]
 
     def is_nvidia_backend(self) -> bool:
@@ -121,7 +122,7 @@ class AliceBobBackendPreferences(BackendPreferences):
     )
 
     @property
-    def parameters(self) -> Dict[str, Any]:
+    def parameters(self) -> dict[str, Any]:
         parameters = {
             "distance": self.distance,
             "kappa1": self.kappa_1,

classiq/interface/backend/ionq/ionq_quantum_program.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, Annotated, Optional
 
 from pydantic import BaseModel, ConfigDict, Field
-from typing_extensions import Annotated
 
 # This file is based on autogenerated code from: https://static.ionq.co/schemas/circuit-v0.json using
 # https://pydantic-docs.helpmanual.io/datamodel_code_generator/
@@ -25,14 +24,14 @@ class Gate(BaseModel):
     gate: PydanticGateName
     target: Optional[int] = None
     control: Optional[int] = None
-    targets: Optional[List[int]] = None
-    controls: Optional[List[int]] = None
+    targets: Optional[list[int]] = None
+    controls: Optional[list[int]] = None
     model_config = ConfigDict(extra="allow")
 
 
 class IonqQuantumCircuit(BaseModel):
     qubits: int
-    circuit: List[Gate]
+    circuit: list[Gate]
     model_config = ConfigDict(extra="allow")
 
     @classmethod

classiq/interface/backend/pydantic_backend.py

@@ -1,7 +1,6 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Annotated
 
 from pydantic import Field, StrictStr, constr
-from typing_extensions import Annotated
 
 AZURE_QUANTUM_RESOURCE_ID_REGEX = r"^/subscriptions/([a-fA-F0-9-]*)/resourceGroups/([^\s/]*)/providers/Microsoft\.Quantum/Workspaces/([^\s/]*)$"
 

classiq/interface/chemistry/fermionic_operator.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import itertools
-from typing import Set, Tuple, Union
+from typing import Union
 
 import numpy as np
 import pydantic
@@ -12,8 +12,8 @@ from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
 
-LadderOperator = Tuple[str, int]
-FermionicOperatorTuple = Tuple["FermionicOperator", float]
+LadderOperator = tuple[str, int]
+FermionicOperatorTuple = tuple["FermionicOperator", float]
 
 _SUBSCRIPT_UNICODE_CHARS = {
     "0": "\u2080",
@@ -118,7 +118,7 @@ class FermionicOperator(HashablePydanticBaseModel):
         )
 
     @property
-    def all_indices(self) -> Set[int]:
+    def all_indices(self) -> set[int]:
         return {op[1] for op in self.op_list}
 
 
@@ -195,7 +195,7 @@ class SummedFermionicOperator(HashablePydanticBaseModel):
         return True
 
     @property
-    def _all_indices(self) -> Set[int]:
+    def _all_indices(self) -> set[int]:
         return set(
             itertools.chain.from_iterable(op.all_indices for op, _ in self.op_list)
         )

classiq/interface/chemistry/ground_state_problem.py

@@ -1,9 +1,8 @@
-from typing import List, Literal, Optional, Tuple, Union, cast
+from typing import Annotated, Literal, Optional, Union, cast
 
 import pydantic
 from pydantic import ConfigDict, Field
 from pydantic_core.core_schema import ValidationInfo
-from typing_extensions import Annotated
 
 from classiq.interface.chemistry.fermionic_operator import SummedFermionicOperator
 from classiq.interface.chemistry.molecule import Molecule
@@ -29,7 +28,7 @@ And use a list, and manually check its length
 """
 NumSpinUpParticles = pydantic.NonNegativeInt
 NumSpinDownParticles = pydantic.NonNegativeInt
-NumParticles = Tuple[NumSpinUpParticles, NumSpinDownParticles]
+NumParticles = tuple[NumSpinUpParticles, NumSpinDownParticles]
 
 
 class FermionMapping(StrEnum):
@@ -74,7 +73,7 @@ class MoleculeProblem(GroundStateProblem):
     molecule: Molecule
     basis: str = pydantic.Field(default="sto3g", description="Molecular basis set")
     freeze_core: bool = pydantic.Field(default=False)
-    remove_orbitals: List[int] = pydantic.Field(
+    remove_orbitals: list[int] = pydantic.Field(
         default_factory=list, description="list of orbitals to remove"
     )
 
@@ -85,7 +84,7 @@ class HamiltonianProblem(GroundStateProblem):
     hamiltonian: SummedFermionicOperator = pydantic.Field(
         description="Hamiltonian as a fermionic operator"
     )
-    num_particles: List[pydantic.PositiveInt] = pydantic.Field(
+    num_particles: list[pydantic.PositiveInt] = pydantic.Field(
         description="Tuple containing the numbers of alpha particles and beta particles"
     )
 
@@ -94,9 +93,9 @@ class HamiltonianProblem(GroundStateProblem):
     def _validate_num_particles(
         cls,
         num_particles: Union[
-            List[Union[int, float]], Tuple[Union[int, float], Union[int, float]]
+            list[Union[int, float]], tuple[Union[int, float], Union[int, float]]
         ],
-    ) -> List[int]:
+    ) -> list[int]:
         assert isinstance(num_particles, (list, tuple))
         assert len(num_particles) == 2
 
@@ -105,7 +104,7 @@ class HamiltonianProblem(GroundStateProblem):
         assert num_particles[0] >= 1
         assert num_particles[1] >= 1
 
-        return cast(List[int], num_particles)
+        return cast(list[int], num_particles)
 
 
 CHEMISTRY_PROBLEMS = (MoleculeProblem, HamiltonianProblem)

classiq/interface/chemistry/molecule.py

@@ -1,4 +1,4 @@
-from typing import List, Literal, Union
+from typing import Literal, Union
 
 import pydantic
 from pydantic import ConfigDict
@@ -19,7 +19,7 @@ class Atom(HashablePydanticBaseModel):
 
 
 class Molecule(HashablePydanticBaseModel):
-    atoms: List[Atom] = pydantic.Field(
+    atoms: list[Atom] = pydantic.Field(
         description="A list of atoms each containing the atoms symbol and  its (x,y,z) location",
         min_length=1,
     )
@@ -31,7 +31,7 @@ class Molecule(HashablePydanticBaseModel):
     )
 
     @property
-    def atoms_type(self) -> List[AtomType]:
+    def atoms_type(self) -> list[AtomType]:
         return [(atom.symbol, [atom.x, atom.y, atom.z]) for atom in self.atoms]
 
     @classmethod
@@ -42,7 +42,7 @@ class Molecule(HashablePydanticBaseModel):
 
     @pydantic.field_validator("atoms", mode="before")
     @classmethod
-    def _validate_atoms(cls, atoms: List[Union[AtomType, Atom]]) -> List[Atom]:
+    def _validate_atoms(cls, atoms: list[Union[AtomType, Atom]]) -> list[Atom]:
         return [cls._validate_atom(atom) for atom in atoms]
 
     @staticmethod