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

classiq/interface/executor/{quantum_program.py → quantum_code.py}

@@ -1,28 +1,30 @@
 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 import ionq_quantum_program
+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,
 )
 
-Arguments = Dict[PydanticArgumentNameType, Any]
-MultipleArguments = Tuple[Arguments, ...]
-CodeType = Union[str, ionq_quantum_program.IonqQuantumCircuit]
-RegistersInitialization = Dict[str, RegisterInitialization]
-Qubits = Tuple[int, ...]
-OutputQubitsMap = Dict[str, Qubits]
+Arguments = dict[PydanticArgumentNameType, Any]
+MultipleArguments = tuple[Arguments, ...]
+CodeType = str
+RegistersInitialization = dict[str, RegisterInitialization]
+Qubits = tuple[int, ...]
+OutputQubitsMap = dict[str, Qubits]
 
 
-class QuantumBaseProgram(BaseModel):
+class QuantumBaseCode(BaseModel):
     syntax: QuantumInstructionSet = pydantic.Field(
         default=QuantumInstructionSet.QASM, description="The syntax of the program."
     )
@@ -30,18 +32,23 @@ class QuantumBaseProgram(BaseModel):
         ..., description="The textual representation of the program"
     )
 
-    @pydantic.validator("code")
-    def load_quantum_program(cls, code: CodeType, values: Dict[str, Any]) -> CodeType:
-        if not isinstance(code, str):
-            return code
+    @pydantic.field_validator("code")
+    @classmethod
+    def load_quantum_program(
+        cls, code: Union[CodeType, IonqQuantumCircuit], values: ValidationInfo
+    ) -> CodeType:
+        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.model_dump_json()
 
-        syntax = values.get("syntax")
-        if syntax == QuantumInstructionSet.IONQ:
-            return ionq_quantum_program.IonqQuantumCircuit.from_string(code)
         return code
 
 
-class QuantumProgram(QuantumBaseProgram):
+class QuantumCode(QuantumBaseCode):
     arguments: MultipleArguments = pydantic.Field(
         default=(),
         description="The parameters dictionary for a parametrized quantum program.",
@@ -51,43 +58,46 @@ class QuantumProgram(QuantumBaseProgram):
         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 ValueError("Only QASM or Q# programs support arguments")
+            raise ClassiqValueError("Only QASM or Q# programs support arguments")
 
-        if values.get("syntax") == QuantumInstructionSet.QSHARP and len(arguments) > 1:
-            raise ValueError(
+        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 ValueError("Only QASM supports the requested configuration")
+            raise ClassiqValueError("Only QASM supports the requested configuration")
 
         return synthesis_execution_data
 
@@ -96,9 +106,9 @@ class QuantumProgram(QuantumBaseProgram):
         file_path: Union[str, Path],
         syntax: Optional[Union[str, QuantumInstructionSet]] = None,
         arguments: MultipleArguments = (),
-    ) -> QuantumProgram:
+    ) -> QuantumCode:
         path = Path(file_path)
         code = path.read_text()
         if syntax is None:
             syntax = QuantumInstructionSet.from_suffix(path.suffix.lstrip("."))
-        return QuantumProgram(syntax=syntax, code=code, arguments=arguments)
+        return QuantumCode(syntax=syntax, code=code, arguments=arguments)

classiq/interface/executor/quantum_instruction_set.py

@@ -1,4 +1,5 @@
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
 
 
 class QuantumInstructionSet(StrEnum):
@@ -14,4 +15,4 @@ class QuantumInstructionSet(StrEnum):
             return QuantumInstructionSet.QSHARP
         if suffix == "ionq":
             return QuantumInstructionSet.IONQ
-        raise ValueError("Illegal suffix")
+        raise ClassiqValueError("Illegal suffix")

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,29 +11,26 @@ _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, machine_precision=number_utils.MAX_FRACTION_PLACES
-        )
+        initial_condition_length = number_utils.size(initial_condition)
         register_length = len(qubits)
         if initial_condition_length > register_length:
             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,51 +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.executor.quantum_program import OutputQubitsMap, Qubits
+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):
@@ -57,7 +70,8 @@ class SimulatedState(BaseModel):
         return self.state[item]
 
 
-ParsedStateVector: TypeAlias = List[SimulatedState]
+SimulatedState.model_rebuild()
+ParsedStateVector: TypeAlias = list[SimulatedState]
 
 
 class VaRResult(BaseModel):
@@ -66,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)
 
@@ -80,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)
 
 
@@ -97,8 +111,47 @@ def get_sampled_state(
     return None
 
 
+def reduce_parsed_states(
+    parsed_states: ParsedStates, outputs: tuple[Name, ...]
+) -> ParsedStates:
+    return {
+        state: {
+            output: value for output, value in parsed_state.items() if output in outputs
+        }
+        for state, parsed_state in parsed_states.items()
+    }
+
+
+def get_parsed_counts(counts: Counts, parsed_states: ParsedStates) -> ParsedCounts:
+    parsed_counts: ParsedCounts = []
+    for bitstring, count in counts.items():
+        parsed_state = parsed_states[bitstring]
+        if sampled_state := get_sampled_state(parsed_counts, parsed_state):
+            sampled_state.shots += count
+        else:
+            parsed_counts.append(SampledState(state=parsed_state, shots=count))
+    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(
@@ -108,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)",
     )
@@ -124,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)",
     )
@@ -136,47 +192,35 @@ 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:
-        parsed_counts: ParsedCounts = []
-        for bitstring, count in self.counts.items():
-            parsed_state = self.parsed_states[bitstring]
-            if sampled_state := get_sampled_state(parsed_counts, parsed_state):
-                sampled_state.shots += count
-            else:
-                parsed_counts.append(SampledState(state=parsed_state, shots=count))
-        return sorted(parsed_counts, key=lambda k: k.shots, reverse=True)
+        return get_parsed_counts(self.counts, self.parsed_states)
 
     @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"""
@@ -207,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():
@@ -223,8 +267,19 @@ class ExecutionDetails(BaseModel, QmodPyObject):
             reduced_counts[reduced_strs] += state_count
         return dict(reduced_counts)
 
-    def register_output_from_qubits(self, qubits: Tuple[int, ...]) -> Dict[float, int]:
-        register_output: Dict[float, int] = {}
+    def parsed_counts_of_outputs(
+        self, output_names: Union[Name, tuple[Name, ...]]
+    ) -> ParsedCounts:
+        if isinstance(output_names, Name):
+            output_names = (output_names,)
+        if any(name not in self.output_qubits_map for name in output_names):
+            raise ClassiqError(_UNAVAILABLE_OUTPUT_ERROR_MSG)
+
+        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] = {}
         value_from_str_bin = functools.partial(
             self._get_register_value_from_binary_string_results, register_qubits=qubits
         )
@@ -232,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)
@@ -247,33 +304,34 @@ 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)
 
-    def __iter__(self) -> Iterator[EstimationResult]:  # type: ignore
+    def __iter__(self) -> Iterator[EstimationResult]:  # type: ignore[override]
+        # TODO This is a bug waiting to happen. We change the meaning of
+        # __iter__ in a derived class.
         return iter(self.results)
 
     def __getitem__(self, index: int) -> EstimationResult:

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]
-    solution: Optional[Solution]
+    time: Optional[float] = None
+    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