quapp-common 0.0.12.dev14__tar.gz → 0.0.13.dev1__tar.gz

{quapp_common-0.0.12.dev14/quapp_common.egg-info → quapp_common-0.0.13.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-common
-Version: 0.0.12.dev14
+Version: 0.0.13.dev1
 Summary: Quapp common library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)
@@ -29,6 +29,8 @@ Requires-Dist: qibo
 Requires-Dist: dimod
 Requires-Dist: qulacs
 Requires-Dist: qiskit
+Requires-Dist: pytket
+Requires-Dist: pennylane
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
 Requires-Dist: bumpver; extra == "dev"
@@ -75,16 +77,25 @@ responses while work continues in the background.
       scheduler.
     - Safety: updates to jobs already DONE/FAILED are ignored to prevent
       post-completion mutations.
-- Multi-language SDK support (v0.0.12.dev1):
-    - Language enum for validating and resolving Python/JavaScript runtimes.
-    - SubprocessDispatcher to delegate tasks to non-Python runtimes via
-      subprocess with timeout management and JSON payload processing.
-    - 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.
+- Multi-language SDK support:
+    - Language enum for validating and resolving Python, JavaScript, and Q#
+      runtimes.
+    - 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
 
@@ -103,6 +114,38 @@ Notes:
 
 ## Recently Changes Highlights
 
+### 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.
+    - Add Q# runner configuration to `SubprocessDispatcher` (`dotnet run --project .`, 300 s timeout).
+
 ### v0.0.12.dev14
 - Fix: `CircuitAdapter._adapt_openqasm` for `Sdk.PENNYLANE` now catches the
   "Failed to load the qasm plugin" error raised by `qml.from_qasm` on

{quapp_common-0.0.12.dev14 → quapp_common-0.0.13.dev1}/README.md

@@ -36,16 +36,25 @@ responses while work continues in the background.
       scheduler.
     - Safety: updates to jobs already DONE/FAILED are ignored to prevent
       post-completion mutations.
-- Multi-language SDK support (v0.0.12.dev1):
-    - Language enum for validating and resolving Python/JavaScript runtimes.
-    - SubprocessDispatcher to delegate tasks to non-Python runtimes via
-      subprocess with timeout management and JSON payload processing.
-    - 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.
+- Multi-language SDK support:
+    - Language enum for validating and resolving Python, JavaScript, and Q#
+      runtimes.
+    - 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
 
@@ -64,6 +73,38 @@ Notes:
 
 ## Recently Changes Highlights
 
+### 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.
+    - Add Q# runner configuration to `SubprocessDispatcher` (`dotnet run --project .`, 300 s timeout).
+
 ### v0.0.12.dev14
 - Fix: `CircuitAdapter._adapt_openqasm` for `Sdk.PENNYLANE` now catches the
   "Failed to load the qasm plugin" error raised by `qml.from_qasm` on

{quapp_common-0.0.12.dev14 → quapp_common-0.0.13.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quapp-common"
-version = "0.0.12.dev14"
+version = "0.0.13.dev1"
 description = "Quapp common library supporting Quapp Platform for Quantum Computing"
 readme = "README.md"
 authors = [{ name = "CITYNOW Co. Ltd. ", email = "corp@citynow.vn" }]
@@ -25,7 +25,9 @@ dependencies = [
     "qibo",
     "dimod",
     "qulacs",
-    "qiskit"
+    "qiskit",
+    "pytket",
+    "pennylane"
 ]
 requires-python = ">=3.7"
 
@@ -34,3 +36,6 @@ dev = ["black", "bumpver", "isort", "pip-tools", "pytest"]
 
 [project.urls]
 Homepage = "https://citynow.asia/"
+
+[tool.pylint.main]
+source-roots = ["."]

{quapp_common-0.0.12.dev14 → quapp_common-0.0.13.dev1}/quapp_common/component/bridge.py

@@ -1,19 +1,19 @@
-"""
-    QApp Platform Project
-    bridge.py
-    Copyright © CITYNOW Co. Ltd. All rights reserved.
-"""
 #  Quapp Platform Project
 #  bridge.py
 #  Copyright © CITYNOW Co. Ltd. All rights reserved.
+from typing import Any, Dict
 
-from .circuit_adapter import CircuitAdapter
-from .dispatcher import SubprocessDispatcher
-from .result_serializer import ResultSerializer
+from .circuit_adapter import adapt
+from .dispatcher import dispatch
+from .result_serializer import serialize
 from ..config.logging_config import logger
 from ..enum.language import Language
 from ..enum.sdk import Sdk
 
+#  Quapp Platform Project
+#  bridge.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
 logger = logger.bind(context=__name__)
 
 
@@ -32,7 +32,7 @@ class SubprocessBridge:
         self.sdk = sdk
         logger.debug(f"SubprocessBridge initialized | language={language.value} | sdk={sdk}")
 
-    def processing(self, invocation_input: dict):
+    def processing(self, invocation_input: Dict[str, Any]):
         """Call JS handler's processing() and convert a result to a native circuit.
 
         Args:
@@ -47,9 +47,9 @@ class SubprocessBridge:
         logger.info(f"SubprocessBridge.processing: dispatching to {self.language.value} | sdk={self.sdk}")
         logger.debug(f"SubprocessBridge.processing: input_keys={list(invocation_input.keys())}")
 
-        result = SubprocessDispatcher.dispatch(self.language, {
+        result = dispatch(self.language, {
             "action": "processing",
-            "input" : invocation_input
+            "input": invocation_input
         })
 
         status = result.get("status")
@@ -62,11 +62,15 @@ class SubprocessBridge:
         payload = result.get("result")
         if payload is None:
             raise RuntimeError("JS processing returned no 'result' field")
+        if not isinstance(payload, dict):
+            raise RuntimeError(
+                    f"JS processing returned invalid 'result' type: {type(payload).__name__}"
+            )
 
         fmt = payload.get("format")
         logger.debug(f"SubprocessBridge.processing: JS returned format={fmt}; adapting for sdk={self.sdk}")
 
-        circuit = CircuitAdapter.adapt(self.sdk, payload)
+        circuit = adapt(self.sdk, payload)
         logger.info(f"SubprocessBridge.processing: circuit adapted successfully | type={type(circuit).__name__}")
         return circuit
 
@@ -85,11 +89,12 @@ class SubprocessBridge:
         logger.info(f"SubprocessBridge.post_processing: dispatching to {self.language.value}")
         logger.debug(f"SubprocessBridge.post_processing: job_result type={type(job_result).__name__}")
 
-        serialized = ResultSerializer.serialize(job_result)
-        logger.debug(f"SubprocessBridge.post_processing: serialized result keys={list(serialized.keys()) if isinstance(serialized, dict) else type(serialized).__name__}")
+        serialized = serialize(job_result)
+        logger.debug(
+                f"SubprocessBridge.post_processing: serialized result keys={list(serialized.keys()) if isinstance(serialized, dict) else type(serialized).__name__}")
 
-        result = SubprocessDispatcher.dispatch(self.language, {
-            "action"    : "post_processing",
+        result = dispatch(self.language, {
+            "action": "post_processing",
             "job_result": serialized
         })
 

quapp_common-0.0.13.dev1/quapp_common/component/circuit_adapter.py

@@ -0,0 +1,282 @@
+#  Quapp Platform Project
+#  circuit_adapter.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+import importlib
+import re
+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
+from qiskit import QuantumCircuit as QiskitCircuit
+from qulacs import QuantumCircuit as QulacsCircuit
+from qulacs.gate import DenseMatrix as DenseMatrixGate
+
+from ..config.logging_config import logger
+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")
+    logger.debug(f"adapt() called | sdk={sdk} | format={fmt}")
+    if fmt == "openqasm":
+        circuit = result.get("circuit")
+        if circuit is None:
+            raise ValueError("Missing 'circuit' field in openqasm response")
+        return _adapt_openqasm(sdk, circuit)
+    if fmt == "qubo":
+        qubo = result.get("qubo")
+        if qubo is None:
+            raise ValueError("Missing 'qubo' field in qubo response")
+        return _adapt_qubo(sdk, qubo)
+    if fmt == "json":
+        logger.debug("Returning raw JSON data pass-through")
+        return result.get("data")
+    raise ValueError(f"Unsupported circuit interchange format: {fmt}")
+
+
+def _adapt_openqasm(sdk, qasm_str):
+    """Convert an OpenQASM 2.0 string to a native SDK circuit object."""
+    logger.debug(f"Adapting OpenQASM circuit for SDK: {sdk} | qasm_length={len(qasm_str)}")
+    _handlers = {
+        Sdk.QISKIT: _openqasm_to_qiskit,
+        Sdk.BRAKET: _openqasm_to_braket,
+        Sdk.PENNYLANE: _openqasm_to_pennylane,
+        Sdk.PYQUIL: _openqasm_to_pyquil,
+        Sdk.QIBO: _openqasm_to_qibo,
+        Sdk.QULACS: _openqasm_to_qulacs,
+        Sdk.CUDA_QUANTUM: _openqasm_to_cuda_quantum,
+    }
+    handler = _handlers.get(sdk)
+    if handler is None:
+        raise ValueError(f"OpenQASM adaptation not supported for SDK: {sdk}")
+    return handler(qasm_str)
+
+
+def _adapt_qubo(sdk, qubo_raw: Dict[str, Any]):
+    """Convert a QUBO dict with string keys ('x0,x1') to a BinaryQuadraticModel.
+
+    JS returns keys like "x0,x1" as strings. We parse them into tuple keys
+    for dimod's from_qubo() method.
+    """
+    logger.debug(f"Adapting QUBO for SDK: {sdk} | num_entries={len(qubo_raw)}")
+
+    qubo_dict = {}
+    for key, val in qubo_raw.items():
+        if isinstance(key, str) and "," in key:
+            parts = tuple(k.strip() for k in key.split(",", 1))
+            qubo_dict[parts] = val
+        else:
+            qubo_dict[(key, key)] = val
+
+    logger.debug(f"QUBO parsed: {len(qubo_dict)} entries -> BinaryQuadraticModel")
+    return BinaryQuadraticModel.from_qubo(qubo_dict)
+
+
+def _count_qasm_qubits(qasm_str):
+    """Sum qubit counts across all `qreg <name>[<n>];` declarations."""
+    return sum(int(m) for m in re.findall(r'qreg\s+\w+\[(\d+)]', qasm_str))
+
+
+def _openqasm_to_braket(qasm_str):
+    logger.debug("Converting OpenQASM via pytket -> tk_to_braket")
+    tk_to_braket = importlib.import_module("pytket.extensions.braket").tk_to_braket
+    result = tk_to_braket(circuit_from_qasm_str(qasm_str))
+    # tk_to_braket returns (Circuit, n_shots) in pytket-braket >= 0.35
+    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
+
+
+def _openqasm_to_cuda_quantum(qasm_str):
+    logger.debug("CUDA-Q: passing OpenQASM string through directly")
+    # CUDA-Q accepts OpenQASM directly via kernel builder
+    return qasm_str
+
+
+def _openqasm_to_pennylane(qasm_str):
+    logger.debug("Converting OpenQASM via PennyLane qml.from_qasm wrapper")
+    for _compat_name in ("Expectation", "Variance", "Sample", "Probability",
+                         "State", "MidMeasure"):
+        if not hasattr(_plm, _compat_name):
+            setattr(_plm, _compat_name, _compat_name)
+
+    num_wires = _count_qasm_qubits(qasm_str)
+    logger.debug(f"PennyLane: detected {num_wires} qubits; wrapping with qml.probs over all wires")
+    try:
+        base_fn = qml.from_qasm(qasm_str, measurements=[])
+
+        def _circuit():
+            base_fn()
+            if num_wires > 0:
+                return qml.probs(wires=list(range(num_wires)))
+            return None
+
+        return _circuit
+    except Exception as _e:
+        if "qasm plugin" not in str(_e) and "pennylane-qiskit" not in str(_e):
+            raise
+        logger.warning(
+                f"qml.from_qasm unavailable ({_e}); falling back to Qiskit bridge for PennyLane QASM conversion"
+        )
+        return _qiskit_to_pennylane(qasm_str, num_wires)
+
+
+def _openqasm_to_pyquil(qasm_str):
+    logger.debug("Converting OpenQASM via pytket -> tk_to_pyquil")
+    tk_to_pyquil = importlib.import_module("pytket.extensions.pyquil").tk_to_pyquil
+    return tk_to_pyquil(circuit_from_qasm_str(qasm_str))
+
+
+def _openqasm_to_qibo(qasm_str):
+    logger.debug("Converting OpenQASM via Qibo Circuit.from_qasm")
+    return Circuit.from_qasm(qasm_str)
+
+
+def _openqasm_to_qiskit(qasm_str):
+    logger.debug("Converting OpenQASM via Qiskit QuantumCircuit")
+    return _load_qasm_circuit(qasm_str)
+
+
+def _openqasm_to_qulacs(qasm_str):
+    logger.debug("Converting OpenQASM for Qulacs via Qiskit bridge")
+    # Try the Qiskit bridge first; fall back to raw pass-through if
+    # qiskit is not installed or the conversion fails.
+    try:
+        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)
+    except Exception as e:
+        logger.warning(f"Qiskit bridge failed for Qulacs ({e}); falling back to raw OpenQASM pass-through")
+        return qasm_str
+
+
+def _qiskit_to_pennylane(qasm_str, num_wires):
+    """Parse an OpenQASM 2.0 string via Qiskit and return a PennyLane callable.
+
+    Fallback for environments where qml.from_qasm is unavailable because
+    pennylane-qiskit is not installed (PennyLane < 0.36).
+    """
+    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} "
+            f"num_instructions={len(qiskit_circ.data)}"
+    )
+
+    instructions = [
+        (inst.operation.name,
+         [qubit_map[q] for q in inst.qubits],
+         [float(p) for p in inst.operation.params])
+        for inst in qiskit_circ.data
+    ]
+
+    _skip = frozenset({'measure', 'barrier', 'reset', 'id'})
+    _gate_map = {
+        'h': lambda q, p: qml.Hadamard(wires=q[0]),
+        'x': lambda q, p: qml.PauliX(wires=q[0]),
+        'y': lambda q, p: qml.PauliY(wires=q[0]),
+        'z': lambda q, p: qml.PauliZ(wires=q[0]),
+        's': lambda q, p: qml.S(wires=q[0]),
+        'sdg': lambda q, p: qml.PhaseShift(-np.pi / 2, wires=q[0]),
+        't': lambda q, p: qml.T(wires=q[0]),
+        'tdg': lambda q, p: qml.PhaseShift(-np.pi / 4, wires=q[0]),
+        'cx': lambda q, p: qml.CNOT(wires=q),
+        'cz': lambda q, p: qml.CZ(wires=q),
+        'swap': lambda q, p: qml.SWAP(wires=q),
+        'rx': lambda q, p: qml.RX(p[0], wires=q[0]),
+        'ry': lambda q, p: qml.RY(p[0], wires=q[0]),
+        'rz': lambda q, p: qml.RZ(p[0], wires=q[0]),
+        'p': lambda q, p: qml.PhaseShift(p[0], wires=q[0]),
+        'u1': lambda q, p: qml.PhaseShift(p[0], wires=q[0]),
+        'u2': lambda q, p: qml.U2(p[0], p[1], wires=q[0]),
+        'u3': lambda q, p: qml.U3(p[0], p[1], p[2], wires=q[0]),
+        'u': lambda q, p: qml.U3(p[0], p[1], p[2], wires=q[0]),
+    }
+
+    def _circuit():
+        for name, qubits, params in instructions:
+            if name in _skip:
+                continue
+            gate_fn = _gate_map.get(name)
+            if gate_fn is not None:
+                gate_fn(qubits, params)
+            else:
+                logger.warning(f"PennyLane Qiskit bridge: unrecognized gate '{name}'; skipping")
+        if num_wires > 0:
+            return qml.probs(wires=list(range(num_wires)))
+        return None
+
+    return _circuit
+
+
+def _qiskit_to_qulacs(qiskit_circ):
+    """Convert a Qiskit QuantumCircuit to a qulacs QuantumCircuit.
+
+    Fixed gates are mapped via named qulacs methods; parametric and
+    unrecognized gates fall back to DenseMatrix (unitary passthrough).
+    Measurement, barrier, reset, and identity instructions are skipped.
+    """
+    n = qiskit_circ.num_qubits
+    logger.debug(f"_qiskit_to_qulacs: num_qubits={n} num_instructions={len(qiskit_circ.data)}")
+    qulacs_circ = QulacsCircuit(n)
+    qubit_map = {bit: idx for idx, bit in enumerate(qiskit_circ.qubits)}
+
+    _SINGLE = {
+        'h': 'add_H_gate', 'x': 'add_X_gate',
+        'y': 'add_Y_gate', 'z': 'add_Z_gate',
+        's': 'add_S_gate', 'sdg': 'add_Sdag_gate',
+        't': 'add_T_gate', 'tdg': 'add_Tdag_gate',
+    }
+    _TWO = {
+        'cx': 'add_CNOT_gate',
+        'cz': 'add_CZ_gate',
+        'swap': 'add_SWAP_gate',
+    }
+    _SKIP = {'measure', 'barrier', 'reset', 'id'}
+
+    for inst in qiskit_circ.data:
+        gate = inst.operation
+        qubits = [qubit_map[q] for q in inst.qubits]
+        name = gate.name
+
+        if name in _SKIP:
+            continue
+        elif name in _SINGLE:
+            getattr(qulacs_circ, _SINGLE[name])(qubits[0])
+        elif name in _TWO:
+            getattr(qulacs_circ, _TWO[name])(qubits[0], qubits[1])
+        else:
+            # Parametric gates (rx, ry, rz, u*, p, ...) and any
+            # unrecognized gate: extract the unitary and apply it
+            # as a DenseMatrix. Single-qubit gates have no ordering
+            # ambiguity; multi-qubit gates are passed with qulacs'
+            # index order matching Qiskit's instruction qubit order.
+            logger.debug(f"Gate '{name}' not in named map; converting via DenseMatrix on qubits={qubits}")
+            qulacs_circ.add_gate(DenseMatrixGate(qubits, gate.to_matrix()))
+
+    logger.debug(f"_qiskit_to_qulacs: conversion complete")
+    return qulacs_circ

quapp_common-0.0.13.dev1/quapp_common/component/dispatcher.py

@@ -0,0 +1,119 @@
+#  Quapp Platform Project
+#  dispatcher.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+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 = 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': [_QSHARP_BINARY],
+        'timeout': 300,
+    },
+}
+
+
+def dispatch(language: Language, request_data: dict,
+             timeout: int = None) -> dict:
+    """Dispatch request_data to a subprocess runner.
+
+    Args:
+        language: The target language runtime.
+        request_data: Dict to serialize as JSON and pipe to stdin.
+        timeout: Optional timeout in seconds. Overrides the runner by default.
+
+    Returns:
+        Parsed JSON dict from the subprocess stdout.
+    """
+    runner = RUNNER_MAP.get(language)
+    if runner is None:
+        raise ValueError(f"No runner configured for language: {language}")
+
+    effective_timeout = timeout if timeout is not None else runner[
+        'timeout']
+    action = request_data.get('action', 'handle')
+    logger.info(f"Dispatching to {language.value} runner, action={action}, "
+                f"timeout={effective_timeout}s")
+
+    payload = json.dumps(request_data)
+    cwd = WORKING_DIR or os.getcwd()
+    result = subprocess.run(runner['command'], input=payload,
+                            capture_output=True, text=True,
+                            timeout=effective_timeout, cwd=cwd, check=True)
+
+    if result.stderr:
+        logger.debug(f"Subprocess stderr: {result.stderr[:500]}")
+
+    if result.returncode != 0:
+        error_message = _extract_error_message(result)
+        logger.error(
+                f"Handler runner failed (exit={result.returncode}): {error_message[:500]}")
+        raise RuntimeError(f"Handler runner failed: {error_message}")
+
+    if not result.stdout:
+        raise RuntimeError("Handler runner produced no output")
+
+    try:
+        return json.loads(result.stdout)
+    except json.JSONDecodeError as exc:
+        raise RuntimeError(
+                f"Handler runner returned invalid JSON: {exc}") from exc
+
+
+def is_subprocess_language(language_str: str) -> bool:
+    """
+    Determines if a given language string represents a subprocess-compatible language.
+
+    This method checks whether the specified language can be executed as a subprocess
+    (i.e., it is not equivalent to Python). It resolves the language using the
+    `Language.resolve` method and compares it to `Language.PYTHON`. If the language
+    is unresolvable or an exception occurs, it assumes the language is not valid for
+    subprocess execution.
+
+    Args:
+        language_str (str): The language string to be validated.
+
+    Returns:
+        bool: True if the language is a subprocess-compatible language, False otherwise.
+    """
+    try:
+        lang = Language.resolve(language_str)
+        return lang != Language.PYTHON
+    except Exception:
+        return False
+
+
+def _extract_error_message(result) -> str:
+    """Extract the most meaningful error message from a failed subprocess.
+
+    Priority order:
+      1. Structured JSON on stdout  – {"status":"error","error":"..."}
+      2. Raw stderr text
+      3. Generic exit-code string
+    """
+    if result.stdout:
+        try:
+            parsed = json.loads(result.stdout)
+            if parsed.get('status') == 'error':
+                return (parsed.get('error') or parsed.get(
+                        'stack') or 'Unknown JS error')
+        except (json.JSONDecodeError, AttributeError):
+            pass
+    if result.stderr:
+        return result.stderr.strip()
+    return f"exit code {result.returncode}"