quapp-common 0.0.14.dev7__tar.gz → 0.0.14.dev9__tar.gz

{quapp_common-0.0.14.dev7/quapp_common.egg-info → quapp_common-0.0.14.dev9}/PKG-INFO

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

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

@@ -33,9 +33,9 @@ class PostProcessingTask(AsyncTask):
         job_response.content_type = MediaType.APPLICATION_JSON
 
         try:
-            # RuntimePhase.POST_PROCESSING duoc dinh nghia nhung truoc day khong
-            # noi nao dung, nen code user chay trong post_processing_fn khong he
-            # co phase trong log lan trong ErrorReport.
+            # RuntimePhase.POST_PROCESSING was defined but never used anywhere,
+            # so user code running inside post_processing_fn had no phase, in
+            # the log or in the ErrorReport.
             with phase(RuntimePhase.POST_PROCESSING):
                 self.logger.info("Execute post_processing ...")
                 job_result_post_processing = self.post_processing_fn(

{quapp_common-0.0.14.dev7 → quapp_common-0.0.14.dev9}/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.dev7 → quapp_common-0.0.14.dev9}/quapp_common/model/device/custom_device.py

@@ -35,11 +35,11 @@ class CustomDevice(Device, ABC):
         update_job_metadata(job_response, analysis_callback.on_start)
 
         try:
-            # Device._on_analysis co `with phase(...)`, ban override nay khong --
-            # va day moi la ban thuc su chay: QiskitDevice, OqcCloudDevice...
-            # deu ke thua CustomDevice. Thieu no thi log cua analysis khong co
-            # field `phase`, Grafana khong loc duoc va ErrorReport cua loi trong
-            # analysis ra phase=None.
+            # Device._on_analysis has `with phase(...)`; this override did not
+            # -- and this is the version that actually runs, because
+            # QiskitDevice, OqcCloudDevice and the rest all inherit CustomDevice.
+            # Without it, analysis lines carry no `phase` field, Grafana cannot
+            # filter on it, and an error during analysis reports phase=None.
             with phase(RuntimePhase.ANALYSIS):
                 self.logger.debug(
                         "Producing histogram data from original job result")

{quapp_common-0.0.14.dev7 → quapp_common-0.0.14.dev9/quapp_common.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-common
-Version: 0.0.14.dev7
+Version: 0.0.14.dev9
 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.dev7 → quapp_common-0.0.14.dev9}/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.dev7 → quapp_common-0.0.14.dev9}/tests/test_error_log_dedupe.py

@@ -70,7 +70,7 @@ def raise_and_catch(exception):
         return caught
 
 
-# ------------------------------------------------------- mot loi = mot dong
+# ------------------------------------------------- one error = one line
 
 def test_single_job_failed_line_per_error(captured):
     bind_job('job_1')
@@ -80,7 +80,7 @@ def test_single_job_failed_line_per_error(captured):
                              phase=RuntimePhase.EXECUTION)
 
     failed = [r for r in captured if r.get('event') == 'job_failed']
-    assert len(failed) == 1, f'mong doi 1 dong, nhan {len(failed)}'
+    assert len(failed) == 1, f'expected 1 line, got {len(failed)}'
     assert failed[0]['_level'] == 'ERROR'
 
 
@@ -111,7 +111,7 @@ def test_phase_failed_is_separate_and_single(captured):
     assert events['job_failed'] == 0
 
 
-# --------------------------------------------------- khong con log o call-site
+# ------------------------------------------ no logging left at the call site
 
 @pytest.mark.parametrize('relative', CALL_SITE_FILES)
 def test_no_redundant_logger_exception_before_builder(relative):
@@ -126,11 +126,11 @@ def test_no_redundant_logger_exception_before_builder(relative):
             re.MULTILINE)
 
     assert not pattern.search(source), (
-            f'{relative}: con log exception ngay truoc '
-            f'build_error_job_response -- se ra 2 dong ERROR cho mot loi')
+            f'{relative}: still logs the exception right before '
+            f'build_error_job_response -- that yields 2 ERROR lines for one error')
 
 
-# ------------------------------------------------------------ dong thoi
+# ------------------------------------------------------------ concurrency
 
 def test_concurrent_jobs_do_not_duplicate_or_mix(captured):
     """4 concurrent jobs: each gets exactly its own lines, no context mixing."""
@@ -158,13 +158,13 @@ def test_concurrent_jobs_do_not_duplicate_or_mix(captured):
     per_job = Counter(r.get('job_id') for r in captured)
     assert set(per_job) == {'job_0', 'job_1', 'job_2', 'job_3'}
     assert len(set(per_job.values())) == 1, \
-        f'so dong khong deu giua cac job: {dict(per_job)}'
+        f'line counts differ between jobs: {dict(per_job)}'
 
     # No line carries a job_id belonging to a job other than its own message.
     mixed = [r for r in captured
              if r.get('job_id') and 'job_' in r['_message']
              and r['job_id'] not in r['_message']]
-    assert not mixed, f'{len(mixed)} dong lan context giua cac job'
+    assert not mixed, f'{len(mixed)} lines mixed context between jobs'
 
 
 def test_thread_pool_keeps_phase(captured):

{quapp_common-0.0.14.dev7 → quapp_common-0.0.14.dev9}/tests/test_error_report.py

@@ -346,7 +346,7 @@ def test_phase_emits_failed_and_reraises(captured):
                   if r['extra'].get('event') == 'phase_failed')
     assert failed['extra']['phase'] == 'COMPILATION'
     assert failed['level'].name == 'WARNING', \
-        'phase_failed phai thay duoc o LOG_LEVEL=INFO'
+        'phase_failed has to be visible at LOG_LEVEL=INFO'
     assert 'duration_ms' in failed['extra']
 
 

{quapp_common-0.0.14.dev7 → quapp_common-0.0.14.dev9}/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.dev7 → quapp_common-0.0.14.dev9}/tests/test_log_secret_leak.py

@@ -71,7 +71,7 @@ def _connect(api_token):
     raise ConnectionError('provider refused the connection')
 
 
-# ------------------------------------------------- (1) secret trong message
+# ------------------------------------------- (1) the secret is in the message
 
 def test_secret_in_message_is_redacted(real_sink):
     bind_job('job_1')
@@ -104,7 +104,7 @@ def test_secret_in_exception_string_is_redacted(real_sink):
     assert 'Traceback' in output
 
 
-# --------------------------------------- (2) secret trong bien cuc bo
+# ------------------------------ (2) the secret is in a local variable
 
 def test_diagnose_true_would_leak_local_variables():
     """Pin loguru's behaviour so the test above means something: with
@@ -118,8 +118,9 @@ def test_diagnose_true_would_leak_local_variables():
     except ConnectionError:
         job_logger().exception('provider connection failed')
 
-    assert TOKEN in buffer.getvalue(), \
-        'loguru khong con in gia tri bien cuc bo -- xem lai co can diagnose=False'
+    assert TOKEN in buffer.getvalue(), (
+        'loguru no longer prints local variable values -- recheck whether '
+        'diagnose=False is still needed')
 
 
 def test_diagnose_false_does_not_leak_local_variables():
@@ -136,7 +137,7 @@ def test_diagnose_false_does_not_leak_local_variables():
 
 
 
-# ------------------------------------------------- json sink dung traceback sach
+# ------------------------------ the json sink uses a clean traceback
 
 def test_json_stack_trace_has_no_variable_values():
     """stackTrace in JSON comes from traceback.format_exception (the standard

{quapp_common-0.0.14.dev7 → quapp_common-0.0.14.dev9}/tests/test_no_sdk_dependency.py

@@ -71,7 +71,7 @@ def module_level_imports(path: Path):
 
 
 def test_package_has_python_files():
-    assert python_files(), 'khong tim thay file .py nao'
+    assert python_files(), 'found no .py files at all'
 
 
 @pytest.mark.parametrize('path', python_files(), ids=lambda p: p.name)
@@ -79,7 +79,7 @@ def test_no_module_level_sdk_import(path):
     offenders = module_level_imports(path) & SDK_MODULES
     assert not offenders, (
             f'{path.relative_to(PACKAGE_ROOT)} import SDK o module level: '
-            f'{sorted(offenders)}. Chuyen vao trong function (xem _require() '
+            f'{sorted(offenders)}. Move it inside the function (see _require() '
             f'trong circuit_adapter.py).')
 
 
@@ -94,8 +94,8 @@ def test_pyproject_declares_no_sdk():
                  in SDK_MODULES]
 
     assert not offenders, (
-            f'pyproject khai bao SDK trong dependencies: {offenders}. '
-            f'SDK thuoc ve lib con.')
+            f'pyproject declares an SDK in dependencies: {offenders}. '
+            f'SDKs belong to the child libs.')
 
 
 def test_circuit_adapter_uses_require_helper():

{quapp_common-0.0.14.dev7 → quapp_common-0.0.14.dev9}/tests/test_phase_coverage.py

@@ -76,35 +76,38 @@ def phases_wrapped_in(relative_path):
     return found
 
 
-# ------------------------------------------- (1) CustomDevice phai co ANALYSIS
+# ----------------------------------- (1) CustomDevice must open ANALYSIS
 
 def test_custom_device_analysis_is_wrapped():
-    """Ban override moi la ban chay that, no phai mo phase nhu ban goc."""
+    """The override is the version that runs, so it must open the same phase as
+    the original."""
     assert 'ANALYSIS' in phases_wrapped_in('model/device/custom_device.py'), (
-        'CustomDevice._on_analysis khong co `with phase(RuntimePhase.ANALYSIS)`; '
-        'moi device Qiskit dung ban nay nen log analysis se mat field phase')
+        'CustomDevice._on_analysis has no `with phase(RuntimePhase.ANALYSIS)`; '
+        'every Qiskit device uses this version, so analysis lines would lose '
+        'their phase field')
 
 
 def test_base_device_still_wraps_its_phases():
-    """Khong duoc lam hong ban goc khi sua ban override."""
+    """Fixing the override must not break the original."""
     wrapped = phases_wrapped_in('model/device/device.py')
     assert {'COMPILATION', 'EXECUTION', 'ANALYSIS'} <= wrapped
 
 
-# ------------------------------------ (2) post_processing phai co POST_PROCESSING
+# -------------------------- (2) post_processing must open POST_PROCESSING
 
 def test_post_processing_task_is_wrapped():
     wrapped = phases_wrapped_in('async_tasks/post_processing_task.py')
     assert 'POST_PROCESSING' in wrapped, (
-        'post_processing_fn (code cua user) chay ngoai moi phase, nen loi trong '
-        'do khong biet thuoc giai doan nao')
+        'post_processing_fn (user code) runs outside every phase, so an error '
+        'in it belongs to no known stage')
 
 
 def test_every_declared_phase_is_actually_used():
-    """RuntimePhase khai bao ra thi phai co noi mo -- tru CALLBACK/POLLING.
+    """A declared RuntimePhase must be opened somewhere -- except CALLBACK and
+    POLLING.
 
-    CALLBACK va POLLING duoc dat qua `phase=` cua build_error_job_response chu
-    khong qua `with phase(...)`, nen khong tinh o day.
+    CALLBACK and POLLING are set through build_error_job_response's `phase=`
+    argument rather than `with phase(...)`, so they do not count here.
     """
     used = set()
     for path in PACKAGE_ROOT.rglob('*.py'):
@@ -113,13 +116,13 @@ def test_every_declared_phase_is_actually_used():
     declared = {member.name for member in RuntimePhase}
     never_opened = declared - used - {'CALLBACK', 'POLLING'}
     assert not never_opened, (
-        f'RuntimePhase khong bao gio duoc mo: {sorted(never_opened)}')
+        f'RuntimePhase never opened anywhere: {sorted(never_opened)}')
 
 
-# --------------------------------------------------- hanh vi khi chay that
+# ------------------------------------------------------ behaviour at runtime
 
 def test_analysis_phase_reaches_the_log_record(captured):
-    """Trong `with phase(ANALYSIS)`, dong log phai mang phase=ANALYSIS."""
+    """Inside `with phase(ANALYSIS)`, a log line must carry phase=ANALYSIS."""
     from quapp_common.config.log_context import phase
 
     bind_job('job_A', sdk='qiskit')
@@ -132,8 +135,8 @@ def test_analysis_phase_reaches_the_log_record(captured):
 
 
 def test_failure_inside_analysis_keeps_the_phase():
-    """`phase()` reset contextvar trong finally, nen ErrorReport phai doc duoc
-    phase da that bai qua _FAILED_PHASE."""
+    """`phase()` resets the contextvar in finally, so ErrorReport has to read the
+    failed phase through _FAILED_PHASE."""
     from quapp_common.config.log_context import phase
 
     bind_job('job_B')
@@ -155,19 +158,21 @@ def test_failure_inside_post_processing_keeps_the_phase():
     assert effective_phase() is RuntimePhase.POST_PROCESSING
 
 
-# ------------------------------------------------- (3) trace_id khong bi tach
+# ------------------------------------------------- (3) trace_id is not split
 
 def test_rebinding_same_job_keeps_one_trace_id():
-    """AsyncInvocationTask bind roi Handler.__init__ bind lai -- van mot trace."""
+    """AsyncInvocationTask binds, then Handler.__init__ binds again -- still one
+    trace."""
     bind_job('job_SAME')
     first = trace_id()
 
     bind_job('job_SAME', sdk='qiskit', provider='QUAO_QUANTUM_SIMULATOR')
-    assert trace_id() == first, 'cung mot job ma co hai traceId'
+    assert trace_id() == first, 'one job ended up with two traceIds'
 
 
 def test_binding_without_job_id_then_with_it_keeps_the_trace():
-    """Cua vao HTTP bind truoc khi biet job_id; trace phai duoc mang theo."""
+    """The HTTP entry point binds before the job_id is known; the trace has to
+    carry over."""
     bind_job(None)
     first = trace_id()
 
@@ -176,7 +181,7 @@ def test_binding_without_job_id_then_with_it_keeps_the_trace():
 
 
 def test_different_job_gets_a_fresh_trace_id():
-    """Khong duoc tron trace giua hai job khac nhau."""
+    """Traces must never be mixed between two different jobs."""
     bind_job('job_ONE')
     first = trace_id()
 
@@ -192,6 +197,6 @@ def test_explicit_trace_id_always_wins():
 
 def test_trace_id_is_present_on_every_record(captured):
     bind_job('job_T')
-    logger.bind(**log_context.job_context()).info('mot dong bat ky')
+    logger.bind(**log_context.job_context()).info('any line at all')
 
     assert captured[-1].get(TRACE_ID)