quapp-common 0.0.14.dev8__tar.gz → 0.0.14.dev10__tar.gz

{quapp_common-0.0.14.dev8/quapp_common.egg-info → quapp_common-0.0.14.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-common
-Version: 0.0.14.dev8
+Version: 0.0.14.dev10
 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.14.dev8 → quapp_common-0.0.14.dev10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quapp-common"
-version = "0.0.14.dev8"
+version = "0.0.14.dev10"
 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.14.dev10/quapp_common/component/callback/update_job_metadata.py

@@ -0,0 +1,157 @@
+#  Quapp Platform Project
+#  update_job_metadata.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+import json
+import math
+
+import requests
+
+from ..backend.job_manager import JobManager
+from ...config.log_context import phase
+from ...config.logging_config import job_logger
+from ...data.response.job_response import JobResponse
+from ...enum.runtime_phase import RuntimePhase
+from ...util.http_utils import create_application_json_header, \
+    get_job_id_from_url
+from ...util.response_utils import generate_response
+
+
+def _sanitize(value):
+    """Replace what strict JSON cannot carry, recursively.
+
+    Only used on the fallback path. NaN/Infinity become None because
+    ``allow_nan=False`` rejects them -- which is what requests did too, so the
+    fallback still produces valid JSON instead of a bare ``NaN`` literal the
+    backend cannot parse.
+    """
+    if isinstance(value, dict):
+        return {key: _sanitize(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_sanitize(item) for item in value]
+    if isinstance(value, float) and not math.isfinite(value):
+        return None
+    return value
+
+
+def _json_payload(payload: dict, logger) -> str:
+    """Serialize the callback body, degrading what json cannot encode to text.
+
+    ``requests.patch(json=...)`` calls ``json.dumps(..., allow_nan=False)`` with
+    no ``default=``, so ONE object json cannot encode anywhere inside
+    job_response raised TypeError and the request never left the process. Worse,
+    the ``except`` path below then sends the SAME body to the on_error callback,
+    which fails identically -- the job is left RUNNING with nothing reported.
+
+    That really happened: quapp-pennylane put PennyLane's ``Shots`` object into
+    job_result and "Object of type Shots is not JSON serializable" took down both
+    callbacks of job 2b96f552-787d-40bd-8cfb-b5fe40983fd2.
+
+    The strict pass runs first, so a well-formed body is serialized exactly as
+    requests would have; only a body that would otherwise raise falls back.
+    Coercing to text is right here: these values are for display, and losing the
+    job is far worse than showing ``Shots(total_shots=1024)``.
+    """
+    try:
+        return json.dumps(payload, allow_nan=False)
+    except (TypeError, ValueError) as exception:
+        logger.warning(
+                f'Callback body is not strictly JSON serializable ({exception}); '
+                f'sending it with those values coerced to text. The value comes '
+                f'from a provider lib and should be converted to a plain type '
+                f'before it reaches job_response.')
+        return json.dumps(_sanitize(payload), allow_nan=False, default=str)
+
+
+def update_job_metadata(job_response: JobResponse, callback_url: str):
+    # Helpers to improve readability and remove duplication
+    def _log_http_result(tag: str, resp):
+        logger.info(
+                f"Request to {tag} completed with status code: {resp.status_code}")
+        if resp.status_code in (401, 403):
+            logger.error(
+                    f"Request to {tag} was rejected with status code {resp.status_code}. "
+                    f"The job update is lost, so the platform will not see this state change. "
+                    f"Check that the response carries the user token and the project header.")
+        elif not resp.ok:
+            logger.warning(
+                    f"Unexpected status code received from {tag}: {resp.status_code}, response content: {resp.content}")
+
+    def _update_local_status() -> None:
+        """
+                Update local JobManager status based on callback URL semantics:
+                - contains 'FAILED' => FAILED
+                - contains 'FINALIZATION_PASSED' => DONE
+                - otherwise => RUNNING
+                """
+        url_upper = (callback_url or "").upper()
+        if "FAILED" in url_upper:
+            JobManager.set_failed(job_id=job_id)
+        elif "FINALIZATION_PASSED" in url_upper:
+            JobManager.set_done(job_id=job_id)
+        else:
+            JobManager.set_running(job_id=job_id)
+
+    def _patch_scheduler() -> None:
+        job_details = JobManager.get_job(job_id)
+        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')}
+        scheduler_response = requests.patch(url=scheduler_callback_url,
+                                            json=scheduler_payload)
+        _log_http_result('scheduler', scheduler_response)
+
+    job_id = get_job_id_from_url(callback_url)
+    logger = job_logger(job_id)
+    logger.info(
+            f'Calling backend to update job metadata at URL: {callback_url}')
+
+    if not getattr(job_response, 'user_token', None):
+        logger.error(
+                'Job update is being sent without a user token, the backend will reject it. '
+                'The response was built without the invocation credentials.')
+
+    request_body = generate_response(job_response)
+
+    # The callback runs after the caller's `with phase(...)` has closed, so a
+    # failure here was reported with phase=None -- what happened to job
+    # 2b96f552-787d-40bd-8cfb-b5fe40983fd2. RuntimePhase.CALLBACK was declared
+    # for exactly this and had no place that opened it.
+    with phase(RuntimePhase.CALLBACK):
+        try:
+            request_headers = create_application_json_header(
+                    token=job_response.user_token,
+                    project_header=job_response.project_header,
+                    workspace_header=job_response.workspace_header)
+
+            # data= rather than json=: the body goes through _json_payload so no
+            # provider object can kill this callback. Content-Type is already
+            # application/json in the headers above.
+            response = requests.patch(
+                    url=callback_url,
+                    data=_json_payload({'data': request_body}, logger),
+                    headers=request_headers)
+
+            # 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)
+
+            raise exception

{quapp_common-0.0.14.dev8 → quapp_common-0.0.14.dev10}/quapp_common/component/dispatcher.py

@@ -46,10 +46,6 @@ RUNNER_MAP = {
         'command': [_QSHARP_BINARY],
         'timeout': 300,
     },
-    Language.C: {
-        'command': ['./handler_compiled'],
-        'timeout': 300,
-    },
 }
 
 # Cap the stack/stderr length carried on the exception so job_result stays small.

{quapp_common-0.0.14.dev8 → quapp_common-0.0.14.dev10}/quapp_common/util/error_classifier.py

@@ -329,6 +329,23 @@ register_rules(
              code='INPUT_TOO_FEW_ITEMS',
              resolution='A field in the input has fewer items than expected.'),
 
+        # --- serialization -------------------------------------------------
+        # A provider lib left a vendor object in job_response and json could not
+        # encode it, so the callback body never went out. This is a lib bug, not
+        # a user one: it landed as category UNKNOWN before this rule, which told
+        # nobody anything (job 2b96f552-787d-40bd-8cfb-b5fe40983fd2, PennyLane's
+        # Shots object). Placed above the vaguer rules because the message is
+        # unmistakable.
+        Rule(match=lambda e: isinstance(e, TypeError)
+                             and 'is not json serializable' in str(e).lower(),
+             category=ErrorCategory.PLATFORM_INTERNAL,
+             code='PLATFORM_RESULT_NOT_SERIALIZABLE',
+             resolution='An object in the job result cannot be converted to '
+                        'JSON, so the platform could not report the result.',
+             steps=('Report this to the Quapp team with the job id',
+                    'The provider lib has to convert the value to a plain type '
+                    'before it goes into job_result')),
+
         # --- dependency ----------------------------------------------------
         Rule(match=lambda e: isinstance(e, ModuleNotFoundError),
              category=ErrorCategory.DEPENDENCY,

{quapp_common-0.0.14.dev8 → quapp_common-0.0.14.dev10/quapp_common.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-common
-Version: 0.0.14.dev8
+Version: 0.0.14.dev10
 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.14.dev8 → quapp_common-0.0.14.dev10}/quapp_common.egg-info/SOURCES.txt

@@ -89,6 +89,7 @@ quapp_common/util/http_utils.py
 quapp_common/util/invocation_failure.py
 quapp_common/util/json_parser_utils.py
 quapp_common/util/response_utils.py
+tests/test_callback_payload.py
 tests/test_circuit_adapter.py
 tests/test_dispatcher_runner_error.py
 tests/test_error_classifier.py

quapp_common-0.0.14.dev10/tests/test_callback_payload.py

@@ -0,0 +1,173 @@
+#  Quapp Platform Project
+#  test_callback_payload.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+"""One unserializable value must not cost us the whole job.
+
+`requests.patch(json=...)` calls `json.dumps(..., allow_nan=False)` with no
+`default=`, so a single object json cannot encode anywhere inside `job_response`
+raised TypeError before the request ever left the process. The `except` path then
+sent the SAME body to the on_error callback, which failed identically -- so the
+backend heard nothing at all and the job stayed RUNNING forever.
+
+Seen in production on job 2b96f552-787d-40bd-8cfb-b5fe40983fd2: quapp-pennylane
+put PennyLane's `Shots` object into job_result and both callbacks died with
+"Object of type Shots is not JSON serializable".
+
+The provider lib is fixed separately (shots is coerced to int). These tests lock
+the platform-side guarantee: the callback goes out regardless.
+"""
+
+import json
+
+import pytest
+
+from quapp_common.component.callback import update_job_metadata as module
+from quapp_common.component.callback.update_job_metadata import (
+    _json_payload, update_job_metadata,
+)
+from quapp_common.config.logging_config import job_logger
+
+
+class Shots:
+    """Stands in for pennylane.measurements.Shots: json cannot encode it."""
+
+    def __init__(self, total):
+        self.total_shots = total
+
+    def __str__(self):
+        return f'Shots(total_shots={self.total_shots})'
+
+
+@pytest.fixture
+def logger():
+    return job_logger('job_payload')
+
+
+# ------------------------------------------- the payload itself
+
+def test_serializable_body_is_untouched(logger):
+    body = {'data': {'jobResult': {'counts': {'00': 512}}, 'shots': 1024}}
+
+    assert _json_payload(body, logger) == json.dumps(body, allow_nan=False)
+
+
+def test_unserializable_value_becomes_text(logger):
+    body = {'data': {'shots': Shots(1024)}}
+
+    payload = json.loads(_json_payload(body, logger))
+
+    assert payload['data']['shots'] == 'Shots(total_shots=1024)'
+
+
+def test_nan_does_not_produce_invalid_json(logger):
+    """NaN is not JSON. requests rejected it too (allow_nan=False), so the
+    fallback has to drop it rather than emit a bare NaN literal the backend
+    cannot parse."""
+    body = {'data': {'probability': float('nan'), 'shots': Shots(8)}}
+
+    text = _json_payload(body, logger)
+
+    assert 'NaN' not in text
+    assert json.loads(text)['data']['probability'] is None
+
+
+def test_nested_unserializable_value_is_reached(logger):
+    body = {'data': {'jobResult': {'meta': [{'shots': Shots(2048)}]}}}
+
+    payload = json.loads(_json_payload(body, logger))
+
+    assert payload['data']['jobResult']['meta'][0]['shots'] == \
+           'Shots(total_shots=2048)'
+
+
+# ------------------------------------ the callback actually goes out
+
+class FakeResponse:
+    status_code = 200
+    ok = True
+    content = b'{}'
+
+
+@pytest.fixture
+def sent(monkeypatch):
+    """Capture the outgoing PATCH instead of making one."""
+    calls = []
+
+    def _patch(url, data=None, json=None, headers=None, **kwargs):
+        calls.append({'url': url, 'data': data, 'json': json})
+        return FakeResponse()
+
+    monkeypatch.setattr(module.requests, 'patch', _patch)
+    monkeypatch.setattr(module.JobManager, 'set_running', lambda job_id: None)
+    monkeypatch.setattr(module.JobManager, 'set_done', lambda job_id: None)
+    monkeypatch.setattr(module.JobManager, 'set_failed', lambda job_id: None)
+    monkeypatch.setattr(module.JobManager, 'get_job', lambda job_id: None)
+    return calls
+
+
+def test_callback_is_sent_even_with_a_provider_object(monkeypatch, sent):
+    """The regression itself: this used to raise TypeError instead of sending."""
+    monkeypatch.setattr(module, 'generate_response',
+                        lambda job_response: {'shots': Shots(1024)})
+
+    class Response:
+        user_token = 'token'
+        project_header = None
+        workspace_header = None
+
+    update_job_metadata(Response(),
+                        'http://backend/jobs/job_1/ANALYSIS_PASSED')
+
+    assert len(sent) == 1, 'the callback never went out'
+    assert sent[0]['json'] is None, 'body must be pre-serialized, not json='
+    assert 'Shots(total_shots=1024)' in sent[0]['data']
+
+
+# ------------------------------- the error is classified, not "UNKNOWN"
+
+def test_serialization_failure_gets_a_real_category():
+    """It arrived as category=UNKNOWN, owner=UNKNOWN, which told nobody anything.
+
+    A vendor object in job_result is a provider-lib bug, so it belongs to the
+    platform team, not the user.
+    """
+    from quapp_common.enum.error_category import ErrorCategory
+    from quapp_common.enum.runtime_phase import RuntimePhase
+    from quapp_common.util.error_classifier import classify
+
+    try:
+        json.dumps({'shots': Shots(1024)})
+    except TypeError as caught:
+        error = caught
+
+    rule, _ = classify(error, RuntimePhase.ANALYSIS)
+
+    assert rule.code == 'PLATFORM_RESULT_NOT_SERIALIZABLE'
+    assert rule.category is ErrorCategory.PLATFORM_INTERNAL
+    assert rule.steps
+
+
+def test_callback_failure_carries_the_callback_phase(monkeypatch, sent):
+    """The caller's `with phase(...)` has already closed by callback time, so the
+    report said phase=None. RuntimePhase.CALLBACK was declared for this."""
+    from quapp_common.config.log_context import bind_job, effective_phase
+    from quapp_common.enum.runtime_phase import RuntimePhase
+
+    def _boom(url, **kwargs):
+        raise ConnectionError('backend unreachable')
+
+    monkeypatch.setattr(module.requests, 'patch', _boom)
+    monkeypatch.setattr(module, 'generate_response', lambda job_response: {})
+
+    class Response:
+        user_token = 'token'
+        project_header = None
+        workspace_header = None
+
+    bind_job('job_phase')
+    with pytest.raises(ConnectionError):
+        update_job_metadata(Response(),
+                            'http://backend/jobs/job_phase/ANALYSIS_PASSED')
+
+    assert effective_phase() is RuntimePhase.CALLBACK

{quapp_common-0.0.14.dev8 → quapp_common-0.0.14.dev10}/tests/test_dispatcher_runner_error.py

@@ -89,7 +89,7 @@ def test_structured_error_legacy_string_form(fake_run):
         'status': 'error', 'error': 'invalid JSON on stdin'})))
 
     with pytest.raises(HandlerRuntimeError) as info:
-        dispatch(Language.C, REQUEST)
+        dispatch(Language.QSHARP, REQUEST)
 
     assert 'invalid JSON on stdin' in str(info.value)
 
@@ -97,11 +97,11 @@ def test_structured_error_legacy_string_form(fake_run):
 # ------------------------------------------------------------- (3) killed by signal
 
 def test_signal_is_detected(fake_run):
-    """handler.c segfaults: returncode = -11, stdout empty."""
+    """A subprocess handler is killed by a signal: returncode = -11, stdout empty."""
     fake_run(FakeCompletedProcess(returncode=-11, stdout=''))
 
     with pytest.raises(HandlerRuntimeError) as info:
-        dispatch(Language.C, REQUEST)
+        dispatch(Language.QSHARP, REQUEST)
 
     error = info.value
     assert error.error_type == 'Signal'

{quapp_common-0.0.14.dev8 → quapp_common-0.0.14.dev10}/tests/test_language_dispatcher.py

@@ -10,14 +10,8 @@ class TestLanguageCEnum(unittest.TestCase):
 
 
 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)
+    def test_language_c_not_registered(self):
+        self.assertNotIn(Language.C, RUNNER_MAP)
 
 
 class TestLanguageCppEnum(unittest.TestCase):

quapp_common-0.0.14.dev8/quapp_common/component/callback/update_job_metadata.py

@@ -1,95 +0,0 @@
-#  Quapp Platform Project
-#  update_job_metadata.py
-#  Copyright © CITYNOW Co. Ltd. All rights reserved.
-
-import requests
-
-from ..backend.job_manager import JobManager
-from ...config.logging_config import job_logger
-from ...data.response.job_response import JobResponse
-from ...util.http_utils import create_application_json_header, \
-    get_job_id_from_url
-from ...util.response_utils import generate_response
-
-
-def update_job_metadata(job_response: JobResponse, callback_url: str):
-    # Helpers to improve readability and remove duplication
-    def _log_http_result(tag: str, resp):
-        logger.info(
-                f"Request to {tag} completed with status code: {resp.status_code}")
-        if resp.status_code in (401, 403):
-            logger.error(
-                    f"Request to {tag} was rejected with status code {resp.status_code}. "
-                    f"The job update is lost, so the platform will not see this state change. "
-                    f"Check that the response carries the user token and the project header.")
-        elif not resp.ok:
-            logger.warning(
-                    f"Unexpected status code received from {tag}: {resp.status_code}, response content: {resp.content}")
-
-    def _update_local_status() -> None:
-        """
-                Update local JobManager status based on callback URL semantics:
-                - contains 'FAILED' => FAILED
-                - contains 'FINALIZATION_PASSED' => DONE
-                - otherwise => RUNNING
-                """
-        url_upper = (callback_url or "").upper()
-        if "FAILED" in url_upper:
-            JobManager.set_failed(job_id=job_id)
-        elif "FINALIZATION_PASSED" in url_upper:
-            JobManager.set_done(job_id=job_id)
-        else:
-            JobManager.set_running(job_id=job_id)
-
-    def _patch_scheduler() -> None:
-        job_details = JobManager.get_job(job_id)
-        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')}
-        scheduler_response = requests.patch(url=scheduler_callback_url,
-                                            json=scheduler_payload)
-        _log_http_result('scheduler', scheduler_response)
-
-    job_id = get_job_id_from_url(callback_url)
-    logger = job_logger(job_id)
-    logger.info(
-            f'Calling backend to update job metadata at URL: {callback_url}')
-
-    if not getattr(job_response, 'user_token', None):
-        logger.error(
-                'Job update is being sent without a user token, the backend will reject it. '
-                'The response was built without the invocation credentials.')
-
-    request_body = generate_response(job_response)
-
-    try:
-        request_headers = create_application_json_header(
-                token=job_response.user_token,
-                project_header=job_response.project_header,
-                workspace_header=job_response.workspace_header)
-
-        response = requests.patch(url=callback_url, json={'data': request_body},
-                                  headers=request_headers)
-
-        # 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)
-
-        raise exception