qilisdk 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

qilisdk/analog/__init__.py

@@ -14,7 +14,7 @@
 
 from .algorithms import TimeEvolution
 from .hamiltonian import Hamiltonian, I, X, Y, Z
-from .quantum_objects import QuantumObject, basis, bra, expect, ket, tensor
+from .quantum_objects import QuantumObject, basis_state, bra, expect_val, ket, tensor_prod
 from .schedule import Schedule
 
 __all__ = [
@@ -26,9 +26,9 @@ __all__ = [
     "X",
     "Y",
     "Z",
-    "basis",
+    "basis_state",
     "bra",
-    "expect",
+    "expect_val",
     "ket",
-    "tensor",
+    "tensor_prod",
 ]

qilisdk/analog/quantum_objects.py

@@ -24,7 +24,11 @@ from scipy.sparse.linalg import norm as scipy_norm
 from qilisdk.yaml import yaml
 
 Complex = int | float | complex
-TWO = 2
+
+
+###############################################################################
+# Main Class Definition
+###############################################################################
 
 
 @yaml.register_class
@@ -39,9 +43,9 @@ class QuantumObject:
 
     The internal data is stored as a SciPy CSR (Compressed Sparse Row) matrix for
     efficient arithmetic and manipulation. The expected shapes for the data are:
-      - (2**N, 2**N) for operators or density matrices,
+      - (2**N, 2**N) for operators or density matrices (or scalars),
       - (2**N, 1) for ket states,
-      - (1, 2**N) for bra states.
+      - (1, 2**N) or (2**N,) for bra states.
     """
 
     def __init__(self, data: np.ndarray | sparray | spmatrix) -> None:
@@ -50,10 +54,12 @@ class QuantumObject:
 
         Converts a NumPy array to a CSR matrix if needed and validates the shape of the input.
         The input must represent a valid quantum state or operator with appropriate dimensions.
+        Notice that 1D arrays of shape (2N,) are considered/transformed to bras with shape (1, 2N).
 
         Args:
             data (np.ndarray | sparray | spmatrix): A dense NumPy array or a SciPy sparse matrix
-                representing a quantum state or operator.
+                representing a quantum state or operator. Should be of shape: (2**N, 2**N) for operators
+                (1, 2**N) for ket states, (2**N, 1) or (2**N,) for bra states, or (1, 1) for scalars.
 
         Raises:
             ValueError: If the input data is not a NumPy array or a SciPy sparse matrix,
@@ -65,21 +71,18 @@ class QuantumObject:
             self._data = data.tocsr()
         else:
             raise ValueError("Input must be a NumPy array or a SciPy sparse matrix")
-        invalid_shape = (
-            len(self._data.shape) > TWO
-            or (self._data.shape[0] == 1 and self._data.shape[1] != 1 and self._data.shape[1] % 2 != 0)
-            or (self._data.shape[1] == 1 and self._data.shape[0] != 1 and self._data.shape[0] % 2 != 0)
-            or (self._data.shape[0] != self._data.shape[1] and self._data.shape[0] != 1 and self._data.shape[1] != 1)
-            or (
-                self._data.shape[1] == self._data.shape[0] and self._data.shape[0] % 2 != 0 and self._data.shape[0] != 1
-            )
-        )
-        if invalid_shape:
+
+        # Valid shapes are operators = (2**N, 2**N) (scalars included), bra's = (1, 2**N) / (2**N,), or ket's =(2**N, 1):
+        valid_shape = self.is_operator() or self.is_ket() or self.is_bra()
+
+        if len(self._data.shape) != 2 or not valid_shape:  # noqa: PLR2004
             raise ValueError(
                 "Dimension of data is wrong. expected data to have shape similar to (2**N, 2**N), (1, 2**N), (2**N, 1)",
                 f"but received {self._data.shape}",
             )
 
+    # ------------- Properties --------------
+
     @property
     def data(self) -> csr_matrix:
         """
@@ -126,7 +129,9 @@ class QuantumObject:
         """
         return self._data.shape
 
-    def dag(self) -> QuantumObject:
+    # ----------- Matrix Logic Operations ------------
+
+    def adjoint(self) -> QuantumObject:
         """
         Compute the adjoint (conjugate transpose) of the QuantumObject.
 
@@ -141,9 +146,9 @@ class QuantumObject:
         Compute the partial trace over subsystems not in 'keep'.
 
         This method calculates the reduced density matrix by tracing out
-        the subsystems that are not specified in the 'keep' parameter. The
-        input 'dims' represents the dimensions of each subsystem, and 'keep'
-        indicates the indices of the subsystems to be retained.
+        the subsystems that are not specified in the 'keep' parameter.
+        The input 'dims' represents the dimensions of each subsystem,
+        and 'keep' indicates the indices of the subsystems to be retained.
 
         Args:
             dims (list[int]): A list specifying the dimensions of each subsystem.
@@ -162,26 +167,22 @@ class QuantumObject:
         if rho.shape != (total_dim, total_dim):
             raise ValueError("Dimension mismatch between provided dims and QuantumObject shape")
 
-        n = len(dims)
         # Use letters from the ASCII alphabet (both cases) for einsum indices.
         # For each subsystem, assign two letters: one for the row index and one for the column index.
-        row_letters = []
-        col_letters = []
-        out_row = []  # Letters that will remain in the output for the row part.
-        out_col = []  # Letters for the column part.
+        row_letters, col_letters = [], []
+        out_row, out_col = [], []  # Letters that will remain in the output for the row part and for the column part.
         letters = iter(string.ascii_letters)
 
-        for i in range(n):
+        for i in range(len(dims)):
             if i in keep:
-                # For a subsystem we want to keep, use two different letters
-                r = next(letters)
-                c = next(letters)
+                # For a subsystem we want to keep, use two different letters (r, c)
+                r, c = next(letters), next(letters)
                 row_letters.append(r)
                 col_letters.append(c)
                 out_row.append(r)
                 out_col.append(c)
             else:
-                # For subsystems to be traced out, assign the same letter so that those indices are summed.
+                # For subsystems to be traced out, assign the same letter (r, r) so that those indices are summed.
                 r = next(letters)
                 row_letters.append(r)
                 col_letters.append(r)
@@ -209,26 +210,34 @@ class QuantumObject:
         """
         Compute the norm of the QuantumObject.
 
-        For density matrices, the norm order can be specified. For state vectors,
-        the norm is computed accordingly.
+        For density matrices, the norm order can be specified. For state vectors, the norm is computed accordingly.
 
         Args:
             order (int or {"fro", "tr"}, optional): The order of the norm.
-                If the QuantumObject represents a density matrix and 'tr' is specified,
-                the trace norm is returned. Defaults to 1.
+                Only applies if the QuantumObject represents a density matrix. Other than all the
+                orders accepted by scipy, it also accepts 'tr' for the trace norm. Defaults to 1.
+
+        Raises:
+            ValueError: If the QuantumObject is not a valid density matrix or state vector,
 
         Returns:
             float: The computed norm of the QuantumObject.
         """
         if self.is_scalar():
             return self.dense[0][0]
-        if self.is_dm() or self.shape[0] == self.shape[1]:
+
+        if self.is_density_matrix() or self.shape[0] == self.shape[1]:
             if order == "tr":
-                return self._data.trace()
+                return np.sum(np.abs(np.linalg.eigvalsh(self.dense)))
             return scipy_norm(self._data, ord=order)
+
         if self.is_bra():
             return np.sqrt(self._data @ self._data.conj().T).toarray()[0, 0]
-        return np.sqrt(self._data.conj().T @ self._data).toarray()[0, 0]
+
+        if self.is_ket():
+            return np.sqrt(self._data.conj().T @ self._data).toarray()[0, 0]
+
+        raise ValueError("The QuantumObject is not a valid density matrix or state vector. Cannot compute the norm.")
 
     def unit(self, order: int | Literal["fro", "tr"] = "tr") -> QuantumObject:
         """
@@ -238,8 +247,8 @@ class QuantumObject:
 
         Args:
             order (int or {"fro", "tr"}, optional): The order of the norm to use for normalization.
-                If the QuantumObject represents a density matrix and 'tr' is specified,
-                the trace norm is used. Defaults to "tr".
+                Only applies if the QuantumObject represents a density matrix. Other than all the
+                orders accepted by scipy, it also accepts 'tr' for the trace norm. Defaults to "tr".
 
         Raises:
             ValueError: If the norm of the QuantumObject is 0, making normalization impossible.
@@ -250,6 +259,7 @@ class QuantumObject:
         norm = self.norm(order=order)
         if norm == 0:
             raise ValueError("Cannot normalize a zero-norm Quantum Object")
+
         return QuantumObject(self._data / norm)
 
     def expm(self) -> QuantumObject:
@@ -261,6 +271,40 @@ class QuantumObject:
         """
         return QuantumObject(expm(self._data))
 
+    def to_density_matrix(self) -> QuantumObject:
+        """
+        Convert the QuantumObject to a density matrix.
+
+        If the QuantumObject represents a state vector (ket or bra), this method
+        calculates the corresponding density matrix by taking the outer product.
+        If the QuantumObject is already a density matrix, it is returned unchanged.
+        The resulting density matrix is normalized.
+
+        Raises:
+            ValueError: If the QuantumObject is a scalar, as a density matrix cannot be derived.
+
+        Returns:
+            QuantumObject: A new QuantumObject representing the density matrix.
+        """
+        if self.is_scalar():
+            raise ValueError("Cannot make a density matrix from scalar.")
+
+        if self.is_density_matrix():
+            return self
+
+        if self.is_bra():
+            return (self.adjoint() @ self).unit()
+
+        if self.is_ket():
+            return (self @ self.adjoint()).unit()
+
+        raise ValueError(
+            "Cannot make a density matrix from this QuantumObject. "
+            "It must be either a ket, a bra or already a density matrix."
+        )
+
+    # ----------- Checks for Matrices ------------
+
     def is_ket(self) -> bool:
         """
         Check if the QuantumObject represents a ket (column vector) state.
@@ -268,7 +312,7 @@ class QuantumObject:
         Returns:
             bool: True if the QuantumObject is a ket state, False otherwise.
         """
-        return self.shape[0] % 2 == 0 and self.shape[1] == 1
+        return self.shape[1] == 1 and self.shape[0].bit_count() == 1
 
     def is_bra(self) -> bool:
         """
@@ -277,7 +321,7 @@ class QuantumObject:
         Returns:
             bool: True if the QuantumObject is a bra state, False otherwise.
         """
-        return self.shape[1] % 2 == 0 and self.shape[0] == 1
+        return self.shape[0] == 1 and self.shape[1].bit_count() == 1
 
     def is_scalar(self) -> bool:
         """
@@ -286,14 +330,22 @@ class QuantumObject:
         Returns:
             bool: True if the QuantumObject is a scalar, False otherwise.
         """
-        return self.data.shape == (1, 1)
+        return self.shape == (1, 1)
+
+    def is_operator(self) -> bool:
+        """
+        Check if the QuantumObject is an operator (square matrix).
+
+        Returns:
+            bool: True if the QuantumObject is an operator, False otherwise.
+        """
+        return self._data.shape[1] == self._data.shape[0] and self._data.shape[0].bit_count() == 1
 
-    def is_dm(self, tol: float = 1e-8) -> bool:
+    def is_density_matrix(self, tol: float = 1e-8) -> bool:
         """
         Determine if the QuantumObject is a valid density matrix.
 
-        A valid density matrix must be square, Hermitian, positive semi-definite,
-        and have a trace equal to 1.
+        A valid density matrix must be square, Hermitian, positive semi-definite, and have a trace equal to 1.
 
         Args:
             tol (float, optional): The numerical tolerance for verifying Hermiticity,
@@ -303,11 +355,11 @@ class QuantumObject:
             bool: True if the QuantumObject is a valid density matrix, False otherwise.
         """
         # Check if rho is a square matrix
-        if self.shape[0] != self.shape[1]:
+        if not self.is_operator():
             return False
 
         # Check Hermitian condition: rho should be equal to its conjugate transpose
-        if not np.allclose(self.dense, self._data.conj().T.toarray(), atol=tol):
+        if not self.is_hermitian(tol=tol):
             return False
 
         # Check if eigenvalues are non-negative (positive semi-definite)
@@ -318,7 +370,7 @@ class QuantumObject:
         # Check if the trace is 1
         return np.isclose(self._data.trace(), 1, atol=tol)
 
-    def is_herm(self, tol: float = 1e-8) -> bool:
+    def is_hermitian(self, tol: float = 1e-8) -> bool:
         """
         Check if the QuantumObject is Hermitian.
 
@@ -331,39 +383,20 @@ class QuantumObject:
         """
         return np.allclose(self.dense, self._data.conj().T.toarray(), atol=tol)
 
-    def to_density_matrix(self) -> QuantumObject:
-        """
-        Convert the QuantumObject to a density matrix.
-
-        If the QuantumObject represents a state vector (ket or bra), this method
-        calculates the corresponding density matrix by taking the outer product.
-        If the QuantumObject is already a density matrix, it is returned unchanged.
-        The resulting density matrix is normalized.
-
-        Raises:
-            ValueError: If the QuantumObject is a scalar, as a density matrix cannot be derived.
-
-        Returns:
-            QuantumObject: A new QuantumObject representing the density matrix.
-        """
-        if self.is_scalar():
-            raise ValueError("Cannot make a density matrix from scalar.")
-        if self.is_dm():
-            return self
-        if self.is_bra():
-            return (self.dag() @ self).unit()
-        return (self @ self.dag()).unit()
+    # ----------- Basic Arithmetic Operators ------------
 
     def __add__(self, other: QuantumObject | Complex) -> QuantumObject:
         if isinstance(other, QuantumObject):
             return QuantumObject(self._data + other._data)
         if isinstance(other, Complex) and other == 0:
             return self
+
         raise TypeError("Addition is only supported between QuantumState instances")
 
     def __sub__(self, other: QuantumObject) -> QuantumObject:
         if isinstance(other, QuantumObject):
             return QuantumObject(self._data - other._data)
+
         raise TypeError("Subtraction is only supported between QuantumState instances")
 
     def __mul__(self, other: QuantumObject | Complex) -> QuantumObject:
@@ -371,11 +404,13 @@ class QuantumObject:
             return QuantumObject(self._data * other)
         if isinstance(other, QuantumObject):
             return QuantumObject(self._data * other._data)
+
         raise TypeError("Unsupported multiplication type")
 
     def __matmul__(self, other: QuantumObject) -> QuantumObject:
         if isinstance(other, QuantumObject):
             return QuantumObject(self._data @ other._data)
+
         raise TypeError("Dot product is only supported between QuantumState instances")
 
     def __rmul__(self, other: QuantumObject | Complex) -> QuantumObject:
@@ -385,19 +420,23 @@ class QuantumObject:
         return f"{self.dense}"
 
 
-def basis(N: int, n: int) -> QuantumObject:
+###############################################################################
+# Outside class Function Definitions
+###############################################################################
+
+
+def basis_state(n: int, N: int) -> QuantumObject:
     """
-    Generate the basis vector representation of a Fock state.
+    Generate the n'th basis vector representation, on a N-size Hilbert space (N=2**num_qubits).
 
-    This function creates a column vector (ket) representing the Fock state |n⟩
-    in a Hilbert space of dimension N.
+    This function creates a column vector (ket) representing the Fock state |n⟩ in a Hilbert space of dimension N.
 
     Args:
-        N (int): The dimension of the Hilbert space (number of Fock states).
-        n (int): The desired number state.
+        n (int): The desired number state (from 0 to N-1).
+        N (int): The dimension of the Hilbert space, has a value 2**num_qubits.
 
     Returns:
-        QuantumObject: A QuantumObject representing the Fock state |n⟩.
+        QuantumObject: A QuantumObject representing the |n⟩'th basis state on a N-size Hilbert space (N=2**num_qubits).
     """
     return QuantumObject(csc_array(([1], ([n], [0])), shape=(N, 1)))
 
@@ -406,9 +445,8 @@ def ket(*state: int) -> QuantumObject:
     """
     Generate a ket state for a multi-qubit system.
 
-    This function creates a tensor product of individual qubit states (kets)
-    based on the input values. Each input must be either 0 or 1. For example,
-    ket(0, 1) creates a two-qubit ket state |0⟩ ⊗ |1⟩.
+    This function creates a tensor product of individual qubit states (kets) based on the input values.
+    Each input must be either 0 or 1. For example, ket(0, 1) creates a two-qubit ket state |0⟩ ⊗ |1⟩.
 
     Args:
         *state (int): A sequence of integers representing the state of each qubit (0 or 1).
@@ -420,17 +458,17 @@ def ket(*state: int) -> QuantumObject:
         QuantumObject: A QuantumObject representing the multi-qubit ket state.
     """
     if any(s not in {0, 1} for s in state):
-        raise ValueError("the state can only be 1 or 0.")
-    return tensor([QuantumObject(csc_array(([1], ([s], [0])), shape=(2, 1))) for s in state])
+        raise ValueError(f"the state can only contain 1s or 0s. But received: {state}")
+
+    return tensor_prod([QuantumObject(csc_array(([1], ([s], [0])), shape=(2, 1))) for s in state])
 
 
 def bra(*state: int) -> QuantumObject:
     """
     Generate a bra state for a multi-qubit system.
 
-    This function creates a tensor product of individual qubit states (bras)
-    based on the input values. Each input must be either 0 or 1. For example,
-    bra(0, 1) creates a two-qubit bra state ⟨0| ⊗ ⟨1|.
+    This function creates a tensor product of individual qubit states (bras) based on the input values.
+    Each input must be either 0 or 1. For example, bra(0, 1) creates a two-qubit bra state ⟨0| ⊗ ⟨1|.
 
     Args:
         *state (int): A sequence of integers representing the state of each qubit (0 or 1).
@@ -442,11 +480,12 @@ def bra(*state: int) -> QuantumObject:
         QuantumObject: A QuantumObject representing the multi-qubit bra state.
     """
     if any(s not in {0, 1} for s in state):
-        raise ValueError("the state can only be 1 or 0.")
-    return tensor([QuantumObject(csc_array(([1], ([0], [s])), shape=(1, 2))) for s in state])
+        raise ValueError(f"the state can only contain 1s or 0s. But received:: {state}")
 
+    return tensor_prod([QuantumObject(csc_array(([1], ([0], [s])), shape=(1, 2))) for s in state])
 
-def tensor(operators: list[QuantumObject]) -> QuantumObject:
+
+def tensor_prod(operators: list[QuantumObject]) -> QuantumObject:
     """
     Calculate the tensor product of a list of QuantumObjects.
 
@@ -463,10 +502,11 @@ def tensor(operators: list[QuantumObject]) -> QuantumObject:
     if len(operators) > 1:
         for i in range(1, len(operators)):
             out = kron(out, operators[i].data)
+
     return QuantumObject(out)
 
 
-def expect(operator: QuantumObject, state: QuantumObject) -> Complex:
+def expect_val(operator: QuantumObject, state: QuantumObject) -> Complex:
     """
     Calculate the expectation value of an operator with respect to a quantum state.
 
@@ -477,10 +517,17 @@ def expect(operator: QuantumObject, state: QuantumObject) -> Complex:
         operator (QuantumObject): The quantum operator represented as a QuantumObject.
         state (QuantumObject): The quantum state or density matrix represented as a QuantumObject.
 
+    Raises:
+        ValueError: If the operator is not a square matrix.
+
     Returns:
         Complex: The expectation value. The result is guaranteed to be real if the operator
                  is Hermitian, and may be complex otherwise.
     """
+    if not operator.is_operator():
+        raise ValueError("The operator must be a square matrix.")
+
     if state.data.shape[1] == state.data.shape[0]:
         return (operator @ state).dense.trace()
-    return (state.dag() @ operator @ state).dense[0, 0]
+
+    return (state.adjoint() @ operator @ state).dense[0, 0]

qilisdk/digital/ansatz.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from abc import ABC, abstractmethod
-from typing import ClassVar, Literal, Union
+from typing import Any, ClassVar, Literal, Union
 
 from qilisdk.digital.circuit import Circuit
 from qilisdk.digital.gates import CNOT, CZ, U1, U2, U3, M
@@ -103,6 +103,23 @@ class HardwareEfficientAnsatz(Ansatz):
             "grouped": self._construct_layer_grouped,
         }
 
+    def __getstate__(self) -> dict[str, Any]:
+        state = self.__dict__.copy()
+        # Exclude the mapping that contains bound methods (not serializable).
+        state.pop("construct_layer_handlers", None)
+        return state
+
+    def __setstate__(self, state) -> None:  # noqa: ANN001
+        """
+        Restore the object's state after deserialization and reinitialize any attributes that were omitted.
+        """
+        self.__dict__.update(state)
+        # Reconstruct the mapping with the proper bound methods.
+        self.construct_layer_handlers = {
+            "interposed": self._construct_layer_interposed,
+            "grouped": self._construct_layer_grouped,
+        }
+
     @property
     def nparameters(self) -> int:
         """

qilisdk/digital/vqe.py

@@ -83,6 +83,7 @@ class VQEResult(Result):
         )
 
 
+@yaml.register_class
 class VQE(DigitalAlgorithm):
     """
     Implements the Variational Quantum Eigensolver (VQE) algorithm.

qilisdk/extras/__init__.py

@@ -25,7 +25,7 @@ OPTIONAL_FEATURES: list[OptionalFeature] = [
     ),
     OptionalFeature(
         name="qaas",
-        dependencies=["httpx", "keyring", "pydantic", "pydantic-settings"],
+        dependencies=["httpx", "keyring"],
         symbols=[Symbol(path="qilisdk.extras.qaas.qaas_backend", name="QaaSBackend")],
     ),
 ]

qilisdk/extras/cuda/cuda_backend.py

@@ -277,7 +277,7 @@ class CudaBackend(DigitalBackend, AnalogBackend):
 
         return CudaAnalogResult(
             final_expected_values=np.array(
-                [exp_val.expectation() for exp_val in evolution_result.final_expectation_values()]
+                [exp_val.expectation() for exp_val in evolution_result.final_expectation_values()[0]]
             ),
             expected_values=(
                 np.array(
@@ -287,12 +287,12 @@ class CudaBackend(DigitalBackend, AnalogBackend):
                 else None
             ),
             final_state=(
-                QuantumObject(np.array(evolution_result.final_state())).dag()
+                QuantumObject(np.array(evolution_result.final_state())).adjoint()
                 if evolution_result.final_state() is not None
                 else None
             ),
             intermediate_states=(
-                [QuantumObject(np.array(state)).dag() for state in evolution_result.intermediate_states()]
+                [QuantumObject(np.array(state)).adjoint() for state in evolution_result.intermediate_states()]
                 if evolution_result.intermediate_states() is not None
                 else None
             ),

qilisdk/extras/qaas/models.py

@@ -16,9 +16,20 @@ from enum import Enum
 
 from pydantic import BaseModel, ConfigDict, Field
 
+from qilisdk.analog import Hamiltonian, QuantumObject, Schedule, TimeEvolution
+from qilisdk.analog.hamiltonian import PauliOperator
+from qilisdk.common.optimizer import Optimizer
+from qilisdk.digital import VQE, Circuit
+from qilisdk.yaml import yaml
+
+from .qaas_analog_result import QaaSAnalogResult
+from .qaas_digital_result import QaaSDigitalResult
+from .qaas_time_evolution_result import QaaSTimeEvolutionResult
+from .qaas_vqe_result import QaaSVQEResult
+
 
 class QaaSModel(BaseModel):
-    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
+    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True, arbitrary_types_allowed=True)
 
 
 class LoginPayload(BaseModel): ...
@@ -51,7 +62,71 @@ class DeviceStatus(str, Enum):
     OFFLINE = "offline"
 
 
+class DeviceType(str, Enum):
+    """Device type"""
+
+    QUANTUM_DIGITAL = "quantum_device"
+    QUANTUM_ANALOG = "quantum_analog_device"
+    SIMULATOR = "simulator_device"
+
+
+@yaml.register_class
 class Device(QaaSModel):
     id: int = Field(...)
     name: str = Field(...)
     status: DeviceStatus = Field(...)
+    type: DeviceType = Field(...)
+
+
+class ExecutePayloadType(str, Enum):
+    DIGITAL = "digital"
+    ANALOG = "analog"
+    VQE = "vqe"
+    TIME_EVOLUTION = "time_evolution"
+
+
+@yaml.register_class
+class DigitalPayload(QaaSModel):
+    circuit: Circuit = Field(...)
+    nshots: int = Field(...)
+
+
+@yaml.register_class
+class AnalogPayload(QaaSModel):
+    schedule: Schedule = Field(...)
+    initial_state: QuantumObject = Field(...)
+    observables: list[PauliOperator | Hamiltonian] = Field(...)
+    store_intermediate_results: bool = Field(...)
+
+
+@yaml.register_class
+class VQEPayload(QaaSModel):
+    vqe: VQE = Field(...)
+    optimizer: Optimizer = Field(...)
+    nshots: int = Field(...)
+    store_intermediate_results: bool = Field(...)
+
+
+@yaml.register_class
+class TimeEvolutionPayload(QaaSModel):
+    time_evolution: TimeEvolution = Field()
+    store_intermediate_results: bool = Field()
+
+
+@yaml.register_class
+class ExecutePayload(QaaSModel):
+    type: ExecutePayloadType = Field(...)
+    device_id: int = Field(...)
+    digital_payload: DigitalPayload | None = None
+    analog_payload: AnalogPayload | None = None
+    vqe_payload: VQEPayload | None = None
+    time_evolution_payload: TimeEvolutionPayload | None = None
+
+
+@yaml.register_class
+class ExecuteResponse(QaaSModel):
+    type: ExecutePayloadType = Field(...)
+    digital_result: QaaSDigitalResult | None = None
+    analog_result: QaaSAnalogResult | None = None
+    vqe_result: QaaSVQEResult | None = None
+    time_evolution_result: QaaSTimeEvolutionResult | None = None

qilisdk/extras/qaas/qaas_backend.py

@@ -17,27 +17,39 @@ import json
 import logging
 from base64 import urlsafe_b64encode
 from datetime import datetime, timezone
-from typing import TYPE_CHECKING
+from os import environ
+from typing import TYPE_CHECKING, cast
 
 import httpx
-from pydantic import ValidationError
+from pydantic import TypeAdapter, ValidationError
 
 from qilisdk.analog.analog_backend import AnalogBackend
 from qilisdk.digital.digital_backend import DigitalBackend
 
 from .keyring import delete_credentials, load_credentials, store_credentials
-from .models import Device, Token
+from .models import (
+    AnalogPayload,
+    Device,
+    DigitalPayload,
+    ExecutePayload,
+    ExecutePayloadType,
+    ExecuteResponse,
+    TimeEvolutionPayload,
+    Token,
+    VQEPayload,
+)
 from .qaas_settings import QaaSSettings
 
 if TYPE_CHECKING:
-    from qilisdk.analog.hamiltonian import Hamiltonian, PauliOperator
-    from qilisdk.analog.quantum_objects import QuantumObject
-    from qilisdk.analog.schedule import Schedule
-    from qilisdk.common.algorithm import Algorithm
-    from qilisdk.digital.circuit import Circuit
+    from qilisdk.analog import Hamiltonian, QuantumObject, Schedule, TimeEvolution
+    from qilisdk.analog.hamiltonian import PauliOperator
+    from qilisdk.common.optimizer import Optimizer
+    from qilisdk.digital import VQE, Circuit
 
     from .qaas_analog_result import QaaSAnalogResult
     from .qaas_digital_result import QaaSDigitalResult
+    from .qaas_time_evolution_result import QaaSTimeEvolutionResult
+    from .qaas_vqe_result import QaaSVQEResult
 
 logging.basicConfig(
     format="%(levelname)s [%(asctime)s] %(name)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S", level=logging.DEBUG
@@ -54,9 +66,7 @@ class QaaSBackend(DigitalBackend, AnalogBackend):
       c) keyring (fallback).
     """
 
-    _api_url: str = "https://qilimanjaroqaas.ddns.net:8080/api/v1"
-    _authorization_request_url: str = "https://qilimanjaroqaas.ddns.net:8080/api/v1/authorisation-tokens"
-    _authorization_refresh_url: str = "https://qilimanjaroqaas.ddns.net:8080/api/v1/authorisation-tokens/refresh"
+    _api_url: str = environ.get("PUBLIC_API_URL", "https://qilimanjaroqaas.ddns.net:8080/api/v1")
 
     def __init__(self) -> None:
         """
@@ -70,6 +80,14 @@ class QaaSBackend(DigitalBackend, AnalogBackend):
                 "Please call QaaSBackend.login(username, apikey) or ensure environment variables are set."
             )
         self._username, self._token = credentials
+        self._selected_device: Device | None = None
+
+    @property
+    def selected_device(self) -> Device | None:
+        return self._selected_device
+
+    def set_device(self, device: Device) -> None:
+        self._selected_device = device
 
     @classmethod
     def login(
@@ -105,7 +123,7 @@ class QaaSBackend(DigitalBackend, AnalogBackend):
             encoded_assertion = urlsafe_b64encode(json.dumps(assertion, indent=2).encode("utf-8")).decode("utf-8")
             with httpx.Client(timeout=10.0) as client:
                 response = client.post(
-                    QaaSBackend._authorization_request_url,
+                    QaaSBackend._api_url + "/authorisation-tokens",
                     json={
                         "grantType": "urn:ietf:params:oauth:grant-type:jwt-bearer",
                         "assertion": encoded_assertion,
@@ -134,12 +152,37 @@ class QaaSBackend(DigitalBackend, AnalogBackend):
                 headers={"X-Client-Version": "0.23.2", "Authorization": f"Bearer {self._token.access_token}"},
             )
             response.raise_for_status()
-            response_json = response.json()
-            devices = [Device(**item) for item in response_json["items"]]
+
+            devices_list_adapter = TypeAdapter(list[Device])
+            devices = devices_list_adapter.validate_python(response.json()["items"])
+
+            # Previous two lines are the same as doing:
+            # response_json = response.json()
+            # devices = [Device(**item) for item in response_json["items"]]
+
             return devices
 
+    def _ensure_device_selected(self) -> Device:
+        if self._selected_device is None:
+            raise ValueError("Device not selected.")
+        return self._selected_device
+
     def execute(self, circuit: Circuit, nshots: int = 1000) -> QaaSDigitalResult:
-        raise NotImplementedError
+        device = self._ensure_device_selected()
+        payload = ExecutePayload(
+            type=ExecutePayloadType.DIGITAL,
+            device_id=device.id,
+            digital_payload=DigitalPayload(circuit=circuit, nshots=nshots),
+        )
+        with httpx.Client(timeout=20.0) as client:
+            response = client.post(
+                QaaSBackend._api_url + "/execute",
+                headers={"X-Client-Version": "0.23.2", "Authorization": f"Bearer {self._token.access_token}"},
+                json=payload.model_dump_json(),
+            )
+            response.raise_for_status()
+            execute_response = ExecuteResponse(**response.json())
+            return cast("QaaSDigitalResult", execute_response.digital_result)
 
     def evolve(
         self,
@@ -148,7 +191,65 @@ class QaaSBackend(DigitalBackend, AnalogBackend):
         observables: list[PauliOperator | Hamiltonian],
         store_intermediate_results: bool = False,
     ) -> QaaSAnalogResult:
-        raise NotImplementedError
-
-    def run(self, algorithm: Algorithm) -> None:
-        raise NotImplementedError
+        device = self._ensure_device_selected()
+        payload = ExecutePayload(
+            type=ExecutePayloadType.ANALOG,
+            device_id=device.id,
+            analog_payload=AnalogPayload(
+                schedule=schedule,
+                initial_state=initial_state,
+                observables=observables,
+                store_intermediate_results=store_intermediate_results,
+            ),
+        )
+        with httpx.Client(timeout=20.0) as client:
+            response = client.post(
+                QaaSBackend._api_url + "/execute",
+                headers={"X-Client-Version": "0.23.2", "Authorization": f"Bearer {self._token.access_token}"},
+                json=payload.model_dump_json(),
+            )
+            response.raise_for_status()
+            execute_response = ExecuteResponse(**response.json())
+            return cast("QaaSAnalogResult", execute_response.analog_result)
+
+    def run_vqe(
+        self, vqe: VQE, optimizer: Optimizer, nshots: int = 1000, store_intermediate_results: bool = False
+    ) -> QaaSVQEResult:
+        device = self._ensure_device_selected()
+        payload = ExecutePayload(
+            type=ExecutePayloadType.VQE,
+            device_id=device.id,
+            vqe_payload=VQEPayload(
+                vqe=vqe, optimizer=optimizer, nshots=nshots, store_intermediate_results=store_intermediate_results
+            ),
+        )
+        with httpx.Client(timeout=20.0) as client:
+            response = client.post(
+                QaaSBackend._api_url + "/execute",
+                headers={"X-Client-Version": "0.23.2", "Authorization": f"Bearer {self._token.access_token}"},
+                json=payload.model_dump_json(),
+            )
+            response.raise_for_status()
+            execute_response = ExecuteResponse(**response.json())
+            return cast("QaaSVQEResult", execute_response.vqe_result)
+
+    def run_time_evolution(
+        self, time_evolution: TimeEvolution, store_intermediate_results: bool = False
+    ) -> QaaSTimeEvolutionResult:
+        device = self._ensure_device_selected()
+        payload = ExecutePayload(
+            type=ExecutePayloadType.TIME_EVOLUTION,
+            device_id=device.id,
+            time_evolution_payload=TimeEvolutionPayload(
+                time_evolution=time_evolution, store_intermediate_results=store_intermediate_results
+            ),
+        )
+        with httpx.Client(timeout=20.0) as client:
+            response = client.post(
+                QaaSBackend._api_url + "/execute",
+                headers={"X-Client-Version": "0.23.2", "Authorization": f"Bearer {self._token.access_token}"},
+                json=payload.model_dump_json(),
+            )
+            response.raise_for_status()
+            execute_response = ExecuteResponse(**response.json())
+            return cast("QaaSTimeEvolutionResult", execute_response.time_evolution_result)

qilisdk/extras/qaas/qaas_time_evolution_result.py

@@ -0,0 +1,20 @@
+# Copyright 2025 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from qilisdk.analog.analog_result import AnalogResult
+from qilisdk.yaml import yaml
+
+
+@yaml.register_class
+class QaaSTimeEvolutionResult(AnalogResult): ...

qilisdk/extras/qaas/qaas_vqe_result.py

@@ -0,0 +1,20 @@
+# Copyright 2025 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from qilisdk.digital.vqe import VQEResult
+from qilisdk.yaml import yaml
+
+
+@yaml.register_class
+class QaaSVQEResult(VQEResult): ...

qilisdk/yaml.py

@@ -19,6 +19,7 @@ import types
 
 import numpy as np
 from dill import dumps, loads
+from pydantic import BaseModel
 from ruamel.yaml import YAML
 
 
@@ -39,7 +40,7 @@ def ndarray_constructor(constructor, node):
 
 def function_representer(representer, data):
     """Represent a non-lambda function by serializing it."""
-    serialized_function = base64.b64encode(dumps(data)).decode("utf-8")
+    serialized_function = base64.b64encode(dumps(data, recurse=True)).decode("utf-8")
     return representer.represent_scalar("!function", serialized_function)
 
 
@@ -51,7 +52,7 @@ def function_constructor(constructor, node):
 
 def lambda_representer(representer, data):
     """Represent a lambda function by serializing its code."""
-    serialized_lambda = base64.b64encode(dumps(data)).decode("utf-8")
+    serialized_lambda = base64.b64encode(dumps(data, recurse=True)).decode("utf-8")
     return representer.represent_scalar("!lambda", serialized_lambda)
 
 
@@ -62,6 +63,33 @@ def lambda_constructor(constructor, node):
     return loads(serialized_lambda)  # noqa: S301
 
 
+def pydantic_model_representer(representer, data):
+    """Representer for Pydantic Models."""
+    value = {"type": f"{data.__class__.__module__}.{data.__class__.__name__}", "data": data.model_dump()}
+    return representer.represent_mapping("!PydanticModel", value)
+
+
+def pydantic_model_constructor(constructor, node):
+    """Constructor for Pydantic Models."""
+    mapping = constructor.construct_mapping(node, deep=True)
+    model_type_str = mapping["type"]
+    data = mapping["data"]
+    module_name, class_name = model_type_str.rsplit(".", 1)
+    mod = __import__(module_name, fromlist=[class_name])
+    model_cls = getattr(mod, class_name)
+    return model_cls.model_validate(data)
+
+
+def complex_representer(representer, data: complex):
+    value = {"real": data.real, "imag": data.imag}
+    return representer.represent_mapping("!complex", value)
+
+
+def complex_constructor(constructor, node):
+    mapping = constructor.construct_mapping(node, deep=True)
+    return complex(mapping["real"], mapping["imag"])
+
+
 yaml = YAML(typ="unsafe")
 yaml.representer.add_representer(np.ndarray, ndarray_representer)
 yaml.constructor.add_constructor("!ndarray", ndarray_constructor)
@@ -69,3 +97,7 @@ yaml.representer.add_representer(types.FunctionType, function_representer)
 yaml.constructor.add_constructor("!function", function_constructor)
 yaml.representer.add_representer(types.LambdaType, lambda_representer)
 yaml.constructor.add_constructor("!lambda", lambda_constructor)
+yaml.representer.add_representer(BaseModel, pydantic_model_representer)
+yaml.constructor.add_constructor("!PydanticModel", pydantic_model_constructor)
+yaml.representer.add_representer(complex, complex_representer)
+yaml.constructor.add_constructor("!complex", complex_constructor)

{qilisdk-0.1.1.dist-info → qilisdk-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qilisdk
-Version: 0.1.1
+Version: 0.1.3
 Summary: qilisdk is a Python framework for writing digital and analog quantum algorithms and executing them across multiple quantum backends. Its modular design streamlines the development process and enables easy integration with a variety of quantum platforms.
 Author-email: Qilimanjaro Quantum Tech <info@qilimanjaro.tech>
 License-File: LICENCE
@@ -21,15 +21,15 @@ Classifier: Topic :: Scientific/Engineering :: Quantum Computing
 Requires-Python: >=3.10
 Requires-Dist: dill>=0.3.9
 Requires-Dist: numpy>=2.2.4
+Requires-Dist: pydantic-settings>=2.8.0
+Requires-Dist: pydantic>=2.10.6
 Requires-Dist: ruamel-yaml>=0.18.10
 Requires-Dist: scipy>=1.15.1
 Provides-Extra: cuda
-Requires-Dist: cudaq==0.9.1; extra == 'cuda'
+Requires-Dist: cudaq==0.10.0; extra == 'cuda'
 Provides-Extra: qaas
 Requires-Dist: httpx>=0.28.1; extra == 'qaas'
 Requires-Dist: keyring>=25.6.0; extra == 'qaas'
-Requires-Dist: pydantic-settings>=2.8.0; extra == 'qaas'
-Requires-Dist: pydantic>=2.10.6; extra == 'qaas'
 Description-Content-Type: text/markdown
 
 # QiliSDK

{qilisdk-0.1.1.dist-info → qilisdk-0.1.3.dist-info}/RECORD

@@ -2,14 +2,14 @@ qilisdk/__init__.py,sha256=iwacKJYttlh9DgQgNmnAjkU9CyjDQG42X3gr9Dg1kME,710
 qilisdk/__init__.pyi,sha256=iwacKJYttlh9DgQgNmnAjkU9CyjDQG42X3gr9Dg1kME,710
 qilisdk/_optionals.py,sha256=gl6yZ2sROY-USvNkXy6964OBOrDNKJAIyBU8D2H13z4,3594
 qilisdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qilisdk/yaml.py,sha256=HX-erLJnHfZK8WQrNPhzZAfJDP93L0eKtlzd1S4_Q18,2701
-qilisdk/analog/__init__.py,sha256=ExHaNL6pYH9HPY1ahskbPHqVyN9BnH8_ZxLCBS1HYp0,974
+qilisdk/yaml.py,sha256=QTDiLB8-3GWOfFKxvKwfEtJjTYXRxGP3ldUAEERB51E,4055
+qilisdk/analog/__init__.py,sha256=0J2XPJKMrvBM8jRa4nhxMKTB0fQ5kt4emb4lp4uv3Qs,1004
 qilisdk/analog/algorithms.py,sha256=OiQma6y5ueNE1buXXbNexme1k1aQaIg1A00C6mX10JQ,4621
 qilisdk/analog/analog_backend.py,sha256=GRCqlCslo8F0iB8N6Mn-_0IFJos6xRbadwVvk3lYilc,1753
 qilisdk/analog/analog_result.py,sha256=aaTGQmKm8-cuFvs_lhCAP0JOaUxsmsNcVbn_M5rvkm4,4705
 qilisdk/analog/exceptions.py,sha256=66nF1b3God6LgJ1IQd0thC3iyr6z1iMcZTfmDsSr4LE,686
 qilisdk/analog/hamiltonian.py,sha256=ELQXIauk_foOQbOChTFIV4fYzTwqHhSP1tMw8PwytaQ,25126
-qilisdk/analog/quantum_objects.py,sha256=_M7hkZOD-NW0FjoTtkrFFDVICxQ2cH7OP0xlfqjtuTE,18833
+qilisdk/analog/quantum_objects.py,sha256=jXKaPQV3ZV0so1BzzB9zCCAjOhgSLFCaTQtwGaYwwfU,20641
 qilisdk/analog/schedule.py,sha256=AHpiBPN1YZb9J2WNw6MyRPjRWAyqLVIiGFj5y_rwDmA,12807
 qilisdk/common/__init__.py,sha256=sB9yxB1512KdJuWGSHx7TWvIxLMFBX1m7zm6NVkWEAA,657
 qilisdk/common/algorithm.py,sha256=_MBdMHIJogTPnR8QRCvpf364lxQNDqGWWyZpsgplcyI,636
@@ -19,31 +19,33 @@ qilisdk/common/optimizer.py,sha256=jIBntTMw5qw03RRp5gzQe4BO9bh_z3Oeh_qfwbot0bI,5
 qilisdk/common/optimizer_result.py,sha256=Xqrej4QfuDofya-MpyfXm-FIlJqrCu7worio5oqb3rQ,3990
 qilisdk/common/result.py,sha256=wgNCC_M0eQMArWl5nmDc0-1N5IvW1sxSnIZa7_OllCE,633
 qilisdk/digital/__init__.py,sha256=vAk9BGKUxKc5faOppR64kUnJxV2WKxJK_FGpGyxuheY,1144
-qilisdk/digital/ansatz.py,sha256=lKiEo8PXG5QoxXB7b2Sp0oF3JL2meHrew66d9iOwWMk,5830
+qilisdk/digital/ansatz.py,sha256=TG-GMDDb8v2WjkynhTRgHp5OUkGborLI4rmPAf33FPs,6546
 qilisdk/digital/circuit.py,sha256=ruE1bJJkJrCKQgbBYU0-sNHWwEI1QKiUbK76owjb32M,3628
 qilisdk/digital/digital_algorithm.py,sha256=ncrmqd_y__1aaOA5ttOLlwCNyIBNdEpBazLapVa54-w,744
 qilisdk/digital/digital_backend.py,sha256=PH514eEEjPAo3R_JnzsG4DVrwssIMzWHJFjcpT440TU,3393
 qilisdk/digital/digital_result.py,sha256=PmqVOp4W1COZOFYcROxuLG7WAYjBAB6EM5BeY0J-eRY,5293
 qilisdk/digital/exceptions.py,sha256=21RnaSBkzZOuQWcIWVB303F4nyU1ABOykhAYow4m7lA,871
 qilisdk/digital/gates.py,sha256=Ylf9iwDNONaatzIrrPpXi6H59C7bMvrq-tWyIK5ZykU,29614
-qilisdk/digital/vqe.py,sha256=ynEL2oTTDZayeR3nDxV3vI4J0SCQQ_qY4uZcDUbTimo,6627
-qilisdk/extras/__init__.py,sha256=kki6xpa5TInawohC_vNacHZ4UAWxrEoK_lpl5eUkRpk,1543
+qilisdk/digital/vqe.py,sha256=HdxueeBO6MQYKyy8xo2_x50hqHd693RPvXaxEFIcEJI,6648
+qilisdk/extras/__init__.py,sha256=jAfA4d8AaTWXqAsQTpv_Rf1tQ0kcfQ_mmxF6rA-Mlro,1510
 qilisdk/extras/__init__.pyi,sha256=xQ4zOPeSaNM5zGfb07fK4lcbAu4y95YfgSlHs5TkR3Y,717
 qilisdk/extras/cuda/__init__.py,sha256=LDSTo7NstSbHMvvqvx7ZLxh0HFTEXg1O_B76SyEEHk8,588
 qilisdk/extras/cuda/cuda_analog_result.py,sha256=0IoBZpkPfxS5CDps1Z6uRH1ATWG689klYR1RvGyUhBU,737
-qilisdk/extras/cuda/cuda_backend.py,sha256=ew8Dethe1bIFrSRd0rv-cl7joozrHrPNV1IBn7LtOhQ,16403
+qilisdk/extras/cuda/cuda_backend.py,sha256=jnzdMkCUpQQhJ6S9dQgVTOJSciWcl5VhnG84VdZqgYA,16414
 qilisdk/extras/cuda/cuda_digital_result.py,sha256=bgHCrmcUVCBngo443PhfLkMxAT8Kk24FRubU3bJsdsQ,742
 qilisdk/extras/qaas/__init__.py,sha256=LDSTo7NstSbHMvvqvx7ZLxh0HFTEXg1O_B76SyEEHk8,588
 qilisdk/extras/qaas/keyring.py,sha256=xjJj6wrRALj31foctYTGZ07wgusVyIGuzeKxU-MNAA0,1774
-qilisdk/extras/qaas/models.py,sha256=EfNX1DSRAUaanYjdmIXkktduxoKWvXrJnobFQs-HXBM,1584
+qilisdk/extras/qaas/models.py,sha256=Phf_j8LPmBUeUbe_StgM-aSz8o1HecCnfsjFbvMAlTY,3801
 qilisdk/extras/qaas/qaas_analog_result.py,sha256=MLWKtRWLwKZl7Q-tWv615-P_LKFxJIRrK_ni_jQvaP8,738
-qilisdk/extras/qaas/qaas_backend.py,sha256=vP-FLsSQjET4-DARmeXHOogdXArVpCOelJl4pgXeQy8,5830
+qilisdk/extras/qaas/qaas_backend.py,sha256=2S953of7KUZ_JBNuqPBHCGa3uOu6Jve3CQxoppJvZyc,10030
 qilisdk/extras/qaas/qaas_digital_result.py,sha256=9EaZujlXvdmqdfVD-laDJq_I8YO5bc3XHRvEobOYR1U,743
 qilisdk/extras/qaas/qaas_settings.py,sha256=Vl-OPs0ijht7GqxjztY-Id3nEinfE48j_J-d9mJ4Ctk,935
+qilisdk/extras/qaas/qaas_time_evolution_result.py,sha256=sj9-xe1CbuO-yOkG5ac-f49CpIM4-X6tKnd9RBVfRMU,745
+qilisdk/extras/qaas/qaas_vqe_result.py,sha256=tQUJ904aW7BzSzd-Dxi8TvL6AIQAnDsiOGuMB8fft58,720
 qilisdk/utils/__init__.py,sha256=cFdezrFwesp9azZEBG_CWq3_Qp1yH8do_PyJbIIdSkU,920
 qilisdk/utils/openqasm2.py,sha256=QGQi2rrkYB_cqRgCyp3V3uDyfnVvcdMxykIiK0-sqXM,8316
 qilisdk/utils/serialization.py,sha256=vp-q2SZ9cBq3NX-gfT3ZDt0tzF3KnxkhV0cM7imJ2zo,3870
-qilisdk-0.1.1.dist-info/METADATA,sha256=5b1v-c6eoSFicRoWRbkOpESHMjmK8LjTB4DrGPfOynk,18039
-qilisdk-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-qilisdk-0.1.1.dist-info/licenses/LICENCE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-qilisdk-0.1.1.dist-info/RECORD,,
+qilisdk-0.1.3.dist-info/METADATA,sha256=IwKsI6lbnMmSkdb-zRYDrGQOAwqTktRKOvVcP6N5jTs,18006
+qilisdk-0.1.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+qilisdk-0.1.3.dist-info/licenses/LICENCE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+qilisdk-0.1.3.dist-info/RECORD,,