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

qilisdk/__init__.py

@@ -12,36 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import sys
-from typing import List
+from qilisdk import analog, common, digital, extras, utils
 
-from qilisdk.common import Algorithm, Model, Optimizer, Result
-
-from ._optionals import ImportedFeature, OptionalFeature, Symbol, import_optional_dependencies
-
-# Put your always-available, core symbols here
-__all__ = ["Algorithm", "Model", "Optimizer", "Result"]
-
-# Define your optional features
-OPTIONAL_FEATURES: List[OptionalFeature] = [
-    OptionalFeature(
-        name="cuda-backend",
-        dependencies=["cudaq"],
-        symbols=[Symbol(path="qilisdk.extras.cuda.cuda_backend", name="CudaBackend")],
-    ),
-    OptionalFeature(
-        name="qaas",
-        dependencies=["httpx", "keyring", "pydantic", "pydantic-settings"],
-        symbols=[Symbol(path="qilisdk.extras.qaas.qaas_backend", name="QaaSBackend")],
-    ),
-    # Add more OptionalFeature() entries for other extras if needed
-]
-
-current_module = sys.modules[__name__]
-
-# Dynamically import (or stub) each feature's symbols and attach them
-for feature in OPTIONAL_FEATURES:
-    imported_feature: ImportedFeature = import_optional_dependencies(feature)
-    for symbol_name, symbol_obj in imported_feature.symbols.items():
-        setattr(current_module, symbol_name, symbol_obj)
-        __all__ += [symbol_name]  # noqa: PLE0604
+__all__ = ["analog", "common", "digital", "extras", "utils"]

qilisdk/__init__.pyi

@@ -12,19 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from qilisdk.analog import Hamiltonian
-from qilisdk.common import Algorithm, Model, Optimizer, Result
-from qilisdk.digital import DigitalSimulationMethod
-from qilisdk.extras.cuda import CudaBackend
-from qilisdk.extras.qaas.qaas_backend import QaaSBackend
+from qilisdk import analog, common, digital, extras, utils
 
-__all__ = [
-    "Algorithm",
-    "CudaBackend",
-    "DigitalSimulationMethod",
-    "Hamiltonian",
-    "Model",
-    "Optimizer",
-    "QaaSBackend",
-    "Result",
-]
+__all__ = ["analog", "common", "digital", "extras", "utils"]

qilisdk/analog/__init__.py

@@ -12,6 +12,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from .algorithms import TimeEvolution
 from .hamiltonian import Hamiltonian, I, X, Y, Z
+from .quantum_objects import QuantumObject, basis, bra, expect, ket, tensor
+from .schedule import Schedule
 
-__all__ = ["Hamiltonian", "I", "X", "Y", "Z"]
+__all__ = [
+    "Hamiltonian",
+    "I",
+    "QuantumObject",
+    "Schedule",
+    "TimeEvolution",
+    "X",
+    "Y",
+    "Z",
+    "basis",
+    "bra",
+    "expect",
+    "ket",
+    "tensor",
+]

qilisdk/analog/analog_result.py

@@ -16,7 +16,7 @@ from pprint import pformat
 import numpy as np
 
 from qilisdk.analog.quantum_objects import QuantumObject
-from qilisdk.common import Result
+from qilisdk.common.result import Result
 from qilisdk.yaml import yaml
 
 

qilisdk/common/__init__.py

@@ -12,9 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .algorithm import Algorithm
-from .model import Model
-from .optimizer import Optimizer, SciPyOptimizer
-from .result import Result
+from .optimizer import SciPyOptimizer
 
-__all__ = ["Algorithm", "Model", "Optimizer", "Result", "SciPyOptimizer"]
+__all__ = ["SciPyOptimizer"]

qilisdk/digital/__init__.py

@@ -12,9 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from .ansatz import HardwareEfficientAnsatz
 from .circuit import Circuit
-from .digital_backend import DigitalBackend, DigitalSimulationMethod
-from .digital_result import DigitalResult
+from .digital_backend import DigitalSimulationMethod
 from .gates import (
     CNOT,
     CZ,
@@ -24,10 +24,6 @@ from .gates import (
     U1,
     U2,
     U3,
-    Adjoint,
-    BasicGate,
-    Controlled,
-    Exponential,
     Gate,
     H,
     M,
@@ -37,6 +33,7 @@ from .gates import (
     Y,
     Z,
 )
+from .vqe import VQE
 
 __all__ = [
     "CNOT",
@@ -47,16 +44,12 @@ __all__ = [
     "U1",
     "U2",
     "U3",
-    "Adjoint",
-    "BasicGate",
+    "VQE",
     "Circuit",
-    "Controlled",
-    "DigitalBackend",
-    "DigitalResult",
     "DigitalSimulationMethod",
-    "Exponential",
     "Gate",
     "H",
+    "HardwareEfficientAnsatz",
     "M",
     "S",
     "T",

qilisdk/digital/digital_result.py

@@ -15,7 +15,7 @@ import heapq
 import operator
 from pprint import pformat
 
-from qilisdk.common import Result
+from qilisdk.common.result import Result
 from qilisdk.yaml import yaml
 
 

qilisdk/extras/__init__.py

@@ -11,3 +11,30 @@
 # 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.
+import sys
+
+from qilisdk._optionals import ImportedFeature, OptionalFeature, Symbol, import_optional_dependencies
+
+__all__ = []
+
+OPTIONAL_FEATURES: list[OptionalFeature] = [
+    OptionalFeature(
+        name="cuda",
+        dependencies=["cudaq"],
+        symbols=[Symbol(path="qilisdk.extras.cuda.cuda_backend", name="CudaBackend")],
+    ),
+    OptionalFeature(
+        name="qaas",
+        dependencies=["httpx", "keyring", "pydantic", "pydantic-settings"],
+        symbols=[Symbol(path="qilisdk.extras.qaas.qaas_backend", name="QaaSBackend")],
+    ),
+]
+
+current_module = sys.modules[__name__]
+
+# Dynamically import (or stub) each feature's symbols and attach them
+for feature in OPTIONAL_FEATURES:
+    imported_feature: ImportedFeature = import_optional_dependencies(feature)
+    for symbol_name, symbol_obj in imported_feature.symbols.items():
+        setattr(current_module, symbol_name, symbol_obj)
+        __all__ += [symbol_name]  # noqa: PLE0604

qilisdk/extras/__init__.pyi

@@ -0,0 +1,18 @@
+# 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 .cuda.cuda_backend import CudaBackend
+from .qaas.qaas_backend import QaaSBackend
+
+__all__ = ["CudaBackend", "QaaSBackend"]

qilisdk/extras/cuda/__init__.py

@@ -11,8 +11,3 @@
 # 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 .cuda_backend import CudaBackend
-from .cuda_digital_result import CudaDigitalResult
-
-__all__ = ["CudaBackend", "CudaDigitalResult"]

qilisdk/extras/cuda/cuda_backend.py

@@ -31,10 +31,7 @@ from qilisdk.digital import (
     U1,
     U2,
     U3,
-    Adjoint,
-    BasicGate,
     Circuit,
-    Controlled,
     H,
     M,
     S,
@@ -45,6 +42,7 @@ from qilisdk.digital import (
 )
 from qilisdk.digital.digital_backend import DigitalBackend, DigitalSimulationMethod
 from qilisdk.digital.exceptions import UnsupportedGateError
+from qilisdk.digital.gates import Adjoint, BasicGate, Controlled
 
 from .cuda_analog_result import CudaAnalogResult
 from .cuda_digital_result import CudaDigitalResult

qilisdk/extras/qaas/qaas_analog_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 QaaSAnalogResult(AnalogResult): ...

qilisdk/extras/qaas/qaas_backend.py

@@ -30,13 +30,13 @@ from .models import Device, Token
 from .qaas_settings import QaaSSettings
 
 if TYPE_CHECKING:
-    from qilisdk.analog.analog_result import AnalogResult
     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 .qaas_analog_result import QaaSAnalogResult
     from .qaas_digital_result import QaaSDigitalResult
 
 logging.basicConfig(
@@ -147,7 +147,7 @@ class QaaSBackend(DigitalBackend, AnalogBackend):
         initial_state: QuantumObject,
         observables: list[PauliOperator | Hamiltonian],
         store_intermediate_results: bool = False,
-    ) -> AnalogResult:
+    ) -> QaaSAnalogResult:
         raise NotImplementedError
 
     def run(self, algorithm: Algorithm) -> None:

qilisdk-0.1.1.dist-info/METADATA

@@ -0,0 +1,538 @@
+Metadata-Version: 2.4
+Name: qilisdk
+Version: 0.1.1
+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
+Keywords: analog quantum computing,digital quantum computing,qilimanjaro,quantum computing
+Classifier: Development Status :: 1 - Planning
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Scientific/Engineering :: Quantum Computing
+Requires-Python: >=3.10
+Requires-Dist: dill>=0.3.9
+Requires-Dist: numpy>=2.2.4
+Requires-Dist: ruamel-yaml>=0.18.10
+Requires-Dist: scipy>=1.15.1
+Provides-Extra: cuda
+Requires-Dist: cudaq==0.9.1; 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
+
+[![Python Versions](https://img.shields.io/pypi/pyversions/qilisdk.svg)](https://pypi.org/project/qilisdk/)
+[![PyPI Version](https://img.shields.io/pypi/v/qilisdk.svg)](https://pypi.org/project/qilisdk/)
+[![License](https://img.shields.io/pypi/l/qilisdk.svg)](#license)
+
+**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.
+
+---
+
+## Table of Contents
+- [QiliSDK](#qilisdk)
+  - [Table of Contents](#table-of-contents)
+  - [Installation](#installation)
+    - [Base Installation](#base-installation)
+    - [Optional Extras](#optional-extras)
+  - [Usage](#usage)
+    - [Digital Quantum Circuits](#digital-quantum-circuits)
+    - [Hamiltonian and Analog Operations](#hamiltonian-and-analog-operations)
+    - [Optimizers](#optimizers)
+    - [Quantum-as-a-Service (QaaS)](#quantum-as-a-service-qaas)
+    - [CUDA-Accelerated Simulation](#cuda-accelerated-simulation)
+    - [Time Evolution](#time-evolution)
+    - [Variational Quantum Eigensolver (VQE)](#variational-quantum-eigensolver-vqe)
+    - [Open QASM Serialization](#open-qasm-serialization)
+    - [YAML Serialization](#yaml-serialization)
+  - [Development](#development)
+    - [Prerequisites](#prerequisites)
+    - [Setup \& Dependency Management](#setup--dependency-management)
+    - [Testing](#testing)
+    - [Linting \& Formatting](#linting--formatting)
+    - [Type Checking](#type-checking)
+    - [Changelog Management](#changelog-management)
+    - [Contributing](#contributing)
+  - [License](#license)
+  - [Acknowledgments](#acknowledgments)
+
+---
+
+## Installation
+
+QiliSDK is available via [PyPI](https://pypi.org/project/qilisdk/). You can install the core package as well as optional extras for additional features.
+
+### Base Installation
+
+Install the core QiliSDK package using pip:
+
+```bash
+pip install qilisdk
+```
+
+### Optional Extras
+
+QiliSDK supports optional modules for additional functionality:
+
+- **QaaS (Quantum-as-a-Service):**
+  To interface with Qilimanjaro’s cloud-based quantum services, install the QaaS extra:
+
+  ```bash
+  pip install qilisdk[qaas]
+  ```
+
+- **CUDA Acceleration:**
+  For GPU-accelerated quantum simulation using NVIDIA GPUs, install the CUDA extra:
+
+  ```bash
+  pip install qilisdk[cuda]
+  ```
+
+  You can also install both optional dependencies using a single command:
+
+  ```bash
+  pip install qilisdk[cuda,qaas]
+  ```
+
+---
+
+## Usage
+
+QiliSDK is designed to simplify both digital and analog quantum computing workflows. This guide provides example code snippets for creating quantum circuits, performing Hamiltonian arithmetic, optimization, simulation on various backends (including CUDA and cloud-based QaaS), and using additional utility functions.
+
+### Digital Quantum Circuits
+
+Create and simulate quantum circuits with a flexible gate framework. The following example demonstrates how to assemble a circuit, adjust gate parameters, and execute it with the Qibo backend:
+
+```python
+import numpy as np
+from qilisdk.digital import Circuit, H, RX, CNOT, M
+
+# Create a circuit with 2 qubits
+circuit = Circuit(2)
+circuit.add(H(0))              # Apply Hadamard on qubit 0
+circuit.add(RX(0, theta=np.pi))  # Apply RX rotation on qubit 0
+circuit.add(CNOT(0, 1))          # Add a CNOT gate between qubit 0 and 1
+
+# Retrieve the current gate parameters
+print("Initial parameters:", circuit.get_parameter_values())
+
+# Update circuit parameters (e.g., update RX rotation angle)
+circuit.set_parameter_values([2 * np.pi])
+
+# Execute the circuit simulation using CudaBackend
+backend = CudaBackend()
+results = backend.execute(circuit)
+
+# Display the simulation output and measurement probabilities
+print("Simulation Results:")
+print(results)
+print("Probabilities:", results.probabilities)
+```
+
+### Hamiltonian and Analog Operations
+
+Utilize the `Hamiltonian` class for Pauli operator arithmetic. Build expressions, iterate through terms, and even round-trip using the parse feature:
+
+```python
+from qilisdk.analog import Hamiltonian, X, Y, Z, I
+
+# Build a Hamiltonian expression using Pauli operators
+H_expr = (Z(0) + X(0)) * (Z(0) - X(0))
+print("Hamiltonian Expression:", H_expr)
+
+# Iterate over Hamiltonian terms
+for coeff, ops in H_expr:
+    print("Coefficient:", coeff, "Operators:", ops)
+
+# Parse a Hamiltonian from its string representation
+parsed_H = Hamiltonian.parse("-2j Y(0)")
+assert H_expr == parsed_H, "The Hamiltonian does not match after parsing."
+```
+
+### Optimizers
+
+Run optimization routines using the `SciPyOptimizer` and integrate them with a variational algorithm (VQE). In the example below, a simple quadratic cost function is minimized:
+
+```python
+from qilisdk.common import SciPyOptimizer
+
+def cost_function(params):
+    # A simple quadratic cost: minimum at [1, 1, 1]
+    return sum((p - 1) ** 2 for p in params)
+
+# Initialize the optimizer with the BFGS method
+optimizer = SciPyOptimizer(method="BFGS")
+initial_parameters = [0, 0, 0]
+result = optimizer.optimize(cost_function, initial_parameters)
+
+print("Optimal cost:", result.optimal_cost)
+print("Optimal Parameters:", result.optimal_parameters)
+```
+
+### Quantum-as-a-Service (QaaS)
+
+QiliSDK now includes a draft backend for interfacing with Qilimanjaro's QaaS platform. This module supports secure login and a unified interface for both digital circuits and analog evolutions:
+
+```python
+from qilisdk.extras import QaaSBackend
+
+# Login to QaaSBackend with credentials (or use environment variables)
+# This only needs to be run once.
+QaaSBackend.login(username="your_username", apikey="your_apikey")
+
+# Instantiate QaaSBackend
+qaas_backend = QaaSBackend()
+
+# Execute a pre-built circuit (see Digital Quantum Circuits section)
+results = qaas_backend.execute(circuit)
+print("QaaS Simulation Results:", results)
+```
+
+### CUDA-Accelerated Simulation
+
+For users with NVIDIA GPUs, the `CudaBackend` provides GPU-accelerated simulation using several simulation methods. For example, using the TENSOR_NETWORK method:
+
+```python
+from qilisdk.extras import CudaBackend
+from qilisdk.digital import Circuit, H, M, DigitalSimulationMethod
+
+# Build a single-qubit circuit
+circuit = Circuit(nqubits=1)
+circuit.add(H(0))
+circuit.add(M(0))
+
+# Initialize CudaBackend with the TENSOR_NETWORK simulation method
+cuda_backend = CudaBackend(digital_simulation_method=DigitalSimulationMethod.TENSOR_NETWORK)
+results = cuda_backend.execute(circuit, nshots=1000)
+print("CUDA Backend Results:", results)
+```
+
+### Time Evolution
+
+For analog simulations, the new `TimeEvolution` and `Schedule` classes allow you to simulate time-dependent quantum dynamics. The following example uses a linear schedule to interpolate between two Hamiltonians on a CUDA backend:
+
+```python
+import numpy as np
+from qilisdk.analog import TimeEvolution, Schedule, tensor, ket, X, Z, Y
+from qilisdk.extras import CudaBackend
+
+T = 10       # Total evolution time
+dt = 0.1     # Time-step
+steps = np.linspace(0, T, int(T / dt))
+nqubits = 1
+
+# Define two Hamiltonians for the simulation
+H1 = sum(X(i) for i in range(nqubits))
+H2 = sum(Z(i) for i in range(nqubits))
+
+# Create a schedule for the time evolution
+schedule = Schedule(
+    T,
+    dt,
+    hamiltonians={"h1": H1, "h2": H2},
+    schedule={
+        t: {"h1": 1 - steps[t] / T, "h2": steps[t] / T}
+        for t in range(len(steps))
+    },
+)
+
+# Prepare an initial state (equal superposition)
+state = tensor([(ket(0) + ket(1)).unit() for _ in range(nqubits)]).unit()
+
+# Perform time evolution on the CUDA backend with observables to monitor
+time_evolution = TimeEvolution(
+    backend=CudaBackend(),
+    schedule=schedule,
+    initial_state=state,
+    observables=[Z(0), X(0), Y(0)],
+)
+results = time_evolution.evolve(store_intermediate_results=True)
+print("Time Evolution Results:", results)
+```
+
+### Variational Quantum Eigensolver (VQE)
+
+The VQE algorithm integrates ansatz design, cost function evaluation, and classical optimization. Below is an illustrative example that sets up a VQE instance using a hardware-efficient ansatz and the SciPy optimizer:
+
+```python
+import numpy as np
+from qilisdk.common import SciPyOptimizer
+from qilisdk.digital import HardwareEfficientAnsatz, VQE
+from qilisdk.extras import CudaBackend
+
+
+# Define problem parameters
+n_items = 4
+weights = [np.random.randint(1, 5) for _ in range(n_items)]
+values  = [np.random.randint(1, 10) for _ in range(n_items)]
+max_weight_perc = 0.6
+max_w = int(max_weight_perc * sum(weights))
+nqubits = n_items
+
+# Initialize a hardware-efficient ansatz
+ansatz = HardwareEfficientAnsatz(
+    n_qubits=nqubits,
+    connectivity="Full",
+    layers=1,
+    one_qubit_gate="U3",
+    two_qubit_gate="CNOT"
+)
+
+# Use a CUDA backend for simulation
+backend = CudaBackend()
+
+LM = sum(values)
+
+def cost_function(result):
+    # Get the most probable outcomes from the digital result
+    most_probable = result.get_probabilities()
+    final_cost = 0
+    for bitstring, prob in most_probable:
+        x_n = [int(bit) for bit in bitstring]
+        total_weight = sum(weights[i] * x_n[i] for i in range(n_items))
+        penalty = (total_weight - max_w) if total_weight > max_w else 0
+        reward = -sum(values[i] * x_n[i] for i in range(n_items))
+        final_cost += prob * (LM * penalty + reward)
+    return final_cost
+
+optimizer = SciPyOptimizer(
+    method="Powell",
+    bounds=[(0, np.pi)] * ansatz.nparameters
+)
+
+# Initialize and execute the VQE algorithm
+vqe = VQE(ansatz, [0.5] * ansatz.nparameters, cost_function)
+results = vqe.execute(backend, optimizer, store_intermediate_results=True)
+
+print("Optimal Cost:", results.optimal_cost)
+print("Optimal Parameters:", results.optimal_parameters)
+print("Intermediate Optimization Steps:")
+for intermediate in results.intermediate_results:
+    print("Cost:", intermediate.cost)
+```
+
+### Open QASM Serialization
+
+Serialize and deserialize quantum circuits using Open QASM 2.0 grammar. The utility functions below allow conversion to a QASM string or file and vice versa:
+
+```python
+from qilisdk.digital import Circuit, CNOT, RX, H, M
+from qilisdk.utils import to_qasm2, from_qasm2, to_qasm2_file, from_qasm2_file
+
+# Create a sample circuit
+circuit = Circuit(3)
+circuit.add(H(0))
+circuit.add(CNOT(0, 1))
+circuit.add(RX(2, theta=3.1415))
+circuit.add(M(0, 1, 2))
+
+# Serialize to QASM string
+qasm_code = to_qasm2(circuit)
+print("Generated QASM:")
+print(qasm_code)
+
+# Deserialize back to a circuit
+reconstructed_circuit = from_qasm2(qasm_code)
+
+# Save to and load from a file
+to_qasm2_file(circuit, "circuit.qasm")
+reconstructed_circuit = from_qasm2_file("circuit.qasm")
+```
+
+### YAML Serialization
+
+Easily save and restore circuits, hamiltonians, simulation and execution results, and virtually any other class in YAML format using the provided serialization functions:
+
+```python
+from qilisdk.digital import Circuit, H, CNOT, M
+from qilisdk.utils import serialize, deserialize, serialize_to, deserialize_from
+
+circuit = Circuit(2)
+circuit.add(H(0))
+circuit.add(CNOT(0, 1))
+circuit.add(M(0, 1))
+
+# Serialize a circuit to a YAML string
+yaml_string = serialize(circuit)
+
+# Deserialize back into a Circuit object
+restored_circuit = deserialize(yaml_string, cls=Circuit)
+
+# Alternatively, work with files:
+serialize_to(circuit, 'circuit.yml')
+restored_circuit = deserialize_from('circuit.yml', cls=Circuit)
+```
+
+---
+
+## Development
+
+This section covers how to set up a local development environment for qilisdk, run tests, enforce code style, manage dependencies, and contribute to the project. We use a number of tools to maintain code quality and consistency:
+
+- **[uv](https://pypi.org/project/uv/)** for dependency management and packaging.
+- **[ruff](https://beta.ruff.rs/docs/)** for linting and code formatting.
+- **[mypy](http://mypy-lang.org/)** for static type checking.
+- **[towncrier](https://github.com/twisted/towncrier)** for automated changelog generation.
+
+### Prerequisites
+
+- Python **3.10+** (we test against multiple versions, but 3.10 is the minimum for local dev).
+- [Git](https://git-scm.com/) for version control.
+- [uv](https://pypi.org/project/uv/) for dependency management.
+
+### Setup & Dependency Management
+
+1. **Clone the repository**:
+   ```bash
+   git clone https://github.com/qilimanjaro-tech/qilisdk.git
+   cd qilisdk
+   ```
+
+2. **Install [uv](https://pypi.org/project/uv/) globally** (if not already):
+   ```bash
+   curl -LsSf https://astral.sh/uv/install.sh | sh
+   ```
+
+3. **Sync dependencies**:
+   - We maintain a `pyproject.toml` listing all dev and optional requirements.
+   - To install the dev environment locally, run:
+     ```bash
+     uv sync
+     ```
+     This sets up a virtual environment and installs all pinned dependencies (including `ruff`, `mypy`, `towncrier`, etc.).
+   - To install extra dependencies such as `qibo-backend`, run:
+     ```bash
+     uv sync --extra qibo-backend -extra ...
+     ```
+     This sets up a virtual environment and installs all pinned dependencies (previous), plus the specified extras.
+
+4. **Activate the virtual environment**:
+   - uv typically creates and manages its own environment, e.g., `.venv/`.
+   - Run:
+     ```bash
+     source .venv/bin/activate
+     ```
+     *(Exact command can vary depending on your shell and OS.)*
+
+Now you can run all development commands (tests, linting, etc.) within this environment.
+
+### Testing
+
+TODO: to_be_filled
+
+### Linting & Formatting
+
+We enforce code style and best practices using [**ruff**](https://beta.ruff.rs/docs/). ruff handles:
+
+- Lint checks (similar to flake8, pylint).
+- Formatting (similar to black or isort).
+- Automated fixes for certain issues.
+
+To check linting:
+
+```bash
+ruff check
+```
+
+To automatically fix lint issues (where possible):
+
+```bash
+ruff check --fix
+```
+
+To automatically format your code:
+
+```bash
+ruff format
+```
+
+*(We recommend running `ruff check --fix` and `ruff format` before committing any changes.)*
+
+### Type Checking
+
+We use [**mypy**](http://mypy-lang.org/) for static type checking. This helps ensure our code is type-safe and maintainable.
+
+```bash
+mypy qilisdk
+```
+
+If you have extra modules or tests you want type-checked, specify them:
+
+```bash
+mypy qilisdk tests
+```
+
+*(We encourage developers to annotate new functions, classes, and methods with type hints.)*
+
+### Changelog Management
+
+We manage our changelog using [**towncrier**](https://github.com/twisted/towncrier). Instead of editing `CHANGELOG.md` directly, **each pull request** includes a small *news fragment* file in the `changes/` directory describing the user-facing changes.
+
+For example, if you create a PR with id #123 adding a new feature, you add:
+```
+changes/123.feature.rst
+```
+Inside this file, you briefly describe the new feature:
+```rst
+Added a new `cool_feature` in the `qilisdk.extras` module.
+```
+Instead of manually creating the file, you can run:
+```bash
+towncrier create --no-edit
+```
+When we cut a new release, we update the version in `pyproject.toml` file and run:
+```bash
+towncrier
+```
+This aggregates all the news fragments into the `CHANGELOG.md` under the new version and removes the used fragments.
+
+### Contributing
+
+We welcome contributions! Here’s the workflow:
+
+1. **Fork** this repository and create a feature branch.
+2. **Write** your changes (code, docs, or tests).
+3. **Add a news fragment** (if applicable) in `changes/` describing the user-facing impact.
+4. **Run** the following checks locally:
+   ```bash
+   ruff check --fix
+   ruff format
+   mypy qilisdk
+   pytest tests
+   ```
+5. **Commit** and push your branch to your fork. `pre-commit` will also run the checks automatically.
+6. **Open a Pull Request** against the `main` branch here.
+
+Our CI will run tests, linting, and type checks. Please make sure your branch passes these checks before requesting a review.
+
+---
+
+## License
+
+This project is licensed under the [Apache License](LICENSE).
+
+---
+
+## Acknowledgments
+
+- Thanks to all the contributors who help develop qilisdk!
+- [uv](https://pypi.org/project/uv/) for making dependency management smoother.
+- [ruff](https://beta.ruff.rs/docs/), [mypy](http://mypy-lang.org/), and [towncrier](https://github.com/twisted/towncrier) for their amazing tooling.
+
+---
+
+Feel free to open [issues](https://github.com/qilimanjaro-tech/qilisdk/issues) or [pull requests](https://github.com/qilimanjaro-tech/qilisdk/pulls) if you have questions or contributions. Happy coding!

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

@@ -1,47 +1,49 @@
-qilisdk/__init__.py,sha256=O3tFo8LdNtcDjkgP5uoEc9V8cxMzCeMbY-FBFSXJfdk,1823
-qilisdk/__init__.pyi,sha256=oiX2eVc8cHCGuip0Too3tnN7OD48H5QnGbatryFQHMs,1008
+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=44Z3QEELqCjm1BDAAE9i16_pZoo8zaGLkbTIsPo4TOw,685
+qilisdk/analog/__init__.py,sha256=ExHaNL6pYH9HPY1ahskbPHqVyN9BnH8_ZxLCBS1HYp0,974
 qilisdk/analog/algorithms.py,sha256=OiQma6y5ueNE1buXXbNexme1k1aQaIg1A00C6mX10JQ,4621
 qilisdk/analog/analog_backend.py,sha256=GRCqlCslo8F0iB8N6Mn-_0IFJos6xRbadwVvk3lYilc,1753
-qilisdk/analog/analog_result.py,sha256=pi4TOvBbBpt1_8PrRRzS2iYByQy-qUXwpNeBf2RqEwM,4698
+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/schedule.py,sha256=AHpiBPN1YZb9J2WNw6MyRPjRWAyqLVIiGFj5y_rwDmA,12807
-qilisdk/common/__init__.py,sha256=Djp6uVxpw9U5pBRGcUD0C1EvU_MRo2fhodeGgXV0pmo,798
+qilisdk/common/__init__.py,sha256=sB9yxB1512KdJuWGSHx7TWvIxLMFBX1m7zm6NVkWEAA,657
 qilisdk/common/algorithm.py,sha256=_MBdMHIJogTPnR8QRCvpf364lxQNDqGWWyZpsgplcyI,636
 qilisdk/common/backend.py,sha256=dPzjqplkDTfCbLvY68M5z0ALxmgugWeCjVLuG_EqW70,609
 qilisdk/common/model.py,sha256=lwK0xW_sitLj7bw7aNh5xrMWVE2HoKIk2irkGpsc8as,607
 qilisdk/common/optimizer.py,sha256=jIBntTMw5qw03RRp5gzQe4BO9bh_z3Oeh_qfwbot0bI,5860
 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=PW29pvoLPt4OgESbiW-hgcH9FLbwuWfwrpoeSo94WWo,1268
+qilisdk/digital/__init__.py,sha256=vAk9BGKUxKc5faOppR64kUnJxV2WKxJK_FGpGyxuheY,1144
 qilisdk/digital/ansatz.py,sha256=lKiEo8PXG5QoxXB7b2Sp0oF3JL2meHrew66d9iOwWMk,5830
 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=0f1h4JHWRPkKEBCerYptmLN7yG5_IN4YchUPNEH6ZOY,5286
+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=LDSTo7NstSbHMvvqvx7ZLxh0HFTEXg1O_B76SyEEHk8,588
-qilisdk/extras/cuda/__init__.py,sha256=hesw7M0_AoWBaeW4iGb-rq5eD16b7aP7VKI_oE7ACN0,726
+qilisdk/extras/__init__.py,sha256=kki6xpa5TInawohC_vNacHZ4UAWxrEoK_lpl5eUkRpk,1543
+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=71hDYkl04WSNkwvEodAq9S-pT_qxAz7bWONdkQ59G0w,16382
+qilisdk/extras/cuda/cuda_backend.py,sha256=ew8Dethe1bIFrSRd0rv-cl7joozrHrPNV1IBn7LtOhQ,16403
 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/qaas_backend.py,sha256=u69Jl-LPvDw3BV_gQGZAwLeTKVhqyBUM_YgoLZmbfB8,5831
+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_digital_result.py,sha256=9EaZujlXvdmqdfVD-laDJq_I8YO5bc3XHRvEobOYR1U,743
 qilisdk/extras/qaas/qaas_settings.py,sha256=Vl-OPs0ijht7GqxjztY-Id3nEinfE48j_J-d9mJ4Ctk,935
 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.0.dist-info/METADATA,sha256=2n4gy_pBnb3rf9NhpUX52zoKMP3LrmpU8dMydImZsYI,8161
-qilisdk-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-qilisdk-0.1.0.dist-info/licenses/LICENCE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-qilisdk-0.1.0.dist-info/RECORD,,
+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.0.dist-info/METADATA

@@ -1,237 +0,0 @@
-Metadata-Version: 2.4
-Name: qilisdk
-Version: 0.1.0
-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
-Keywords: analog quantum computing,digital quantum computing,qilimanjaro,quantum computing
-Classifier: Development Status :: 1 - Planning
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Scientific/Engineering
-Classifier: Topic :: Scientific/Engineering :: Physics
-Classifier: Topic :: Scientific/Engineering :: Quantum Computing
-Requires-Python: >=3.10
-Requires-Dist: dill>=0.3.9
-Requires-Dist: numpy>=2.2.4
-Requires-Dist: ruamel-yaml>=0.18.10
-Requires-Dist: scipy>=1.15.1
-Provides-Extra: cuda
-Requires-Dist: cudaq==0.9.1; 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
-
-[![Python Versions](https://img.shields.io/pypi/pyversions/qilisdk.svg)](https://pypi.org/project/qilisdk/)
-[![PyPI Version](https://img.shields.io/pypi/v/qilisdk.svg)](https://pypi.org/project/qilisdk/)
-[![License](https://img.shields.io/pypi/l/qilisdk.svg)](#license)
-
-**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.
-
-> **Note**: The instructions below focus on developing and contributing to qilisdk. For installation and usage as an end user, see the [Usage](#usage) section (placeholder).
-
----
-
-## Table of Contents
-- [qilisdk](#qilisdk)
-  - [Table of Contents](#table-of-contents)
-  - [Development](#development)
-    - [Prerequisites](#prerequisites)
-    - [Setup \& Dependency Management](#setup--dependency-management)
-    - [Testing](#testing)
-    - [Linting \& Formatting](#linting--formatting)
-    - [Type Checking](#type-checking)
-    - [Changelog Management](#changelog-management)
-    - [Contributing](#contributing)
-  - [Usage](#usage)
-  - [License](#license)
-  - [Acknowledgments](#acknowledgments)
-
----
-
-## Development
-
-This section covers how to set up a local development environment for qilisdk, run tests, enforce code style, manage dependencies, and contribute to the project. We use a number of tools to maintain code quality and consistency:
-
-- **[uv](https://pypi.org/project/uv/)** for dependency management and packaging.
-- **[ruff](https://beta.ruff.rs/docs/)** for linting and code formatting.
-- **[mypy](http://mypy-lang.org/)** for static type checking.
-- **[towncrier](https://github.com/twisted/towncrier)** for automated changelog generation.
-
-### Prerequisites
-
-- Python **3.10+** (we test against multiple versions, but 3.10 is the minimum for local dev).
-- [Git](https://git-scm.com/) for version control.
-- [uv](https://pypi.org/project/uv/) for dependency management.
-
-### Setup & Dependency Management
-
-1. **Clone the repository**:
-   ```bash
-   git clone https://github.com/qilimanjaro-tech/qilisdk.git
-   cd qilisdk
-   ```
-
-2. **Install [uv](https://pypi.org/project/uv/) globally** (if not already):
-   ```bash
-   curl -LsSf https://astral.sh/uv/install.sh | sh
-   ```
-
-3. **Sync dependencies**:
-   - We maintain a `pyproject.toml` listing all dev and optional requirements.
-   - To install the dev environment locally, run:
-     ```bash
-     uv sync
-     ```
-     This sets up a virtual environment and installs all pinned dependencies (including `ruff`, `mypy`, `towncrier`, etc.).
-   - To install extra dependencies such as `qibo-backend`, run:
-     ```bash
-     uv sync --extra qibo-backend -extra ...
-     ```
-     This sets up a virtual environment and installs all pinned dependencies (previous), plus the specified extras.
-
-4. **Activate the virtual environment**:
-   - uv typically creates and manages its own environment, e.g., `.venv/`.
-   - Run:
-     ```bash
-     source .venv/bin/activate
-     ```
-     *(Exact command can vary depending on your shell and OS.)*
-
-Now you can run all development commands (tests, linting, etc.) within this environment.
-
-### Testing
-
-TODO: to_be_filled
-
-### Linting & Formatting
-
-We enforce code style and best practices using [**ruff**](https://beta.ruff.rs/docs/). ruff handles:
-
-- Lint checks (similar to flake8, pylint).
-- Formatting (similar to black or isort).
-- Automated fixes for certain issues.
-
-To check linting:
-
-```bash
-ruff check
-```
-
-To automatically fix lint issues (where possible):
-
-```bash
-ruff check --fix
-```
-
-To automatically format your code:
-
-```bash
-ruff format
-```
-
-*(We recommend running `ruff check --fix` and `ruff format` before committing any changes.)*
-
-### Type Checking
-
-We use [**mypy**](http://mypy-lang.org/) for static type checking. This helps ensure our code is type-safe and maintainable.
-
-```bash
-mypy qilisdk
-```
-
-If you have extra modules or tests you want type-checked, specify them:
-
-```bash
-mypy qilisdk tests
-```
-
-*(We encourage developers to annotate new functions, classes, and methods with type hints.)*
-
-### Changelog Management
-
-We manage our changelog using [**towncrier**](https://github.com/twisted/towncrier). Instead of editing `CHANGELOG.md` directly, **each pull request** includes a small *news fragment* file in the `changes/` directory describing the user-facing changes.
-
-For example, if you create a PR with id #123 adding a new feature, you add:
-```
-changes/123.feature.rst
-```
-Inside this file, you briefly describe the new feature:
-```rst
-Added a new `cool_feature` in the `qilisdk.extras` module.
-```
-Instead of manually creating the file, you can run:
-```bash
-towncrier create --no-edit
-```
-When we cut a new release, we update the version in `pyproject.toml` file and run:
-```bash
-towncrier
-```
-This aggregates all the news fragments into the `CHANGELOG.md` under the new version and removes the used fragments.
-
-### Contributing
-
-We welcome contributions! Here’s the workflow:
-
-1. **Fork** this repository and create a feature branch.
-2. **Write** your changes (code, docs, or tests).
-3. **Add a news fragment** (if applicable) in `changes/` describing the user-facing impact.
-4. **Run** the following checks locally:
-   ```bash
-   ruff check --fix
-   ruff format
-   mypy qilisdk
-   pytest tests
-   ```
-5. **Commit** and push your branch to your fork. `pre-commit` will also run the checks automatically.
-6. **Open a Pull Request** against the `main` branch here.
-
-Our CI will run tests, linting, and type checks. Please make sure your branch passes these checks before requesting a review.
-
----
-
-## Usage
-
-*(Placeholder for end users. Provide a brief snippet on how to install qilisdk and use its main features. For example:)*
-
-```bash
-pip install qilisdk
-```
-
-```python
-from qilisdk import core_feature
-
-result = core_feature.do_something()
-print(result)
-```
-
----
-
-## License
-
-This project is licensed under the [Apache License](LICENSE).
-
----
-
-## Acknowledgments
-
-- Thanks to all the contributors who help develop qilisdk!
-- [uv](https://pypi.org/project/uv/) for making dependency management smoother.
-- [ruff](https://beta.ruff.rs/docs/), [mypy](http://mypy-lang.org/), and [towncrier](https://github.com/twisted/towncrier) for their amazing tooling.
-
----
-
-Feel free to open [issues](https://github.com/qilimanjaro-tech/qilisdk/issues) or [pull requests](https://github.com/qilimanjaro-tech/qilisdk/pulls) if you have questions or contributions. Happy coding!