qilisdk 0.1.1__tar.gz → 0.1.2__tar.gz

{qilisdk-0.1.1 → qilisdk-0.1.2}/CHANGELOG.md

@@ -1,3 +1,12 @@
+# Qilisdk 0.1.2 (2025-04-22)
+
+### Misc
+
+- Improved `QaaSBacked` functionality to include methods for executing digital and analog algorithms.
+  
+  [PR #27](https://github.com/qilimanjaro-tech/qilisdk/pulls/27)
+
+
 # Qilisdk 0.1.1 (2025-04-11)
 
 ### Misc

{qilisdk-0.1.1 → qilisdk-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qilisdk
-Version: 0.1.1
+Version: 0.1.2
 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

{qilisdk-0.1.1 → qilisdk-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "qilisdk"
-version = "0.1.1"
+version = "0.1.2"
 description = "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."
 readme = "README.md"
 authors = [{name = "Qilimanjaro Quantum Tech", email = "info@qilimanjaro.tech"}]

{qilisdk-0.1.1 → qilisdk-0.1.2}/src/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-0.1.1 → qilisdk-0.1.2}/src/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-0.1.2/src/qilisdk/extras/qaas/models.py

@@ -0,0 +1,132 @@
+# 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 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, arbitrary_types_allowed=True)
+
+
+class LoginPayload(BaseModel): ...
+
+
+class Token(QaaSModel):
+    """
+    Represents the structure of the login response:
+    {
+        "accessToken": "...",
+        "expiresIn": 123456789,
+        "issuedAt": "123456789",
+        "refreshToken": "...",
+        "tokenType": "bearer"
+    }
+    """
+
+    access_token: str = Field(alias="accessToken")
+    expires_in: int = Field(alias="expiresIn")
+    issued_at: str = Field(alias="issuedAt")
+    refresh_token: str = Field(alias="refreshToken")
+    token_type: str = Field(alias="tokenType")
+
+
+class DeviceStatus(str, Enum):
+    """Device status typing for posting"""
+
+    ONLINE = "online"
+    MAINTENANCE = "maintenance"
+    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-0.1.2/src/qilisdk/extras/qaas/qaas_backend.py

@@ -0,0 +1,254 @@
+# 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 __future__ import annotations
+
+import json
+import logging
+from base64 import urlsafe_b64encode
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, cast
+
+import httpx
+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 (
+    AnalogPayload,
+    Device,
+    DigitalPayload,
+    ExecutePayload,
+    ExecutePayloadType,
+    ExecuteResponse,
+    TimeEvolutionPayload,
+    Token,
+    VQEPayload,
+)
+from .qaas_settings import QaaSSettings
+
+if TYPE_CHECKING:
+    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
+)
+
+
+class QaaSBackend(DigitalBackend, AnalogBackend):
+    """
+    Manages communication with a hypothetical QaaS service via synchronous HTTP calls.
+
+    Credentials to log in can come from:
+      a) method parameters,
+      b) environment (via Pydantic),
+      c) keyring (fallback).
+    """
+
+    _api_url: str = "https://qilimanjaroqaas.ddns.net:8080/api/v1"
+
+    def __init__(self) -> None:
+        """
+        Normally, you won't call __init__() directly.
+        Instead, use QaaSBackend.login(...) to create a logged-in instance.
+        """  # noqa: DOC501
+        credentials = load_credentials()
+        if credentials is None:
+            raise RuntimeError(
+                "No valid QaaS credentials found in keyring."
+                "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(
+        cls,
+        username: str | None = None,
+        apikey: str | None = None,
+    ) -> bool:
+        # Use provided parameters or fall back to environment variables via Settings()
+        if not username or not apikey:
+            try:
+                # Load environment variables into the settings object.
+                settings = QaaSSettings()  # type: ignore[call-arg]
+                username = username or settings.username
+                apikey = apikey or settings.apikey
+            except ValidationError:
+                # Environment credentials could not be validated.
+                # Optionally, log error details here.
+                return False
+
+        if not username or not apikey:
+            # Insufficient credentials provided.
+            return False
+
+        # Send login request to QaaS
+        try:
+            assertion = {
+                "username": username,
+                "api_key": apikey,
+                "user_id": None,
+                "audience": QaaSBackend._api_url,
+                "iat": int(datetime.now(timezone.utc).timestamp()),
+            }
+            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._api_url + "/authorisation-tokens",
+                    json={
+                        "grantType": "urn:ietf:params:oauth:grant-type:jwt-bearer",
+                        "assertion": encoded_assertion,
+                        "scope": "user profile",
+                    },
+                    headers={"X-Client-Version": "0.23.2"},
+                )
+                response.raise_for_status()
+                # Suppose QaaS returns {"token": "..."} in JSON
+                token = Token(**response.json())
+        except httpx.RequestError:
+            # Log error message
+            return False
+
+        store_credentials(username=username, token=token)
+        return True
+
+    @classmethod
+    def logout(cls) -> None:
+        delete_credentials()
+
+    def list_devices(self) -> list[Device]:
+        with httpx.Client(timeout=20.0) as client:
+            response = client.get(
+                QaaSBackend._api_url + "/devices",
+                headers={"X-Client-Version": "0.23.2", "Authorization": f"Bearer {self._token.access_token}"},
+            )
+            response.raise_for_status()
+
+            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:
+        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,
+        schedule: Schedule,
+        initial_state: QuantumObject,
+        observables: list[PauliOperator | Hamiltonian],
+        store_intermediate_results: bool = False,
+    ) -> 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-0.1.2/src/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-0.1.2/src/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-0.1.1 → qilisdk-0.1.2}/src/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)