classiq 0.43.3__py3-none-any.whl → 0.45.0__py3-none-any.whl

classiq/applications/hamiltonian/pauli_decomposition.py

@@ -0,0 +1,113 @@
+from typing import List, Tuple, Union
+
+import numpy as np
+from sympy import fwht
+
+from classiq.qmod import (  # type:ignore[attr-defined]
+    Pauli,
+    PauliTerm,
+)
+
+ATOL = 1e-12
+PAULI_MATRICES_DICT = {
+    Pauli.I: np.array([[1, 0], [0, 1]], dtype=np.complex128),
+    Pauli.Z: np.array([[1, 0], [0, -1]], dtype=np.complex128),
+    Pauli.X: np.array([[0, 1], [1, 0]], dtype=np.complex128),
+    Pauli.Y: np.array([[0, -1j], [1j, 0]], dtype=np.complex128),
+}
+
+
+def _get_pauli_string(set_index: int, term_index: int, num_qubits: int) -> List[Pauli]:
+    """
+    The basis of 4^N Pauli strings on N qubits can be partitioned to 2^N sets, each contains 2^N Pauli strings.
+    In the k-th set we have Pauli strings of the form s_1s_2...s_N, where s_j is in {I,Z} if k_j is 0,
+    and in {X,iY} if k_j=1. The function get_pauli_string returns the m-th Pauli string in the k-th set of Pauli strings
+    """
+
+    # returns the Pauli (I,Z) or (iY, X) appearing in the pauli_index position for a given set
+    def _get_paulis_for_set(set_index: int, pauli_index: int) -> Tuple[Pauli, Pauli]:
+        if (set_index >> pauli_index) & 1:
+            return Pauli.Y, Pauli.X
+        else:
+            return Pauli.Z, Pauli.I
+
+    return [
+        (
+            _get_paulis_for_set(set_index, s)[0]
+            if (term_index >> s) & 1
+            else _get_paulis_for_set(set_index, s)[1]
+        )
+        for s in range(num_qubits)
+    ][::-1]
+
+
+def _coefficents_for_set(mat: np.ndarray, set_index: int) -> list:
+    """
+    The 2^N coefficients in a 2^N x 2^N matrix that are decomposed to the elements
+    in the k-th set are the indices [i,j] such that i^j=k
+    The function coefficents_for_set returns the matrix entries that are decomposed to the same Pauli strigs set
+    """
+    return [mat[k, k ^ set_index] / len(mat) for k in range(len(mat))]
+
+
+def _get_signed_coefficient(
+    c: complex, k: int, i: int, is_hermitian: bool
+) -> Union[complex, float]:
+    # correct from iY to Y
+    coef = complex((1j) ** ((i & k).bit_count()) * c)
+    if is_hermitian:
+        return coef.real
+    else:
+        return coef
+
+
+def matrix_to_hamiltonian(
+    mat: np.ndarray, tol: float = ATOL, is_hermitian: bool = True
+) -> List[PauliTerm]:
+    """
+    The decomposition per set is done by the Walsh-Hadamard transform,
+    since the transformation between {e_0,e_3} ({e_1,e_2}) to {I,Z} ({X,iY}) is the Hadamard matrix.
+    """
+    mat.shape[0] != 0, "matrix is of size 0"
+    if is_hermitian:
+        assert np.allclose(
+            mat, np.conjugate(mat.T)
+        ), "Matrix is not hermitian, please pass is_hermitian=False"
+    assert mat.shape[0] == mat.shape[1], "Matrix is not square"
+    mat_dimension = mat.shape[0]
+    assert mat_dimension.bit_count() == 1, "Matrix dimension is not a power of 2"
+    num_qubits = (mat_dimension - 1).bit_length()
+    hamiltonian = []
+    for k in range(2**num_qubits):
+        coef = fwht(
+            _coefficents_for_set(mat, k)
+        )  # the transformation per set is given by the Walsh-Hadamard transform
+        hamiltonian += [
+            PauliTerm(
+                pauli=_get_pauli_string(k, i, num_qubits),
+                coefficient=_get_signed_coefficient(coef[i], k, i, is_hermitian),
+            )
+            for i in range(2**num_qubits)
+            if abs(coef[i]) > tol
+        ]
+    return hamiltonian
+
+
+# convert a single puali string of length N to 2**N X 2**N matrix
+def pauli_string_to_mat(seq: List[Pauli]) -> np.ndarray:
+    real_matrix = PAULI_MATRICES_DICT[seq[0]]
+    for p in seq[1:]:
+        real_matrix = np.kron(real_matrix, PAULI_MATRICES_DICT[p])
+    return real_matrix
+
+
+# return matrix from hamiltonian
+def hamiltonian_to_matrix(hamiltonian: List[PauliTerm]) -> np.ndarray:
+    matrix = np.zeros(
+        [2 ** len(hamiltonian[0].pauli), 2 ** len(hamiltonian[0].pauli)],
+        dtype=np.complex_,
+    )
+    for p in hamiltonian:
+        matrix += p.coefficient * pauli_string_to_mat(p.pauli)
+
+    return matrix

classiq/applications/qnn/circuit_utils.py

@@ -4,12 +4,12 @@ from typing import Iterable, List, Tuple, Union
 
 from torch import Tensor
 
+from classiq.interface.exceptions import ClassiqQNNError, ClassiqValueError
 from classiq.interface.generator.circuit_code.types_and_constants import QasmVersion
 from classiq.interface.generator.model.preferences.preferences import QuantumFormat
 from classiq.interface.generator.quantum_program import QuantumProgram
 
 from classiq.applications.qnn.types import Arguments, Circuit
-from classiq.exceptions import ClassiqQNNError, ClassiqValueError
 
 WEIGHT_INITIALS = ["weight_", "w_"]
 INPUT_INITIALS = ["input_", "i_"]

classiq/applications/qnn/datasets/dataset_base_classes.py

@@ -4,8 +4,9 @@ from typing import List, Literal, Optional, Sequence, Tuple, TypeVar, Union
 from torch import Tensor, tensor
 from torch.utils.data import Dataset
 
+from classiq.interface.exceptions import ClassiqIndexError, ClassiqValueError
+
 from classiq.applications.qnn.types import DataAndLabel, Transform
-from classiq.exceptions import ClassiqIndexError, ClassiqValueError
 
 T = TypeVar("T")
 

classiq/applications/qnn/datasets/dataset_not.py

@@ -1,10 +1,11 @@
+from classiq.interface.exceptions import ClassiqIndexError
+
 from classiq.applications.qnn.datasets.dataset_base_classes import MyDataset
 from classiq.applications.qnn.datasets.datasets_utils import (
     all_bits_to_one,
     all_bits_to_zero,
 )
 from classiq.applications.qnn.types import DataAndLabel
-from classiq.exceptions import ClassiqIndexError
 
 
 class DatasetNot(MyDataset):

classiq/applications/qnn/qlayer.py

@@ -6,6 +6,8 @@ import torch.nn as nn
 from torch import Tensor
 from torch.nn.parameter import Parameter
 
+from classiq.interface.exceptions import ClassiqQNNError, ClassiqTorchError
+
 from classiq.applications.qnn.circuit_utils import (
     extract_parameters,
     is_single_layer_circuit,
@@ -26,7 +28,6 @@ from classiq.applications.qnn.types import (
     MultipleArguments,
     PostProcessFunction,
 )
-from classiq.exceptions import ClassiqQNNError, ClassiqTorchError
 from classiq.synthesis import SerializedQuantumProgram
 
 
@@ -181,6 +182,6 @@ class QLayer(nn.Module):
         self.weight = Parameter(value)
 
     def forward(self, x: Tensor) -> Tensor:
-        return QLayerFunction.apply(  # type: ignore[no-untyped-call]
+        return QLayerFunction.apply(
             x, self.weight, self.quantum_program, self._execute, self._post_process
         )

classiq/applications/qnn/torch_utils.py

@@ -6,6 +6,8 @@ import torch
 import torch.nn as nn
 from torch import Tensor
 
+from classiq.interface.exceptions import ClassiqValueError
+
 from classiq.applications.qnn.circuit_utils import is_single_layer_circuit
 from classiq.applications.qnn.types import (
     ExecuteFuncitonOnlyArguments,
@@ -13,7 +15,6 @@ from classiq.applications.qnn.types import (
     Shape,
     TensorToArgumentsCallable,
 )
-from classiq.exceptions import ClassiqValueError
 
 
 def get_shape_second_dimension(shape: torch.Size) -> int:

classiq/applications/qsvm/qsvm_model_constructor.py

@@ -1,6 +1,7 @@
 from typing import Any, List, Tuple
 
 from classiq.interface.applications.qsvm import DataList, LabelsInt
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -11,7 +12,6 @@ from classiq.interface.model.native_function_definition import NativeFunctionDef
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 
-from classiq.exceptions import ClassiqValueError
 from classiq.qmod.builtins.enums import Pauli, QSVMFeatureMapEntanglement
 from classiq.qmod.utilities import qmod_val_to_expr_str
 

classiq/execution/execution_session.py

@@ -1,6 +1,7 @@
 import json
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union, cast
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.executor.execution_result import ResultsCollection
 from classiq.interface.executor.result import (
@@ -16,7 +17,6 @@ from classiq.applications.combinatorial_helpers.pauli_helpers.pauli_utils import
     _pauli_dict_to_str,
     _pauli_terms_to_qmod,
 )
-from classiq.exceptions import ClassiqValueError
 from classiq.executor import execute
 from classiq.qmod.builtins import PauliTerm
 from classiq.qmod.builtins.classical_execution_primitives import (

classiq/execution/jobs.py

@@ -1,8 +1,9 @@
 import webbrowser
 from datetime import datetime
-from typing import List, Optional, Union
+from typing import Any, List, Optional, Union
 from urllib.parse import urljoin
 
+from classiq.interface.exceptions import ClassiqAPIError
 from classiq.interface.execution.jobs import ExecutionJobDetailsV1
 from classiq.interface.executor.execution_request import ExecutionJobDetails
 from classiq.interface.executor.execution_result import ResultsCollection
@@ -13,7 +14,6 @@ from classiq._internals.api_wrapper import CLASSIQ_ACCEPT_HEADER, ApiWrapper
 from classiq._internals.async_utils import syncify_function
 from classiq._internals.client import client
 from classiq._internals.jobs import JobID, JobPoller
-from classiq.exceptions import ClassiqAPIError
 
 _JobDetails = Union[ExecutionJobDetails, ExecutionJobDetailsV1]
 
@@ -109,6 +109,9 @@ class ExecutionJob:
 
     result = syncify_function(result_async)
 
+    def result_value(self, *args: Any, **kwargs: Any) -> Any:
+        return self.result(*args, **kwargs)[0].value
+
     async def poll_async(self, timeout_sec: Optional[float] = None) -> None:
         if not self.status.is_final():
             await self._poll_job(timeout_sec=timeout_sec)

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

classiq/interface/analyzer/cytoscape_graph.py

@@ -2,10 +2,9 @@ from typing import Any, Dict, List, Optional
 
 import pydantic
 
+from classiq.interface.enum_utils import StrEnum
 from classiq.interface.helpers.versioned_model import VersionedModel
 
-from classiq._internals.enum_utils import StrEnum
-
 
 class CytoScapePosition(pydantic.BaseModel):
     x: int = pydantic.Field(

classiq/interface/analyzer/result.py

@@ -6,12 +6,11 @@ from pydantic import Field
 from typing_extensions import Annotated
 
 from classiq.interface.analyzer.analysis_params import MAX_FILE_LENGTH
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
 from classiq.interface.helpers.versioned_model import VersionedModel
 
-from classiq._internals.enum_utils import StrEnum
-from classiq.exceptions import ClassiqValueError
-
 Match = List[List[int]]
 
 

classiq/interface/ast_node.py

@@ -1,4 +1,3 @@
-import os
 from typing import Optional
 
 import pydantic
@@ -6,23 +5,7 @@ import pydantic
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
-
-
-class SourceReference(HashablePydanticBaseModel):
-    start_line: int
-    start_column: int
-    end_line: int
-    end_column: int
-    file_name: Optional[str] = pydantic.Field(default=None)
-
-    def __str__(self) -> str:
-        file_string = (
-            f"file {os.path.basename(self.file_name)} " if self.file_name else ""
-        )
-        start_character_string = (
-            f" character {self.start_column + 1}" if self.start_column > 0 else ""
-        )
-        return f"{file_string}line {self.start_line + 1}{start_character_string}"
+from classiq.interface.source_reference import SourceReference
 
 
 class ASTNode(HashablePydanticBaseModel):

classiq/interface/backend/backend_preferences.py

@@ -1,10 +1,9 @@
 from __future__ import annotations
 
-from datetime import timedelta
 from typing import Any, Dict, Iterable, List, Optional, Union
 
 import pydantic
-from pydantic import BaseModel, PrivateAttr, validator
+from pydantic import BaseModel, validator
 
 from classiq.interface.backend import pydantic_backend
 from classiq.interface.backend.quantum_backend_providers import (
@@ -19,11 +18,10 @@ from classiq.interface.backend.quantum_backend_providers import (
     ProviderTypeVendor,
     ProviderVendor,
 )
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.hardware import Provider
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 
-from classiq.exceptions import ClassiqValueError
-
 
 class BackendPreferences(BaseModel):
     # Due to the way the field is currently implemented, i.e. it redefined with different types
@@ -56,9 +54,6 @@ class BackendPreferences(BaseModel):
         return False
 
 
-AWS_DEFAULT_JOB_TIMEOUT_SECONDS = int(timedelta(minutes=240).total_seconds())
-
-
 class AliceBobBackendPreferences(BackendPreferences):
     backend_service_provider: ProviderTypeVendor.ALICE_BOB
     distance: Optional[int] = pydantic.Field(
@@ -76,7 +71,6 @@ class AliceBobBackendPreferences(BackendPreferences):
     api_key: pydantic_backend.PydanticAliceBobApiKeyType = pydantic.Field(
         ..., description="AliceBob API key"
     )
-    _parameters: Dict[str, Any] = PrivateAttr(default_factory=dict)
 
     @pydantic.root_validator(pre=True)
     def _set_backend_service_provider(cls, values: Dict[str, Any]) -> Dict[str, Any]:
@@ -86,14 +80,13 @@ class AliceBobBackendPreferences(BackendPreferences):
 
     @property
     def parameters(self) -> Dict[str, Any]:
-        self._parameters = {
+        parameters = {
             "distance": self.distance,
-            "kappa_1": self.kappa_1,
-            "kappa_2": self.kappa_2,
-            "average_nb_photons": self.average_nb_photons,
+            "kappa1": self.kappa_1,
+            "kappa2": self.kappa_2,
+            "averageNbPhotons": self.average_nb_photons,
         }
-        self._parameters = {k: v for k, v in self._parameters.items() if v is not None}
-        return self._parameters
+        return {k: v for k, v in parameters.items() if v is not None}
 
 
 class ClassiqBackendPreferences(BackendPreferences):
@@ -118,10 +111,6 @@ class AwsBackendPreferences(BackendPreferences):
     s3_folder: pydantic_backend.PydanticS3BucketKey = pydantic.Field(
         description="S3 Folder Path Within The S3 Bucket"
     )
-    job_timeout: pydantic_backend.PydanticExecutionTimeout = pydantic.Field(
-        description="Timeout for Jobs sent for execution in seconds.",
-        default=AWS_DEFAULT_JOB_TIMEOUT_SECONDS,
-    )
 
     @validator("s3_bucket_name")
     def _validate_s3_bucket_name(
@@ -156,6 +145,10 @@ class IBMBackendPreferences(BackendPreferences):
         default_factory=IBMBackendProvider,
         description="Provider specs. for identifying a single IBM Quantum provider.",
     )
+    qctrl_api_key: Optional[str] = pydantic.Field(
+        default=None,
+        description="QCTRL API key to access QCTRL optimization abilities",
+    )
 
     @pydantic.root_validator(pre=True)
     def _set_backend_service_provider(cls, values: Dict[str, Any]) -> Dict[str, Any]:

classiq/interface/backend/ionq/ionq_quantum_program.py

@@ -37,7 +37,7 @@ class IonqQuantumCircuit(BaseModel):
     circuit: List[Gate]
 
     # Ionq changes format sometimes.
-    #   One example is that `IonqQauntumCircuit` got a field name "gateset" with the value "qis"
+    #   One example is that `IonqQuantumCircuit` got a field name "gateset" with the value "qis"
     #   Another is that `Gate` got a field named "rotation"
     class Config:
         extra = pydantic.Extra.allow

classiq/interface/backend/pydantic_backend.py

@@ -1,4 +1,3 @@
-from datetime import timedelta
 from typing import TYPE_CHECKING
 
 import pydantic
@@ -11,12 +10,10 @@ INVALID_API_KEY: str = _IONQ_API_KEY_LENGTH * "a"
 INVALID_API_KEY_ALICE_BOB: str = _ALICE_BOB_API_KEY_LENGTH * "a"
 INVALID_EMAIL_OQC: str = "aa@aa.aa"
 INVALID_PASSWORD_OQC: str = "Aa1!Aa1!"
-MAX_EXECUTION_TIMEOUT_SECONDS = timedelta(hours=4).total_seconds()
 
 EXECUTION_PARAMETER_PATTERN = "[_a-z][_a-z0-9]*"
 
 if TYPE_CHECKING:
-    PydanticExecutionTimeout = int
     PydanticAwsRoleArn = str
     PydanticS3BucketKey = str
     PydanticS3BucketName = str
@@ -42,8 +39,6 @@ else:
 
     PydanticAliceBobApiKeyType = pydantic.constr(min_length=1, strip_whitespace=True)
 
-    PydanticExecutionTimeout = pydantic.conint(gt=0, le=MAX_EXECUTION_TIMEOUT_SECONDS)
-
     PydanticArgumentNameType = pydantic.constr(regex="[_a-zA-Z][_a-zA-Z0-9]*")
 
     PydanticExecutionParameter = pydantic.constr(regex=EXECUTION_PARAMETER_PATTERN)

classiq/interface/backend/quantum_backend_providers.py

@@ -1,6 +1,6 @@
 from typing import Literal, Union
 
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
 
 
 class AnalyzerProviderVendor(StrEnum):
@@ -41,8 +41,9 @@ class ClassiqSimulatorBackendNames(StrEnum):
 class IonqBackendNames(StrEnum):
     SIMULATOR = "simulator"
     HARMONY = "qpu.harmony"
-    ARIA = "qpu.aria-1"
-    S11 = "qpu.s11"
+    ARIA_1 = "qpu.aria-1"
+    ARIA_2 = "qpu.aria-2"
+    FORTE_1 = "qpu.forte-1"
 
 
 class AzureQuantumBackendNames(StrEnum):

classiq/interface/chemistry/fermionic_operator.py

@@ -6,12 +6,11 @@ from typing import Set, Tuple, Union
 import numpy as np
 import pydantic
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
 
-from classiq.exceptions import ClassiqValueError
-
 LadderOperator = Tuple[str, int]
 FermionicOperatorTuple = Tuple["FermionicOperator", float]
 

classiq/interface/chemistry/ground_state_problem.py

@@ -6,13 +6,12 @@ from typing_extensions import Annotated
 
 from classiq.interface.chemistry.fermionic_operator import SummedFermionicOperator
 from classiq.interface.chemistry.molecule import Molecule
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
 
-from classiq._internals.enum_utils import StrEnum
-from classiq.exceptions import ClassiqValueError
-
 """
 The correct type hint is:
 NumSpinUpParticles = pydantic.NonNegativeInt

classiq/interface/chemistry/molecule.py

@@ -3,13 +3,12 @@ from typing import List, Literal, Union
 import pydantic
 
 from classiq.interface.chemistry.elements import ELEMENTS
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.helpers.custom_pydantic_types import AtomType
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
 
-from classiq.exceptions import ClassiqValueError
-
 
 class Atom(HashablePydanticBaseModel):
     symbol: Literal[tuple(ELEMENTS)] = pydantic.Field(description="The atom symbol")  # type: ignore[valid-type]

classiq/interface/chemistry/operator.py

@@ -1,6 +1,5 @@
 from functools import reduce
 from typing import (
-    TYPE_CHECKING,
     Any,
     Collection,
     Dict,
@@ -16,12 +15,14 @@ import pydantic
 import sympy
 from more_itertools import all_equal
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.function_params import validate_expression_str
 from classiq.interface.generator.parameters import (
     ParameterComplexType,
     ParameterType,
     PydanticParameterComplexType,
 )
+from classiq.interface.generator.types.builtin_enum_declarations import Pauli
 from classiq.interface.helpers.custom_pydantic_types import (
     PydanticPauliList,
     PydanticPauliMonomial,
@@ -32,11 +33,6 @@ from classiq.interface.helpers.hashable_pydantic_base_model import (
 )
 from classiq.interface.helpers.versioned_model import VersionedModel
 
-from classiq.exceptions import ClassiqValueError
-
-if TYPE_CHECKING:
-    from classiq.qmod.builtins.enums import Pauli
-
 
 class PauliOperator(HashablePydanticBaseModel, VersionedModel):
     """
@@ -140,8 +136,12 @@ class PauliOperator(HashablePydanticBaseModel, VersionedModel):
     def num_qubits(self) -> int:
         return len(self.pauli_list[0][0])
 
+    @property
+    def all_coefficients_numeric(self) -> bool:
+        return all(isinstance(summand[1], complex) for summand in self.pauli_list)
+
     def to_matrix(self) -> np.ndarray:
-        if not all(isinstance(summand[1], complex) for summand in self.pauli_list):
+        if not self.all_coefficients_numeric:
             raise ClassiqValueError(
                 "Supporting only Hamiltonian with numeric coefficients."
             )
@@ -478,9 +478,7 @@ def validate_operator_has_no_complex_coefficients(
     return pauli_operator
 
 
-def pauli_integers_to_str(paulis: List["Pauli"]) -> str:
-    from classiq.qmod.builtins.enums import Pauli
-
+def pauli_integers_to_str(paulis: List[Pauli]) -> str:
     return "".join([Pauli(pauli).name for pauli in paulis])
 
 

classiq/interface/combinatorial_optimization/encoding_types.py

@@ -1,4 +1,4 @@
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
 
 
 class EncodingType(StrEnum):

classiq/interface/combinatorial_optimization/mht_qaoa_input.py

@@ -5,7 +5,7 @@ import numpy as np
 import pydantic
 from pydantic import BaseModel
 
-from classiq.exceptions import ClassiqValueError
+from classiq.interface.exceptions import ClassiqValueError
 
 _TOLERANCE_DECIMALS = 6
 

classiq/interface/combinatorial_optimization/solver_types.py

@@ -1,4 +1,4 @@
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
 
 
 class QSolver(StrEnum):

classiq/interface/debug_info/debug_info.py

@@ -0,0 +1,32 @@
+from typing import Dict, Optional, Union
+from uuid import UUID
+
+from pydantic import BaseModel, Field
+
+from classiq.interface.ide.visual_model import OperationLevel
+
+
+class FunctionDebugInfo(BaseModel):
+    name: str
+    parameters: Dict[str, Union[int, float, None]]
+    level: OperationLevel
+    is_allocate_or_free: bool = Field(default=False)
+
+
+class DebugInfoCollection(BaseModel):
+    # Pydantic only started supporting UUID as keys in Pydantic V2
+    # See https://github.com/pydantic/pydantic/issues/2096#issuecomment-814860206
+    # For now, we use strings as keys in the raw data and use UUID in the wrapper logic
+    data: Dict[str, FunctionDebugInfo] = Field(default_factory=dict)
+
+    def __setitem__(self, key: UUID, value: FunctionDebugInfo) -> None:
+        self.data[str(key)] = value
+
+    def get(self, key: UUID) -> Optional[FunctionDebugInfo]:
+        return self.data.get(str(key))
+
+    def __getitem__(self, key: UUID) -> FunctionDebugInfo:
+        return self.data[str(key)]
+
+    def __contains__(self, key: UUID) -> bool:
+        return str(key) in self.data

classiq/{exceptions.py → interface/exceptions.py}

@@ -176,3 +176,7 @@ class ClassiqExecutorInvalidHamiltonianError(ClassiqCombOptError):
 
 class ClassiqSemanticError(ClassiqError):
     pass
+
+
+class ClassiqDeprecationWarning(FutureWarning):
+    pass

classiq/interface/executor/aws_execution_cost.py

@@ -4,8 +4,8 @@ from typing import Any, Dict, List, Optional
 import pydantic
 from pydantic import validator
 
-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 Granularity(StrEnum):