quapp-common 0.0.12.dev15__tar.gz → 0.0.13.dev2__tar.gz

{quapp_common-0.0.12.dev15/quapp_common.egg-info → quapp_common-0.0.13.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-common
-Version: 0.0.12.dev15
+Version: 0.0.13.dev2
 Summary: Quapp common library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)
@@ -80,15 +80,22 @@ responses while work continues in the background.
 - Multi-language SDK support:
     - Language enum for validating and resolving Python, JavaScript, and Q#
       runtimes.
-    - SubprocessDispatcher to delegate tasks to non-Python runtimes via
-      subprocess with timeout management and JSON payload processing; supports
-      Node.js and `dotnet run` (Q#) runners.
-    - SubprocessBridge integrating dispatcher, circuit adapter, and result
-      serializer for seamless JS-Python handler interaction.
-    - CircuitAdapter for converting JS subprocess circuit outputs into native
-      SDK formats (OpenQASM, QUBO, JSON) across Qiskit, Braket, PennyLane, etc.
-    - ResultSerializer for converting complex job results into JSON-serializable
-      dictionaries for subprocess communication.
+    - Standalone `dispatch()` function (formerly `SubprocessDispatcher` class)
+      to delegate tasks to non-Python runtimes via subprocess with timeout
+      management and JSON payload processing; supports Node.js and precompiled
+      Q# binary (`./handler_runner_bin/Function[.exe]`) runners.
+    - Working directory configurable via `QUAPP_WORKING_DIR` environment
+      variable; falls back to `os.getcwd()` when unset.
+    - `SubprocessBridge` class integrating standalone dispatcher, circuit
+      adapter, and result serializer for seamless JS/Q#-Python handler
+      interaction.
+    - Standalone `adapt()` function (formerly `CircuitAdapter` class) for
+      converting subprocess circuit outputs into native SDK formats (OpenQASM,
+      QUBO, JSON) across Qiskit, Braket, PennyLane, PyQuil, Qibo, Qulacs, and
+      CUDA Quantum.
+    - Standalone `serialize()` function (formerly `ResultSerializer` class) for
+      converting complex job results into JSON-serializable dictionaries for
+      subprocess communication.
 
 ## Installation
 
@@ -107,6 +114,42 @@ Notes:
 
 ## Recently Changes Highlights
 
+### v0.0.13.dev2
+- Fix: `_openqasm_to_braket` in `circuit_adapter.py` now injects a default
+  `Probability` result type when the Braket circuit produced by `tk_to_braket`
+  has no result types. OpenQASM circuits submitted from non-Python runtimes (e.g.
+  Q#) do not carry explicit measurement annotations, so the converted Braket
+  circuit would have an empty `result_types` list and fail at execution time. The
+  fix adds `circuit.probability(target=list(range(circuit.qubit_count)))` before
+  returning, ensuring every Braket job has at least one result type.
+
+### v0.0.13.dev1
+- Refactor: Replace class-based subprocess components with standalone
+  module-level functions for simpler imports and testability:
+    - `SubprocessDispatcher` class → `dispatch()` and `is_subprocess_language()`
+      in `dispatcher.py`.
+    - `CircuitAdapter` class → `adapt()` and private helper functions in
+      `circuit_adapter.py`.
+    - `ResultSerializer` class → `serialize()` in `result_serializer.py`.
+    - `SubprocessBridge` retains its class form but delegates internally to the
+      new standalone functions.
+- Refactor `dispatcher.py`: `WORKING_DIR` is now read from the
+  `QUAPP_WORKING_DIR` environment variable (previously hardcoded `None`);
+  falls back to `os.getcwd()` when the variable is unset.
+- Refactor `dispatcher.py`: Q# runner command changed from
+  `dotnet run --project HandlerRunner.csproj` to a precompiled
+  platform-specific binary — `./handler_runner_bin/Function.exe` on Windows
+  and `./handler_runner_bin/Function` on other platforms — eliminating the
+  `dotnet` toolchain requirement at runtime.
+- Refactor `circuit_adapter.py`: Extract `_load_qasm_circuit(qasm_str)` private
+  utility that centralises OpenQASM 2.0 string parsing with Qiskit version
+  compatibility — uses `qiskit.qasm2.loads` (Qiskit >= 1.0) and falls back to
+  `QiskitCircuit.from_qasm_str` (Qiskit < 1.0).
+- Fix: `subprocess.run` now passes `check=True` so a non-zero exit code raises
+  `CalledProcessError` before the manual return-code branch is reached.
+- Add unit tests: `tests/test_circuit_adapter.py`,
+  `tests/test_json_parser_utils.py`, `tests/test_result_serializer.py`.
+
 ### v0.0.12.dev15
 - Extend multi-language SDK support with Q# (QSharp) runtime:
     - Add `QSHARP` to `Language` enum.

{quapp_common-0.0.12.dev15 → quapp_common-0.0.13.dev2}/README.md

@@ -39,15 +39,22 @@ responses while work continues in the background.
 - Multi-language SDK support:
     - Language enum for validating and resolving Python, JavaScript, and Q#
       runtimes.
-    - SubprocessDispatcher to delegate tasks to non-Python runtimes via
-      subprocess with timeout management and JSON payload processing; supports
-      Node.js and `dotnet run` (Q#) runners.
-    - SubprocessBridge integrating dispatcher, circuit adapter, and result
-      serializer for seamless JS-Python handler interaction.
-    - CircuitAdapter for converting JS subprocess circuit outputs into native
-      SDK formats (OpenQASM, QUBO, JSON) across Qiskit, Braket, PennyLane, etc.
-    - ResultSerializer for converting complex job results into JSON-serializable
-      dictionaries for subprocess communication.
+    - Standalone `dispatch()` function (formerly `SubprocessDispatcher` class)
+      to delegate tasks to non-Python runtimes via subprocess with timeout
+      management and JSON payload processing; supports Node.js and precompiled
+      Q# binary (`./handler_runner_bin/Function[.exe]`) runners.
+    - Working directory configurable via `QUAPP_WORKING_DIR` environment
+      variable; falls back to `os.getcwd()` when unset.
+    - `SubprocessBridge` class integrating standalone dispatcher, circuit
+      adapter, and result serializer for seamless JS/Q#-Python handler
+      interaction.
+    - Standalone `adapt()` function (formerly `CircuitAdapter` class) for
+      converting subprocess circuit outputs into native SDK formats (OpenQASM,
+      QUBO, JSON) across Qiskit, Braket, PennyLane, PyQuil, Qibo, Qulacs, and
+      CUDA Quantum.
+    - Standalone `serialize()` function (formerly `ResultSerializer` class) for
+      converting complex job results into JSON-serializable dictionaries for
+      subprocess communication.
 
 ## Installation
 
@@ -66,6 +73,42 @@ Notes:
 
 ## Recently Changes Highlights
 
+### v0.0.13.dev2
+- Fix: `_openqasm_to_braket` in `circuit_adapter.py` now injects a default
+  `Probability` result type when the Braket circuit produced by `tk_to_braket`
+  has no result types. OpenQASM circuits submitted from non-Python runtimes (e.g.
+  Q#) do not carry explicit measurement annotations, so the converted Braket
+  circuit would have an empty `result_types` list and fail at execution time. The
+  fix adds `circuit.probability(target=list(range(circuit.qubit_count)))` before
+  returning, ensuring every Braket job has at least one result type.
+
+### v0.0.13.dev1
+- Refactor: Replace class-based subprocess components with standalone
+  module-level functions for simpler imports and testability:
+    - `SubprocessDispatcher` class → `dispatch()` and `is_subprocess_language()`
+      in `dispatcher.py`.
+    - `CircuitAdapter` class → `adapt()` and private helper functions in
+      `circuit_adapter.py`.
+    - `ResultSerializer` class → `serialize()` in `result_serializer.py`.
+    - `SubprocessBridge` retains its class form but delegates internally to the
+      new standalone functions.
+- Refactor `dispatcher.py`: `WORKING_DIR` is now read from the
+  `QUAPP_WORKING_DIR` environment variable (previously hardcoded `None`);
+  falls back to `os.getcwd()` when the variable is unset.
+- Refactor `dispatcher.py`: Q# runner command changed from
+  `dotnet run --project HandlerRunner.csproj` to a precompiled
+  platform-specific binary — `./handler_runner_bin/Function.exe` on Windows
+  and `./handler_runner_bin/Function` on other platforms — eliminating the
+  `dotnet` toolchain requirement at runtime.
+- Refactor `circuit_adapter.py`: Extract `_load_qasm_circuit(qasm_str)` private
+  utility that centralises OpenQASM 2.0 string parsing with Qiskit version
+  compatibility — uses `qiskit.qasm2.loads` (Qiskit >= 1.0) and falls back to
+  `QiskitCircuit.from_qasm_str` (Qiskit < 1.0).
+- Fix: `subprocess.run` now passes `check=True` so a non-zero exit code raises
+  `CalledProcessError` before the manual return-code branch is reached.
+- Add unit tests: `tests/test_circuit_adapter.py`,
+  `tests/test_json_parser_utils.py`, `tests/test_result_serializer.py`.
+
 ### v0.0.12.dev15
 - Extend multi-language SDK support with Q# (QSharp) runtime:
     - Add `QSHARP` to `Language` enum.

{quapp_common-0.0.12.dev15 → quapp_common-0.0.13.dev2}/pyproject.toml

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

{quapp_common-0.0.12.dev15 → quapp_common-0.0.13.dev2}/quapp_common/component/circuit_adapter.py

@@ -9,6 +9,10 @@ from typing import Any, Dict
 import numpy as np
 import pennylane as qml
 import pennylane.measurements as _plm
+try:
+    import qiskit.qasm2 as _qasm2
+except ImportError:
+    _qasm2 = None
 from dimod import BinaryQuadraticModel
 from pytket.qasm import circuit_from_qasm_str
 from qibo.models import Circuit
@@ -22,6 +26,16 @@ from ..enum.sdk import Sdk
 logger = logger.bind(context=__name__)
 
 
+def _load_qasm_circuit(qasm_str: str) -> QiskitCircuit:
+    """Parse OpenQASM 2.0 string into a Qiskit QuantumCircuit.
+
+    Compatible with Qiskit >= 1.0 (qiskit.qasm2.loads) and < 1.0 (from_qasm_str).
+    """
+    if _qasm2 is not None:
+        return _qasm2.loads(qasm_str)
+    return QiskitCircuit.from_qasm_str(qasm_str)
+
+
 def adapt(sdk: Sdk, result: dict):
     """Route to the appropriate adapter based on the 'format' field."""
     fmt = result.get("format")
@@ -93,7 +107,11 @@ def _openqasm_to_braket(qasm_str):
     is_tuple = isinstance(result, tuple)
     logger.debug(
             f"tk_to_braket returned tuple={is_tuple}; unpacking index 0" if is_tuple else "tk_to_braket returned Circuit directly")
-    return result[0] if is_tuple else result
+    circuit = result[0] if is_tuple else result
+    if not circuit.result_types:
+        circuit.probability(target=list(range(circuit.qubit_count)))
+        logger.debug(f"No result types found; added Probability over {circuit.qubit_count} qubits")
+    return circuit
 
 
 def _openqasm_to_cuda_quantum(qasm_str):
@@ -142,8 +160,8 @@ def _openqasm_to_qibo(qasm_str):
 
 
 def _openqasm_to_qiskit(qasm_str):
-    logger.debug("Converting OpenQASM via Qiskit QuantumCircuit.from_qasm_str")
-    return QiskitCircuit.from_qasm_str(qasm_str)
+    logger.debug("Converting OpenQASM via Qiskit QuantumCircuit")
+    return _load_qasm_circuit(qasm_str)
 
 
 def _openqasm_to_qulacs(qasm_str):
@@ -151,7 +169,7 @@ def _openqasm_to_qulacs(qasm_str):
     # Try the Qiskit bridge first; fall back to raw pass-through if
     # qiskit is not installed or the conversion fails.
     try:
-        qiskit_circ = QiskitCircuit.from_qasm_str(qasm_str)
+        qiskit_circ = _load_qasm_circuit(qasm_str)
         logger.debug(
                 f"Qiskit parsed circuit: num_qubits={qiskit_circ.num_qubits} num_gates={len(qiskit_circ.data)}")
         return _qiskit_to_qulacs(qiskit_circ)
@@ -166,7 +184,7 @@ def _qiskit_to_pennylane(qasm_str, num_wires):
     Fallback for environments where qml.from_qasm is unavailable because
     pennylane-qiskit is not installed (PennyLane < 0.36).
     """
-    qiskit_circ = QiskitCircuit.from_qasm_str(qasm_str)
+    qiskit_circ = _load_qasm_circuit(qasm_str)
     qubit_map = {bit: idx for idx, bit in enumerate(qiskit_circ.qubits)}
     logger.debug(
             f"_qiskit_to_pennylane: num_qubits={qiskit_circ.num_qubits} "

{quapp_common-0.0.12.dev15 → quapp_common-0.0.13.dev2}/quapp_common/component/dispatcher.py

@@ -5,21 +5,24 @@
 import json
 import os
 import subprocess
+import sys
 
 from ..config.logging_config import logger
 from ..enum.language import Language
 
 logger = logger.bind(context=__name__)
 
-WORKING_DIR: str = None
+WORKING_DIR: str = os.environ.get('QUAPP_WORKING_DIR')
+
+_QSHARP_BINARY = './handler_runner_bin/Function.exe' if sys.platform == 'win32' else './handler_runner_bin/Function'
 
 RUNNER_MAP = {
     Language.JAVASCRIPT: {
         'command': ['node', 'handler_runner.js'],
         'timeout': 300,
     },
-        Language.QSHARP: {
-        'command': ['dotnet', 'run', '--project', 'HandlerRunner.csproj'],
+    Language.QSHARP: {
+        'command': [_QSHARP_BINARY],
         'timeout': 300,
     },
 }

{quapp_common-0.0.12.dev15 → quapp_common-0.0.13.dev2/quapp_common.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-common
-Version: 0.0.12.dev15
+Version: 0.0.13.dev2
 Summary: Quapp common library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)
@@ -80,15 +80,22 @@ responses while work continues in the background.
 - Multi-language SDK support:
     - Language enum for validating and resolving Python, JavaScript, and Q#
       runtimes.
-    - SubprocessDispatcher to delegate tasks to non-Python runtimes via
-      subprocess with timeout management and JSON payload processing; supports
-      Node.js and `dotnet run` (Q#) runners.
-    - SubprocessBridge integrating dispatcher, circuit adapter, and result
-      serializer for seamless JS-Python handler interaction.
-    - CircuitAdapter for converting JS subprocess circuit outputs into native
-      SDK formats (OpenQASM, QUBO, JSON) across Qiskit, Braket, PennyLane, etc.
-    - ResultSerializer for converting complex job results into JSON-serializable
-      dictionaries for subprocess communication.
+    - Standalone `dispatch()` function (formerly `SubprocessDispatcher` class)
+      to delegate tasks to non-Python runtimes via subprocess with timeout
+      management and JSON payload processing; supports Node.js and precompiled
+      Q# binary (`./handler_runner_bin/Function[.exe]`) runners.
+    - Working directory configurable via `QUAPP_WORKING_DIR` environment
+      variable; falls back to `os.getcwd()` when unset.
+    - `SubprocessBridge` class integrating standalone dispatcher, circuit
+      adapter, and result serializer for seamless JS/Q#-Python handler
+      interaction.
+    - Standalone `adapt()` function (formerly `CircuitAdapter` class) for
+      converting subprocess circuit outputs into native SDK formats (OpenQASM,
+      QUBO, JSON) across Qiskit, Braket, PennyLane, PyQuil, Qibo, Qulacs, and
+      CUDA Quantum.
+    - Standalone `serialize()` function (formerly `ResultSerializer` class) for
+      converting complex job results into JSON-serializable dictionaries for
+      subprocess communication.
 
 ## Installation
 
@@ -107,6 +114,42 @@ Notes:
 
 ## Recently Changes Highlights
 
+### v0.0.13.dev2
+- Fix: `_openqasm_to_braket` in `circuit_adapter.py` now injects a default
+  `Probability` result type when the Braket circuit produced by `tk_to_braket`
+  has no result types. OpenQASM circuits submitted from non-Python runtimes (e.g.
+  Q#) do not carry explicit measurement annotations, so the converted Braket
+  circuit would have an empty `result_types` list and fail at execution time. The
+  fix adds `circuit.probability(target=list(range(circuit.qubit_count)))` before
+  returning, ensuring every Braket job has at least one result type.
+
+### v0.0.13.dev1
+- Refactor: Replace class-based subprocess components with standalone
+  module-level functions for simpler imports and testability:
+    - `SubprocessDispatcher` class → `dispatch()` and `is_subprocess_language()`
+      in `dispatcher.py`.
+    - `CircuitAdapter` class → `adapt()` and private helper functions in
+      `circuit_adapter.py`.
+    - `ResultSerializer` class → `serialize()` in `result_serializer.py`.
+    - `SubprocessBridge` retains its class form but delegates internally to the
+      new standalone functions.
+- Refactor `dispatcher.py`: `WORKING_DIR` is now read from the
+  `QUAPP_WORKING_DIR` environment variable (previously hardcoded `None`);
+  falls back to `os.getcwd()` when the variable is unset.
+- Refactor `dispatcher.py`: Q# runner command changed from
+  `dotnet run --project HandlerRunner.csproj` to a precompiled
+  platform-specific binary — `./handler_runner_bin/Function.exe` on Windows
+  and `./handler_runner_bin/Function` on other platforms — eliminating the
+  `dotnet` toolchain requirement at runtime.
+- Refactor `circuit_adapter.py`: Extract `_load_qasm_circuit(qasm_str)` private
+  utility that centralises OpenQASM 2.0 string parsing with Qiskit version
+  compatibility — uses `qiskit.qasm2.loads` (Qiskit >= 1.0) and falls back to
+  `QiskitCircuit.from_qasm_str` (Qiskit < 1.0).
+- Fix: `subprocess.run` now passes `check=True` so a non-zero exit code raises
+  `CalledProcessError` before the manual return-code branch is reached.
+- Add unit tests: `tests/test_circuit_adapter.py`,
+  `tests/test_json_parser_utils.py`, `tests/test_result_serializer.py`.
+
 ### v0.0.12.dev15
 - Extend multi-language SDK support with Q# (QSharp) runtime:
     - Add `QSHARP` to `Language` enum.