quapp-pennylane 0.0.4.dev11__tar.gz → 0.0.5.dev2__tar.gz

quapp_pennylane-0.0.5.dev2/PKG-INFO

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: quapp-pennylane
+Version: 0.0.5.dev2
+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.dev7
+Requires-Dist: autoray==0.6.11
+Requires-Dist: pennylane==0.37.0
+Requires-Dist: matplotlib
+Requires-Dist: PennyLane-Rigetti==0.36.0
+Requires-Dist: PennyLane_Lightning==0.37.0
+Requires-Dist: pydantic<2.0.0,>=1.7.2
+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
+
+# 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 and export, robust job
+submission and result fetching flows, and consistent job-scoped logging across
+all components.
+
+## Features
+
+- **Provider & device factories** — PennyLane-compatible factories for local
+  simulators (e.g., `default.qubit`) and vendor-backed hardware (Rigetti QVM,
+  AWS Braket, IBM Quantum).
+- **Circuit export** — `PennylaneCircuitExportTask` with a `_PennylaneDrawableCircuit`
+  adapter that satisfies the `CircuitExportTask.draw()` contract using `qml.draw_mpl`.
+- **Job execution** — `QAppPennylaneDevice` drives the full execution pipeline:
+  tape construction, device selection, QNode creation, probability histogram
+  generation, and timing metrics.
+- **Rigetti QVM support** — dynamic device-name derivation for N-qubit QVM
+  topologies (`Nq-qvm`, `Nq-pyqvm`) alongside fixed 9-qubit variants.
+- **Structured logging** — job-scoped, instance-bound loggers emit structured
+  key=value fields at every major step for traceability and debugging.
+- **Compatibility shims** — `quapp_pennylane/__init__.py` patches API breaks
+  between `pennylane-rigetti==0.36.0` and PennyLane 0.37–0.42+ at import time
+  (see [Compatibility](#compatibility) below).
+
+## Installation
+
+```bash
+pip install quapp-pennylane
+```
+
+## Requirements
+
+| Dependency | Version |
+|---|---|
+| Python | ≥ 3.10 |
+| quapp-common | 0.0.11.dev7 |
+| pennylane | 0.37.0 |
+| PennyLane-Rigetti | 0.36.0 |
+| PennyLane-Lightning | 0.37.0 |
+| pydantic | ≥ 1.7.2, < 2.0.0 |
+| autoray | 0.6.11 |
+
+## Project Structure
+
+```
+quapp_pennylane/
+├── __init__.py                          # Compatibility shims (loaded at import)
+├── async_tasks/
+│   └── pennylane_circuit_export_task.py # PennylaneCircuitExportTask + adapter
+├── component/
+│   └── backend/
+│       └── pennylane_invocation.py
+├── factory/
+│   ├── pennylane_device_factory.py
+│   ├── pennylane_handler_factory.py
+│   └── pennylane_provider_factory.py
+├── handler/
+│   └── invocation_handler.py
+└── model/
+    ├── device/
+    │   ├── qapp_pennylane_device.py     # Core execution device
+    │   ├── aws_braket_device.py
+    │   └── ibm_quantum_device.py
+    └── provider/
+        ├── qapp_pennylane_provider.py
+        ├── aws_braket_provider.py
+        ├── ibm_cloud_provider.py
+        └── ibm_quantum_provider.py
+```
+
+## Compatibility
+
+`quapp_pennylane/__init__.py` applies the following shims at import time so that
+`pennylane-rigetti==0.36.0` works against PennyLane 0.37–0.42+:
+
+| Symbol | Change | Shim |
+|---|---|---|
+| `measurements.Expectation` | Renamed to `ExpectationMP` in PennyLane 0.37+ | Alias `Expectation → ExpectationMP` |
+| `operation.Tensor` | Removed in PennyLane 0.40+; replaced by `ops.Prod` | Alias `Tensor → Prod` for isinstance checks |
+| `pennylane.QubitDevice` | Moved to `pennylane.devices` in PennyLane ~0.40+ | Re-export at top-level namespace |
+| `pydantic.BaseModel.__config__` | Removed in Pydantic v2; `qcs-api-client<0.22.0` reads `self.__config__.env_prefix` | Inject a stub `__config__` with `env_prefix=''` onto `BaseModel` |
+
+`pydantic` is pinned to `>=1.7.2,<2.0.0` in `pyproject.toml` to make the v1
+requirement of `qcs-api-client<0.22.0` explicit and prevent pip from resolving v2.
+
+## Recent Changes
+
+### 0.0.5.dev2
+
+- **fix(export)**: Fix `_PennylaneDrawableCircuit.draw()` — `qml.draw_mpl` requires
+  a `QNode`, not a bare callable; now captures the circuit into a `QuantumTape`,
+  derives wires, creates a `default.qubit` device, and wraps in a `QNode` before
+  rendering with `qml.draw_mpl`.
+- **build**: Bump version to `0.0.5.dev2`.
+
+### 0.0.5.dev1
+
+- **feat(device)**: Add structured key=value log fields to `QAppPennylaneDevice`
+  at every execution stage — initialization, tape diagnostics, device resolution,
+  QNode setup, execution timing, histogram generation, and finalization.
+- **feat(device)**: Default shots fallback — `shots=None` or `shots=0` in
+  `CircuitRunningOption` falls back to 1024 with a warning instead of raising.
+- **feat(export)**: Introduce `_PennylaneDrawableCircuit` adapter in
+  `PennylaneCircuitExportTask` to wrap PennyLane circuits for the
+  `CircuitExportTask.draw()` contract using `qml.draw_mpl`.
+- **feat(export)**: Emit Python runtime information and duration timing in
+  `_transpile_circuit`.
+- **fix(compat)**: Patch `pydantic.BaseModel.__config__` at import time for
+  Pydantic v2 environments — `qcs-api-client<0.22.0` accesses
+  `self.__config__.env_prefix` (a Pydantic v1 inner Config class removed in v2).
+- **fix(deps)**: Pin `pydantic>=1.7.2,<2.0.0` in `pyproject.toml` to prevent
+  pip from resolving Pydantic v2.
+- **fix(compat)**: Extend compatibility shims for `pennylane-rigetti==0.36.0`
+  against PennyLane 0.37–0.42+: `measurements.Expectation`, `operation.Tensor`,
+  and `pennylane.QubitDevice`.
+- **build**: Bump version to `0.0.5.dev1`.
+
+For detailed API references, refer to the in-code documentation or contact the
+maintainers at [corp@citynow.vn](mailto:corp@citynow.vn).

quapp_pennylane-0.0.5.dev2/README.md

@@ -0,0 +1,126 @@
+# 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 and export, robust job
+submission and result fetching flows, and consistent job-scoped logging across
+all components.
+
+## Features
+
+- **Provider & device factories** — PennyLane-compatible factories for local
+  simulators (e.g., `default.qubit`) and vendor-backed hardware (Rigetti QVM,
+  AWS Braket, IBM Quantum).
+- **Circuit export** — `PennylaneCircuitExportTask` with a `_PennylaneDrawableCircuit`
+  adapter that satisfies the `CircuitExportTask.draw()` contract using `qml.draw_mpl`.
+- **Job execution** — `QAppPennylaneDevice` drives the full execution pipeline:
+  tape construction, device selection, QNode creation, probability histogram
+  generation, and timing metrics.
+- **Rigetti QVM support** — dynamic device-name derivation for N-qubit QVM
+  topologies (`Nq-qvm`, `Nq-pyqvm`) alongside fixed 9-qubit variants.
+- **Structured logging** — job-scoped, instance-bound loggers emit structured
+  key=value fields at every major step for traceability and debugging.
+- **Compatibility shims** — `quapp_pennylane/__init__.py` patches API breaks
+  between `pennylane-rigetti==0.36.0` and PennyLane 0.37–0.42+ at import time
+  (see [Compatibility](#compatibility) below).
+
+## Installation
+
+```bash
+pip install quapp-pennylane
+```
+
+## Requirements
+
+| Dependency | Version |
+|---|---|
+| Python | ≥ 3.10 |
+| quapp-common | 0.0.11.dev7 |
+| pennylane | 0.37.0 |
+| PennyLane-Rigetti | 0.36.0 |
+| PennyLane-Lightning | 0.37.0 |
+| pydantic | ≥ 1.7.2, < 2.0.0 |
+| autoray | 0.6.11 |
+
+## Project Structure
+
+```
+quapp_pennylane/
+├── __init__.py                          # Compatibility shims (loaded at import)
+├── async_tasks/
+│   └── pennylane_circuit_export_task.py # PennylaneCircuitExportTask + adapter
+├── component/
+│   └── backend/
+│       └── pennylane_invocation.py
+├── factory/
+│   ├── pennylane_device_factory.py
+│   ├── pennylane_handler_factory.py
+│   └── pennylane_provider_factory.py
+├── handler/
+│   └── invocation_handler.py
+└── model/
+    ├── device/
+    │   ├── qapp_pennylane_device.py     # Core execution device
+    │   ├── aws_braket_device.py
+    │   └── ibm_quantum_device.py
+    └── provider/
+        ├── qapp_pennylane_provider.py
+        ├── aws_braket_provider.py
+        ├── ibm_cloud_provider.py
+        └── ibm_quantum_provider.py
+```
+
+## Compatibility
+
+`quapp_pennylane/__init__.py` applies the following shims at import time so that
+`pennylane-rigetti==0.36.0` works against PennyLane 0.37–0.42+:
+
+| Symbol | Change | Shim |
+|---|---|---|
+| `measurements.Expectation` | Renamed to `ExpectationMP` in PennyLane 0.37+ | Alias `Expectation → ExpectationMP` |
+| `operation.Tensor` | Removed in PennyLane 0.40+; replaced by `ops.Prod` | Alias `Tensor → Prod` for isinstance checks |
+| `pennylane.QubitDevice` | Moved to `pennylane.devices` in PennyLane ~0.40+ | Re-export at top-level namespace |
+| `pydantic.BaseModel.__config__` | Removed in Pydantic v2; `qcs-api-client<0.22.0` reads `self.__config__.env_prefix` | Inject a stub `__config__` with `env_prefix=''` onto `BaseModel` |
+
+`pydantic` is pinned to `>=1.7.2,<2.0.0` in `pyproject.toml` to make the v1
+requirement of `qcs-api-client<0.22.0` explicit and prevent pip from resolving v2.
+
+## Recent Changes
+
+### 0.0.5.dev2
+
+- **fix(export)**: Fix `_PennylaneDrawableCircuit.draw()` — `qml.draw_mpl` requires
+  a `QNode`, not a bare callable; now captures the circuit into a `QuantumTape`,
+  derives wires, creates a `default.qubit` device, and wraps in a `QNode` before
+  rendering with `qml.draw_mpl`.
+- **build**: Bump version to `0.0.5.dev2`.
+
+### 0.0.5.dev1
+
+- **feat(device)**: Add structured key=value log fields to `QAppPennylaneDevice`
+  at every execution stage — initialization, tape diagnostics, device resolution,
+  QNode setup, execution timing, histogram generation, and finalization.
+- **feat(device)**: Default shots fallback — `shots=None` or `shots=0` in
+  `CircuitRunningOption` falls back to 1024 with a warning instead of raising.
+- **feat(export)**: Introduce `_PennylaneDrawableCircuit` adapter in
+  `PennylaneCircuitExportTask` to wrap PennyLane circuits for the
+  `CircuitExportTask.draw()` contract using `qml.draw_mpl`.
+- **feat(export)**: Emit Python runtime information and duration timing in
+  `_transpile_circuit`.
+- **fix(compat)**: Patch `pydantic.BaseModel.__config__` at import time for
+  Pydantic v2 environments — `qcs-api-client<0.22.0` accesses
+  `self.__config__.env_prefix` (a Pydantic v1 inner Config class removed in v2).
+- **fix(deps)**: Pin `pydantic>=1.7.2,<2.0.0` in `pyproject.toml` to prevent
+  pip from resolving Pydantic v2.
+- **fix(compat)**: Extend compatibility shims for `pennylane-rigetti==0.36.0`
+  against PennyLane 0.37–0.42+: `measurements.Expectation`, `operation.Tensor`,
+  and `pennylane.QubitDevice`.
+- **build**: Bump version to `0.0.5.dev1`.
+
+For detailed API references, refer to the in-code documentation or contact the
+maintainers at [corp@citynow.vn](mailto:corp@citynow.vn).

{quapp_pennylane-0.0.4.dev11 → quapp_pennylane-0.0.5.dev2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quapp-pennylane"
-version = "0.0.4.dev11"
+version = "0.0.5.dev2"
 description = "Quapp pennylane library supporting Quapp Platform for Quantum Computing"
 readme = "README.md"
 authors = [{ name = "CITYNOW Co. Ltd. ", email = "corp@citynow.vn" }]

quapp_pennylane-0.0.5.dev2/quapp_pennylane/async_tasks/pennylane_circuit_export_task.py

@@ -0,0 +1,81 @@
+#  Quapp Platform Project
+#  pennylane_circuit_export_task.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+import pennylane as qml
+import sys
+import time
+from abc import ABC
+from quapp_common.async_tasks.export_circuit_task import CircuitExportTask
+
+
+class _PennylaneDrawableCircuit:
+    """Adapter wrapping a PennyLane circuit to satisfy CircuitExportTask's .draw() contract."""
+
+    def __init__(self, circuit):
+        self._circuit = circuit
+
+    def draw(self, **kwargs):
+        """
+        Generate a visual representation of a quantum circuit.
+
+        This method constructs a quantum circuit by invoking the internal `_circuit`
+         method and then creates a corresponding visualization using matplotlib.
+        QuantumTape is used to capture the quantum circuit, while the `qml.draw_mpl`
+        function is used to render the visualization.
+
+        :param kwargs: Optional keyword arguments to be passed to internal
+            operations or specific quantum circuit functionality.
+        :return: A matplotlib figure containing the visualization of the quantum
+            circuit generated.
+        :rtype: matplotlib.figure.Figure
+        """
+        with qml.tape.QuantumTape() as tape:
+            self._circuit()
+        wires = tape.wires.tolist() or [0]
+        dev = qml.device("default.qubit", wires=wires)
+        qnode = qml.QNode(self._circuit, dev)
+        fig, _ = qml.draw_mpl(qnode)()
+        return fig
+
+
+class PennylaneCircuitExportTask(CircuitExportTask, ABC):
+    """
+    Handles the exportation of Pennylane circuits.
+
+    This class is responsible for transpiling quantum circuits using Pennylane's
+    framework. It provides functionality to translate circuit data into a format
+    that can be handled and processed efficiently. The transpilation process is
+    monitored and logged for debugging, performance tracking, and error handling.
+
+    :ivar circuit_data_holder: Holder object containing circuit-related data,
+        such as the quantum circuit to be transpiled.
+    :type circuit_data_holder: CircuitDataHolder
+    :ivar logger: Logger instance used for logging information, warnings,
+        debugging details, and errors during circuit export and transpilation.
+    :type logger: logging.Logger
+    """
+
+    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 = self.circuit_data_holder.circuit
+            if circuit is None:
+                raise ValueError("No circuit found in circuit_data_holder")
+
+            transpiled_circuit = _PennylaneDrawableCircuit(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.dev11 → quapp_pennylane-0.0.5.dev2}/quapp_pennylane/model/device/qapp_pennylane_device.py

@@ -40,12 +40,16 @@ class QAppPennylaneDevice(CustomDevice):
 
         run the circuit and return the result
         """
-        self.logger.debug(
-                f'Creating job with {getattr(options, "shots", None)} shots')
+        DEFAULT_SHOTS = 1024
+        raw_shots = getattr(options, "shots", None)
+        self.logger.debug(f'Creating job with {raw_shots} shots')
+
+        # PennyLane rejects shots=0 or None; fall back to DEFAULT_SHOTS
+        effective_shots = raw_shots if (raw_shots is not None and raw_shots > 0) else DEFAULT_SHOTS
 
-        if getattr(options, "shots", None) is None:
+        if raw_shots != effective_shots:
             self.logger.warning(
-                    "Option 'shots' is None; falling back to device or default shots")
+                    f"Option 'shots' is {raw_shots!r}; using default shots={DEFAULT_SHOTS}")
 
         with QuantumTape() as tape:
             self.logger.debug('Entering QuantumTape context to build circuit')
@@ -92,23 +96,23 @@ class QAppPennylaneDevice(CustomDevice):
                 if parts[1] in [DEVICE_TYPE_9Q_SQUARE_QVM,
                                 DEVICE_TYPE_9Q_SQUARE_PYQVM]:
                     self.device = qml.device(device_name, device=device_type,
-                                             shots=options.shots)
+                                             shots=effective_shots)
                 else:
                     derived_device = str(tape.num_wires) + device_type[1:]
                     self.logger.debug(
                             f'Derived Rigetti device name: {derived_device}')
                     self.device = qml.device(device_name, device=derived_device,
-                                             shots=options.shots)
+                                             shots=effective_shots)
             elif unsupported_default_qubit_autograd:
                 self.logger.info(
                         f'Falling back to default.qubit due to unsupported "{device_name}" with autograd')
                 self.device = qml.device('default.qubit', wires=tape.wires,
-                                         shots=options.shots)
+                                         shots=effective_shots)
             else:
                 self.logger.info(
-                        f'Selecting device | name="{device_name}" | wires={tape.wires} | shots={getattr(options, "shots", None)}')
+                        f'Selecting device | name="{device_name}" | wires={tape.wires} | shots={effective_shots}')
                 self.device = qml.device(device_name, wires=tape.wires,
-                                         shots=options.shots)
+                                         shots=effective_shots)
         except Exception as e:
             self.logger.exception(
                     f'Failed to create device "{device_name}" from spec "{self.device_specification}": {e}')
@@ -180,7 +184,7 @@ class QAppPennylaneDevice(CustomDevice):
                 for i, prob in enumerate(probs):
                     bitstring = format(i,
                                        f'0{num_bits}b') if num_bits > 0 else '0'
-                    result_histogram[bitstring] = int(prob * options.shots)
+                    result_histogram[bitstring] = int(prob * effective_shots)
                 self.logger.info(
                         f'Histogram generated | entries={len(result_histogram)}')
             else:

quapp_pennylane-0.0.5.dev2/quapp_pennylane.egg-info/PKG-INFO

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: quapp-pennylane
+Version: 0.0.5.dev2
+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.dev7
+Requires-Dist: autoray==0.6.11
+Requires-Dist: pennylane==0.37.0
+Requires-Dist: matplotlib
+Requires-Dist: PennyLane-Rigetti==0.36.0
+Requires-Dist: PennyLane_Lightning==0.37.0
+Requires-Dist: pydantic<2.0.0,>=1.7.2
+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
+
+# 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 and export, robust job
+submission and result fetching flows, and consistent job-scoped logging across
+all components.
+
+## Features
+
+- **Provider & device factories** — PennyLane-compatible factories for local
+  simulators (e.g., `default.qubit`) and vendor-backed hardware (Rigetti QVM,
+  AWS Braket, IBM Quantum).
+- **Circuit export** — `PennylaneCircuitExportTask` with a `_PennylaneDrawableCircuit`
+  adapter that satisfies the `CircuitExportTask.draw()` contract using `qml.draw_mpl`.
+- **Job execution** — `QAppPennylaneDevice` drives the full execution pipeline:
+  tape construction, device selection, QNode creation, probability histogram
+  generation, and timing metrics.
+- **Rigetti QVM support** — dynamic device-name derivation for N-qubit QVM
+  topologies (`Nq-qvm`, `Nq-pyqvm`) alongside fixed 9-qubit variants.
+- **Structured logging** — job-scoped, instance-bound loggers emit structured
+  key=value fields at every major step for traceability and debugging.
+- **Compatibility shims** — `quapp_pennylane/__init__.py` patches API breaks
+  between `pennylane-rigetti==0.36.0` and PennyLane 0.37–0.42+ at import time
+  (see [Compatibility](#compatibility) below).
+
+## Installation
+
+```bash
+pip install quapp-pennylane
+```
+
+## Requirements
+
+| Dependency | Version |
+|---|---|
+| Python | ≥ 3.10 |
+| quapp-common | 0.0.11.dev7 |
+| pennylane | 0.37.0 |
+| PennyLane-Rigetti | 0.36.0 |
+| PennyLane-Lightning | 0.37.0 |
+| pydantic | ≥ 1.7.2, < 2.0.0 |
+| autoray | 0.6.11 |
+
+## Project Structure
+
+```
+quapp_pennylane/
+├── __init__.py                          # Compatibility shims (loaded at import)
+├── async_tasks/
+│   └── pennylane_circuit_export_task.py # PennylaneCircuitExportTask + adapter
+├── component/
+│   └── backend/
+│       └── pennylane_invocation.py
+├── factory/
+│   ├── pennylane_device_factory.py
+│   ├── pennylane_handler_factory.py
+│   └── pennylane_provider_factory.py
+├── handler/
+│   └── invocation_handler.py
+└── model/
+    ├── device/
+    │   ├── qapp_pennylane_device.py     # Core execution device
+    │   ├── aws_braket_device.py
+    │   └── ibm_quantum_device.py
+    └── provider/
+        ├── qapp_pennylane_provider.py
+        ├── aws_braket_provider.py
+        ├── ibm_cloud_provider.py
+        └── ibm_quantum_provider.py
+```
+
+## Compatibility
+
+`quapp_pennylane/__init__.py` applies the following shims at import time so that
+`pennylane-rigetti==0.36.0` works against PennyLane 0.37–0.42+:
+
+| Symbol | Change | Shim |
+|---|---|---|
+| `measurements.Expectation` | Renamed to `ExpectationMP` in PennyLane 0.37+ | Alias `Expectation → ExpectationMP` |
+| `operation.Tensor` | Removed in PennyLane 0.40+; replaced by `ops.Prod` | Alias `Tensor → Prod` for isinstance checks |
+| `pennylane.QubitDevice` | Moved to `pennylane.devices` in PennyLane ~0.40+ | Re-export at top-level namespace |
+| `pydantic.BaseModel.__config__` | Removed in Pydantic v2; `qcs-api-client<0.22.0` reads `self.__config__.env_prefix` | Inject a stub `__config__` with `env_prefix=''` onto `BaseModel` |
+
+`pydantic` is pinned to `>=1.7.2,<2.0.0` in `pyproject.toml` to make the v1
+requirement of `qcs-api-client<0.22.0` explicit and prevent pip from resolving v2.
+
+## Recent Changes
+
+### 0.0.5.dev2
+
+- **fix(export)**: Fix `_PennylaneDrawableCircuit.draw()` — `qml.draw_mpl` requires
+  a `QNode`, not a bare callable; now captures the circuit into a `QuantumTape`,
+  derives wires, creates a `default.qubit` device, and wraps in a `QNode` before
+  rendering with `qml.draw_mpl`.
+- **build**: Bump version to `0.0.5.dev2`.
+
+### 0.0.5.dev1
+
+- **feat(device)**: Add structured key=value log fields to `QAppPennylaneDevice`
+  at every execution stage — initialization, tape diagnostics, device resolution,
+  QNode setup, execution timing, histogram generation, and finalization.
+- **feat(device)**: Default shots fallback — `shots=None` or `shots=0` in
+  `CircuitRunningOption` falls back to 1024 with a warning instead of raising.
+- **feat(export)**: Introduce `_PennylaneDrawableCircuit` adapter in
+  `PennylaneCircuitExportTask` to wrap PennyLane circuits for the
+  `CircuitExportTask.draw()` contract using `qml.draw_mpl`.
+- **feat(export)**: Emit Python runtime information and duration timing in
+  `_transpile_circuit`.
+- **fix(compat)**: Patch `pydantic.BaseModel.__config__` at import time for
+  Pydantic v2 environments — `qcs-api-client<0.22.0` accesses
+  `self.__config__.env_prefix` (a Pydantic v1 inner Config class removed in v2).
+- **fix(deps)**: Pin `pydantic>=1.7.2,<2.0.0` in `pyproject.toml` to prevent
+  pip from resolving Pydantic v2.
+- **fix(compat)**: Extend compatibility shims for `pennylane-rigetti==0.36.0`
+  against PennyLane 0.37–0.42+: `measurements.Expectation`, `operation.Tensor`,
+  and `pennylane.QubitDevice`.
+- **build**: Bump version to `0.0.5.dev1`.
+
+For detailed API references, refer to the in-code documentation or contact the
+maintainers at [corp@citynow.vn](mailto:corp@citynow.vn).

quapp_pennylane-0.0.4.dev11/PKG-INFO

@@ -1,90 +0,0 @@
-Metadata-Version: 2.4
-Name: quapp-pennylane
-Version: 0.0.4.dev11
-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.dev7
-Requires-Dist: autoray==0.6.11
-Requires-Dist: pennylane==0.37.0
-Requires-Dist: matplotlib
-Requires-Dist: PennyLane-Rigetti==0.36.0
-Requires-Dist: PennyLane_Lightning==0.37.0
-Requires-Dist: pydantic<2.0.0,>=1.7.2
-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
-
-# 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
-
-- fix: Patch `pydantic.BaseModel.__config__` at import time for Pydantic v2
-  environments — `qcs-api-client<0.22.0` accesses `self.__config__.env_prefix`
-  (Pydantic v1 inner Config class removed in v2); shim provides a fallback
-  `__config__` on `BaseModel` so instance lookup resolves via class MRO instead
-  of hitting Pydantic v2's `__getattr__` which raises `AttributeError`
-- fix: Pin `pydantic>=1.7.2,<2.0.0` in `pyproject.toml` — makes the Pydantic v1
-  requirement of `qcs-api-client<0.22.0` explicit to prevent pip from resolving v2
-- fix: Extend compatibility shims in `quapp_pennylane/__init__.py` for
-  `pennylane-rigetti==0.36.0` against PennyLane 0.37–0.42+:
-  - `measurements.Expectation` — renamed to `ExpectationMP` in PennyLane 0.37+
-  - `operation.Tensor` — removed in PennyLane 0.40+; aliased to `ops.Prod`
-    (its functional replacement for isinstance checks)
-  - `pennylane.QubitDevice` — moved to `pennylane.devices` in PennyLane ~0.40+;
-    re-exported at the top-level namespace
-- build: Bump a version to `0.0.4.dev9`
-
-For detailed usage and API references, please refer to the in-code documentation
-or contact the maintainers.

quapp_pennylane-0.0.4.dev11/README.md

@@ -1,54 +0,0 @@
-# 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
-
-- fix: Patch `pydantic.BaseModel.__config__` at import time for Pydantic v2
-  environments — `qcs-api-client<0.22.0` accesses `self.__config__.env_prefix`
-  (Pydantic v1 inner Config class removed in v2); shim provides a fallback
-  `__config__` on `BaseModel` so instance lookup resolves via class MRO instead
-  of hitting Pydantic v2's `__getattr__` which raises `AttributeError`
-- fix: Pin `pydantic>=1.7.2,<2.0.0` in `pyproject.toml` — makes the Pydantic v1
-  requirement of `qcs-api-client<0.22.0` explicit to prevent pip from resolving v2
-- fix: Extend compatibility shims in `quapp_pennylane/__init__.py` for
-  `pennylane-rigetti==0.36.0` against PennyLane 0.37–0.42+:
-  - `measurements.Expectation` — renamed to `ExpectationMP` in PennyLane 0.37+
-  - `operation.Tensor` — removed in PennyLane 0.40+; aliased to `ops.Prod`
-    (its functional replacement for isinstance checks)
-  - `pennylane.QubitDevice` — moved to `pennylane.devices` in PennyLane ~0.40+;
-    re-exported at the top-level namespace
-- build: Bump a version to `0.0.4.dev9`
-
-For detailed usage and API references, please refer to the in-code documentation
-or contact the maintainers.

quapp_pennylane-0.0.4.dev11/quapp_pennylane/async_tasks/pennylane_circuit_export_task.py

@@ -1,53 +0,0 @@
-#  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.dev11/quapp_pennylane.egg-info/PKG-INFO

@@ -1,90 +0,0 @@
-Metadata-Version: 2.4
-Name: quapp-pennylane
-Version: 0.0.4.dev11
-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.dev7
-Requires-Dist: autoray==0.6.11
-Requires-Dist: pennylane==0.37.0
-Requires-Dist: matplotlib
-Requires-Dist: PennyLane-Rigetti==0.36.0
-Requires-Dist: PennyLane_Lightning==0.37.0
-Requires-Dist: pydantic<2.0.0,>=1.7.2
-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
-
-# 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
-
-- fix: Patch `pydantic.BaseModel.__config__` at import time for Pydantic v2
-  environments — `qcs-api-client<0.22.0` accesses `self.__config__.env_prefix`
-  (Pydantic v1 inner Config class removed in v2); shim provides a fallback
-  `__config__` on `BaseModel` so instance lookup resolves via class MRO instead
-  of hitting Pydantic v2's `__getattr__` which raises `AttributeError`
-- fix: Pin `pydantic>=1.7.2,<2.0.0` in `pyproject.toml` — makes the Pydantic v1
-  requirement of `qcs-api-client<0.22.0` explicit to prevent pip from resolving v2
-- fix: Extend compatibility shims in `quapp_pennylane/__init__.py` for
-  `pennylane-rigetti==0.36.0` against PennyLane 0.37–0.42+:
-  - `measurements.Expectation` — renamed to `ExpectationMP` in PennyLane 0.37+
-  - `operation.Tensor` — removed in PennyLane 0.40+; aliased to `ops.Prod`
-    (its functional replacement for isinstance checks)
-  - `pennylane.QubitDevice` — moved to `pennylane.devices` in PennyLane ~0.40+;
-    re-exported at the top-level namespace
-- build: Bump a version to `0.0.4.dev9`
-
-For detailed usage and API references, please refer to the in-code documentation
-or contact the maintainers.