quapp-pennylane 0.0.4.dev1__tar.gz → 0.0.4.dev2__tar.gz

{quapp_pennylane-0.0.4.dev1 → quapp_pennylane-0.0.4.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-pennylane
-Version: 0.0.4.dev1
+Version: 0.0.4.dev2
 Summary: Quapp pennylane library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)
@@ -19,7 +19,7 @@ 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: quapp-common==0.0.11.dev5
 Requires-Dist: pennylane==0.37.0
 Requires-Dist: matplotlib
 Requires-Dist: PennyLane-Rigetti==0.36.0
@@ -32,6 +32,50 @@ Requires-Dist: pip-tools; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Dynamic: license-file
 
-# qapp-pennylane 0.0.2
+# quapp-pennylane
 
-Add rigetti device
+Quapp PennyLane library supporting the Quapp Platform for Quantum Computing with
+providers, devices, circuit export, invocation, and job fetching utilities.
+
+## Overview
+
+`quapp-pennylane` is a Python library that integrates the Quapp Platform with
+PennyLane-based quantum backends and simulators. It provides common abstractions
+for providers and devices, helpers for circuit construction/export, robust job
+submission and result fetching flows, and consistent, job-scoped logging across
+components. Recent improvements focus on cleaner and more consistent logging,
+better error handling, and clear separation of concerns between invocation and
+fetching flows.
+
+Features
+
+- Provider and device factories for PennyLane-compatible platforms (e.g., local
+  simulators and vendor-backed devices exposed via PennyLane).
+- Circuit export utilities and helpers for building and running PennyLane
+  circuits.
+- Handlers for job invocation and job result fetching with enhanced,
+  context-rich logging.
+- Job-scoped, instance-bound logging for improved traceability and debugging.
+- Refined log levels and simplified imports to reduce noise and improve clarity.
+
+## Installation
+
+Install via pip:
+
+```bash
+pip install quapp-pennylane
+```
+
+## Recently Changes Highlights
+
+- refactor: Update probability measurement handling and histogram generation
+  logic
+- refactor: Add `_transpile_circuit` method with logging improvements
+- refactor: Switch to `job_logger` and improve logging consistency in PennyLane
+  factories
+- build: Bump a version to 0.0.4.dev2 and update dependency `quapp-common` to
+  0.0.11.dev5
+- refactor: Enhance logging and error handling across QAppPennylane components
+
+For detailed usage and API references, please refer to the in-code documentation
+or contact the maintainers.

quapp_pennylane-0.0.4.dev2/README.md

@@ -0,0 +1,47 @@
+# quapp-pennylane
+
+Quapp PennyLane library supporting the Quapp Platform for Quantum Computing with
+providers, devices, circuit export, invocation, and job fetching utilities.
+
+## Overview
+
+`quapp-pennylane` is a Python library that integrates the Quapp Platform with
+PennyLane-based quantum backends and simulators. It provides common abstractions
+for providers and devices, helpers for circuit construction/export, robust job
+submission and result fetching flows, and consistent, job-scoped logging across
+components. Recent improvements focus on cleaner and more consistent logging,
+better error handling, and clear separation of concerns between invocation and
+fetching flows.
+
+Features
+
+- Provider and device factories for PennyLane-compatible platforms (e.g., local
+  simulators and vendor-backed devices exposed via PennyLane).
+- Circuit export utilities and helpers for building and running PennyLane
+  circuits.
+- Handlers for job invocation and job result fetching with enhanced,
+  context-rich logging.
+- Job-scoped, instance-bound logging for improved traceability and debugging.
+- Refined log levels and simplified imports to reduce noise and improve clarity.
+
+## Installation
+
+Install via pip:
+
+```bash
+pip install quapp-pennylane
+```
+
+## Recently Changes Highlights
+
+- refactor: Update probability measurement handling and histogram generation
+  logic
+- refactor: Add `_transpile_circuit` method with logging improvements
+- refactor: Switch to `job_logger` and improve logging consistency in PennyLane
+  factories
+- build: Bump a version to 0.0.4.dev2 and update dependency `quapp-common` to
+  0.0.11.dev5
+- refactor: Enhance logging and error handling across QAppPennylane components
+
+For detailed usage and API references, please refer to the in-code documentation
+or contact the maintainers.

{quapp_pennylane-0.0.4.dev1 → quapp_pennylane-0.0.4.dev2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quapp-pennylane"
-version = "0.0.4.dev1"
+version = "0.0.4.dev2"
 description = "Quapp pennylane library supporting Quapp Platform for Quantum Computing"
 readme = "README.md"
 authors = [{ name = "CITYNOW Co. Ltd. ", email = "corp@citynow.vn" }]
@@ -16,7 +16,7 @@ classifiers = [
 ]
 keywords = ["quapp", "quapp-pennylane", "pennylane", "quantum"]
 dependencies = [
-    "quapp-common==0.0.11.dev1",
+    "quapp-common==0.0.11.dev5",
     "pennylane==0.37.0",
     "matplotlib",
     "PennyLane-Rigetti==0.36.0",

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

@@ -0,0 +1,53 @@
+#  Quapp Platform Project
+#  pennylane_circuit_export_task.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+import sys
+import time
+from abc import ABC
+from io import BytesIO
+
+import pennylane as qml
+from quapp_common.async_tasks.export_circuit_task import CircuitExportTask
+
+
+class PennylaneCircuitExportTask(CircuitExportTask, ABC):
+
+    def _convert(self):
+        self.logger.debug("Preparing circuit figure...")
+        circuit = self.circuit_data_holder.circuit
+        circuit_figure, _ = qml.draw_mpl(circuit)()
+        self.logger.debug("Converting circuit figure to svg file...")
+        figure_buffer = BytesIO()
+        circuit_figure.savefig(figure_buffer, format="svg")
+
+        self.logger.debug("Circuit figure converted successfully")
+        return figure_buffer
+
+    def _transpile_circuit(self):
+        self.logger.info("Transpiling circuit: start")
+        try:
+            self.logger.debug(
+                    f"Runtime | python_impl={getattr(sys.implementation, 'name', 'unknown')}"
+                    f" | version={sys.version.split()[0]}")
+        except Exception as env_err:
+            self.logger.warning(f"Unable to log Python runtime info: {env_err}")
+
+        start = time.perf_counter()
+        try:
+            circuit = getattr(self, "circuit", None)
+            if circuit is None:
+                self.logger.warning(
+                        "No circuit found on instance; skipping transpilation")
+                return None
+
+            # TODO: Replace this placeholder with an actual transpilation step if available.
+            transpiled_circuit = circuit
+
+            self.logger.info("Transpiling circuit: completed successfully")
+            return transpiled_circuit
+        except Exception as e:
+            self.logger.exception(f"Transpiling circuit failed: {e}")
+            raise
+        finally:
+            duration = time.perf_counter() - start
+            self.logger.debug(f"Transpiling circuit: duration_s={duration:.6f}")

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

@@ -0,0 +1,118 @@
+#  Quapp Platform Project
+#  pennylane_invocation.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+from pennylane.tape import QuantumTape
+from quapp_common.component.backend.invocation import Invocation
+from quapp_common.config.thread_config import circuit_exporting_pool
+from quapp_common.data.async_task.circuit_export.backend_holder import \
+    BackendDataHolder
+from quapp_common.data.async_task.circuit_export.circuit_holder import \
+    CircuitDataHolder
+from quapp_common.data.request.invocation_request import InvocationRequest
+from quapp_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
+
+
+class PennylaneInvocation(Invocation):
+
+    def __init__(self, request_data: InvocationRequest, **kwargs):
+        super().__init__(request_data)
+        self.num_qubits = kwargs.get('num_qubits')
+        # Initialization logging
+        try:
+            backend_name = getattr(self.backend_information, 'device_name',
+                                   None)
+            provider_tag = getattr(self.backend_information, "provider_tag",
+                                   None)
+            has_auth = getattr(self.backend_information, "authentication",
+                               None) is not None
+            self_input_keys = list(self.input.keys()) if isinstance(self.input,
+                                                                    dict) else None
+            self.logger.info(
+                    f'Initialized | device="{backend_name}" | provider_tag="{provider_tag}" '
+                    f'| has_auth={has_auth} | num_qubits_hint={self.num_qubits} | input_keys={self_input_keys}')
+        except Exception as e:
+            self.logger.warning(f'Initialization summary failed: {e}')
+
+    def _export_circuit(self, circuit):
+        self.logger.info('Exporting circuit')
+        try:
+            export_url_present = bool(getattr(self, "circuit_export_url", None))
+            self.logger.debug(
+                    f"Preparing circuit export | has_export_url={export_url_present}")
+
+            circuit_export_task = PennylaneCircuitExportTask(
+                    circuit_data_holder=CircuitDataHolder(circuit,
+                                                          self.circuit_export_url),
+                    backend_data_holder=BackendDataHolder(
+                            self.backend_information,
+                            self.authentication.user_token))
+            future = circuit_exporting_pool.submit(circuit_export_task.do)
+            self.logger.info("Circuit export submitted to thread pool")
+
+            # Optional: add a done callback for visibility
+            def _on_done(f):
+                try:
+                    f.result()
+                    self.logger.info("Circuit export task completed")
+                except Exception as task_err:
+                    self.logger.exception(
+                            f"Circuit export task failed: {task_err}")
+
+            future.add_done_callback(_on_done)
+        except Exception as exception:
+            self.logger.exception(f'Failed to export circuit: {exception}')
+            raise
+
+    def _create_provider(self):
+        self.logger.debug('Creating provider')
+        try:
+            provider_tag = getattr(self.backend_information, "provider_tag",
+                                   None)
+            self.logger.debug(
+                    f'Creating provider | tag="{provider_tag}" | sdk="{self.sdk}"')
+            provider = PennyLaneProviderFactory.create_provider(
+                    provider_type=provider_tag, sdk=self.sdk,
+                    authentication=self.backend_information.authentication)
+            self.logger.info('Provider created successfully')
+            return provider
+        except Exception as exception:
+            self.logger.exception(f'Failed to create provider: {exception}')
+            raise
+
+    def _create_device(self, provider: Provider):
+        self.logger.info('Creating device')
+        try:
+            device_name = getattr(self.backend_information, "device_name", None)
+            self.logger.debug(
+                    f'Device params | device="{device_name}" | sdk="{self.sdk}" '
+                    f'| num_qubits={self.num_qubits} | input_keys={list(self.input.keys()) if isinstance(self.input, dict) else None}')
+            device = PennylaneDeviceFactory.create_device(provider=provider,
+                                                          device_specification=device_name,
+                                                          authentication=self.backend_information.authentication,
+                                                          sdk=self.sdk,
+                                                          num_qubits=self.num_qubits,
+                                                          input=self.input)
+            self.logger.info('Device created successfully')
+            return device
+        except Exception as exception:
+            self.logger.exception(f'Failed to create device: {exception}')
+            raise
+
+    def _get_qubit_amount(self, circuit):
+        self.logger.debug('Getting qubit amount')
+        try:
+            with QuantumTape() as tape:
+                circuit()
+            num_wires = getattr(tape, "num_wires", None)
+            self.logger.info(f'Qubit amount detected | wires={num_wires}')
+            return num_wires
+        except Exception as exception:
+            self.logger.exception(
+                    f'Failed to determine qubit amount: {exception}')
+            raise

{quapp_pennylane-0.0.4.dev1 → quapp_pennylane-0.0.4.dev2}/qapp_pennylane/factory/pennylane_device_factory.py

@@ -3,32 +3,41 @@
     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
+#  Quapp Platform Project
+#  pennylane_device_factory.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+from quapp_common.config.logging_config import logger, job_logger
+from quapp_common.enum.provider_tag import ProviderTag
+from quapp_common.enum.sdk import Sdk
+from quapp_common.factory.device_factory import DeviceFactory
+from quapp_common.model.provider.provider import Provider
 
 from ..model.device.qapp_pennylane_device import QAppPennylaneDevice
 
+logger = job_logger('PennylaneDeviceFactory')
+
 
 class PennylaneDeviceFactory(DeviceFactory):
 
     @staticmethod
-    def create_device(provider: Provider, device_specification: str, authentication: dict, sdk: Sdk,
-                      **kwargs):
-        logger.info("[PennylaneDeviceFactory] create_device()")
+    def create_device(provider: Provider, device_specification: str,
+            authentication: dict, sdk: Sdk,
+            **kwargs):
+        logger.info("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')
+                    logger.debug(
+                            'Creating QAppPennylaneDevice')
                     return QAppPennylaneDevice(provider, device_specification)
-                raise ValueError(f'Unsupported SDK for provider type: {provider_type}')
+                raise ValueError(
+                        f'Unsupported SDK for provider type: {provider_type}')
             # case ProviderTag.AWS_BRAKET:
-            #     logger.debug('[PennylaneDeviceFactory] Creating AwsBraketDevice')
+            #     logger.debug('Creating AwsBraketDevice')
             #     return AwsBraketDevice(provider, device_specification, kwargs['backend_name'],
             #                            kwargs['num_qubits'], kwargs['s3_bucket_name'],
             #                            kwargs['s3_prefix'], kwargs['inputs'])
@@ -37,4 +46,4 @@ class PennylaneDeviceFactory(DeviceFactory):
             #                             api_token=authentication.get('api_token'),
             #                             instance=authentication.get('instance'))
             case _:
-                raise ValueError(f"Unsupported provider type: {provider_type}")
+                raise ValueError(f"Unsupported provider type: {provider_type}")

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

@@ -0,0 +1,31 @@
+"""
+    QApp Platform Project pennylane_handler_factory.py Copyright © CITYNOW Co. Ltd. All rights reserved.
+"""
+
+#  Quapp Platform Project
+#  pennylane_handler_factory.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+from quapp_common.config.logging_config import logger, job_logger
+from quapp_common.factory.handler_factory import HandlerFactory
+from quapp_common.handler.handler import Handler
+
+from ..handler.invocation_handler import InvocationHandler
+
+logger = job_logger('PennylaneHandlerFactory')
+
+class PennylaneHandlerFactory(HandlerFactory):
+
+    @staticmethod
+    def create_handler(event, circuit_preparation_fn,
+            post_processing_fn) -> Handler:
+        logger.debug('Creating handler')
+
+        request_data = event.json()
+
+        logger.debug("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 → quapp_pennylane-0.0.4.dev2}/qapp_pennylane/factory/pennylane_provider_factory.py

@@ -3,25 +3,35 @@
     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
+#  Quapp Platform Project
+#  pennylane_provider_factory.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+from quapp_common.config.logging_config import logger, job_logger
+from quapp_common.enum.provider_tag import ProviderTag
+from quapp_common.enum.sdk import Sdk
+from quapp_common.factory.provider_factory import ProviderFactory
 
 from ..model.provider.qapp_pennylane_provider import QAppPennyLaneProvider
 
+logger = job_logger('PennyLaneProviderFactory')
+
+
 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}")
+    def create_provider(provider_type: ProviderTag, sdk: Sdk,
+            authentication: dict):
+        logger.info("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}')
+                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:
@@ -31,4 +41,4 @@ class PennyLaneProviderFactory(ProviderFactory):
             #                              authentication.get('secret_access_key'),
             #                              authentication.get('region_name'))
             case _:
-                raise ValueError(f'Unsupported provider type: {provider_type}')
+                raise ValueError(f'Unsupported provider type: {provider_type}')

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

@@ -0,0 +1,53 @@
+#  Quapp Platform Project
+#  invocation_handler.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+from quapp_common.data.request.invocation_request import InvocationRequest
+from quapp_common.handler.handler import Handler
+
+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
+
+        # Initialization logging
+        self.logger.info(
+                f'InvocationHandler initialized | has_circuit_prep={circuit_preparation_fn is not None} '
+                f'| has_post_processing={post_processing_fn is not None}')
+        self.logger.debug(
+                f'InvocationHandler request_data keys={list(request_data.keys()) if isinstance(request_data, dict) else "n/a"}')
+
+    def handle(self):
+        self.logger.info('InvocationHandler.handle() invoked')
+
+        try:
+            self.logger.debug('Parsing InvocationRequest from request_data')
+            invocation_request = InvocationRequest(self.request_data)
+            self.logger.info('InvocationRequest created successfully')
+        except Exception as exception:
+            self.logger.exception(
+                f'Failed to create InvocationRequest: {exception}')
+            raise
+
+        try:
+            self.logger.debug('Creating PennylaneInvocation backend')
+            backend = PennylaneInvocation(invocation_request)
+            self.logger.info('PennylaneInvocation backend created')
+        except Exception as exception:
+            self.logger.exception(f'Failed to create backend: {exception}')
+            raise
+
+        try:
+            self.logger.info('Submitting job to backend')
+            backend.submit_job(
+                    circuit_preparation_fn=self.circuit_preparation_fn,
+                    post_processing_fn=self.post_processing_fn)
+            self.logger.info('Job submission succeeded')
+        except Exception as exception:
+            self.logger.exception(f'Job submission failed: {exception}')
+            raise