quapp-common 0.0.11.dev9__tar.gz → 0.0.12.dev1__tar.gz

{quapp_common-0.0.11.dev9/quapp_common.egg-info → quapp_common-0.0.12.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-common
-Version: 0.0.11.dev9
+Version: 0.0.12.dev1
 Summary: Quapp common library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)
@@ -25,6 +25,8 @@ Requires-Dist: numpy
 Requires-Dist: matplotlib
 Requires-Dist: pylatexenc
 Requires-Dist: starlette
+Requires-Dist: qibo
+Requires-Dist: dimod
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
 Requires-Dist: bumpver; extra == "dev"
@@ -46,8 +48,10 @@ quantum providers and devices.
 Recent improvements add first-class asynchronous job processing with a
 cross-process JobManager,
 background task execution, and standardized result models for immediate client
-responses while work
-continues in the background.
+responses while work continues in the background.
+Version 0.0.12.dev1 introduces multi-language SDK support, enabling
+dispatching quantum tasks to non-Python runtimes (e.g., JavaScript) via
+subprocess with circuit adaptation and result serialization.
 
 ## Features
 
@@ -72,6 +76,16 @@ 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.
 
 ## Installation
 
@@ -85,9 +99,25 @@ Notes:
 
 - From version 0.0.11.dev7, `starlette` is a direct dependency to support
   background execution helpers.
+- From version 0.0.12.dev1, `qibo` and `dimod` are added as dependencies to
+  support Qibo and D-Wave Ocean SDK integrations.
 
 ## Recently Changes Highlights
 
+### v0.0.12.dev1
+- Version bump to 0.0.12.dev1 and dependency update (add `qibo`, `dimod`).
+- Introduce multi-language SDK support primitives:
+    - `Language` enum for validating and resolving Python/JavaScript runtimes.
+    - `SubprocessDispatcher` for delegating tasks to non-Python runtimes via
+      subprocess with runner configuration and timeout management.
+    - `SubprocessBridge` integrating dispatcher, circuit adapter, and result
+      serializer for 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 (numpy, complex
+      numbers, Enums, datetime) into JSON-serializable dictionaries.
+
+### v0.0.11.dev7 – v0.0.11.dev10
 - Version bump to 0.0.11.dev7 and dependency update (add `starlette`).
 - Introduce asynchronous job processing primitives:
     - AsyncInvocationTask for background execution with immediate client

{quapp_common-0.0.11.dev9 → quapp_common-0.0.12.dev1}/README.md

@@ -11,8 +11,10 @@ quantum providers and devices.
 Recent improvements add first-class asynchronous job processing with a
 cross-process JobManager,
 background task execution, and standardized result models for immediate client
-responses while work
-continues in the background.
+responses while work continues in the background.
+Version 0.0.12.dev1 introduces multi-language SDK support, enabling
+dispatching quantum tasks to non-Python runtimes (e.g., JavaScript) via
+subprocess with circuit adaptation and result serialization.
 
 ## Features
 
@@ -37,6 +39,16 @@ 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.
 
 ## Installation
 
@@ -50,9 +62,25 @@ Notes:
 
 - From version 0.0.11.dev7, `starlette` is a direct dependency to support
   background execution helpers.
+- From version 0.0.12.dev1, `qibo` and `dimod` are added as dependencies to
+  support Qibo and D-Wave Ocean SDK integrations.
 
 ## Recently Changes Highlights
 
+### v0.0.12.dev1
+- Version bump to 0.0.12.dev1 and dependency update (add `qibo`, `dimod`).
+- Introduce multi-language SDK support primitives:
+    - `Language` enum for validating and resolving Python/JavaScript runtimes.
+    - `SubprocessDispatcher` for delegating tasks to non-Python runtimes via
+      subprocess with runner configuration and timeout management.
+    - `SubprocessBridge` integrating dispatcher, circuit adapter, and result
+      serializer for 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 (numpy, complex
+      numbers, Enums, datetime) into JSON-serializable dictionaries.
+
+### v0.0.11.dev7 – v0.0.11.dev10
 - Version bump to 0.0.11.dev7 and dependency update (add `starlette`).
 - Introduce asynchronous job processing primitives:
     - AsyncInvocationTask for background execution with immediate client

{quapp_common-0.0.11.dev9 → quapp_common-0.0.12.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quapp-common"
-version = "0.0.11.dev9"
+version = "0.0.12.dev1"
 description = "Quapp common library supporting Quapp Platform for Quantum Computing"
 readme = "README.md"
 authors = [{ name = "CITYNOW Co. Ltd. ", email = "corp@citynow.vn" }]
@@ -21,7 +21,9 @@ dependencies = [
     "numpy",
     "matplotlib",
     "pylatexenc",
-    "starlette"
+    "starlette",
+    "qibo",
+    "dimod"
 ]
 requires-python = ">=3.7"
 

{quapp_common-0.0.11.dev9 → quapp_common-0.0.12.dev1}/quapp_common/async_tasks/async_invocation_task.py

@@ -69,7 +69,14 @@ class AsyncInvocationTask(AsyncTask):
                                                            self.post_processing_fn).handle()
 
             # Run in the background threadpool so this request can return immediately
-            asyncio.create_task(run_in_threadpool(_run_handle))
+            task = asyncio.create_task(run_in_threadpool(_run_handle))
+
+            def _on_task_done(t: asyncio.Task):
+                if not t.cancelled() and t.exception():
+                    logger.exception(
+                            f"Background job task failed for job {job_id}: {t.exception()}")
+
+            task.add_done_callback(_on_task_done)
 
             # Respond immediately so clients can poll GET /jobs/{job_id}
             return JSONResponse(status_code=200, content=Success(

{quapp_common-0.0.11.dev9 → quapp_common-0.0.12.dev1}/quapp_common/component/backend/invocation.py

@@ -77,7 +77,7 @@ class Invocation(ABC):
         circuit = self.__prepare_circuit(circuit_preparation_fn)
 
         if circuit is None:
-            self.logger.exception(
+            self.logger.error(
                     "Circuit preparation failed, returning None from pre-execute")
             raise ValueError("Circuit preparation failed")
 
@@ -114,7 +114,7 @@ class Invocation(ABC):
 
         try:
             if self.backend_information is None:
-                self.logger.exception(
+                self.logger.error(
                         "Backend information is None before execution")
                 raise ValueError("Backend is not found")
 

{quapp_common-0.0.11.dev9 → quapp_common-0.0.12.dev1}/quapp_common/component/backend/job_fetcher.py

@@ -116,7 +116,7 @@ class JobFetcher(ABC):
                 update_job_metadata(job_response, self.callback_urls[
                     InvocationStep.EXECUTION].on_done)
             elif job_status == JobStatus.ERROR.value:
-                self.logger.exception("Job resulted in error, handling failure")
+                self.logger.error("Job resulted in error, handling failure")
 
                 self._handle_failed_job(original_job_result, job_response)
                 update_job_metadata(job_response, self.callback_urls[
@@ -151,7 +151,7 @@ class JobFetcher(ABC):
     def _handle_failed_job(self, original_job_result,
                            job_response: JobResponse):
         """Handles the job result when the job has encountered an error."""
-        self.logger.exception("Parsing job result from failed job")
+        self.logger.error("Parsing job result from failed job")
         job_response.job_result = parse(original_job_result)
 
     def _process_job_result(self, original_job_result,

{quapp_common-0.0.11.dev9 → quapp_common-0.0.12.dev1}/quapp_common/component/backend/job_fetching.py

@@ -75,7 +75,7 @@ class JobFetching(ABC):
                         InvocationStep.EXECUTION).on_done)
 
             elif JobStatus.ERROR.value.__eq__(job_response.job_status):
-                self.logger.exception("Job resulted in error, handling failure")
+                self.logger.error("Job resulted in error, handling failure")
 
                 job_response.job_result = parse(original_job_result)
 

quapp_common-0.0.12.dev1/quapp_common/component/bridge.py

@@ -0,0 +1,94 @@
+"""
+    QApp Platform Project
+    bridge.py
+    Copyright © CITYNOW Co. Ltd. All rights reserved.
+"""
+#  Quapp Platform Project
+#  bridge.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+import logging
+
+from .circuit_adapter import CircuitAdapter
+from .dispatcher import SubprocessDispatcher
+from .result_serializer import ResultSerializer
+from ..enum.language import Language
+from ..enum.sdk import Sdk
+
+logger = logging.getLogger(__name__)
+
+
+class SubprocessBridge:
+  """Bridge between the Python invocation chain and JS subprocess handlers.
+
+  Provides processing() and post_processing() callables that can be passed
+  to AsyncInvocationTask in place of Python handler functions. Internally,
+  each call dispatches to the JS subprocess with the appropriate action,
+  then converts the result (circuit or post-processed data) back to
+  Python-native objects.
+  """
+
+  def __init__(self, language: Language, sdk: Sdk):
+    self.language = language
+    self.sdk = sdk
+
+  def processing(self, invocation_input: dict):
+    """Call JS handler's processing() and convert a result to a native circuit.
+
+    Args:
+        invocation_input: The input dict from the invocation request.
+
+    Returns:
+        A native SDK circuit object (QuantumCircuit, BQM, etc.)
+
+    Raises:
+        RuntimeError: If the JS subprocess returns an error status.
+    """
+    logger.info(
+            f"SubprocessBridge.processing: dispatching to {self.language.value}")
+
+    result = SubprocessDispatcher.dispatch(self.language, {
+      "action": "processing",
+      "input" : invocation_input
+    })
+
+    if result.get("status") == "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)
+
+  def post_processing(self, job_result):
+    """Serialize a job result, send to JS handler's postProcessing(), return a result.
+
+    Args:
+        job_result: The raw job results from the quantum device execution.
+
+    Returns:
+        The post-processed result from the JS handler.
+
+    Raises:
+        RuntimeError: If the JS subprocess returns an error status.
+    """
+    logger.info(
+            f"SubprocessBridge.post_processing: dispatching to {self.language.value}")
+
+    serialized = ResultSerializer.serialize(job_result)
+
+    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')}")
+
+    payload = result.get("result")
+    if payload is None:
+        raise RuntimeError("JS post_processing returned no 'result' field")
+    return payload

{quapp_common-0.0.11.dev9 → quapp_common-0.0.12.dev1}/quapp_common/component/callback/update_job_metadata.py

@@ -38,8 +38,16 @@ def update_job_metadata(job_response: JobResponse, callback_url: str):
 
     def _patch_scheduler() -> None:
         job_details = JobManager.get_job(job_id)
-        scheduler_callback_url = job_details.get('meta').get(
+        if job_details is None:
+            logger.warning(
+                    f"Job {job_id} not found in JobManager, skipping scheduler patch")
+            return
+        scheduler_callback_url = job_details.get('meta', {}).get(
                 'scheduler_callback_url')
+        if not scheduler_callback_url:
+            logger.debug(
+                    f"No scheduler callback URL for job {job_id}, skipping")
+            return
         scheduler_payload = {'job_id'    : job_id,
                              'status'    : job_details.get('status'),
                              'updated_at': job_details.get('updated_at')}
@@ -55,10 +63,6 @@ def update_job_metadata(job_response: JobResponse, callback_url: str):
     request_body = generate_response(job_response)
 
     try:
-        # Update local job status and notify scheduler
-        _update_local_status()
-        _patch_scheduler()
-
         request_headers = create_application_json_header(
                 token=job_response.user_token,
                 project_header=job_response.project_header,
@@ -70,6 +74,10 @@ def update_job_metadata(job_response: JobResponse, callback_url: str):
         # Log backend response
         _log_http_result('backend', response)
 
+        # Update local job status and notify scheduler only after backend confirms
+        _update_local_status()
+        _patch_scheduler()
+
     except Exception as exception:
         logger.exception(f'Error occurred while calling backend: {exception}',
                          exc_info=True)

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

@@ -0,0 +1,124 @@
+"""
+    QApp Platform Project circuit_adapter.py Copyright © CITYNOW Co. Ltd. All rights reserved.
+"""
+#  Quapp Platform Project
+#  circuit_adapter.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+import logging
+
+from ..enum.sdk import Sdk
+
+logger = logging.getLogger(__name__)
+
+
+class CircuitAdapter:
+    """Convert JS subprocess circuit output to native SDK circuit objects.
+
+    Supported interchange formats:
+      - openqasm: OpenQASM 2.0 string -> SDK-specific QuantumCircuit
+      - qubo: QUBO dict -> dimod.BinaryQuadraticModel
+      - json: Arbitrary JSON pass-through
+    """
+
+    @staticmethod
+    def adapt(sdk: Sdk, result: dict):
+        """Route to the appropriate adapter based on the 'format' field."""
+        fmt = result.get("format")
+        if fmt == "openqasm":
+            circuit = result.get("circuit")
+            if circuit is None:
+                raise ValueError("Missing 'circuit' field in openqasm response")
+            return CircuitAdapter._adapt_openqasm(sdk, circuit)
+        elif fmt == "qubo":
+            qubo = result.get("qubo")
+            if qubo is None:
+                raise ValueError("Missing 'qubo' field in qubo response")
+            return CircuitAdapter._adapt_qubo(sdk, qubo)
+        elif fmt == "json":
+            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}")
+
+        if sdk == Sdk.QISKIT:
+            from qiskit import QuantumCircuit
+            return QuantumCircuit.from_qasm_str(qasm_str)
+
+        elif sdk == Sdk.BRAKET:
+            from pytket.qasm import circuit_from_qasm_str
+            from pytket.extensions.braket import tk_to_braket
+            return tk_to_braket(circuit_from_qasm_str(qasm_str))
+
+        elif sdk == Sdk.PENNYLANE:
+            import pennylane as qml
+            # PennyLane >=0.37 treats QASM `measure` statements as mid-circuit
+            # measurements returning MeasurementValue, which fails QNode
+            # validation. Override with a terminal `qml.probs` over all qubits
+            # so the QNode produces valid output and downstream histogram
+            # logic (which already looks for ProbabilityMP) keeps working.
+            #
+            # NOTE: `qml.from_qasm(..., measurements=[...])` attaches those
+            # measurements via `make_qscript` internally, which means they are
+            # NOT queued into an active `QuantumTape()` context. Downstream
+            # code uses `with QuantumTape() as tape: circuit()` to discover
+            # the circuit's wires, which would then miss the measurement
+            # wires and cause `WireError` at device execution. We therefore
+            # return a wrapper that runs the QASM ops (measurements=[] to
+            # drop QASM's terminal measures) and then explicitly queue a
+            # 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)
+            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
+
+        elif sdk == Sdk.PYQUIL:
+            from pytket.qasm import circuit_from_qasm_str
+            from pytket.extensions.pyquil import tk_to_pyquil
+            return tk_to_pyquil(circuit_from_qasm_str(qasm_str))
+
+        elif sdk == Sdk.QIBO:
+            from qibo.models import Circuit
+            return Circuit.from_qasm(qasm_str)
+
+        elif sdk in (Sdk.CUDA_QUANTUM, Sdk.CU_QUANTUM):
+            # CUDA-Q accepts OpenQASM directly via kernel builder
+            return qasm_str
+
+        raise ValueError(f"OpenQASM adaptation not supported for SDK: {sdk}")
+
+    @staticmethod
+    def _count_qasm_qubits(qasm_str):
+        """Sum qubit counts across all `qreg <name>[<n>];` declarations."""
+        import re
+        return sum(int(m) for m in re.findall(r'qreg\s+\w+\[(\d+)\]', qasm_str))
+
+    @staticmethod
+    def _adapt_qubo(sdk, qubo_raw):
+        """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}")
+
+        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
+
+        from dimod import BinaryQuadraticModel
+        return BinaryQuadraticModel.from_qubo(qubo_dict)

{quapp_common-0.0.11.dev9 → quapp_common-0.0.12.dev1}/quapp_common/component/device/device_selection.py

@@ -60,7 +60,7 @@ class DeviceSelection:
         response = requests.get(self.url, params=request, headers=header)
 
         if response.status_code != 200:
-            logger.exception(
+            logger.error(
                     'Select device fail with status code: {0} and content: {1}'.format(
                             response.status_code, response.content))
 

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

@@ -0,0 +1,79 @@
+"""
+    QApp Platform Project dispatcher.py Copyright © CITYNOW Co. Ltd. All rights reserved.
+"""
+
+#  Quapp Platform Project
+#  dispatcher.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+import json
+import logging
+import os
+import subprocess
+
+from ..enum.language import Language
+
+logger = logging.getLogger(__name__)
+
+
+class SubprocessDispatcher:
+  """Dispatch handler execution to non-Python runtimes via subprocess."""
+
+  # Override this at application startup to set a stable working directory
+  # for subprocess runners (e.g., the project root containing function/).
+  # Defaults to os.getcwd() at dispatch time if not set.
+  WORKING_DIR: str = None
+
+  RUNNER_MAP = {
+    Language.JAVASCRIPT: {
+      'command': ['node', 'function/handler_runner.js'],
+      'timeout': 300,
+    }
+  }
+
+  @staticmethod
+  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 = SubprocessDispatcher.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 = SubprocessDispatcher.WORKING_DIR or os.getcwd()
+    result = subprocess.run(runner['command'], input=payload,
+                            capture_output=True, text=True,
+                            timeout=effective_timeout, cwd=cwd)
+
+    if result.stderr:
+      logger.debug(f"Subprocess stderr: {result.stderr[:500]}")
+
+    if result.returncode != 0:
+      logger.error(
+              f"Handler runner failed (exit={result.returncode}): {result.stderr[:500]}")
+      raise RuntimeError(f"Handler runner failed: {result.stderr}")
+
+    logger.debug(f"Subprocess completed successfully, action={action}")
+    return json.loads(result.stdout)
+
+  @staticmethod
+  def is_subprocess_language(language_str: str) -> bool:
+    try:
+      lang = Language.resolve(language_str)
+      return lang != Language.PYTHON
+    except Exception:
+      return False

quapp_common-0.0.12.dev1/quapp_common/component/result_serializer.py

@@ -0,0 +1,22 @@
+"""
+    QApp Platform Project result_serializer.py Copyright © CITYNOW Co. Ltd. All rights reserved.
+"""
+from ..util.json_parser_utils import parse
+
+
+class ResultSerializer:
+    """Serialize Python job results into JSON-safe dicts for subprocess communication."""
+
+    @staticmethod
+    def serialize(job_result):
+        """
+        Convert a job result (which may contain numpy arrays, complex numbers,
+        Qiskit/Braket objects, etc.) into a plain JSON-serializable dict.
+
+        Reuses the existing parse() utility that handles numpy, complex, datetime,
+        Enum, and custom objects with to_dict()/__dict__.
+        """
+        try:
+            return parse(job_result)
+        except Exception as e:
+            raise RuntimeError(f"Failed to serialize job result: {e}") from e

{quapp_common-0.0.11.dev9 → quapp_common-0.0.12.dev1}/quapp_common/data/request/invocation_request.py

@@ -54,7 +54,7 @@ class InvocationRequest(Request):
         # Validate authentication (if provided)
         authentication = request_data.get("authentication")
         if authentication is not None and not isinstance(authentication, dict):
-            self.logger.exception(
+            self.logger.error(
                     'authentication must be a dictionary if provided, got {0}'.format(
                             type(authentication).__name__))
             raise ValueError(

{quapp_common-0.0.11.dev9 → quapp_common-0.0.12.dev1}/quapp_common/data/request/job_fetching_request.py

@@ -1,14 +1,18 @@
 #  Quapp Platform Project
 #  job_fetching_request.py
 #  Copyright © CITYNOW Co. Ltd. All rights reserved.
+import logging
+
 from .request import Request
 
+_logger = logging.getLogger(__name__)
+
 
 class JobFetchingRequest(Request):
     def __init__(self, request_data: dict | None):
 
         if not isinstance(request_data, dict):
-            self.logger.exception(
+            _logger.error(
                     f"request_data must be a dictionary, got {type(request_data).__name__}")
             raise ValueError(
                     f"request_data must be a dictionary, got {type(request_data).__name__}")
@@ -17,7 +21,7 @@ class JobFetchingRequest(Request):
         provider_authentication = request_data.get("providerAuthentication")
         if provider_authentication is not None and not isinstance(
                 provider_authentication, dict):
-            self.logger.exception(
+            _logger.error(
                     f"Invalid provider_authentication: {type(provider_authentication).__name__}")
             raise ValueError(
                     f"provider_authentication must be a dictionary if provided, got {type(provider_authentication).__name__}")

{quapp_common-0.0.11.dev9 → quapp_common-0.0.12.dev1}/quapp_common/data/request/request.py

@@ -27,7 +27,7 @@ class Request:
         self.workspace_header: CustomHeader = get_custom_header(request_data,
                                                                 'workspaceHeader')
         self.logger = job_logger(self.job_id)
-        JobManager.add_job(job_id=self.job_id, status='RUNNING', meta={
+        JobManager.add_job(job_id=self.job_id, status='PENDING', meta={
             'scheduler_callback_url': request_data.get('schedulerCallBackURL')})
         self.logger.info(
                 f"Initializing Request with job id: {self.job_id} and provider job id: {self.provider_job_id}")

quapp_common-0.0.12.dev1/quapp_common/enum/language.py

@@ -0,0 +1,22 @@
+"""
+    QApp Platform Project language.py Copyright © CITYNOW Co. Ltd. All rights reserved.
+"""
+
+#  Quapp Platform Project
+#  language.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+from ..enum.base_enum import BaseEnum
+
+
+class Language(BaseEnum):
+  PYTHON = 'python'
+  JAVASCRIPT = 'javascript'
+
+  @staticmethod
+  def resolve(language: str):
+    for element in Language:
+      if element.value == language:
+        return element
+
+    raise ValueError(f"Language '{language}' is not supported!")

{quapp_common-0.0.11.dev9 → quapp_common-0.0.12.dev1}/quapp_common/enum/sdk.py

@@ -14,6 +14,8 @@ class Sdk(BaseEnum):
     PENNYLANE = "pennylane"
     PYQUIL = "pyquil"
     QSHARP = "qsharp"
+    QIBO = "qibo"
+    QULACS = "qulacs"
 
     @staticmethod
     def resolve(sdk: str):

{quapp_common-0.0.11.dev9 → quapp_common-0.0.12.dev1}/quapp_common/model/invocation.py

@@ -9,7 +9,6 @@ from datetime import datetime
 
 class Event:
     logger = logging.getLogger("model.Invocation.Event")
-    logger.setLevel(logging.DEBUG)
 
     def __init__(self, request):
         self.request_body = {}

{quapp_common-0.0.11.dev9 → quapp_common-0.0.12.dev1}/quapp_common/util/http_utils.py

@@ -136,6 +136,6 @@ def get_job_id_from_url(url: str):
         except IndexError:
             logger.exception("No job id found after 'job'")
     else:
-        logger.exception("Neither 'job' nor 'jobs' found in URL segments.")
+        logger.error("Neither 'job' nor 'jobs' found in URL segments.")
 
     return job_id

{quapp_common-0.0.11.dev9 → quapp_common-0.0.12.dev1/quapp_common.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-common
-Version: 0.0.11.dev9
+Version: 0.0.12.dev1
 Summary: Quapp common library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)
@@ -25,6 +25,8 @@ Requires-Dist: numpy
 Requires-Dist: matplotlib
 Requires-Dist: pylatexenc
 Requires-Dist: starlette
+Requires-Dist: qibo
+Requires-Dist: dimod
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
 Requires-Dist: bumpver; extra == "dev"
@@ -46,8 +48,10 @@ quantum providers and devices.
 Recent improvements add first-class asynchronous job processing with a
 cross-process JobManager,
 background task execution, and standardized result models for immediate client
-responses while work
-continues in the background.
+responses while work continues in the background.
+Version 0.0.12.dev1 introduces multi-language SDK support, enabling
+dispatching quantum tasks to non-Python runtimes (e.g., JavaScript) via
+subprocess with circuit adaptation and result serialization.
 
 ## Features
 
@@ -72,6 +76,16 @@ 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.
 
 ## Installation
 
@@ -85,9 +99,25 @@ Notes:
 
 - From version 0.0.11.dev7, `starlette` is a direct dependency to support
   background execution helpers.
+- From version 0.0.12.dev1, `qibo` and `dimod` are added as dependencies to
+  support Qibo and D-Wave Ocean SDK integrations.
 
 ## Recently Changes Highlights
 
+### v0.0.12.dev1
+- Version bump to 0.0.12.dev1 and dependency update (add `qibo`, `dimod`).
+- Introduce multi-language SDK support primitives:
+    - `Language` enum for validating and resolving Python/JavaScript runtimes.
+    - `SubprocessDispatcher` for delegating tasks to non-Python runtimes via
+      subprocess with runner configuration and timeout management.
+    - `SubprocessBridge` integrating dispatcher, circuit adapter, and result
+      serializer for 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 (numpy, complex
+      numbers, Enums, datetime) into JSON-serializable dictionaries.
+
+### v0.0.11.dev7 – v0.0.11.dev10
 - Version bump to 0.0.11.dev7 and dependency update (add `starlette`).
 - Introduce asynchronous job processing primitives:
     - AsyncInvocationTask for background execution with immediate client

{quapp_common-0.0.11.dev9 → quapp_common-0.0.12.dev1}/quapp_common.egg-info/SOURCES.txt

@@ -13,6 +13,10 @@ quapp_common/async_tasks/async_task.py
 quapp_common/async_tasks/export_circuit_task.py
 quapp_common/async_tasks/post_processing_task.py
 quapp_common/component/__init__.py
+quapp_common/component/bridge.py
+quapp_common/component/circuit_adapter.py
+quapp_common/component/dispatcher.py
+quapp_common/component/result_serializer.py
 quapp_common/component/backend/__init__.py
 quapp_common/component/backend/invocation.py
 quapp_common/component/backend/job_fetcher.py
@@ -51,6 +55,7 @@ quapp_common/enum/__init__.py
 quapp_common/enum/base_enum.py
 quapp_common/enum/http_header.py
 quapp_common/enum/invocation_step.py
+quapp_common/enum/language.py
 quapp_common/enum/media_type.py
 quapp_common/enum/processing_unit.py
 quapp_common/enum/provider_tag.py

{quapp_common-0.0.11.dev9 → quapp_common-0.0.12.dev1}/quapp_common.egg-info/requires.txt

@@ -4,6 +4,8 @@ numpy
 matplotlib
 pylatexenc
 starlette
+qibo
+dimod
 
 [dev]
 black