quapp-dwave-ocean 0.0.1.dev3__tar.gz → 0.0.1.dev4__tar.gz

{quapp_dwave_ocean-0.0.1.dev3/quapp_dwave_ocean.egg-info → quapp_dwave_ocean-0.0.1.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-dwave-ocean
-Version: 0.0.1.dev3
+Version: 0.0.1.dev4
 Summary: Quapp D-Wave Ocean library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)
@@ -19,12 +19,13 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: quapp-common==0.0.11.dev7
+Requires-Dist: quapp-common==0.0.14.dev10
 Requires-Dist: dwave-cloud-client==0.13.4
 Requires-Dist: dwave-system==1.30.0
 Requires-Dist: dwave-samplers==1.5.0
 Requires-Dist: dimod==0.12.20
 Requires-Dist: numpy==2.2.4
+Requires-Dist: matplotlib
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
 Requires-Dist: bumpver; extra == "dev"

{quapp_dwave_ocean-0.0.1.dev3 → quapp_dwave_ocean-0.0.1.dev4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quapp-dwave-ocean"
-version = "0.0.1.dev3"
+version = "0.0.1.dev4"
 description = "Quapp D-Wave Ocean library supporting Quapp Platform for Quantum Computing"
 readme = "README.md"
 authors = [{ name = "CITYNOW Co. Ltd. ", email = "corp@citynow.vn" }]
@@ -16,12 +16,16 @@ classifiers = [
 ]
 keywords = ["quapp", "quapp-dwave-ocean", "dwave-ocean", "quantum"]
 dependencies = [
-    "quapp-common==0.0.11.dev7",
+    "quapp-common==0.0.14.dev10",
     "dwave-cloud-client==0.13.4",
     "dwave-system==1.30.0",
     "dwave-samplers==1.5.0",
     "dimod==0.12.20",
-    "numpy==2.2.4"
+    "numpy==2.2.4",
+    # d_wave_ocean_circuit_export_task.py:9 import matplotlib nhung truoc
+    # day khong khai bao: no chi co mat nho quapp-common keo theo. Neu
+    # quapp-common bo matplotlib thi lib nay vo luc import, khong bao truoc.
+    "matplotlib"
 ]
 requires-python = ">=3.7"
 

quapp_dwave_ocean-0.0.1.dev4/quapp_dwave_ocean/__init__.py

@@ -0,0 +1,7 @@
+__version__ = "0.4.9"
+
+from .factory.d_wave_handler_factory import DWaveHandlerFactory
+
+# Imported for the side effect: register_rules() has to run before the
+# first job fails, so this import cannot be made lazy.
+from . import error_rules as _error_rules  # noqa: E402,F401

quapp_dwave_ocean-0.0.1.dev4/quapp_dwave_ocean/error_rules.py

@@ -0,0 +1,136 @@
+#  Quapp Platform Project
+#  error_rules.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+"""D-Wave Ocean-specific error classification rules.
+
+Registered into ``quapp_common.util.error_classifier`` when ``quapp_dwave_ocean``
+is imported, so ``quapp-common`` never has to depend on Ocean.
+
+Matching is done on the message text or on the class **NAME as a string**, never
+``isinstance``, and nothing from ``dwave`` / ``dimod`` is imported: the classifier
+has to work even when the SDK is absent.
+
+The first five rules key off messages **this lib itself** raises -- checked
+against the code, not guessed:
+
+    quapp_dwave_ocean/factory/d_wave_provider_factory.py:52
+        ValueError('Authentication details are required for D-Wave provider.')
+    quapp_dwave_ocean/factory/d_wave_provider_factory.py:74
+        ValueError('Unsupported provider!')
+    quapp_dwave_ocean/factory/d_wave_device_factory.py:73
+        ValueError('Unsupported device!')
+    quapp_dwave_ocean/async_tasks/d_wave_ocean_circuit_export_task.py:169,178
+        ValueError('Circuit must not be None')
+        ValueError(f'Expected BinaryQuadraticModel, got {type(circuit)}')
+    quapp_dwave_ocean/component/backend/d_wave_ocean_invocation.py:150
+        AttributeError('... Circuit is not a BinaryQuadraticModel ...')
+    quapp_dwave_ocean/model/provider/d_wave_system_provider.py:49
+        Exception(f'Failed to connect to DWave provider: {exception}')
+
+What makes D-Wave different from the gate-model SDKs: the "circuit" here is a
+``BinaryQuadraticModel`` (a QUBO/Ising problem), not a gate circuit. So the
+"wrong circuit type" error is very easy to hit when a user writes their handler
+following a gate-model example, and it is USER_CODE rather than an SDK fault.
+
+The last two rules match exception names from dwave-cloud-client. If upstream
+renames them the rule becomes inert rather than broken -- the classifier just
+falls back on the phase.
+"""
+
+from quapp_common.enum.error_category import ErrorCategory
+from quapp_common.util.error_classifier import Rule, register_rules
+
+DOC_AUTH = 'errors/dwave-auth'
+DOC_DEVICE = 'errors/dwave-device'
+DOC_CIRCUIT = 'errors/dwave-circuit'
+
+
+def _message(exception) -> str:
+    return str(exception).lower()
+
+
+def _name(exception) -> str:
+    return type(exception).__name__
+
+
+register_rules(
+        # ------------ raised by quapp-dwave-ocean itself (checked against code)
+        # d_wave_provider_factory.py:52 -- the Leap token is missing
+        Rule(match=lambda e: 'authentication details are required' in _message(e),
+             category=ErrorCategory.AUTHENTICATION,
+             code='DWAVE_TOKEN_MISSING',
+             resolution='Authentication details for the D-Wave provider are '
+                        'missing.',
+             steps=('Add your D-Wave Leap API token to the workspace',
+                    'The token is on cloud.dwavesys.com, under API Token'),
+             doc_slug=DOC_AUTH,
+             retryable=False),
+
+        # d_wave_ocean_invocation.py:150 and circuit_export_task.py:169,178
+        # The most common user error on D-Wave: writing the handler from a
+        # gate-model example and returning a QuantumCircuit instead of a
+        # BinaryQuadraticModel.
+        Rule(match=lambda e: 'binaryquadraticmodel' in _message(e)
+                             or 'circuit must not be none' in _message(e),
+             category=ErrorCategory.USER_CODE,
+             code='DWAVE_INVALID_PROBLEM_TYPE',
+             resolution='The problem preparation function did not return a '
+                        'BinaryQuadraticModel.',
+             steps=('Check what your processing function returns',
+                    'D-Wave takes a QUBO/Ising problem, not a gate circuit',
+                    'Use dimod.BinaryQuadraticModel to build the problem'),
+             doc_slug=DOC_CIRCUIT),
+
+        # d_wave_device_factory.py:73 and d_wave_provider_factory.py:74
+        Rule(match=lambda e: 'unsupported device' in _message(e)
+                             or 'unsupported provider' in _message(e),
+             category=ErrorCategory.PROVIDER_DEVICE,
+             code='DWAVE_DEVICE_UNSUPPORTED',
+             resolution="This device or provider is not supported by Quapp's "
+                        'D-Wave lib yet.',
+             steps=('Check the device selected for the job',
+                    'quapp-dwave-ocean serves D-Wave System, Hybrid and the '
+                    'local simulators'),
+             doc_slug=DOC_DEVICE),
+
+        # d_wave_system_provider.py:49
+        Rule(match=lambda e: 'failed to connect to dwave provider' in _message(e),
+             category=ErrorCategory.PROVIDER_UNAVAILABLE,
+             code='DWAVE_CONNECT_FAILED',
+             resolution='D-Wave Leap could not be reached.',
+             steps=('Try again in a few minutes',
+                    'Check that the token is still valid and the endpoint is '
+                    'correct',
+                    'Check the service status on cloud.dwavesys.com'),
+             doc_slug=DOC_AUTH,
+             retryable=True,
+             retry_after=120),
+
+        # ------------------------------- dwave-cloud-client exceptions
+        # The solver is gone or no longer serving: the user has to pick another
+        # one, waiting and retrying will not help.
+        Rule(match=lambda e: _name(e) in {'SolverNotFoundError',
+                                          'SolverOfflineError',
+                                          'SolverAuthenticationError',
+                                          'UnsupportedSolverError'},
+             category=ErrorCategory.PROVIDER_DEVICE,
+             code='DWAVE_SOLVER_UNAVAILABLE',
+             resolution='D-Wave reports the solver does not exist or is '
+                        'unavailable.',
+             steps=('Check the solver name in the function configuration',
+                    'The solver list changes over time -- check Leap'),
+             doc_slug=DOC_DEVICE,
+             retryable=False),
+
+        Rule(match=lambda e: _name(e) in {'RequestTimeout', 'PollingTimeout',
+                                          'ProblemUploadError',
+                                          'InvalidAPIResponseError'},
+             category=ErrorCategory.PROVIDER_UNAVAILABLE,
+             code='DWAVE_API_UNAVAILABLE',
+             resolution='The D-Wave Leap API could not be reached.',
+             steps=('Try again in a few minutes',
+                    'A very large problem can also time out during upload'),
+             retryable=True,
+             retry_after=120),
+)

{quapp_dwave_ocean-0.0.1.dev3 → quapp_dwave_ocean-0.0.1.dev4}/quapp_dwave_ocean/factory/d_wave_device_factory.py

@@ -2,7 +2,7 @@
 #  d_wave_device_factory.py
 #  Copyright © CITYNOW Co. Ltd. All rights reserved.
 
-from quapp_common.config.logging_config import job_logger
+from quapp_common.config.logging_config import logger
 from quapp_common.enum.provider_tag import ProviderTag
 from quapp_common.enum.sdk import Sdk
 from quapp_common.factory.device_factory import DeviceFactory
@@ -14,7 +14,7 @@ from ..model.device.quapp_d_wave_device import QuappDWaveOceanDevice
 from ..model.provider.d_wave_system_provider import (system_devices,
                                                      hybrid_devices)
 
-logger = job_logger(__name__)
+logger = logger.bind(context='DWaveDeviceFactory')
 
 
 class DWaveDeviceFactory(DeviceFactory):

{quapp_dwave_ocean-0.0.1.dev3 → quapp_dwave_ocean-0.0.1.dev4}/quapp_dwave_ocean/factory/d_wave_provider_factory.py

@@ -1,7 +1,7 @@
 #  Quapp Platform Project
 #  d_wave_provider_factory.py
 #  Copyright © CITYNOW Co. Ltd. All rights reserved.
-from quapp_common.config.logging_config import job_logger
+from quapp_common.config.logging_config import logger
 from quapp_common.enum.provider_tag import ProviderTag
 from quapp_common.enum.sdk import Sdk
 from quapp_common.factory.provider_factory import ProviderFactory
@@ -9,7 +9,7 @@ from quapp_common.factory.provider_factory import ProviderFactory
 from ..model.provider.d_wave_system_provider import DWaveSystemProvider
 from ..model.provider.quapp_d_wave_provider import QuappDWaveProvider
 
-logger = job_logger(__name__)
+logger = logger.bind(context='DWaveProviderFactory')
 
 
 class DWaveProviderFactory(ProviderFactory):

{quapp_dwave_ocean-0.0.1.dev3 → quapp_dwave_ocean-0.0.1.dev4}/quapp_dwave_ocean/model/provider/d_wave_system_provider.py

@@ -5,14 +5,14 @@
 from dwave.cloud import Client
 from dwave.system import DWaveSampler, AutoEmbeddingComposite
 
-from quapp_common.config.logging_config import job_logger
+from quapp_common.config.logging_config import logger
 from quapp_common.enum.provider_tag import ProviderTag
 from quapp_common.model.provider.provider import Provider
 
 system_devices = ["Advantage_system4.1"]
 hybrid_devices = ["hybrid_binary_quadratic_model_version2"]
 
-logger = job_logger(__name__)
+logger = logger.bind(context='DWaveSystemProvider')
 
 
 class DWaveSystemProvider(Provider):

{quapp_dwave_ocean-0.0.1.dev3 → quapp_dwave_ocean-0.0.1.dev4}/quapp_dwave_ocean/model/provider/quapp_d_wave_provider.py

@@ -4,11 +4,11 @@
 
 from dwave.samplers import SimulatedAnnealingSampler
 
-from quapp_common.config.logging_config import job_logger
+from quapp_common.config.logging_config import logger
 from quapp_common.enum.provider_tag import ProviderTag
 from quapp_common.model.provider.provider import Provider
 
-logger = job_logger(__name__)
+logger = logger.bind(context='QuappDWaveProvider')
 
 
 class QuappDWaveProvider(Provider):

{quapp_dwave_ocean-0.0.1.dev3 → quapp_dwave_ocean-0.0.1.dev4/quapp_dwave_ocean.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-dwave-ocean
-Version: 0.0.1.dev3
+Version: 0.0.1.dev4
 Summary: Quapp D-Wave Ocean library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)
@@ -19,12 +19,13 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: quapp-common==0.0.11.dev7
+Requires-Dist: quapp-common==0.0.14.dev10
 Requires-Dist: dwave-cloud-client==0.13.4
 Requires-Dist: dwave-system==1.30.0
 Requires-Dist: dwave-samplers==1.5.0
 Requires-Dist: dimod==0.12.20
 Requires-Dist: numpy==2.2.4
+Requires-Dist: matplotlib
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"
 Requires-Dist: bumpver; extra == "dev"

{quapp_dwave_ocean-0.0.1.dev3 → quapp_dwave_ocean-0.0.1.dev4}/quapp_dwave_ocean.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ LICENSE
 README.md
 pyproject.toml
 quapp_dwave_ocean/__init__.py
+quapp_dwave_ocean/error_rules.py
 quapp_dwave_ocean.egg-info/PKG-INFO
 quapp_dwave_ocean.egg-info/SOURCES.txt
 quapp_dwave_ocean.egg-info/dependency_links.txt
@@ -28,4 +29,5 @@ quapp_dwave_ocean/model/device/d_wave_system_device.py
 quapp_dwave_ocean/model/device/quapp_d_wave_device.py
 quapp_dwave_ocean/model/provider/__init__.py
 quapp_dwave_ocean/model/provider/d_wave_system_provider.py
-quapp_dwave_ocean/model/provider/quapp_d_wave_provider.py
+quapp_dwave_ocean/model/provider/quapp_d_wave_provider.py
+tests/test_error_logging.py

{quapp_dwave_ocean-0.0.1.dev3 → quapp_dwave_ocean-0.0.1.dev4}/quapp_dwave_ocean.egg-info/requires.txt

@@ -1,9 +1,10 @@
-quapp-common==0.0.11.dev7
+quapp-common==0.0.14.dev10
 dwave-cloud-client==0.13.4
 dwave-system==1.30.0
 dwave-samplers==1.5.0
 dimod==0.12.20
 numpy==2.2.4
+matplotlib
 
 [dev]
 black

quapp_dwave_ocean-0.0.1.dev4/tests/test_error_logging.py

@@ -0,0 +1,304 @@
+#  Quapp Platform Project
+#  test_error_logging.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+"""Locks four classes of error-logging bug, all found in real provider-lib code.
+
+1. **A copied hook lost its phase.** Some devices copied ``run_circuit`` /
+   ``_on_execution`` / ``_on_analysis`` wholesale from ``Device`` but dropped the
+   ``with phase(...)`` blocks, so that lib's log had no ``phase`` field at any
+   stage. Same class of bug as ``CustomDevice._on_analysis`` in quapp-common.
+
+2. **The error was flattened into a string.** ``job_response.job_result =
+   {"error": str(exception)}`` leaves the Job Log with a bare string: no
+   category, no phase, no rootCause -- exactly what the ticket complained about.
+
+3. **The error was logged twice.** ``logger.exception()`` immediately before
+   ``build_error_job_response`` emits a second ERROR line for the same failure,
+   skewing every metric that counts job_failed.
+
+4. **A fake job_id.** ``job_logger('SomeClass')`` -- the first argument of
+   ``job_logger()`` is the **job_id**. Passing a class name there sets a fake
+   job_id and it BEATS the real one (``_inject_job_context`` only fills keys that
+   are still None), so filtering by jobId in Grafana loses every line that
+   component logged.
+
+The tests discover files inside the package, so this file works for any lib
+without hardcoding names.
+"""
+
+import ast
+import io
+import pathlib
+import re
+import tokenize
+
+import pytest
+
+REPO_ROOT = pathlib.Path(__file__).resolve().parent.parent
+
+# The first release carrying a phase for analysis/post-processing and one traceId
+# per job.
+MINIMUM_COMMON = '0.0.14.dev6'
+
+# Hooks already instrumented in quapp-common: copying one means copying its
+# phases too. _on_execution creates the job and then talks to the provider, which
+# is why it needs both -- a failed transpile and a rejected job are different
+# errors.
+INSTRUMENTED = {'_on_execution': {'COMPILATION', 'EXECUTION'},
+                '_on_analysis' : {'ANALYSIS'}}
+
+
+def package_root() -> pathlib.Path:
+    """The provider lib's package directory, inferred from the tree.
+
+    A few repos hold more than one package -- quapp-hpc also has
+    ``quapp_slurm_hpc``, which only contains ``runner.py`` for the Slurm node and
+    is not the provider lib. Pick by structural evidence (it has ``model/`` or
+    ``factory/``) rather than by name.
+    """
+    candidates = [d for d in REPO_ROOT.iterdir()
+                  if d.is_dir() and re.fullmatch(r'qu?app_\w+', d.name)
+                  and (d / '__init__.py').is_file()]
+    assert candidates, 'found no package at all'
+
+    if len(candidates) > 1:
+        providers = [d for d in candidates
+                     if (d / 'model').is_dir() or (d / 'factory').is_dir()]
+        assert len(providers) == 1, (
+            f'could not identify the provider package: '
+            f'{providers or candidates}')
+        return providers[0]
+
+    return candidates[0]
+
+
+PACKAGE = package_root()
+
+
+def code_only(path) -> str:
+    """Source with comments stripped out.
+
+    Needed because the explanatory comments *quote* the very code being banned
+    (``{"error": str(exception)}``, ``logger.exception(``). A raw scan would
+    report a false positive on the explanation itself.
+    """
+    source = path.read_text(encoding='utf-8')
+    kept = [token for token in
+            tokenize.generate_tokens(io.StringIO(source).readline)
+            if token.type != tokenize.COMMENT]
+    return tokenize.untokenize(kept)
+
+
+def phases_opened_in(source: str) -> set:
+    """The RuntimePhases opened with ``with phase(...)`` in a piece of code."""
+    tree = ast.parse(source.lstrip())
+    return {
+        argument.attr
+        for node in ast.walk(tree) if isinstance(node, ast.With)
+        for item in node.items if isinstance(item.context_expr, ast.Call)
+        if (getattr(item.context_expr.func, 'id', None)
+            or getattr(item.context_expr.func, 'attr', None)) == 'phase'
+        for argument in item.context_expr.args
+        if isinstance(argument, ast.Attribute)
+    }
+
+
+def python_files():
+    return sorted(PACKAGE.rglob('*.py'))
+
+
+# ------------------------------------------- (1) a copied hook keeps its phases
+
+def test_copied_hooks_keep_their_phases():
+    """Overriding an instrumented hook means copying its `with phase(...)` too."""
+    offenders = []
+    for path in python_files():
+        source = path.read_text(encoding='utf-8')
+        tree = ast.parse(source, filename=str(path))
+        for node in ast.walk(tree):
+            if not isinstance(node, ast.FunctionDef) \
+                    or node.name not in INSTRUMENTED:
+                continue
+            opened = phases_opened_in(ast.get_source_segment(source, node))
+            missing = INSTRUMENTED[node.name] - opened
+            if missing:
+                offenders.append(
+                        f'{path.name}::{node.name} is missing {sorted(missing)}')
+
+    assert not offenders, (
+        f'overridden hooks lost their phase: {offenders}. The original in '
+        f'quapp-common has `with phase(...)`; copying it without that leaves the '
+        f'log with no phase field.')
+
+
+def test_at_least_one_phase_is_opened_somewhere():
+    """A lib that overrides no hook needs none; one that does needs a phase."""
+    overrides = any(
+        isinstance(node, ast.FunctionDef) and node.name in INSTRUMENTED
+        for path in python_files()
+        for node in ast.walk(ast.parse(path.read_text(encoding='utf-8')))
+    )
+    if not overrides:
+        pytest.skip('lib overrides no hook; phases come from quapp-common')
+
+    opened = set()
+    for path in python_files():
+        opened |= phases_opened_in(path.read_text(encoding='utf-8'))
+    assert opened, 'hooks are overridden but no phase is opened'
+
+
+# --------------------------------- (2) no hand-rolled error string
+
+@pytest.mark.parametrize('path', python_files(), ids=lambda p: p.name)
+def test_no_hand_rolled_error_dict(path):
+    """`{"error": str(exception)}` bypasses the entire error envelope."""
+    assert '{"error": str(exception)}' not in code_only(path), (
+        f'{path.name}: flattens the error into a string, losing '
+        f'category/phase/rootCause. Use '
+        f'build_error_job_response(..., phase=..., context=...)')
+
+
+def test_error_envelope_carries_phase_and_context():
+    """Every build_error_job_response in the device needs phase= and context=."""
+    for path in python_files():
+        source = code_only(path)
+        calls = source.count('build_error_job_response(')
+        if not calls:
+            continue
+        assert source.count('phase=RuntimePhase.') >= calls, (
+            f'{path.name}: has {calls} error envelopes but is missing phase=, '
+            f'so the ErrorReport would come out with phase=None')
+        assert source.count('context=self._error_context()') >= calls, (
+            f'{path.name}: error envelope is missing context=, leaving support '
+            f'without the device/provider')
+
+
+# ------------------------------------------ (3) one error is logged once
+
+def test_no_duplicate_error_log_before_envelope():
+    """logger.exception()/logger.error() right before the envelope = 2 ERRORs."""
+    offenders = []
+    for path in python_files():
+        source = code_only(path)
+        for match in re.finditer(r'logger\.(exception|error)\(', source):
+            if 'build_error_job_response(' in source[match.end():match.end() + 400]:
+                line = source[:match.start()].count('\n') + 1
+                offenders.append(f'{path.name}:{line}')
+
+    assert not offenders, (
+        f'duplicate ERROR log before build_error_job_response at {offenders}; '
+        f'the envelope already logs once')
+
+
+# ------------------------------------------------- (4) no fake job_id
+
+@pytest.mark.parametrize('path', python_files(), ids=lambda p: p.name)
+def test_no_fake_job_logger_argument(path):
+    """`job_logger()` takes a real job_id; a component name belongs in `context`.
+
+    Two shapes of fake id are caught: a string literal (`job_logger('Provider')`)
+    and `__name__`, which quietly makes the job_id the dotted module path and
+    blows up jobId cardinality in Grafana as well as losing the real job.
+    """
+    tree = ast.parse(path.read_text(encoding='utf-8'), filename=str(path))
+
+    offenders = []
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.Call) or not node.args:
+            continue
+        if (getattr(node.func, 'id', None)
+                or getattr(node.func, 'attr', None)) != 'job_logger':
+            continue
+        first = node.args[0]
+        if isinstance(first, ast.Constant) and isinstance(first.value, str):
+            offenders.append(repr(first.value))
+        elif isinstance(first, ast.Name) and first.id == '__name__':
+            offenders.append('__name__')
+
+    assert not offenders, (
+        f'{path.name}: job_logger() got {offenders} -- those are fake job_ids. '
+        f"Use logger.bind(context='...') for the component name")
+
+
+def test_providers_bind_their_name_to_context():
+    """A provider that logs must bind its own name, so lines say where they came
+    from."""
+    providers = sorted((PACKAGE / 'model' / 'provider').glob('*.py'))
+    if not providers:
+        pytest.skip('lib has no model/provider directory')
+
+    offenders = []
+    for path in providers:
+        if path.name == '__init__.py':
+            continue
+        # code_only: several providers keep their old logging commented out, and
+        # a raw scan would flag those as if they still logged.
+        source = code_only(path)
+        if 'logger' not in source:
+            continue
+        if not re.search(r"logger\.bind\(context='[A-Za-z]+'\)", source):
+            offenders.append(path.name)
+
+    assert not offenders, (
+        f'providers that log without binding context: {offenders}. The component '
+        f'name must be a field, not text inside the message, or Grafana cannot '
+        f'filter on it')
+
+
+# ------------------------------------------ rules + the quapp-common pin
+
+def test_error_rules_module_exists():
+    assert (PACKAGE / 'error_rules.py').is_file(), \
+        "no error_rules.py, so this SDK's errors never get classified"
+
+
+def test_error_rules_are_registered_on_import():
+    init = (PACKAGE / '__init__.py').read_text(encoding='utf-8')
+    assert 'error_rules' in init, \
+        '__init__.py does not import error_rules, so the rules never register'
+
+
+def test_error_rules_imports_no_vendor_sdk():
+    """The classifier has to run even with the SDK absent, hence name matching."""
+    tree = ast.parse((PACKAGE / 'error_rules.py').read_text(encoding='utf-8'))
+
+    roots = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            roots.update(alias.name.split('.')[0] for alias in node.names)
+        elif isinstance(node, ast.ImportFrom) and node.module and not node.level:
+            roots.add(node.module.split('.')[0])
+
+    assert roots <= {'quapp_common'}, \
+        f'error_rules.py may only import quapp_common, but imports: {sorted(roots)}'
+
+
+def test_common_pin_is_exact_and_current():
+    version = pytest.importorskip('packaging.version')
+
+    text = (REPO_ROOT / 'pyproject.toml').read_text(encoding='utf-8')
+    assert not re.findall(r'"quapp-common\s*(>=|>|~=)', text), (
+        'quapp-common must be pinned with `==`: `>=` lets pip pick a higher '
+        'stable release that is missing the feature (which already happened '
+        'with quapp-qiskit 1.0.14)')
+
+    match = re.search(r'"quapp-common\s*==\s*([^"]+)"', text)
+    assert match, 'no quapp-common pin found'
+    assert version.Version(match.group(1)) >= version.Version(MINIMUM_COMMON), (
+        f'pin {match.group(1)} < {MINIMUM_COMMON}: that release has no phase for '
+        f'analysis/post-processing and still splits one job into two traceIds')
+
+
+def test_registered_rules_are_reachable():
+    """Runs for real: import the lib and read the registry. Skips without the SDK."""
+    package_name = PACKAGE.name
+    pytest.importorskip(package_name)
+    __import__(package_name)
+    from quapp_common.util.error_classifier import registered_rules
+
+    codes = {rule.code for rule in registered_rules()}
+    own = {code for code in codes if not code.startswith(
+            ('INPUT_', 'DEPENDENCY_', 'PROVIDER_', 'HANDLER_', 'PLATFORM_',
+             'COMPILATION_', 'EXECUTION_', 'ANALYSIS_', 'POST_'))}
+    assert own, f'no lib-specific rule registered, only generic ones: {sorted(codes)}'

quapp_dwave_ocean-0.0.1.dev3/quapp_dwave_ocean/__init__.py

@@ -1,3 +0,0 @@
-__version__ = "0.4.9"
-
-from .factory.d_wave_handler_factory import DWaveHandlerFactory