quapp-merlin 0.0.1.dev1__tar.gz → 0.0.1.dev2__tar.gz

{quapp_merlin-0.0.1.dev1/quapp_merlin.egg-info → quapp_merlin-0.0.1.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-merlin
-Version: 0.0.1.dev1
+Version: 0.0.1.dev2
 Summary: Quapp common library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)

{quapp_merlin-0.0.1.dev1 → quapp_merlin-0.0.1.dev2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quapp-merlin"
-version = "0.0.1.dev1"
+version = "0.0.1.dev2"
 description = "Quapp common library supporting Quapp Platform for Quantum Computing"
 readme = "README.md"
 authors = [{ name = "CITYNOW Co. Ltd. ", email = "corp@citynow.vn" }]

{quapp_merlin-0.0.1.dev1 → quapp_merlin-0.0.1.dev2}/quapp_merlin/model/device/merlin_device.py

@@ -110,6 +110,40 @@ class MerlinDevice(CustomDevice, ABC):
 
     # ------------------------------------------------------------- helpers
 
+    # A MeasurementStrategy keeps its kind in `.type`, a MeasurementKind enum
+    # (PROBABILITIES / MODE_EXPECTATIONS / AMPLITUDES / PARTIAL). It has no
+    # `.name` of its own -- the first version of this read
+    # type(strategy).__name__ instead, which is always 'MeasurementStrategy',
+    # so nothing ever matched 'probs' and no job ever produced a histogram.
+    MEASUREMENT_KINDS = {'PROBABILITIES'     : 'probs',
+                         'MODE_EXPECTATIONS' : 'mode_expectations',
+                         'AMPLITUDES'        : 'amplitudes',
+                         'PARTIAL'           : 'partial'}
+
+    def _measurement_name(self, model) -> str | None:
+        """Which measurement the quantum layer uses, as a short string.
+
+        Only used to decide whether a histogram makes sense, so anything
+        unrecognised degrades to None rather than raising.
+        """
+        modules = model.modules() if hasattr(model, 'modules') else [model]
+
+        for module in modules:
+            strategy = getattr(module, 'measurement_strategy', None)
+            if strategy is None:
+                continue
+
+            kind = getattr(strategy, 'type', None)
+            name = (getattr(kind, 'name', None) or getattr(kind, 'value', None)
+                    or kind)
+            if name is None:
+                return None
+
+            name = str(name).upper()
+            return self.MEASUREMENT_KINDS.get(name, name.lower())
+
+        return None
+
     def _histogram_from(self, output, shots, batch_size, measurement) -> dict | None:
         """Bin a single-row probability output into a state -> count histogram.
 

{quapp_merlin-0.0.1.dev1 → quapp_merlin-0.0.1.dev2}/quapp_merlin/model/device/merlin_local_device.py

@@ -174,22 +174,3 @@ class MerlinLocalDevice(MerlinDevice):
 
         return output, {'epochs': epochs, 'loss': tensors.plain(history),
                         'final_loss': history[-1] if history else None}
-
-    @staticmethod
-    def _measurement_name(model) -> str | None:
-        """Which MeasurementStrategy the quantum layer uses, as a short string.
-
-        Only used to decide whether a histogram makes sense, so an unknown shape
-        degrades to None instead of raising.
-        """
-        for module in (model.modules() if hasattr(model, 'modules') else [model]):
-            strategy = getattr(module, 'measurement_strategy', None)
-            if strategy is None:
-                continue
-            name = getattr(strategy, 'name', None) or type(strategy).__name__
-            name = str(name).lower()
-            for known in ('probs', 'probabilit', 'expectation', 'amplitude'):
-                if known in name:
-                    return 'probs' if known.startswith('prob') else known
-            return name
-        return None

{quapp_merlin-0.0.1.dev1 → quapp_merlin-0.0.1.dev2}/quapp_merlin/model/device/merlin_remote_device.py

@@ -29,8 +29,7 @@ from quapp_common.model.provider.provider import Provider
 
 from .merlin_device import MerlinDevice
 from ...util import tensors
-from ...util.single_machine import (DEFAULT_MAX_BATCH, batch_size_of,
-                                    quantum_leaves, reject_foreign_backend,
+from ...util.single_machine import (DEFAULT_MAX_BATCH, reject_foreign_backend,
                                     require_batch_fits, require_single_leaf)
 
 # How long we are willing to hold the invocation open waiting for the cloud.
@@ -148,17 +147,3 @@ class MerlinRemoteDevice(MerlinDevice):
             return ','.join(str(job_id) for job_id in job_ids)
 
         return str(job_ids[0])
-
-    @staticmethod
-    def _measurement_name(model) -> str | None:
-        leaves = quantum_leaves(model)
-        for _, leaf in leaves:
-            strategy = getattr(leaf, 'measurement_strategy', None)
-            if strategy is None:
-                continue
-            name = str(getattr(strategy, 'name', None)
-                       or type(strategy).__name__).lower()
-            if name.startswith('prob') or 'probabilit' in name:
-                return 'probs'
-            return name
-        return None

{quapp_merlin-0.0.1.dev1 → quapp_merlin-0.0.1.dev2/quapp_merlin.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quapp-merlin
-Version: 0.0.1.dev1
+Version: 0.0.1.dev2
 Summary: Quapp common library supporting Quapp Platform for Quantum Computing
 Author-email: "CITYNOW Co. Ltd. " <corp@citynow.vn>
 License: The MIT License (MIT)

{quapp_merlin-0.0.1.dev1 → quapp_merlin-0.0.1.dev2}/quapp_merlin.egg-info/SOURCES.txt

@@ -34,5 +34,6 @@ tests/test_error_logging.py
 tests/test_error_rules.py
 tests/test_job_spec.py
 tests/test_lazy_sdk_imports.py
+tests/test_measurement_kind.py
 tests/test_single_machine.py
 tests/test_tensors.py

quapp_merlin-0.0.1.dev2/tests/test_measurement_kind.py

@@ -0,0 +1,114 @@
+#  Quapp Platform Project
+#  test_measurement_kind.py
+#  Copyright © CITYNOW Co. Ltd. All rights reserved.
+
+"""Reading the measurement kind off a MerLin strategy.
+
+This decides whether a job gets a histogram, and the first version got it
+wrong in a way nothing would have noticed: MeasurementStrategy has no `.name`,
+so `type(strategy).__name__` was read instead -- always the string
+'MeasurementStrategy' -- nothing ever matched 'probs', and `_histogram_from`
+returned None for every job ever run.
+
+The stand-ins mirror merlinquantum 0.4.1 exactly: `MeasurementStrategy.type` is
+a `MeasurementKind` enum whose members are PROBABILITIES, MODE_EXPECTATIONS,
+AMPLITUDES and PARTIAL (merlin/measurement/strategies.py:244).
+"""
+
+import enum
+
+import pytest
+
+from quapp_merlin.model.device.merlin_device import MerlinDevice
+
+
+class MeasurementKind(enum.Enum):
+    PROBABILITIES = 'PROBABILITIES'
+    MODE_EXPECTATIONS = 'MODE_EXPECTATIONS'
+    AMPLITUDES = 'AMPLITUDES'
+    PARTIAL = 'PARTIAL'
+
+
+class MeasurementStrategy:
+    """No `.name` -- exactly like the real one. The kind lives in `.type`."""
+
+    def __init__(self, kind):
+        self.type = kind
+
+
+class Module:
+    def __init__(self, children=None, **attributes):
+        self._children = children or {}
+        self.__dict__.update(attributes)
+
+    def modules(self):
+        yield self
+        for child in self._children.values():
+            yield from child.modules()
+
+
+def read(model):
+    """_measurement_name does not touch instance state, so call it unbound."""
+    return MerlinDevice._measurement_name(MerlinDevice, model)
+
+
+@pytest.mark.parametrize('kind, expected', [
+    (MeasurementKind.PROBABILITIES, 'probs'),
+    (MeasurementKind.MODE_EXPECTATIONS, 'mode_expectations'),
+    (MeasurementKind.AMPLITUDES, 'amplitudes'),
+    (MeasurementKind.PARTIAL, 'partial'),
+])
+def test_every_kind_is_recognised(kind, expected):
+    model = Module(measurement_strategy=MeasurementStrategy(kind))
+
+    assert read(model) == expected
+
+
+def test_probabilities_is_what_enables_a_histogram():
+    """The whole point: 'probs' is the only value _histogram_from accepts."""
+    model = Module(measurement_strategy=MeasurementStrategy(
+            MeasurementKind.PROBABILITIES))
+
+    assert read(model) == 'probs'
+
+
+def test_the_strategy_is_found_on_a_nested_layer():
+    """simple() returns a SimpleSequential wrapper; the strategy sits on the
+    QuantumLayer inside it."""
+    layer = Module(measurement_strategy=MeasurementStrategy(
+            MeasurementKind.PROBABILITIES))
+    model = Module(children={'quantum_layer': layer})
+
+    assert read(model) == 'probs'
+
+
+def test_class_name_is_never_used_as_the_kind():
+    """The regression: reading type(strategy).__name__ gave
+    'measurementstrategy', which matches no kind and silently killed the
+    histogram."""
+    model = Module(measurement_strategy=MeasurementStrategy(
+            MeasurementKind.PROBABILITIES))
+
+    assert read(model) != 'measurementstrategy'
+
+
+def test_no_strategy_at_all():
+    assert read(Module()) is None
+
+
+def test_unknown_kind_degrades_instead_of_raising():
+    class Odd(enum.Enum):
+        SOMETHING_NEW = 'SOMETHING_NEW'
+
+    model = Module(measurement_strategy=MeasurementStrategy(Odd.SOMETHING_NEW))
+
+    assert read(model) == 'something_new'
+
+
+def test_a_bare_module_without_modules_still_works():
+    """A handler may return the layer itself rather than a wrapper."""
+
+    class Bare:
+        measurement_strategy = MeasurementStrategy(MeasurementKind.AMPLITUDES)
+
+    assert read(Bare()) == 'amplitudes'