quapp-common 0.0.12.dev10__tar.gz → 0.0.12.dev11__tar.gz

{quapp_common-0.0.12.dev10/quapp_common.egg-info → quapp_common-0.0.12.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-common
-Version: 0.0.12.dev10
+Version: 0.0.12.dev11
 Summary: Quapp common library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)
@@ -103,6 +103,18 @@ Notes:
 
 ## Recently Changes Highlights
 
+### v0.0.12.dev11
+- Enhance: `CircuitAdapter` now emits structured debug logs at each routing
+  decision — SDK selected, QASM string length, qubit count, per-SDK adapter
+  chosen, `tk_to_braket` return type (tuple vs bare Circuit), DenseMatrix
+  fallback for unrecognized/parametric gates in `_qiskit_to_qulacs`, and QUBO
+  entry counts before and after parsing.
+- Enhance: `SubprocessBridge` now emits debug logs on initialisation
+  (`language`, `sdk`), `processing()` (input keys, JS status, adapted circuit
+  type), and `post_processing()` (job-result type, serialised keys, JS status,
+  result type); subprocess failures are additionally promoted to `logger.error`
+  before the `RuntimeError` is raised.
+
 ### v0.0.12.dev10
 - Fix: `CircuitAdapter._adapt_openqasm` for `Sdk.BRAKET` now handles the
   breaking API change in `pytket-braket >= 0.35`, where `tk_to_braket` returns

{quapp_common-0.0.12.dev10 → quapp_common-0.0.12.dev11}/README.md

@@ -64,6 +64,18 @@ Notes:
 
 ## Recently Changes Highlights
 
+### v0.0.12.dev11
+- Enhance: `CircuitAdapter` now emits structured debug logs at each routing
+  decision — SDK selected, QASM string length, qubit count, per-SDK adapter
+  chosen, `tk_to_braket` return type (tuple vs bare Circuit), DenseMatrix
+  fallback for unrecognized/parametric gates in `_qiskit_to_qulacs`, and QUBO
+  entry counts before and after parsing.
+- Enhance: `SubprocessBridge` now emits debug logs on initialisation
+  (`language`, `sdk`), `processing()` (input keys, JS status, adapted circuit
+  type), and `post_processing()` (job-result type, serialised keys, JS status,
+  result type); subprocess failures are additionally promoted to `logger.error`
+  before the `RuntimeError` is raised.
+
 ### v0.0.12.dev10
 - Fix: `CircuitAdapter._adapt_openqasm` for `Sdk.BRAKET` now handles the
   breaking API change in `pytket-braket >= 0.35`, where `tk_to_braket` returns

{quapp_common-0.0.12.dev10 → quapp_common-0.0.12.dev11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quapp-common"
-version = "0.0.12.dev10"
+version = "0.0.12.dev11"
 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.dev10 → quapp_common-0.0.12.dev11}/quapp_common/component/bridge.py

@@ -30,6 +30,7 @@ class SubprocessBridge:
     def __init__(self, language: Language, sdk: Sdk):
         self.language = language
         self.sdk = sdk
+        logger.debug(f"SubprocessBridge initialized | language={language.value} | sdk={sdk}")
 
     def processing(self, invocation_input: dict):
         """Call JS handler's processing() and convert a result to a native circuit.
@@ -43,24 +44,31 @@ class SubprocessBridge:
         Raises:
             RuntimeError: If the JS subprocess returns an error status.
         """
-        logger.info(
-                f"SubprocessBridge.processing: dispatching to {self.language.value}")
+        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, {
             "action": "processing",
             "input" : invocation_input
         })
 
-        if result.get("status") == "error":
+        status = result.get("status")
+        logger.debug(f"SubprocessBridge.processing: JS status={status}")
+
+        if status == "error":
+            logger.error(f"SubprocessBridge.processing: JS error={result.get('error')}")
             raise RuntimeError(f"JS processing failed: {result.get('error')}")
 
         payload = result.get("result")
         if payload is None:
             raise RuntimeError("JS processing returned no 'result' field")
-        logger.debug(
-                f"SubprocessBridge.processing: JS returned format={payload.get('format')}")
 
-        return CircuitAdapter.adapt(self.sdk, payload)
+        fmt = payload.get("format")
+        logger.debug(f"SubprocessBridge.processing: JS returned format={fmt}; adapting for sdk={self.sdk}")
+
+        circuit = CircuitAdapter.adapt(self.sdk, payload)
+        logger.info(f"SubprocessBridge.processing: circuit adapted successfully | type={type(circuit).__name__}")
+        return circuit
 
     def post_processing(self, job_result):
         """Serialize a job result, send to JS handler's postProcessing(), return a result.
@@ -74,21 +82,27 @@ class SubprocessBridge:
         Raises:
             RuntimeError: If the JS subprocess returns an error status.
         """
-        logger.info(
-                f"SubprocessBridge.post_processing: dispatching to {self.language.value}")
+        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__}")
 
         result = SubprocessDispatcher.dispatch(self.language, {
             "action"    : "post_processing",
             "job_result": serialized
         })
 
-        if result.get("status") == "error":
-            raise RuntimeError(
-                    f"JS post_processing failed: {result.get('error')}")
+        status = result.get("status")
+        logger.debug(f"SubprocessBridge.post_processing: JS status={status}")
+
+        if status == "error":
+            logger.error(f"SubprocessBridge.post_processing: JS error={result.get('error')}")
+            raise RuntimeError(f"JS post_processing failed: {result.get('error')}")
 
         payload = result.get("result")
         if payload is None:
             raise RuntimeError("JS post_processing returned no 'result' field")
+
+        logger.info(f"SubprocessBridge.post_processing: completed successfully | result type={type(payload).__name__}")
         return payload

{quapp_common-0.0.12.dev10 → quapp_common-0.0.12.dev11}/quapp_common/component/circuit_adapter.py

@@ -24,6 +24,7 @@ class CircuitAdapter:
     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:
@@ -35,27 +36,33 @@ class CircuitAdapter:
                 raise ValueError("Missing 'qubo' field in qubo response")
             return CircuitAdapter._adapt_qubo(sdk, qubo)
         elif fmt == "json":
+            logger.debug("Returning raw JSON data pass-through")
             return result.get("data")
         raise ValueError(f"Unsupported circuit interchange format: {fmt}")
 
     @staticmethod
     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}")
+        logger.debug(f"Adapting OpenQASM circuit for SDK: {sdk} | qasm_length={len(qasm_str)}")
 
         if sdk == Sdk.QISKIT:
+            logger.debug("Converting OpenQASM via Qiskit QuantumCircuit.from_qasm_str")
             from qiskit import QuantumCircuit
             return QuantumCircuit.from_qasm_str(qasm_str)
 
         elif sdk == Sdk.BRAKET:
+            logger.debug("Converting OpenQASM via pytket -> tk_to_braket")
             import importlib
             from pytket.qasm import circuit_from_qasm_str
             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
-            return result[0] if isinstance(result, tuple) else result
+            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
 
         elif sdk == Sdk.PENNYLANE:
+            logger.debug("Converting OpenQASM via PennyLane qml.from_qasm wrapper")
             import pennylane as qml
             # PennyLane >=0.37 treats QASM `measure` statements as mid-circuit
             # measurements returning MeasurementValue, which fails QNode
@@ -74,6 +81,7 @@ class CircuitAdapter:
             # fresh `qml.probs` over all qubits, so the wires are visible in
             # both `QuantumTape` capture and full QNode execution.
             num_wires = CircuitAdapter._count_qasm_qubits(qasm_str)
+            logger.debug(f"PennyLane: detected {num_wires} qubits; wrapping with qml.probs over all wires")
             base_fn = qml.from_qasm(qasm_str, measurements=[])
 
             def _circuit():
@@ -85,28 +93,32 @@ class CircuitAdapter:
             return _circuit
 
         elif sdk == Sdk.PYQUIL:
+            logger.debug("Converting OpenQASM via pytket -> tk_to_pyquil")
             import importlib
             from pytket.qasm import circuit_from_qasm_str
             tk_to_pyquil = importlib.import_module("pytket.extensions.pyquil").tk_to_pyquil
             return tk_to_pyquil(circuit_from_qasm_str(qasm_str))
 
         elif sdk == Sdk.QIBO:
+            logger.debug("Converting OpenQASM via Qibo Circuit.from_qasm")
             from qibo.models import Circuit
             return Circuit.from_qasm(qasm_str)
 
         elif sdk == Sdk.QULACS:
+            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:
                 from qiskit import QuantumCircuit as QiskitCircuit
-                return CircuitAdapter._qiskit_to_qulacs(
-                    QiskitCircuit.from_qasm_str(qasm_str)
-                )
+                qiskit_circ = QiskitCircuit.from_qasm_str(qasm_str)
+                logger.debug(f"Qiskit parsed circuit: num_qubits={qiskit_circ.num_qubits} num_gates={len(qiskit_circ.data)}")
+                return CircuitAdapter._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
 
         elif sdk == Sdk.CUDA_QUANTUM:
+            logger.debug("CUDA-Q: passing OpenQASM string through directly")
             # CUDA-Q accepts OpenQASM directly via kernel builder
             return qasm_str
 
@@ -125,7 +137,7 @@ class CircuitAdapter:
         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}")
+        logger.debug(f"Adapting QUBO for SDK: {sdk} | num_entries={len(qubo_raw)}")
 
         qubo_dict = {}
         for key, val in qubo_raw.items():
@@ -135,6 +147,7 @@ class CircuitAdapter:
             else:
                 qubo_dict[(key, key)] = val
 
+        logger.debug(f"QUBO parsed: {len(qubo_dict)} entries -> BinaryQuadraticModel")
         from dimod import BinaryQuadraticModel
         return BinaryQuadraticModel.from_qubo(qubo_dict)
 
@@ -150,6 +163,7 @@ class CircuitAdapter:
         from qulacs.gate import DenseMatrix
 
         n = qiskit_circ.num_qubits
+        logger.debug(f"_qiskit_to_qulacs: num_qubits={n} num_instructions={len(qiskit_circ.data)}")
         qulacs_circ = QulacsCirucit(n)
         qubit_map = {bit: idx for idx, bit in enumerate(qiskit_circ.qubits)}
 
@@ -183,6 +197,8 @@ class CircuitAdapter:
                 # 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(DenseMatrix(qubits, gate.to_matrix()))
 
+        logger.debug(f"_qiskit_to_qulacs: conversion complete")
         return qulacs_circ

{quapp_common-0.0.12.dev10 → quapp_common-0.0.12.dev11/quapp_common.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-common
-Version: 0.0.12.dev10
+Version: 0.0.12.dev11
 Summary: Quapp common library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)
@@ -103,6 +103,18 @@ Notes:
 
 ## Recently Changes Highlights
 
+### v0.0.12.dev11
+- Enhance: `CircuitAdapter` now emits structured debug logs at each routing
+  decision — SDK selected, QASM string length, qubit count, per-SDK adapter
+  chosen, `tk_to_braket` return type (tuple vs bare Circuit), DenseMatrix
+  fallback for unrecognized/parametric gates in `_qiskit_to_qulacs`, and QUBO
+  entry counts before and after parsing.
+- Enhance: `SubprocessBridge` now emits debug logs on initialisation
+  (`language`, `sdk`), `processing()` (input keys, JS status, adapted circuit
+  type), and `post_processing()` (job-result type, serialised keys, JS status,
+  result type); subprocess failures are additionally promoted to `logger.error`
+  before the `RuntimeError` is raised.
+
 ### v0.0.12.dev10
 - Fix: `CircuitAdapter._adapt_openqasm` for `Sdk.BRAKET` now handles the
   breaking API change in `pytket-braket >= 0.35`, where `tk_to_braket` returns