quapp-common 0.0.13.dev6__tar.gz → 0.0.13.dev7__tar.gz

{quapp_common-0.0.13.dev6/quapp_common.egg-info → quapp_common-0.0.13.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-common
-Version: 0.0.13.dev6
+Version: 0.0.13.dev7
 Summary: Quapp common library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)

{quapp_common-0.0.13.dev6 → quapp_common-0.0.13.dev7}/pyproject.toml

@@ -1,41 +1,41 @@
-[build-system]
-requires = ["setuptools>=61.0.0", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "quapp-common"
-version = "0.0.13.dev6"
-description = "Quapp common library supporting Quapp Platform for Quantum Computing"
-readme = "README.md"
-authors = [{ name = "CITYNOW Co. Ltd. ", email = "corp@citynow.vn" }]
-license = { file = "LICENSE" }
-classifiers = [
-    "License :: OSI Approved :: MIT License",
-    "Programming Language :: Python",
-    "Programming Language :: Python :: 3",
-]
-keywords = ["quapp", "quapp-common", "quantum"]
-dependencies = [
-    "loguru",
-    "requests",
-    "numpy",
-    "matplotlib",
-    "pylatexenc",
-    "starlette",
-    "qibo",
-    "dimod",
-    "qulacs",
-    "qiskit",
-    "pytket",
-    "pennylane"
-]
-requires-python = ">=3.7"
-
-[project.optional-dependencies]
-dev = ["black", "bumpver", "isort", "pip-tools", "pytest"]
-
-[project.urls]
-Homepage = "https://citynow.asia/"
-
-[tool.pylint.main]
-source-roots = ["."]
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "quapp-common"
+version = "0.0.13.dev7"
+description = "Quapp common library supporting Quapp Platform for Quantum Computing"
+readme = "README.md"
+authors = [{ name = "CITYNOW Co. Ltd. ", email = "corp@citynow.vn" }]
+license = { file = "LICENSE" }
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+]
+keywords = ["quapp", "quapp-common", "quantum"]
+dependencies = [
+    "loguru",
+    "requests",
+    "numpy",
+    "matplotlib",
+    "pylatexenc",
+    "starlette",
+    "qibo",
+    "dimod",
+    "qulacs",
+    "qiskit",
+    "pytket",
+    "pennylane"
+]
+requires-python = ">=3.7"
+
+[project.optional-dependencies]
+dev = ["black", "bumpver", "isort", "pip-tools", "pytest"]
+
+[project.urls]
+Homepage = "https://citynow.asia/"
+
+[tool.pylint.main]
+source-roots = ["."]

{quapp_common-0.0.13.dev6 → quapp_common-0.0.13.dev7}/quapp_common/component/circuit_adapter.py

@@ -1,286 +1,286 @@
-#  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")
-    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):
-    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 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")
+    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):
+    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.dev6 → quapp_common-0.0.13.dev7}/quapp_common/component/dispatcher.py

@@ -25,6 +25,10 @@ RUNNER_MAP = {
         'command': [_QSHARP_BINARY],
         'timeout': 300,
     },
+    Language.C: {
+        'command': ['./handler_compiled'],
+        'timeout': 300,
+    },
 }
 
 

{quapp_common-0.0.13.dev6 → quapp_common-0.0.13.dev7}/quapp_common/enum/language.py

@@ -13,6 +13,7 @@ class Language(BaseEnum):
   PYTHON = 'python'
   JAVASCRIPT = 'javascript'
   QSHARP = 'qsharp'
+  C = 'c'
 
   @staticmethod
   def resolve(language: str):

{quapp_common-0.0.13.dev6 → quapp_common-0.0.13.dev7/quapp_common.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-common
-Version: 0.0.13.dev6
+Version: 0.0.13.dev7
 Summary: Quapp common library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)

{quapp_common-0.0.13.dev6 → quapp_common-0.0.13.dev7}/quapp_common.egg-info/SOURCES.txt

@@ -84,4 +84,5 @@ quapp_common/util/json_parser_utils.py
 quapp_common/util/response_utils.py
 tests/test_circuit_adapter.py
 tests/test_json_parser_utils.py
+tests/test_language_dispatcher.py
 tests/test_result_serializer.py

quapp_common-0.0.13.dev7/tests/test_language_dispatcher.py

@@ -0,0 +1,20 @@
+import unittest
+
+from quapp_common.component.dispatcher import RUNNER_MAP
+from quapp_common.enum.language import Language
+
+
+class TestLanguageCEnum(unittest.TestCase):
+    def test_value_is_c(self):
+        self.assertEqual(Language.C.value, 'c')
+
+
+class TestRunnerMapLanguageC(unittest.TestCase):
+    def test_language_c_registered(self):
+        self.assertIn(Language.C, RUNNER_MAP)
+
+    def test_command_is_compiled_binary(self):
+        self.assertEqual(RUNNER_MAP[Language.C]['command'], ['./handler_compiled'])
+
+    def test_timeout(self):
+        self.assertEqual(RUNNER_MAP[Language.C]['timeout'], 300)