quapp-common 0.0.12.dev3__tar.gz → 0.0.12.dev5__tar.gz

{quapp_common-0.0.12.dev3/quapp_common.egg-info → quapp_common-0.0.12.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-common
-Version: 0.0.12.dev3
+Version: 0.0.12.dev5
 Summary: Quapp common library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)
@@ -49,11 +49,6 @@ 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.
-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.
-Version 0.0.12.dev2 fixes the JavaScript handler runner path in
-`SubprocessDispatcher` so that the subprocess command resolves correctly.
 
 ## Features
 
@@ -106,6 +101,33 @@ Notes:
 
 ## Recently Changes Highlights
 
+### v0.0.12.dev5
+- Version bump to 0.0.12.dev5.
+- Refactor: update logger imports in `SubprocessBridge`, `CircuitAdapter`, and `SubprocessDispatcher`
+  to use relative paths (`from ..config.logging_config import logger`) for consistency across modules.
+
+### v0.0.12.dev4
+- Version bumps to 0.0.12.dev4.
+- Fix: `AsyncInvocationTask._on_task_done` now properly fires the step error
+  callback when a background task raises an unhandled exception — reads
+  `onErrorCallbackUrl` from the event's `preparation` step and calls
+  `update_job_metadata` with a structured error response.
+- Fix: circuit preparation failure in `Invocation.__pre_execute` now returns
+  `None` instead of raising `ValueError`, allowing the caller to handle the
+  empty result gracefully without an unhandled exception propagating.
+- Refactor: replace stdlib `logging` with the project’s loguru-based logger
+  (via `config.logging_config`) in `SubprocessBridge`, `CircuitAdapter`, and
+  `SubprocessDispatcher`; all three now call `logger.bind(context=__name__)`.
+- Style: reformat `SubprocessBridge` and `SubprocessDispatcher` from 2-space
+  to 4-space indentation, consistent with the rest of the codebase.
+
+### v0.0.12.dev3
+- Version bumps to 0.0.12.dev3.
+- Add `QUANTUM_HPC` SDK enum value (display name `"quantum hpc"`) to support
+  the Quapp HPC backend.
+- Make `circuitExportUrl` optional in `Invocation` for SDKs that do not
+  require a circuit-export step.
+
 ### v0.0.12.dev2
 - Version bumps to 0.0.12.dev2.
 - Fix: correct JavaScript handler runner path in `SubprocessDispatcher.RUNNER_MAP` —

{quapp_common-0.0.12.dev3 → quapp_common-0.0.12.dev5}/README.md

@@ -12,11 +12,6 @@ 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.
-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.
-Version 0.0.12.dev2 fixes the JavaScript handler runner path in
-`SubprocessDispatcher` so that the subprocess command resolves correctly.
 
 ## Features
 
@@ -69,6 +64,33 @@ Notes:
 
 ## Recently Changes Highlights
 
+### v0.0.12.dev5
+- Version bump to 0.0.12.dev5.
+- Refactor: update logger imports in `SubprocessBridge`, `CircuitAdapter`, and `SubprocessDispatcher`
+  to use relative paths (`from ..config.logging_config import logger`) for consistency across modules.
+
+### v0.0.12.dev4
+- Version bumps to 0.0.12.dev4.
+- Fix: `AsyncInvocationTask._on_task_done` now properly fires the step error
+  callback when a background task raises an unhandled exception — reads
+  `onErrorCallbackUrl` from the event's `preparation` step and calls
+  `update_job_metadata` with a structured error response.
+- Fix: circuit preparation failure in `Invocation.__pre_execute` now returns
+  `None` instead of raising `ValueError`, allowing the caller to handle the
+  empty result gracefully without an unhandled exception propagating.
+- Refactor: replace stdlib `logging` with the project’s loguru-based logger
+  (via `config.logging_config`) in `SubprocessBridge`, `CircuitAdapter`, and
+  `SubprocessDispatcher`; all three now call `logger.bind(context=__name__)`.
+- Style: reformat `SubprocessBridge` and `SubprocessDispatcher` from 2-space
+  to 4-space indentation, consistent with the rest of the codebase.
+
+### v0.0.12.dev3
+- Version bumps to 0.0.12.dev3.
+- Add `QUANTUM_HPC` SDK enum value (display name `"quantum hpc"`) to support
+  the Quapp HPC backend.
+- Make `circuitExportUrl` optional in `Invocation` for SDKs that do not
+  require a circuit-export step.
+
 ### v0.0.12.dev2
 - Version bumps to 0.0.12.dev2.
 - Fix: correct JavaScript handler runner path in `SubprocessDispatcher.RUNNER_MAP` —

{quapp_common-0.0.12.dev3 → quapp_common-0.0.12.dev5}/pyproject.toml

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

@@ -9,9 +9,12 @@ from starlette.responses import JSONResponse
 
 from ..async_tasks.async_task import AsyncTask
 from ..component.backend.job_manager import JobManager
+from ..component.callback.update_job_metadata import update_job_metadata
 from ..config.logging_config import logger
 from ..factory.handler_factory import HandlerFactory
 from ..model.invocation import Event, Error, Success
+from ..util.http_utils import get_custom_header
+from ..util.response_utils import build_error_job_response
 
 
 class AsyncInvocationTask(AsyncTask):
@@ -72,9 +75,30 @@ class AsyncInvocationTask(AsyncTask):
             task = asyncio.create_task(run_in_threadpool(_run_handle))
 
             def _on_task_done(t: asyncio.Task):
-                if not t.cancelled() and t.exception():
+                if t.cancelled() or t.exception() is None:
+                    return
+                exc = t.exception()
+                logger.exception(
+                        f"Background job task failed for job {job_id}: {exc}")
+                try:
+                    event_data = self.event.json()
+                    on_error_url = (event_data.get('preparation') or {}).get(
+                            'onErrorCallbackUrl')
+                    if on_error_url:
+                        error_response = build_error_job_response(
+                                exc,
+                                message=f"Unhandled background task error: {exc}")
+                        error_response.user_token = event_data.get('userToken')
+                        error_response.user_identity = event_data.get(
+                                'userIdentity')
+                        error_response.project_header = get_custom_header(
+                                event_data, 'projectHeader')
+                        error_response.workspace_header = get_custom_header(
+                                event_data, 'workspaceHeader')
+                        update_job_metadata(error_response, on_error_url)
+                except Exception as fallback_exc:
                     logger.exception(
-                            f"Background job task failed for job {job_id}: {t.exception()}")
+                            f"Failed to notify BE of error for job {job_id}: {fallback_exc}")
 
             task.add_done_callback(_on_task_done)
 

{quapp_common-0.0.12.dev3 → quapp_common-0.0.12.dev5}/quapp_common/component/backend/invocation.py

@@ -79,7 +79,7 @@ class Invocation(ABC):
         if circuit is None:
             self.logger.error(
                     "Circuit preparation failed, returning None from pre-execute")
-            raise ValueError("Circuit preparation failed")
+            return None
 
         try:
             self.logger.debug("Preparing backend data")

quapp_common-0.0.12.dev5/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.
+
+from .circuit_adapter import CircuitAdapter
+from .dispatcher import SubprocessDispatcher
+from .result_serializer import ResultSerializer
+from ..config.logging_config import logger
+from ..enum.language import Language
+from ..enum.sdk import Sdk
+
+logger = logger.bind(context=__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.12.dev3 → quapp_common-0.0.12.dev5}/quapp_common/component/circuit_adapter.py

@@ -5,11 +5,10 @@
 #  circuit_adapter.py
 #  Copyright © CITYNOW Co. Ltd. All rights reserved.
 
-import logging
-
+from ..config.logging_config import logger
 from ..enum.sdk import Sdk
 
-logger = logging.getLogger(__name__)
+logger = logger.bind(context=__name__)
 
 
 class CircuitAdapter:

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

@@ -0,0 +1,80 @@
+"""
+    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 os
+import subprocess
+
+from ..config.logging_config import logger
+from ..enum.language import Language
+
+logger = logger.bind(context=__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', '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.dev3 → quapp_common-0.0.12.dev5/quapp_common.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-common
-Version: 0.0.12.dev3
+Version: 0.0.12.dev5
 Summary: Quapp common library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)
@@ -49,11 +49,6 @@ 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.
-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.
-Version 0.0.12.dev2 fixes the JavaScript handler runner path in
-`SubprocessDispatcher` so that the subprocess command resolves correctly.
 
 ## Features
 
@@ -106,6 +101,33 @@ Notes:
 
 ## Recently Changes Highlights
 
+### v0.0.12.dev5
+- Version bump to 0.0.12.dev5.
+- Refactor: update logger imports in `SubprocessBridge`, `CircuitAdapter`, and `SubprocessDispatcher`
+  to use relative paths (`from ..config.logging_config import logger`) for consistency across modules.
+
+### v0.0.12.dev4
+- Version bumps to 0.0.12.dev4.
+- Fix: `AsyncInvocationTask._on_task_done` now properly fires the step error
+  callback when a background task raises an unhandled exception — reads
+  `onErrorCallbackUrl` from the event's `preparation` step and calls
+  `update_job_metadata` with a structured error response.
+- Fix: circuit preparation failure in `Invocation.__pre_execute` now returns
+  `None` instead of raising `ValueError`, allowing the caller to handle the
+  empty result gracefully without an unhandled exception propagating.
+- Refactor: replace stdlib `logging` with the project’s loguru-based logger
+  (via `config.logging_config`) in `SubprocessBridge`, `CircuitAdapter`, and
+  `SubprocessDispatcher`; all three now call `logger.bind(context=__name__)`.
+- Style: reformat `SubprocessBridge` and `SubprocessDispatcher` from 2-space
+  to 4-space indentation, consistent with the rest of the codebase.
+
+### v0.0.12.dev3
+- Version bumps to 0.0.12.dev3.
+- Add `QUANTUM_HPC` SDK enum value (display name `"quantum hpc"`) to support
+  the Quapp HPC backend.
+- Make `circuitExportUrl` optional in `Invocation` for SDKs that do not
+  require a circuit-export step.
+
 ### v0.0.12.dev2
 - Version bumps to 0.0.12.dev2.
 - Fix: correct JavaScript handler runner path in `SubprocessDispatcher.RUNNER_MAP` —

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

@@ -1,94 +0,0 @@
-"""
-    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.12.dev3/quapp_common/component/dispatcher.py

@@ -1,79 +0,0 @@
-"""
-    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', '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