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

classiq/interface/executor/optimizer_preferences.py

@@ -1,13 +1,13 @@
-from typing import Any, Dict, List, Optional
+from typing import Optional
 
 import pydantic
 from pydantic import BaseModel
+from pydantic_core.core_schema import ValidationInfo
 
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.helpers.custom_pydantic_types import PydanticAlphaParamCVAR
 
-from classiq._internals.enum_utils import StrEnum
-from classiq.exceptions import ClassiqValueError
-
 
 class CostType(StrEnum):
     MIN = "MIN"
@@ -45,7 +45,7 @@ class OptimizerPreferences(BaseModel):
         default=None,
         description="The random seed used for the generation",
     )
-    initial_point: Optional[List[float]] = pydantic.Field(
+    initial_point: Optional[list[float]] = pydantic.Field(
         default=None,
         description="Initial values for the ansatz parameters",
     )
@@ -54,11 +54,12 @@ class OptimizerPreferences(BaseModel):
         description="If True, the optimizer will not compute the variance of the ansatz.",
     )
 
-    @pydantic.validator("tolerance", pre=True, always=True)
+    @pydantic.field_validator("tolerance", mode="before")
+    @classmethod
     def check_tolerance(
-        cls, tolerance: Optional[pydantic.PositiveFloat], values: Dict[str, Any]
+        cls, tolerance: Optional[pydantic.PositiveFloat], info: ValidationInfo
     ) -> Optional[pydantic.PositiveFloat]:
-        optimizer_type = values.get("type")
+        optimizer_type = info.data.get("type")
         if tolerance is not None and optimizer_type == OptimizerType.SPSA:
             raise ClassiqValueError("No tolerance param for SPSA optimizer")
 
@@ -67,11 +68,12 @@ class OptimizerPreferences(BaseModel):
 
         return tolerance
 
-    @pydantic.validator("step_size", pre=True, always=True)
+    @pydantic.field_validator("step_size", mode="before")
+    @classmethod
     def check_step_size(
-        cls, step_size: Optional[pydantic.PositiveFloat], values: Dict[str, Any]
+        cls, step_size: Optional[pydantic.PositiveFloat], info: ValidationInfo
     ) -> Optional[pydantic.PositiveFloat]:
-        optimizer_type = values.get("name")
+        optimizer_type = info.data.get("name")
         if step_size is not None and optimizer_type not in (
             OptimizerType.L_BFGS_B,
             OptimizerType.ADAM,
@@ -110,11 +112,12 @@ class CombinatorialOptimizer(OptimizerPreferences):
         description="Whether to check if all the solutions satisfy the constraints",
     )
 
-    @pydantic.validator("alpha_cvar", pre=True, always=True)
+    @pydantic.field_validator("alpha_cvar", mode="before")
+    @classmethod
     def check_alpha_cvar(
-        cls, alpha_cvar: Optional[PydanticAlphaParamCVAR], values: Dict[str, Any]
+        cls, alpha_cvar: Optional[PydanticAlphaParamCVAR], info: ValidationInfo
     ) -> Optional[PydanticAlphaParamCVAR]:
-        cost_type = values.get("cost_type")
+        cost_type = info.data.get("cost_type")
         if alpha_cvar is not None and cost_type != CostType.CVAR:
             raise ClassiqValueError("Use CVAR params only for CostType.CVAR.")
 

classiq/interface/executor/quantum_code.py

@@ -1,27 +1,27 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any, Dict, Optional, Tuple, Union
+from typing import Any, Optional, Union
 
 import pydantic
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict
+from pydantic_core.core_schema import ValidationInfo
 
 from classiq.interface.backend.ionq.ionq_quantum_program import IonqQuantumCircuit
 from classiq.interface.backend.pydantic_backend import PydanticArgumentNameType
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.executor.register_initialization import RegisterInitialization
 from classiq.interface.generator.synthesis_metadata.synthesis_execution_data import (
     ExecutionData,
 )
 
-from classiq.exceptions import ClassiqValueError
-
-Arguments = Dict[PydanticArgumentNameType, Any]
-MultipleArguments = Tuple[Arguments, ...]
+Arguments = dict[PydanticArgumentNameType, Any]
+MultipleArguments = tuple[Arguments, ...]
 CodeType = str
-RegistersInitialization = Dict[str, RegisterInitialization]
-Qubits = Tuple[int, ...]
-OutputQubitsMap = Dict[str, Qubits]
+RegistersInitialization = dict[str, RegisterInitialization]
+Qubits = tuple[int, ...]
+OutputQubitsMap = dict[str, Qubits]
 
 
 class QuantumBaseCode(BaseModel):
@@ -32,17 +32,18 @@ class QuantumBaseCode(BaseModel):
         ..., description="The textual representation of the program"
     )
 
-    @pydantic.validator("code")
+    @pydantic.field_validator("code")
+    @classmethod
     def load_quantum_program(
-        cls, code: Union[CodeType, IonqQuantumCircuit], values: Dict[str, Any]
+        cls, code: Union[CodeType, IonqQuantumCircuit], values: ValidationInfo
     ) -> CodeType:
-        syntax = values.get("syntax")
+        syntax = values.data.get("syntax")
         if isinstance(code, IonqQuantumCircuit):
             if syntax != QuantumInstructionSet.IONQ:
                 raise ClassiqValueError(
                     f"Invalid code type {type(code)} for syntax: {syntax}"
                 )
-            return code.json()
+            return code.model_dump_json()
 
         return code
 
@@ -57,41 +58,44 @@ class QuantumCode(QuantumBaseCode):
         description="The map of outputs to their qubits in the circuit.",
     )
     registers_initialization: Optional[RegistersInitialization] = pydantic.Field(
-        default_factory=None,
+        default=None,
         description="Initial conditions for the different registers in the circuit.",
     )
     synthesis_execution_data: Optional[ExecutionData] = pydantic.Field(default=None)
     synthesis_execution_arguments: Arguments = pydantic.Field(default_factory=dict)
+    model_config = ConfigDict(validate_assignment=True)
 
-    class Config:
-        validate_assignment = True
-
-    @pydantic.validator("arguments")
+    @pydantic.field_validator("arguments", mode="before")
+    @classmethod
     def validate_arguments(
-        cls, arguments: MultipleArguments, values: Dict[str, Any]
+        cls, arguments: MultipleArguments, info: ValidationInfo
     ) -> MultipleArguments:
-        if arguments and values.get("syntax") not in (
+        if arguments and info.data.get("syntax") not in (
             QuantumInstructionSet.QSHARP,
             QuantumInstructionSet.QASM,
         ):
             raise ClassiqValueError("Only QASM or Q# programs support arguments")
 
-        if values.get("syntax") == QuantumInstructionSet.QSHARP and len(arguments) > 1:
+        if (
+            info.data.get("syntax") == QuantumInstructionSet.QSHARP
+            and len(arguments) > 1
+        ):
             raise ClassiqValueError(
                 f"Q# programs supports only one group of arguments. {len(arguments)} given"
             )
 
         return arguments
 
-    @pydantic.validator("synthesis_execution_data")
+    @pydantic.field_validator("synthesis_execution_data")
+    @classmethod
     def validate_synthesis_execution_data(
         cls,
         synthesis_execution_data: Optional[ExecutionData],
-        values: Dict[str, Any],
+        values: ValidationInfo,
     ) -> Optional[ExecutionData]:
         if (
             synthesis_execution_data is not None
-            and values.get("syntax") is not QuantumInstructionSet.QASM
+            and values.data.get("syntax") is not QuantumInstructionSet.QASM
         ):
             raise ClassiqValueError("Only QASM supports the requested configuration")
 

classiq/interface/executor/quantum_instruction_set.py

@@ -1,5 +1,5 @@
-from classiq._internals.enum_utils import StrEnum
-from classiq.exceptions import ClassiqValueError
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
 
 
 class QuantumInstructionSet(StrEnum):

classiq/interface/executor/register_initialization.py

@@ -1,11 +1,9 @@
-from typing import Any, Dict, List
-
 import pydantic
+from typing_extensions import Self
 
+from classiq.interface.exceptions import ClassiqStateInitializationError
 from classiq.interface.generator.arith import number_utils
 
-from classiq.exceptions import ClassiqStateInitializationError
-
 _NON_INTEGER_INITIALIZATION_ERROR_MSG: str = (
     "Only natural numbers are supported as initial conditions"
 )
@@ -13,22 +11,21 @@ _NON_INTEGER_INITIALIZATION_ERROR_MSG: str = (
 
 class RegisterInitialization(pydantic.BaseModel):
     name: str
-    qubits: List[int]
+    qubits: list[int]
     initial_condition: pydantic.NonNegativeInt
 
-    @pydantic.validator("initial_condition", pre=True)
+    @pydantic.field_validator("initial_condition", mode="before")
+    @classmethod
     def _validate_initial_condition(cls, value: int) -> int:
         if not isinstance(value, int) or value < 0:
             raise ClassiqStateInitializationError(_NON_INTEGER_INITIALIZATION_ERROR_MSG)
         return value
 
-    @pydantic.root_validator()
-    def _validate_register_initialization(
-        cls, values: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        qubits: List[int] = values.get("qubits", list())
-        initial_condition: int = values.get("initial_condition", 0)
-        name: str = values.get("name", "")
+    @pydantic.model_validator(mode="after")
+    def _validate_register_initialization(self) -> Self:
+        qubits: list[int] = self.qubits or []
+        initial_condition: int = self.initial_condition or 0
+        name: str = self.name or ""
 
         initial_condition_length = number_utils.size(initial_condition)
         register_length = len(qubits)
@@ -36,4 +33,4 @@ class RegisterInitialization(pydantic.BaseModel):
             raise ClassiqStateInitializationError(
                 f"Register {name} has {register_length} qubits, which is not enough to represent the number {initial_condition}."
             )
-        return values
+        return self

classiq/interface/executor/result.py

@@ -1,54 +1,64 @@
 import functools
 import operator
 from collections import defaultdict
+from collections.abc import Iterator, Mapping
 from typing import (
+    TYPE_CHECKING,
     Any,
     DefaultDict,
-    Dict,
-    Iterator,
-    List,
-    Mapping,
     Optional,
-    Tuple,
     Union,
 )
 
 import pydantic
 from pydantic import BaseModel
-from typing_extensions import TypeAlias
+from typing_extensions import Self, TypeAlias
 
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.quantum_code import OutputQubitsMap, Qubits
 from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.complex_type import Complex
 from classiq.interface.generator.functions.classical_type import QmodPyObject
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonNegIntTuple
+from classiq.interface.helpers.datastructures import get_sdk_compatible_python_object
 from classiq.interface.helpers.versioned_model import VersionedModel
 
-from classiq.exceptions import ClassiqError
-
 _ILLEGAL_QUBIT_ERROR_MSG: str = "Illegal qubit index requested"
 _REPEATED_QUBIT_ERROR_MSG: str = "Requested a qubit more than once"
 _UNAVAILABLE_OUTPUT_ERROR_MSG: str = "Requested output doesn't exist in the circuit"
 
 State: TypeAlias = str
 Name: TypeAlias = str
-RegisterValue: TypeAlias = Union[float, int]
+RegisterValue: TypeAlias = Union[float, int, list, dict]
 MeasuredShots: TypeAlias = pydantic.NonNegativeInt
 ParsedState: TypeAlias = Mapping[Name, RegisterValue]
 ParsedStates: TypeAlias = Mapping[State, ParsedState]
-Counts: TypeAlias = Dict[State, MeasuredShots]
-StateVector: TypeAlias = Optional[Dict[str, Any]]
+Counts: TypeAlias = dict[State, MeasuredShots]
+StateVector: TypeAlias = Optional[dict[str, Complex]]
+
+if TYPE_CHECKING:
+    DotAccessParsedState = Mapping[Name, Any]
+else:
+    DotAccessParsedState = ParsedState
 
 
 class SampledState(BaseModel):
-    state: ParsedState
+    state: DotAccessParsedState
     shots: MeasuredShots
 
     def __repr__(self) -> str:
         return f"{self.state}: {self.shots}"
 
+    @pydantic.field_validator("state", mode="after")
+    @classmethod
+    def _make_state_sdk_compatible(cls, state: ParsedState) -> DotAccessParsedState:
+        return {
+            name: get_sdk_compatible_python_object(value)
+            for name, value in state.items()
+        }
+
 
-ParsedCounts: TypeAlias = List[SampledState]
+ParsedCounts: TypeAlias = list[SampledState]
 
 
 class SimulatedState(BaseModel):
@@ -60,7 +70,8 @@ class SimulatedState(BaseModel):
         return self.state[item]
 
 
-ParsedStateVector: TypeAlias = List[SimulatedState]
+SimulatedState.model_rebuild()
+ParsedStateVector: TypeAlias = list[SimulatedState]
 
 
 class VaRResult(BaseModel):
@@ -69,10 +80,10 @@ class VaRResult(BaseModel):
 
 
 class GroverSimulationResults(VersionedModel):
-    result: Dict[str, Any]
+    result: dict[str, Any]
 
 
-def _validate_qubit_indices(counts: Counts, indices: Tuple[int, ...]) -> None:
+def _validate_qubit_indices(counts: Counts, indices: tuple[int, ...]) -> None:
     if not indices:
         raise ClassiqError(_ILLEGAL_QUBIT_ERROR_MSG)
 
@@ -83,7 +94,7 @@ def _validate_qubit_indices(counts: Counts, indices: Tuple[int, ...]) -> None:
         raise ClassiqError(_REPEATED_QUBIT_ERROR_MSG)
 
 
-def _slice_str(s: str, indices: Tuple[int, ...]) -> str:
+def _slice_str(s: str, indices: tuple[int, ...]) -> str:
     return "".join(s[i] for i in indices)
 
 
@@ -101,7 +112,7 @@ def get_sampled_state(
 
 
 def reduce_parsed_states(
-    parsed_states: ParsedStates, outputs: Tuple[Name, ...]
+    parsed_states: ParsedStates, outputs: tuple[Name, ...]
 ) -> ParsedStates:
     return {
         state: {
@@ -122,8 +133,25 @@ def get_parsed_counts(counts: Counts, parsed_states: ParsedStates) -> ParsedCoun
     return sorted(parsed_counts, key=lambda k: k.shots, reverse=True)
 
 
+def prepare_parsed_state_vector(
+    state_vector: StateVector, parsed_state_vector_states: ParsedStates
+) -> Optional[ParsedStateVector]:
+    if not state_vector:
+        return None
+
+    parsed_state_vector = [
+        SimulatedState(
+            state=parsed_state_vector_states[bitstring],
+            bitstring=bitstring,
+            amplitude=complex(amplitude_str),
+        )
+        for bitstring, amplitude_str in state_vector.items()
+    ]
+    return sorted(parsed_state_vector, key=lambda k: abs(k.amplitude), reverse=True)
+
+
 class ExecutionDetails(BaseModel, QmodPyObject):
-    vendor_format_result: Dict[str, Any] = pydantic.Field(
+    vendor_format_result: dict[str, Any] = pydantic.Field(
         ..., description="Result in proprietary vendor format"
     )
     counts: Counts = pydantic.Field(
@@ -133,11 +161,14 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         True,
         description="Is the qubit order of counts field such that the LSB is right?",
     )
+    probabilities: dict[State, pydantic.NonNegativeFloat] = pydantic.Field(
+        default_factory=dict, description="Probabilities of each state"
+    )
     parsed_states: ParsedStates = pydantic.Field(
         default_factory=dict,
         description="A mapping between the raw states of counts (bitstrings) to their parsed states (registers' values)",
     )
-    histogram: Optional[Dict[State, pydantic.NonNegativeFloat]] = pydantic.Field(
+    histogram: Optional[dict[State, pydantic.NonNegativeFloat]] = pydantic.Field(
         None,
         description="Histogram of probability per state (an alternative to counts)",
     )
@@ -149,7 +180,7 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         default=None,
         description="The state vector when executed on a simulator, with LSB right qubit order",
     )
-    parsed_state_vector_states: ParsedStates = pydantic.Field(
+    parsed_state_vector_states: Optional[ParsedStates] = pydantic.Field(
         default=None,
         description="A mapping between the raw states of the state vector (bitstrings) to their parsed states (registers' values)",
     )
@@ -161,22 +192,23 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         default=None, description="The total number of shots the circuit was executed"
     )
 
-    @pydantic.validator("counts", pre=True)
+    @pydantic.field_validator("counts", mode="after")
+    @classmethod
     def _clean_spaces_from_counts_keys(cls, v: Counts) -> Counts:
         if not v or " " not in list(v.keys())[0]:
             return v
         return {state.replace(" ", ""): v[state] for state in v}
 
-    @pydantic.validator("num_shots", always=True)
-    def _validate_num_shots(
-        cls, num_shots: Optional[int], values: Dict[str, Any]
-    ) -> Optional[int]:
-        if num_shots is not None:
-            return num_shots
-        counts = values.get("counts")
-        if not counts:
-            return None
-        return sum(shots for _, shots in counts.items())
+    @pydantic.model_validator(mode="after")
+    def _validate_num_shots(self) -> Self:
+        if isinstance(self, ExecutionDetails):
+            if self.num_shots is not None:
+                return self
+            counts = self.counts
+            if not counts:
+                return self
+            self.num_shots = sum(shots for _, shots in counts.items())
+        return self
 
     @property
     def parsed_counts(self) -> ParsedCounts:
@@ -184,17 +216,11 @@ class ExecutionDetails(BaseModel, QmodPyObject):
 
     @property
     def parsed_state_vector(self) -> Optional[ParsedStateVector]:
-        if not self.state_vector:
-            return None
-        parsed_state_vector = [
-            SimulatedState(
-                state=self.parsed_state_vector_states[bitstring],
-                bitstring=bitstring,
-                amplitude=complex(amplitude_str),
-            )
-            for bitstring, amplitude_str in self.state_vector.items()
-        ]
-        return sorted(parsed_state_vector, key=lambda k: abs(k.amplitude), reverse=True)
+        if TYPE_CHECKING:
+            assert self.parsed_state_vector_states is not None
+        return prepare_parsed_state_vector(
+            self.state_vector, self.parsed_state_vector_states
+        )
 
     def flip_execution_counts_bitstring(self) -> None:
         """Backends should return result count bitstring in right to left form"""
@@ -225,15 +251,15 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         return self.counts_of_qubits(*self.output_qubits_map[output_name])
 
     def counts_of_multiple_outputs(
-        self, output_names: Tuple[Name, ...]
-    ) -> Dict[Tuple[State, ...], pydantic.NonNegativeInt]:
+        self, output_names: tuple[Name, ...]
+    ) -> dict[tuple[State, ...], pydantic.NonNegativeInt]:
         if any(name not in self.output_qubits_map for name in output_names):
             raise ClassiqError(_UNAVAILABLE_OUTPUT_ERROR_MSG)
 
-        output_regs: Tuple[Qubits, ...] = tuple(
+        output_regs: tuple[Qubits, ...] = tuple(
             self.output_qubits_map[name] for name in output_names
         )
-        reduced_counts: DefaultDict[Tuple[State, ...], int] = defaultdict(int)
+        reduced_counts: DefaultDict[tuple[State, ...], int] = defaultdict(int)
         for state_str, state_count in self.counts_by_qubit_order(
             lsb_right=False
         ).items():
@@ -242,7 +268,7 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         return dict(reduced_counts)
 
     def parsed_counts_of_outputs(
-        self, output_names: Union[Name, Tuple[Name, ...]]
+        self, output_names: Union[Name, tuple[Name, ...]]
     ) -> ParsedCounts:
         if isinstance(output_names, Name):
             output_names = (output_names,)
@@ -252,8 +278,8 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         reduced_parsed_states = reduce_parsed_states(self.parsed_states, output_names)
         return get_parsed_counts(self.counts, reduced_parsed_states)
 
-    def register_output_from_qubits(self, qubits: Tuple[int, ...]) -> Dict[float, int]:
-        register_output: Dict[float, int] = {}
+    def register_output_from_qubits(self, qubits: tuple[int, ...]) -> dict[float, int]:
+        register_output: dict[float, int] = {}
         value_from_str_bin = functools.partial(
             self._get_register_value_from_binary_string_results, register_qubits=qubits
         )
@@ -261,13 +287,15 @@ class ExecutionDetails(BaseModel, QmodPyObject):
             lsb_right=False
         ).items():
             value = value_from_str_bin(binary_string=results_binary_key)
+            if TYPE_CHECKING:
+                assert isinstance(value, float)
             register_output[value] = register_output.get(value, 0) + counts
 
         return register_output
 
     @staticmethod
     def _get_register_value_from_binary_string_results(
-        binary_string: str, register_qubits: List[int]
+        binary_string: str, register_qubits: list[int]
     ) -> RegisterValue:
         register_binary_string = "".join(
             operator.itemgetter(*register_qubits)(binary_string)
@@ -276,28 +304,27 @@ class ExecutionDetails(BaseModel, QmodPyObject):
 
 
 class MultipleExecutionDetails(VersionedModel):
-    details: List[ExecutionDetails]
+    details: list[ExecutionDetails]
 
     def __getitem__(self, index: int) -> ExecutionDetails:
         return self.details[index]
 
 
-class EstimationMetadata(BaseModel, extra=pydantic.Extra.allow):
+class EstimationMetadata(BaseModel, extra="allow"):
     shots: Optional[pydantic.NonNegativeInt] = None
     remapped_qubits: bool = False
-    input_qubit_map: Optional[List[PydanticNonNegIntTuple]] = None
+    input_qubit_map: Optional[list[PydanticNonNegIntTuple]] = None
 
 
 class EstimationResult(BaseModel, QmodPyObject):
     value: Complex = pydantic.Field(..., description="Estimation for the operator")
-    variance: Complex = pydantic.Field(..., description="Variance of the estimation")
     metadata: EstimationMetadata = pydantic.Field(
         ..., description="Metadata for the estimation"
     )
 
 
 class EstimationResults(VersionedModel):
-    results: List[EstimationResult]
+    results: list[EstimationResult]
 
     def __len__(self) -> int:
         return len(self.results)

classiq/interface/executor/vqe_result.py

@@ -1,7 +1,7 @@
 import base64
 import io
 from datetime import datetime
-from typing import Dict, List, Optional, Tuple
+from typing import Optional
 
 import pydantic
 from PIL import Image
@@ -12,14 +12,14 @@ from classiq.interface.generator.complex_type import Complex
 from classiq.interface.generator.functions.classical_type import QmodPyObject
 from classiq.interface.helpers.custom_pydantic_types import PydanticProbabilityFloat
 
-Solution = Tuple[int, ...]
+Solution = tuple[int, ...]
 
 
 class SolverResult(BaseModel):
     energy: float
     # TODO: add time units (like seconds)
     time: Optional[float] = None
-    solution: Optional[Solution]
+    solution: Optional[Solution] = None
 
 
 class SolutionData(BaseModel):
@@ -34,13 +34,13 @@ class VQEIntermediateData(BaseModel):
     iteration_number: pydantic.PositiveInt = pydantic.Field(
         description="The iteration's number (evaluation count)"
     )
-    parameters: List[float] = pydantic.Field(
+    parameters: list[float] = pydantic.Field(
         description="The optimizer parameters for the variational form"
     )
     mean_all_solutions: Optional[float] = pydantic.Field(
         default=None, description="The mean score of all solutions in this iteration"
     )
-    solutions: List[SolutionData] = pydantic.Field(
+    solutions: list[SolutionData] = pydantic.Field(
         description="Solutions found in this iteration, their score and"
         "number of repetitions"
     )
@@ -50,11 +50,11 @@ class VQEIntermediateData(BaseModel):
 
 
 class VQESolverResult(SolverResult, QmodPyObject):
-    eigenstate: Dict[str, Complex]
-    reduced_probabilities: Optional[Dict[str, float]] = None
+    eigenstate: dict[str, Complex]
+    reduced_probabilities: Optional[dict[str, float]] = None
     optimized_circuit_sample_results: ExecutionDetails
-    intermediate_results: List[VQEIntermediateData]
-    optimal_parameters: Dict[str, float]
+    intermediate_results: list[VQEIntermediateData]
+    optimal_parameters: dict[str, float]
     convergence_graph_str: str
     num_solutions: Optional[int] = None
     num_shots: int
@@ -63,7 +63,7 @@ class VQESolverResult(SolverResult, QmodPyObject):
         self.convergence_graph.show()
 
     @property
-    def convergence_graph(self):
+    def convergence_graph(self) -> Image.Image:
         return Image.open(io.BytesIO(base64.b64decode(self.convergence_graph_str)))
 
     @property