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

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/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,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.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,
@@ -148,7 +190,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.2.dist-info}/METADATA

@@ -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.dist-info → qilisdk-0.1.2.dist-info}/RECORD

@@ -2,7 +2,7 @@ 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/yaml.py,sha256=QTDiLB8-3GWOfFKxvKwfEtJjTYXRxGP3ldUAEERB51E,4055
 qilisdk/analog/__init__.py,sha256=ExHaNL6pYH9HPY1ahskbPHqVyN9BnH8_ZxLCBS1HYp0,974
 qilisdk/analog/algorithms.py,sha256=OiQma6y5ueNE1buXXbNexme1k1aQaIg1A00C6mX10JQ,4621
 qilisdk/analog/analog_backend.py,sha256=GRCqlCslo8F0iB8N6Mn-_0IFJos6xRbadwVvk3lYilc,1753
@@ -19,14 +19,14 @@ 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/digital/vqe.py,sha256=HdxueeBO6MQYKyy8xo2_x50hqHd693RPvXaxEFIcEJI,6648
 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
@@ -35,15 +35,17 @@ qilisdk/extras/cuda/cuda_backend.py,sha256=ew8Dethe1bIFrSRd0rv-cl7joozrHrPNV1IBn
 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=PvXvuL-c5VtPv0IAt2z8AS8witUbVJbVnmxJMwKFiBw,9976
 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.2.dist-info/METADATA,sha256=Pr59Q2KtieNfdr9qiOac3B1Bin1bzbbapoajmejEFy0,18039
+qilisdk-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+qilisdk-0.1.2.dist-info/licenses/LICENCE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+qilisdk-0.1.2.dist-info/RECORD,,