qilisdk 0.1.0__py3-none-any.whl → 0.1.2__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/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/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/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

@@ -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/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_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

@@ -17,27 +17,38 @@ import json
 import logging
 from base64 import urlsafe_b64encode
 from datetime import datetime, timezone
-from typing import TYPE_CHECKING
+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.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 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
@@ -55,8 +66,6 @@ class QaaSBackend(DigitalBackend, AnalogBackend):
     """
 
     _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"
 
     def __init__(self) -> None:
         """
@@ -70,6 +79,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 +122,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 +151,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,
@@ -147,8 +189,66 @@ class QaaSBackend(DigitalBackend, AnalogBackend):
         initial_state: QuantumObject,
         observables: list[PauliOperator | Hamiltonian],
         store_intermediate_results: bool = False,
-    ) -> AnalogResult:
-        raise NotImplementedError
-
-    def run(self, algorithm: Algorithm) -> None:
-        raise NotImplementedError
+    ) -> QaaSAnalogResult:
+        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): ...