quapp-pennylane 0.0.4.dev1__tar.gz

quapp_pennylane-0.0.4.dev1/LICENSE

@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

quapp_pennylane-0.0.4.dev1/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: quapp-pennylane
+Version: 0.0.4.dev1
+Summary: Quapp pennylane library supporting Quapp Platform for Quantum Computing
+Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
+License: The MIT License (MIT)
+        Copyright © CITYNOW Co. Ltd. All rights reserved.
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Project-URL: Homepage, https://citynow.asia/
+Keywords: quapp,quapp-pennylane,pennylane,quantum
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: quapp-common==0.0.11.dev1
+Requires-Dist: pennylane==0.37.0
+Requires-Dist: matplotlib
+Requires-Dist: PennyLane-Rigetti==0.36.0
+Requires-Dist: PennyLane_Lightning==0.37.0
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: bumpver; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: pip-tools; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# qapp-pennylane 0.0.2
+
+Add rigetti device

quapp_pennylane-0.0.4.dev1/README.md

@@ -0,0 +1,3 @@
+# qapp-pennylane 0.0.2
+
+Add rigetti device

quapp_pennylane-0.0.4.dev1/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "quapp-pennylane"
+version = "0.0.4.dev1"
+description = "Quapp pennylane library supporting Quapp Platform for Quantum Computing"
+readme = "README.md"
+authors = [{ name = "CITYNOW Co. Ltd. ", email = "corp@citynow.vn" }]
+license = { file = "LICENSE" }
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+]
+keywords = ["quapp", "quapp-pennylane", "pennylane", "quantum"]
+dependencies = [
+    "quapp-common==0.0.11.dev1",
+    "pennylane==0.37.0",
+    "matplotlib",
+    "PennyLane-Rigetti==0.36.0",
+    "PennyLane_Lightning==0.37.0"
+]
+requires-python = ">=3.10"
+
+[project.optional-dependencies]
+dev = ["black", "bumpver", "isort", "pip-tools", "pytest"]
+
+[project.urls]
+Homepage = "https://citynow.asia/"

quapp_pennylane-0.0.4.dev1/qapp_pennylane/async_tasks/pennylane_circuit_export_task.py

@@ -0,0 +1,21 @@
+"""
+    QApp Platform Project pennylane_circuit_export_task.py Copyright © CITYNOW Co. Ltd. All rights reserved.
+"""
+from qapp_common.async_tasks.export_circuit_task import CircuitExportTask
+from qapp_common.config.logging_config import logger
+import pennylane as qml
+from io import BytesIO
+
+
+class PennylaneCircuitExportTask(CircuitExportTask):
+        
+    def _convert(self):
+        
+        logger.debug("[Circuit export] Preparing circuit figure...")
+        circuit = self.circuit_data_holder.circuit
+        circuit_figure, _ = qml.draw_mpl(circuit)()
+        logger.debug("[Circuit export] Converting circuit figure to svg file...")
+        figure_buffer = BytesIO()
+        circuit_figure.savefig(figure_buffer, format="svg")
+        
+        return figure_buffer

quapp_pennylane-0.0.4.dev1/qapp_pennylane/component/backend/pennylane_invocation.py

@@ -0,0 +1,54 @@
+"""
+    QApp Platform Project pennylane_invocation.py Copyright © CITYNOW Co. Ltd. All rights reserved.
+"""
+
+from qapp_common.component.backend.invocation import Invocation
+from qapp_common.config.logging_config import logger
+from qapp_common.config.thread_config import circuit_exporting_pool
+from qapp_common.data.async_task.circuit_export.backend_holder import BackendDataHolder
+from qapp_common.data.async_task.circuit_export.circuit_holder import CircuitDataHolder
+from qapp_common.data.request.invocation_request import InvocationRequest
+from qapp_common.model.provider.provider import Provider
+
+from ...async_tasks.pennylane_circuit_export_task import PennylaneCircuitExportTask
+from ...factory.pennylane_device_factory import PennylaneDeviceFactory
+from ...factory.pennylane_provider_factory import PennyLaneProviderFactory
+
+from pennylane.tape import QuantumTape
+
+class PennylaneInvocation(Invocation):
+
+    def __init__(self, request_data: InvocationRequest, **kwargs):
+        super().__init__(request_data)
+        self.num_qubits = kwargs.get('num_qubits')
+
+    def _export_circuit(self, circuit):
+        logger.info("[PennylaneInvocation] _export_circuit()")
+
+        circuit_export_task = PennylaneCircuitExportTask(
+            circuit_data_holder=CircuitDataHolder(circuit, self.circuit_export_url),
+            backend_data_holder=BackendDataHolder(
+                self.backend_information, self.authentication.user_token
+            ),
+        )
+        circuit_exporting_pool.submit(circuit_export_task.do)
+
+    def _create_provider(self):
+        logger.info('[PennylaneInvocation] _create_provider()')
+
+        return PennyLaneProviderFactory.create_provider(
+            provider_type=self.backend_information.provider_tag, sdk=self.sdk,
+            authentication=self.backend_information.authentication)
+
+    def _create_device(self, provider: Provider):
+        logger.info('[PennylaneInvocation] Creating device')
+        return PennylaneDeviceFactory.create_device(provider=provider,
+                                                    device_specification=self.backend_information.device_name,
+                                                    authentication=self.backend_information.authentication,
+                                                    sdk=self.sdk, num_qubits=self.num_qubits,
+                                                    input=self.input)
+
+    def _get_qubit_amount(self, circuit):
+        with QuantumTape() as tape:
+            circuit()
+        return tape.num_wires

quapp_pennylane-0.0.4.dev1/qapp_pennylane/factory/pennylane_device_factory.py

@@ -0,0 +1,40 @@
+"""
+    QApp Platform Project
+    pennylane_device_factory.py
+    Copyright © CITYNOW Co. Ltd. All rights reserved.
+"""
+from qapp_common.config.logging_config import logger
+from qapp_common.enum.provider_tag import ProviderTag
+from qapp_common.enum.sdk import Sdk
+from qapp_common.factory.device_factory import DeviceFactory
+from qapp_common.model.provider.provider import Provider
+
+from ..model.device.qapp_pennylane_device import QAppPennylaneDevice
+
+
+class PennylaneDeviceFactory(DeviceFactory):
+
+    @staticmethod
+    def create_device(provider: Provider, device_specification: str, authentication: dict, sdk: Sdk,
+                      **kwargs):
+        logger.info("[PennylaneDeviceFactory] create_device()")
+
+        provider_type = ProviderTag.resolve(provider.get_provider_type().value)
+
+        match provider_type:
+            case ProviderTag.QUAO_QUANTUM_SIMULATOR:
+                if Sdk.PENNYLANE == sdk:
+                    logger.debug('[PennylaneDeviceFactory] Creating QAppPennylaneDevice')
+                    return QAppPennylaneDevice(provider, device_specification)
+                raise ValueError(f'Unsupported SDK for provider type: {provider_type}')
+            # case ProviderTag.AWS_BRAKET:
+            #     logger.debug('[PennylaneDeviceFactory] Creating AwsBraketDevice')
+            #     return AwsBraketDevice(provider, device_specification, kwargs['backend_name'],
+            #                            kwargs['num_qubits'], kwargs['s3_bucket_name'],
+            #                            kwargs['s3_prefix'], kwargs['inputs'])
+            # case ProviderTag.IBM_QUANTUM:
+            #     return IbmQuantumDevice(provider, device_specification,
+            #                             api_token=authentication.get('api_token'),
+            #                             instance=authentication.get('instance'))
+            case _:
+                raise ValueError(f"Unsupported provider type: {provider_type}")

quapp_pennylane-0.0.4.dev1/qapp_pennylane/factory/pennylane_handler_factory.py

@@ -0,0 +1,25 @@
+"""
+    QApp Platform Project pennylane_handler_factory.py Copyright © CITYNOW Co. Ltd. All rights reserved.
+"""
+
+from qapp_common.config.logging_config import logger
+from qapp_common.factory.handler_factory import HandlerFactory
+from qapp_common.handler.handler import Handler
+
+from ..handler.invocation_handler import InvocationHandler
+
+
+class PennylaneHandlerFactory(HandlerFactory):
+
+    @staticmethod
+    def create_handler(event, circuit_preparation_fn, post_processing_fn) -> Handler:
+        logger.info("[PennylaneHandlerFactory] create_handler()")
+
+        request_data = event.json()
+
+        logger.debug("[PennylaneHandlerFactory] Create InvocationHandler")
+        return InvocationHandler(
+            request_data=request_data,
+            circuit_preparation_fn=circuit_preparation_fn,
+            post_processing_fn=post_processing_fn,
+        )

quapp_pennylane-0.0.4.dev1/qapp_pennylane/factory/pennylane_provider_factory.py

@@ -0,0 +1,34 @@
+"""
+    QApp Platform Project
+    pennylane_provider_factory.py
+    Copyright © CITYNOW Co. Ltd. All rights reserved.
+"""
+from qapp_common.config.logging_config import logger
+from qapp_common.enum.provider_tag import ProviderTag
+from qapp_common.enum.sdk import Sdk
+from qapp_common.factory.provider_factory import ProviderFactory
+
+from ..model.provider.qapp_pennylane_provider import QAppPennyLaneProvider
+
+class PennyLaneProviderFactory(ProviderFactory):
+
+    @staticmethod
+    def create_provider(provider_type: ProviderTag, sdk: Sdk, authentication: dict):
+        logger.info("[PennyLaneProviderFactory] create_provider()")
+        logger.debug(f"provider_type: {provider_type}, sdk: {sdk}, authentication: {authentication}")
+
+        match provider_type:
+            case ProviderTag.QUAO_QUANTUM_SIMULATOR:
+                if Sdk.PENNYLANE.__eq__(sdk):
+                    return QAppPennyLaneProvider()
+                raise ValueError(f'Unsupported SDK for provider type: {provider_type}')
+            # case ProviderTag.IBM_CLOUD:
+            #     return IbmCloudProvider(authentication.get('token'), authentication.get('crn'))
+            # case ProviderTag.IBM_QUANTUM:
+            #     return IbmQuantumProvider(authentication.get('token'))
+            # case ProviderTag.AWS_BRAKET:
+            #     return AwsBraketProvider(authentication.get('access_key_id'),
+            #                              authentication.get('secret_access_key'),
+            #                              authentication.get('region_name'))
+            case _:
+                raise ValueError(f'Unsupported provider type: {provider_type}')

quapp_pennylane-0.0.4.dev1/qapp_pennylane/handler/invocation_handler.py

@@ -0,0 +1,27 @@
+"""
+    QApp platform Project invocation_handler.py Copyright © CITYNOW Co. Ltd. All rights reserved.
+"""
+from qapp_common.data.request.invocation_request import InvocationRequest
+from qapp_common.handler.handler import Handler
+from qapp_common.config.logging_config import logger
+
+from ..component.backend.pennylane_invocation import PennylaneInvocation
+
+
+class InvocationHandler(Handler):
+
+    def __init__(self, request_data: dict,
+                 circuit_preparation_fn,
+                 post_processing_fn):
+        super().__init__(request_data, post_processing_fn)
+        self.circuit_preparation_fn = circuit_preparation_fn
+
+    def handle(self):
+        logger.info("[InvocationHandler] handle()")
+
+        invocation_request = InvocationRequest(self.request_data)
+
+        backend = PennylaneInvocation(invocation_request)
+
+        backend.submit_job(circuit_preparation_fn=self.circuit_preparation_fn,
+                           post_processing_fn=self.post_processing_fn)

quapp_pennylane-0.0.4.dev1/qapp_pennylane/model/device/aws_braket_device.py

@@ -0,0 +1,92 @@
+# """
+#     QApp Platform Project
+#     aws_braket_device.py
+#     Copyright © CITYNOW Co. Ltd. All rights reserved.
+# """
+# from dateutil.parser import parse
+# import pennylane as qml
+# from qapp_common.config.logging_config import logger
+# from qapp_common.data.device.circuit_running_option import CircuitRunningOption
+# from qapp_common.enum.status.job_status import JobStatus
+# from qapp_common.model.device.device import Device
+# from qapp_common.model.provider.provider import Provider
+#
+#
+# class AwsBraketDevice(Device):
+#     def _create_job(self, circuit, options: CircuitRunningOption):
+#         logger.debug('[AwsBraketDevice] Creating job for circuit')
+#
+#         device = qml.device(self.device, device_arn=self.backend.arn, aws_session=self.session,
+#                             s3_destination_folder=self.s3_folder, wires=self.num_qubits,
+#                             shots=options.shots)
+#         qnode = qml.QNode(circuit, device)
+#         qml.compile(qnode)(self.inputs)
+#         return device.task
+#
+#     def _is_simulator(self) -> bool:
+#         logger.debug('[AwsBraketDevice] Checking if the device is a simulator')
+#
+#         return 'SIMULATOR'.__eq__(self.device._device.type.value)
+#
+#     def _produce_histogram_data(self, job_result) -> dict | None:
+#         logger.debug('[AwsBraketDevice] Producing histogram data')
+#         return dict(job_result.measurement_counts)
+#
+#     def _get_provider_job_id(self, job) -> str:
+#         logger.debug('[AwsBraketDevice] Getting job id')
+#         return job.id
+#
+#     def _get_job_status(self, job) -> str:
+#         logger.debug('[AwsBraketDevice] Getting job status')
+#
+#         job_state = job.state()
+#         logger.debug('[AwsBraketDevice] Job status is: %s', job_state)
+#
+#         if JobStatus.COMPLETED.value.__eq__(job_state):
+#             job_state = JobStatus.DONE.value
+#         return job_state
+#
+#     def _calculate_execution_time(self, job_result) -> None:
+#         logger.debug("[AwsBraketDevice] _calculate_execution_time()")
+#
+#         if "task_metadata" not in job_result:
+#             return
+#
+#         task_metadata = job_result["task_metadata"]
+#
+#         if task_metadata is None \
+#                 or not bool(task_metadata) \
+#                 or "createdAt" not in task_metadata \
+#                 or "endedAt" not in task_metadata:
+#             return
+#
+#         created_at = task_metadata["createdAt"]
+#         ended_at = task_metadata["endedAt"]
+#
+#         if created_at is None or ended_at is None:
+#             return
+#
+#         created_at = parse(created_at.replace("T", " ").replace("Z", ""))
+#         ended_at = parse(ended_at.replace("T", " ").replace("Z", ""))
+#
+#         offset = ended_at - created_at
+#
+#         self.execution_time = offset.total_seconds()
+#
+#         logger.debug("[AwsBraketDevice] Execution time calculation was: {0} seconds"
+#                      .format(self.execution_time))
+#
+#
+#     def _get_job_result(self, job):
+#         logger.debug('[AwsBraketDevice] Getting job result')
+#
+#         return job.result()
+#
+#     def __init__(self, provider: Provider, device_arn: str, backend_name: str, num_qubits: int,
+#                  s3_bucket_name: str, s3_prefix: str, inputs):
+#
+#         super().__init__(provider, device_arn, backend_name)
+#         self.s3_folder = (s3_bucket_name, s3_prefix)
+#         self.inputs = inputs
+#         self.num_qubits = num_qubits
+#         self.session = provider.collect_provider()

quapp_pennylane-0.0.4.dev1/qapp_pennylane/model/device/ibm_quantum_device.py

@@ -0,0 +1,27 @@
+# """
+#     QApp Platform Project
+#     ibm_quantum_device.py
+#     Copyright © CITYNOW Co. Ltd. All rights reserved.
+# """
+# from qapp_common.config.logging_config import logger
+# from qapp_common.data.device.circuit_running_option import CircuitRunningOption
+# from qiskit import transpile
+#
+# from ..device.pennylane_device import PennylaneDevice
+#
+#
+# class IbmQuantumDevice(PennylaneDevice):
+#     def __init__(self, provider, device_specification, api_token, instance):
+#         super().__init__(provider, device_specification, 'qiskit.remote')
+#         self.channel = 'ibm_quantum'
+#         self.instance = instance
+#         self.token = api_token
+#
+#     def _create_job(self, circuit, options: CircuitRunningOption):
+#         logger.debug('[IbmQuantumDevice] Creating job with {0} shots'.format(options.shots))
+#         transpiled_circuit = transpile(circuit, self.device)
+#         return self.device.run(transpiled_circuit, shots=options.shots)
+#
+#     def _is_simulator(self) -> bool:
+#         logger.debug('[IbmQuantumDevice] Is simulator')
+#         return self.device.configuration().simulator

quapp_pennylane-0.0.4.dev1/qapp_pennylane/model/device/pennylane_device.py

@@ -0,0 +1,60 @@
+# """
+#     QApp Platform Project
+#     pennylane_device.py
+#     Copyright © CITYNOW Co. Ltd. All rights reserved.
+# """
+# from abc import ABC
+#
+# from qapp_common.config.logging_config import logger
+# from qapp_common.model.device.device import Device
+# from qapp_common.model.provider.provider import Provider
+#
+#
+# class PennylaneDevice(Device, ABC):
+#     def _produce_histogram_data(self, job_result) -> dict | None:
+#         logger.info('[PennylaneDevice] Producing histogram data')
+#
+#
+#         try:
+#             histogram_data = job_result.get_counts()
+#         except Exception as pennylane_error:
+#             logger.debug("[PennylaneDevice] Can't produce histogram with error: {0}".format(
+#                 str(pennylane_error)))
+#             histogram_data = None
+#
+#         return histogram_data
+#
+#     def _get_provider_job_id(self, job) -> str:
+#         logger.debug('[PennylaneDevice] Getting job id')
+#
+#         return None
+#
+#     def _get_job_status(self, job) -> str:
+#         logger.debug('[PennylaneDevice] Getting job status')
+#
+#         return "DONE"
+#
+#     def _get_job_result(self, job) -> dict:
+#         logger.debug('[PennylaneDevice] Getting job result')
+#         return job
+#
+#     def _calculate_execution_time(self, job_result):
+#         logger.debug('[PennylaneDevice] Calculating execution time')
+#
+#
+#         # metadata = job_result.metadata
+#
+#         # if metadata is None or not bool(metadata) or 'time_taken_execute' not in metadata:
+#         #     return None
+#
+#         # self.execution_time = metadata['time_taken_execute']
+#
+#         # logger.debug('[PennylaneDevice] Execution time calculation was: {0} seconds'.format(
+#         #     self.execution_time))
+#
+#         return None
+#
+#     def __init__(self, provider: Provider, device_specification: str, backend_name: str):
+#         super().__init__(provider, device_specification)
+#         self.backend = self.device
+#         self.device = backend_name

quapp_pennylane-0.0.4.dev1/qapp_pennylane/model/device/qapp_pennylane_device.py

@@ -0,0 +1,200 @@
+"""
+    QApp Platform Project
+    qapp_pennylane_device.py
+    Copyright © CITYNOW Co. Ltd. All rights reserved.
+"""
+import math
+import time
+
+import pennylane as qml
+from pennylane.tape import QuantumTape
+from qapp_common.config.logging_config import logger
+from qapp_common.data.device.circuit_running_option import CircuitRunningOption
+from qapp_common.data.response.authentication import Authentication
+from qapp_common.data.response.project_header import ProjectHeader
+from qapp_common.enum.invocation_step import InvocationStep
+from qapp_common.model.device.custom_device import CustomDevice
+from qapp_common.model.provider.provider import Provider
+
+
+class QAppPennylaneDevice(CustomDevice):
+    def __init__(self, provider: Provider, device_specification: str):
+        super().__init__(provider, device_specification)
+        logger.debug('[QAppPennylaneDevice] Initializing device specification')
+        self.device_specification = device_specification
+
+    def _create_job(self, circuit, options: CircuitRunningOption):
+        """
+        @param circuit: circuit to run
+        @param options: options for running circuit
+        ex: options.shots: number of shots
+        
+        run the circuit and return the result
+        """
+        logger.debug(
+            '[QAppPennylaneDevice] Creating job with {0} shots'.format(
+                options.shots))
+
+        with QuantumTape() as tape:
+            circuit()
+
+        parts = self.device_specification.split('/')
+        device_name = parts[0]
+
+        """
+        with rigetti device, device_specification includes 
+        rigetti.qvm/9q-square-pyqvm, 9q-square-qvm: 9qubit
+        rigetti.qvm/Nq-pyqvm, Nq-qvm: Nqubit (32 with QApp platform)
+        """
+        unsupported_default_qubit_autograd = qml.__version__ > '0.37.0' and device_name == 'default.qubit.autograd'
+        if not qml.plugin_devices.__contains__(device_name):
+            if unsupported_default_qubit_autograd:
+                logger.warning(
+                    f'[QAppPennylaneDevice] Using default.qubit for device {device_name} in PennyLane version {qml.__version__}')
+            else:
+                logger.error(
+                    f'[QAppPennylaneDevice] The device {device_name} is not supported in PennyLane version {qml.__version__}.')
+                raise ValueError(
+                    f'The device {device_name} is not supported in PennyLane version {qml.__version__}. '
+                )
+
+        if device_name == "rigetti.qvm":
+            device_type = parts[1]
+            if parts[1] in ["9q-square-qvm", "9q-square-pyqvm"]:
+                self.device = qml.device(device_name, device=device_type,
+                                         shots=options.shots)
+            else:
+                self.device = qml.device(device_name, device=str(tape.num_wires) + device_type[1:],
+                                         shots=options.shots)
+        elif unsupported_default_qubit_autograd:
+            self.device = qml.device('default.qubit', wires=tape.wires, shots=options.shots)
+        else:
+            self.device = qml.device(device_name, wires=tape.wires, shots=options.shots)
+
+        start_time = time.time()
+
+        qnode_params = {'interface': "autograd",
+                        'diff_method': "parameter-shift"} if unsupported_default_qubit_autograd else {}
+        qnode = qml.QNode(circuit, self.device, **qnode_params)
+
+        job_result = qnode()
+        end_time = time.time()
+
+        result_histogram = {}
+
+        # generate histogram
+        if qml.probs() in qnode.tape.observables:
+            histogram_index = qnode.tape.observables.index(qml.probs())
+            probs = job_result[histogram_index]
+            num_bits = math.ceil(math.log2(len(probs)))
+            for i, prob in enumerate(probs):
+                bitstring = format(i, f'0{num_bits}b')
+                result_histogram[bitstring] = int(prob * options.shots)
+        else:
+            result_histogram = None
+
+        shots = getattr(qnode.device, 'shots', options.shots)
+
+        data = {"result": job_result, "histogram": result_histogram,
+                "time_taken_execute": end_time - start_time, "shots": shots}
+
+        logger.info(data)
+        return data
+
+    def _is_simulator(self) -> bool:
+        logger.debug('[QAppPennylaneDevice] Is simulator')
+        return True
+
+    def _produce_histogram_data(self, job_result) -> dict | None:
+        logger.info('[PennylaneDevice] Producing histogram data')
+
+        histogram = job_result.get('histogram')
+
+        if histogram is None:
+            logger.debug("[PennylaneDevice] Can't produce histogram")
+
+        return job_result.get('histogram')
+
+    def _get_provider_job_id(self, job) -> str:
+        logger.debug('[PennylaneDevice] Getting job id')
+
+        # no job id in local simulator
+        return ""
+
+    def _get_job_status(self, job) -> str:
+        logger.debug('[PennylaneDevice] Getting job status')
+
+        return "DONE"
+
+    def _get_job_result(self, job) -> dict:
+        logger.debug('[PennylaneDevice] Getting job result')
+
+        return job
+
+    def _calculate_execution_time(self, job_result):
+        logger.debug('[PennylaneDevice] Calculating execution time')
+
+        self.execution_time = job_result.get('time_taken_execute')
+
+        logger.debug(
+            '[PennylaneDevice] Execution time calculation was: {0} seconds'.format(
+                self.execution_time))
+
+    def run_circuit(self,
+                    circuit,
+                    post_processing_fn,
+                    options: CircuitRunningOption,
+                    callback_dict: dict,
+                    authentication: Authentication,
+                    project_header: ProjectHeader):
+        """
+        @param project_header: project header
+        @param callback_dict: callback url dictionary
+        @param options: Options for run circuit
+        @param authentication: Authentication for calling quao server
+        @param post_processing_fn: Post-processing function
+        @param circuit: Circuit was run
+        """
+        original_job_result, job_response = self._on_execution(
+            authentication=authentication,
+            project_header=project_header,
+            execution_callback=callback_dict.get(InvocationStep.EXECUTION),
+            circuit=circuit,
+            options=options)
+
+        if original_job_result is None:
+            return
+
+        job_response = self._on_analysis(
+            job_response=job_response,
+            original_job_result=original_job_result,
+            analysis_callback=callback_dict.get(InvocationStep.ANALYSIS))
+
+        if job_response is None:
+            return
+
+        self._on_finalization(job_result=original_job_result.get('result'),
+                              authentication=authentication,
+                              post_processing_fn=post_processing_fn,
+                              finalization_callback=callback_dict.get(
+                                  InvocationStep.FINALIZATION),
+                              project_header=project_header)
+
+    def _get_shots(self, job_result) -> int | None:
+        """
+        Retrieve the number of shots from the job result.
+
+        This method checks if the job result contains the 'shots' attribute
+        and returns its value. If the 'shots' attribute is not present,
+        the method returns None.
+
+        Args:
+            job_result: An object representing the result of a job, which
+                        may contain the number of shots.
+
+        Returns:
+            int | None: The number of shots if available; otherwise, None.
+        """
+        logger.debug('[PennylaneDevice] Calculating number of shots')
+
+        return getattr(job_result, 'shots', None)

quapp_pennylane-0.0.4.dev1/qapp_pennylane/model/provider/aws_braket_provider.py

@@ -0,0 +1,33 @@
+# """
+#     QApp Platform Project
+#     aws_braket_provider.py
+#     Copyright © CITYNOW Co. Ltd. All rights reserved.
+# """
+# import boto3
+# from braket.aws import AwsDevice, AwsSession
+# from qapp_common.config.logging_config import logger
+# from qapp_common.enum.provider_tag import ProviderTag
+# from qapp_common.model.provider.provider import Provider
+
+
+# class AwsBraketProvider(Provider):
+#     def __init__(self, access_key_id, secret_access_key, region_name):
+#         super().__init__(ProviderTag.AWS_BRAKET)
+#         self.access_key_id = access_key_id
+#         self.secret_access_key = secret_access_key
+#         self.region_name = region_name
+
+#     def get_backend(self, device_specification):
+#         logger.debug('[AwsBraketProvider] get_backend()')
+
+#         session = self.collect_provider()
+
+#         return AwsDevice(arn=device_specification, aws_session=session)
+
+#     def collect_provider(self):
+#         logger.debug('[AwsBraketProvider] collect_provider()')
+
+#         session = boto3.Session(aws_access_key_id=self.access_key_id,
+#                                 aws_secret_access_key=self.secret_access_key,
+#                                 region_name=self.region_name)
+#         return AwsSession(boto_session=session)

quapp_pennylane-0.0.4.dev1/qapp_pennylane/model/provider/ibm_cloud_provider.py

@@ -0,0 +1,30 @@
+# """
+#     QApp Platform Project
+#     ibm_cloud_provider.py
+#     Copyright © CITYNOW Co. Ltd. All rights reserved.
+# """
+# from qapp_common.config.logging_config import logger
+# from qapp_common.enum.provider_tag import ProviderTag
+# from qapp_common.model.provider.provider import Provider
+# from qiskit_ibm_runtime import QiskitRuntimeService
+# from qiskit_ibm_runtime.accounts import ChannelType
+
+
+# class IbmCloudProvider(Provider):
+
+#     def __init__(self, api_key, crn):
+#         super().__init__(ProviderTag.IBM_CLOUD)
+#         self.api_key = api_key
+#         self.crn = crn
+#         self.channel: ChannelType = "ibm_cloud"
+
+#     def get_backend(self, device_specification: str):
+#         logger.debug('[IbmCloudProvider] Get backend')
+
+#         provider = self.collect_provider()
+
+#         return provider.get_backend(name=device_specification)
+
+#     def collect_provider(self):
+#         logger.debug('[IbmCloudProvider] Connect to provider')
+#         return QiskitRuntimeService(channel=self.channel, token=self.api_key, instance=self.crn)

quapp_pennylane-0.0.4.dev1/qapp_pennylane/model/provider/ibm_quantum_provider.py

@@ -0,0 +1,27 @@
+# """
+#     QApp Platform Project
+#     ibm_quantum_provider.py
+#     Copyright © CITYNOW Co. Ltd. All rights reserved.
+# """
+# from qapp_common.enum.provider_tag import ProviderTag
+# from qapp_common.model.provider.provider import Provider
+# from qapp_common.config.logging_config import logger
+# from qiskit_ibm_provider import IBMProvider
+
+
+# class IbmQuantumProvider(Provider):
+#     def __init__(self, api_token):
+#         super().__init__(ProviderTag.IBM_QUANTUM)
+#         self.api_token = api_token
+
+#     def get_backend(self, device_specification):
+#         logger.debug('[IbmQuantumProvider] get_backend()')
+
+#         provider = self.collect_provider()
+
+#         return provider.get_backend(device_specification)
+
+#     def collect_provider(self):
+#         logger.debug('[IbmQuantumProvider] collect_provider()')
+
+#         return IBMProvider(token=self.api_token)

quapp_pennylane-0.0.4.dev1/qapp_pennylane/model/provider/qapp_pennylane_provider.py

@@ -0,0 +1,27 @@
+"""
+    QApp Platform Project
+    qapp_pennylane_provider.py
+    Copyright © CITYNOW Co. Ltd. All rights reserved.
+"""
+from qapp_common.config.logging_config import logger
+from qapp_common.enum.provider_tag import ProviderTag
+from qapp_common.model.provider.provider import Provider
+
+
+class QAppPennyLaneProvider(Provider):
+    def __init__(self, ):
+        logger.debug('[QAppPennyLaneProvider] get_backend()')
+        super().__init__(ProviderTag.QUAO_QUANTUM_SIMULATOR)
+
+    def get_backend(self, device_specification):
+        logger.debug('[QAppPennyLaneProvider] get_backend()')
+
+        try:
+            # with pennylane, create backend later 
+            return None
+        except Exception:
+            raise ValueError('[QAppPennyLaneProvider] Unsupported device')
+
+    def collect_provider(self):
+        logger.debug('[QAppPennyLaneProvider] collect_provider()')
+        return None

quapp_pennylane-0.0.4.dev1/quapp_pennylane.egg-info/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.4
+Name: quapp-pennylane
+Version: 0.0.4.dev1
+Summary: Quapp pennylane library supporting Quapp Platform for Quantum Computing
+Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
+License: The MIT License (MIT)
+        Copyright © CITYNOW Co. Ltd. All rights reserved.
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Project-URL: Homepage, https://citynow.asia/
+Keywords: quapp,quapp-pennylane,pennylane,quantum
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: quapp-common==0.0.11.dev1
+Requires-Dist: pennylane==0.37.0
+Requires-Dist: matplotlib
+Requires-Dist: PennyLane-Rigetti==0.36.0
+Requires-Dist: PennyLane_Lightning==0.37.0
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: bumpver; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: pip-tools; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# qapp-pennylane 0.0.2
+
+Add rigetti device

quapp_pennylane-0.0.4.dev1/quapp_pennylane.egg-info/SOURCES.txt

@@ -0,0 +1,31 @@
+LICENSE
+README.md
+pyproject.toml
+qapp_pennylane/__init__.py
+qapp_pennylane/async_tasks/__init__.py
+qapp_pennylane/async_tasks/pennylane_circuit_export_task.py
+qapp_pennylane/component/__init__.py
+qapp_pennylane/component/backend/__init__.py
+qapp_pennylane/component/backend/pennylane_invocation.py
+qapp_pennylane/factory/__init__.py
+qapp_pennylane/factory/pennylane_device_factory.py
+qapp_pennylane/factory/pennylane_handler_factory.py
+qapp_pennylane/factory/pennylane_provider_factory.py
+qapp_pennylane/handler/__init__.py
+qapp_pennylane/handler/invocation_handler.py
+qapp_pennylane/model/__init__.py
+qapp_pennylane/model/device/__init__.py
+qapp_pennylane/model/device/aws_braket_device.py
+qapp_pennylane/model/device/ibm_quantum_device.py
+qapp_pennylane/model/device/pennylane_device.py
+qapp_pennylane/model/device/qapp_pennylane_device.py
+qapp_pennylane/model/provider/__init__.py
+qapp_pennylane/model/provider/aws_braket_provider.py
+qapp_pennylane/model/provider/ibm_cloud_provider.py
+qapp_pennylane/model/provider/ibm_quantum_provider.py
+qapp_pennylane/model/provider/qapp_pennylane_provider.py
+quapp_pennylane.egg-info/PKG-INFO
+quapp_pennylane.egg-info/SOURCES.txt
+quapp_pennylane.egg-info/dependency_links.txt
+quapp_pennylane.egg-info/requires.txt
+quapp_pennylane.egg-info/top_level.txt

quapp_pennylane-0.0.4.dev1/quapp_pennylane.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

quapp_pennylane-0.0.4.dev1/quapp_pennylane.egg-info/requires.txt

@@ -0,0 +1,12 @@
+quapp-common==0.0.11.dev1
+pennylane==0.37.0
+matplotlib
+PennyLane-Rigetti==0.36.0
+PennyLane_Lightning==0.37.0
+
+[dev]
+black
+bumpver
+isort
+pip-tools
+pytest

quapp_pennylane-0.0.4.dev1/quapp_pennylane.egg-info/top_level.txt

@@ -0,0 +1 @@
+qapp_pennylane

quapp_pennylane-0.0.4.dev1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+