sinter 1.12.dev1690241034__tar.gz → 1.12.dev1690946907__tar.gz

{sinter-1.12.dev1690241034 → sinter-1.12.dev1690946907}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sinter
-Version: 1.12.dev1690241034
+Version: 1.12.dev1690946907
 Summary: Samples stim circuits and decodes them using pymatching.
 Author: Craig Gidney
 Author-email: craig.gidney@gmail.com

{sinter-1.12.dev1690241034 → sinter-1.12.dev1690946907}/setup.py

@@ -17,9 +17,9 @@ from setuptools import setup
 with open('README.md', encoding='UTF-8') as f:
     long_description = f.read()
 with open('requirements.txt', encoding='UTF-8') as f:
-    requirements = [line.split()[0] for line in f.read().splitlines()]
+    requirements = f.read().splitlines()
 
-__version__ = '1.12.dev1690241034'
+__version__ = '1.12.dev1690946907'
 
 setup(
     name='sinter',
@@ -35,7 +35,7 @@ setup(
     python_requires='>=3.7.0',
     data_files=['README.md', 'requirements.txt', 'readme_example_plot.png'],
     install_requires=requirements,
-    tests_require=['pytest'],
+    tests_require=['pytest', 'pymatching'],
     entry_points={
         'console_scripts': ['sinter=sinter._main:main'],
     },

{sinter-1.12.dev1690241034 → sinter-1.12.dev1690946907}/src/sinter/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '1.12.dev1690241034'
+__version__ = '1.12.dev1690946907'
 
 from sinter._anon_task_stats import (
     AnonTaskStats,

{sinter-1.12.dev1690241034 → sinter-1.12.dev1690946907}/src/sinter/_decoding_all_built_in_decoders.py

@@ -2,7 +2,6 @@ from typing import Dict
 
 from sinter._decoding_decoder_class import Decoder
 from sinter._decoding_fusion_blossom import FusionBlossomDecoder
-from sinter._decoding_internal import InternalDecoder
 from sinter._decoding_pymatching import PyMatchingDecoder
 from sinter._decoding_vacuous import VacuousDecoder
 
@@ -10,8 +9,4 @@ BUILT_IN_DECODERS: Dict[str, Decoder] = {
     'vacuous': VacuousDecoder(),
     'pymatching': PyMatchingDecoder(),
     'fusion_blossom': FusionBlossomDecoder(),
-    'internal': InternalDecoder('internal'),
-    'internal_correlated': InternalDecoder('internal_correlated'),
-    'internal_2': InternalDecoder('internal_2'),
-    'internal_correlated_2': InternalDecoder('internal_correlated_2'),
 }

{sinter-1.12.dev1690241034 → sinter-1.12.dev1690946907}/src/sinter/_decoding_test.py

@@ -1,6 +1,8 @@
+import os
+
 import pathlib
 import tempfile
-from typing import Optional
+from typing import Dict, List, Optional, Tuple
 
 import numpy as np
 import pytest
@@ -11,28 +13,44 @@ import stim
 from sinter._collection import post_selection_mask_from_4th_coord
 from sinter._decoding import sample_decode
 from sinter._decoding_all_built_in_decoders import BUILT_IN_DECODERS
-
-_DECODER_KEY_AND_PACKAGE = [
-    ('vacuous', 'sinter'),
-    ('pymatching', 'pymatching'),
-    ('fusion_blossom', 'fusion_blossom'),
-    ('internal', 'gqec'),
-    ('internal_correlated', 'gqec'),
-    ('internal_2', 'gqec'),
-    ('internal_correlated_2', 'gqec'),
-]
+from sinter._decoding_vacuous import VacuousDecoder
+
+
+def get_test_decoders() -> Tuple[List[str], Dict[str, sinter.Decoder]]:
+    available_decoders = list(BUILT_IN_DECODERS.keys())
+    custom_decoders = {}
+    try:
+        import pymatching
+    except ImportError:
+        available_decoders.remove('pymatching')
+    try:
+        import fusion_blossom
+    except ImportError:
+        available_decoders.remove('fusion_blossom')
+
+    e = os.environ.get('SINTER_PYTEST_CUSTOM_DECODERS')
+    if e is not None:
+        for term in e.split(';'):
+            module, method = term.split(':')
+            for name, obj in getattr(__import__(module), method)().items():
+                custom_decoders[name] = obj
+                available_decoders.append(name)
+
+    available_decoders.append("also_vacuous")
+    custom_decoders["also_vacuous"] = VacuousDecoder()
+    return available_decoders, custom_decoders
+
+TEST_DECODER_NAMES, TEST_CUSTOM_DECODERS = get_test_decoders()
 
 DECODER_CASES = [
-    (a, b, c)
-    for a, b in _DECODER_KEY_AND_PACKAGE
-    for c in [None, True]
+    (decoder, force_streaming)
+    for decoder in TEST_DECODER_NAMES
+    for force_streaming in [None, True]
 ]
 
 
-@pytest.mark.parametrize('decoder,required_import,force_streaming', DECODER_CASES)
-def test_decode_repetition_code(decoder: str, required_import: str, force_streaming: Optional[bool]):
-    pytest.importorskip(required_import)
-
+@pytest.mark.parametrize('decoder,force_streaming', DECODER_CASES)
+def test_decode_repetition_code(decoder: str, force_streaming: Optional[bool]):
     circuit = stim.Circuit.generated('repetition_code:memory',
                                      rounds=3,
                                      distance=3,
@@ -44,17 +62,17 @@ def test_decode_repetition_code(decoder: str, required_import: str, force_stream
         dem_path=None,
         num_shots=1000,
         decoder=decoder,
+        __private__unstable__force_decode_on_disk=force_streaming,
+        custom_decoders=TEST_CUSTOM_DECODERS,
     )
     assert result.discards == 0
-    if decoder != 'vacuous':
+    if 'vacuous' not in decoder:
         assert 1 <= result.errors <= 100
     assert result.shots == 1000
 
 
-@pytest.mark.parametrize('decoder,required_import,force_streaming', DECODER_CASES)
-def test_decode_surface_code(decoder: str, required_import: str, force_streaming: Optional[bool]):
-    pytest.importorskip(required_import)
-
+@pytest.mark.parametrize('decoder,force_streaming', DECODER_CASES)
+def test_decode_surface_code(decoder: str, force_streaming: Optional[bool]):
     circuit = stim.Circuit.generated(
         "surface_code:rotated_memory_x",
         distance=3,
@@ -69,14 +87,14 @@ def test_decode_surface_code(decoder: str, required_import: str, force_streaming
         dem_path=None,
         decoder=decoder,
         __private__unstable__force_decode_on_disk=force_streaming,
+        custom_decoders=TEST_CUSTOM_DECODERS,
     )
-    if decoder != 'vacuous':
+    if 'vacuous' not in decoder:
         assert 0 <= stats.errors <= 50
 
 
-@pytest.mark.parametrize('decoder,required_import,force_streaming', DECODER_CASES)
-def test_empty(decoder: str, required_import: str, force_streaming: Optional[bool]):
-    pytest.importorskip(required_import)
+@pytest.mark.parametrize('decoder,force_streaming', DECODER_CASES)
+def test_empty(decoder: str, force_streaming: Optional[bool]):
     circuit = stim.Circuit()
     result = sample_decode(
         circuit_obj=circuit,
@@ -86,15 +104,15 @@ def test_empty(decoder: str, required_import: str, force_streaming: Optional[boo
         num_shots=1000,
         decoder=decoder,
         __private__unstable__force_decode_on_disk=force_streaming,
+        custom_decoders=TEST_CUSTOM_DECODERS,
     )
     assert result.discards == 0
     assert result.shots == 1000
     assert result.errors == 0
 
 
-@pytest.mark.parametrize('decoder,required_import,force_streaming', DECODER_CASES)
-def test_no_observables(decoder: str, required_import: str, force_streaming: Optional[bool]):
-    pytest.importorskip(required_import)
+@pytest.mark.parametrize('decoder,force_streaming', DECODER_CASES)
+def test_no_observables(decoder: str, force_streaming: Optional[bool]):
     circuit = stim.Circuit("""
         X_ERROR(0.1) 0
         M 0
@@ -108,15 +126,15 @@ def test_no_observables(decoder: str, required_import: str, force_streaming: Opt
         num_shots=1000,
         decoder=decoder,
         __private__unstable__force_decode_on_disk=force_streaming,
+        custom_decoders=TEST_CUSTOM_DECODERS,
     )
     assert result.discards == 0
     assert result.shots == 1000
     assert result.errors == 0
 
 
-@pytest.mark.parametrize('decoder,required_import,force_streaming', DECODER_CASES)
-def test_invincible_observables(decoder: str, required_import: str, force_streaming: Optional[bool]):
-    pytest.importorskip(required_import)
+@pytest.mark.parametrize('decoder,force_streaming', DECODER_CASES)
+def test_invincible_observables(decoder: str, force_streaming: Optional[bool]):
     circuit = stim.Circuit("""
         X_ERROR(0.1) 0
         M 0 1
@@ -131,15 +149,15 @@ def test_invincible_observables(decoder: str, required_import: str, force_stream
         num_shots=1000,
         decoder=decoder,
         __private__unstable__force_decode_on_disk=force_streaming,
+        custom_decoders=TEST_CUSTOM_DECODERS,
     )
     assert result.discards == 0
     assert result.shots == 1000
     assert result.errors == 0
 
 
-@pytest.mark.parametrize('decoder,required_import,force_streaming,offset', [(a, b, c, d) for a, b, c in DECODER_CASES for d in range(8)])
-def test_observable_offsets_mod8(decoder: str, required_import: str, force_streaming: bool, offset: int):
-    pytest.importorskip(required_import)
+@pytest.mark.parametrize('decoder,force_streaming,offset', [(a, b, c) for a, b in DECODER_CASES for c in range(8)])
+def test_observable_offsets_mod8(decoder: str, force_streaming: bool, offset: int):
     circuit = stim.Circuit("""
         X_ERROR(0.1) 0
         MR 0
@@ -157,15 +175,15 @@ def test_observable_offsets_mod8(decoder: str, required_import: str, force_strea
         num_shots=1000,
         decoder=decoder,
         __private__unstable__force_decode_on_disk=force_streaming,
+        custom_decoders=TEST_CUSTOM_DECODERS,
     )
     assert result.discards == 0
     assert result.shots == 1000
     assert 50 <= result.errors <= 150
 
 
-@pytest.mark.parametrize('decoder,required_import,force_streaming', DECODER_CASES)
-def test_no_detectors(decoder: str, required_import: str, force_streaming: Optional[bool]):
-    pytest.importorskip(required_import)
+@pytest.mark.parametrize('decoder,force_streaming', DECODER_CASES)
+def test_no_detectors(decoder: str, force_streaming: Optional[bool]):
     circuit = stim.Circuit("""
         X_ERROR(0.1) 0
         M 0
@@ -179,14 +197,14 @@ def test_no_detectors(decoder: str, required_import: str, force_streaming: Optio
         num_shots=1000,
         decoder=decoder,
         __private__unstable__force_decode_on_disk=force_streaming,
+        custom_decoders=TEST_CUSTOM_DECODERS,
     )
     assert result.discards == 0
     assert 50 <= result.errors <= 150
 
 
-@pytest.mark.parametrize('decoder,required_import,force_streaming', DECODER_CASES)
-def test_no_detectors_with_post_mask(decoder: str, required_import: str, force_streaming: Optional[bool]):
-    pytest.importorskip(required_import)
+@pytest.mark.parametrize('decoder,force_streaming', DECODER_CASES)
+def test_no_detectors_with_post_mask(decoder: str, force_streaming: Optional[bool]):
     circuit = stim.Circuit("""
         X_ERROR(0.1) 0
         M 0
@@ -201,14 +219,14 @@ def test_no_detectors_with_post_mask(decoder: str, required_import: str, force_s
         num_shots=1000,
         decoder=decoder,
         __private__unstable__force_decode_on_disk=force_streaming,
+        custom_decoders=TEST_CUSTOM_DECODERS,
     )
     assert result.discards == 0
     assert 50 <= result.errors <= 150
 
 
-@pytest.mark.parametrize('decoder,required_import,force_streaming', DECODER_CASES)
-def test_post_selection(decoder: str, required_import: str, force_streaming: Optional[bool]):
-    pytest.importorskip(required_import)
+@pytest.mark.parametrize('decoder,force_streaming', DECODER_CASES)
+def test_post_selection(decoder: str, force_streaming: Optional[bool]):
     circuit = stim.Circuit("""
         X_ERROR(0.6) 0
         M 0
@@ -233,15 +251,15 @@ def test_post_selection(decoder: str, required_import: str, force_streaming: Opt
         num_shots=2000,
         decoder=decoder,
         __private__unstable__force_decode_on_disk=force_streaming,
+        custom_decoders=TEST_CUSTOM_DECODERS,
     )
     assert 1050 <= result.discards <= 1350
-    if decoder != 'vacuous':
+    if 'vacuous' not in decoder:
         assert 40 <= result.errors <= 160
 
 
-@pytest.mark.parametrize('decoder,required_import,force_streaming', DECODER_CASES)
-def test_observable_post_selection(decoder: str, required_import: str, force_streaming: Optional[bool]):
-    pytest.importorskip(required_import)
+@pytest.mark.parametrize('decoder,force_streaming', DECODER_CASES)
+def test_observable_post_selection(decoder: str, force_streaming: Optional[bool]):
     circuit = stim.Circuit("""
         X_ERROR(0.1) 0
         X_ERROR(0.2) 1
@@ -259,15 +277,15 @@ def test_observable_post_selection(decoder: str, required_import: str, force_str
         num_shots=10000,
         decoder=decoder,
         __private__unstable__force_decode_on_disk=force_streaming,
+        custom_decoders=TEST_CUSTOM_DECODERS,
     )
     np.testing.assert_allclose(result.discards / result.shots, 0.2, atol=0.1)
-    if decoder != 'vacuous':
+    if 'vacuous' not in decoder:
         np.testing.assert_allclose(result.errors / (result.shots - result.discards), 0.1, atol=0.05)
 
 
-@pytest.mark.parametrize('decoder,required_import,force_streaming', DECODER_CASES)
-def test_error_splitting(decoder: str, required_import: str, force_streaming: Optional[bool]):
-    pytest.importorskip(required_import)
+@pytest.mark.parametrize('decoder,force_streaming', DECODER_CASES)
+def test_error_splitting(decoder: str, force_streaming: Optional[bool]):
     circuit = stim.Circuit("""
         X_ERROR(0.1) 0
         X_ERROR(0.2) 1
@@ -285,19 +303,19 @@ def test_error_splitting(decoder: str, required_import: str, force_streaming: Op
         decoder=decoder,
         count_observable_error_combos=True,
         __private__unstable__force_decode_on_disk=force_streaming,
+        custom_decoders=TEST_CUSTOM_DECODERS,
     )
     assert result.discards == 0
     assert set(result.custom_counts.keys()) == {'obs_mistake_mask=E_', 'obs_mistake_mask=_E', 'obs_mistake_mask=EE'}
-    if decoder != 'vacuous':
+    if 'vacuous' not in decoder:
         np.testing.assert_allclose(result.errors / result.shots, 1 - 0.8 * 0.9, atol=0.05)
         np.testing.assert_allclose(result.custom_counts['obs_mistake_mask=E_'] / result.shots, 0.1 * 0.2, atol=0.05)
         np.testing.assert_allclose(result.custom_counts['obs_mistake_mask=_E'] / result.shots, 0.1 * 0.8, atol=0.05)
         np.testing.assert_allclose(result.custom_counts['obs_mistake_mask=EE'] / result.shots, 0.9 * 0.2, atol=0.05)
 
 
-@pytest.mark.parametrize('decoder,required_import,force_streaming', DECODER_CASES)
-def test_detector_counting(decoder: str, required_import: str, force_streaming: Optional[bool]):
-    pytest.importorskip(required_import)
+@pytest.mark.parametrize('decoder,force_streaming', DECODER_CASES)
+def test_detector_counting(decoder: str, force_streaming: Optional[bool]):
     circuit = stim.Circuit("""
         X_ERROR(0.1) 0
         X_ERROR(0.2) 1
@@ -317,6 +335,7 @@ def test_detector_counting(decoder: str, required_import: str, force_streaming:
         decoder=decoder,
         count_detection_events=True,
         __private__unstable__force_decode_on_disk=force_streaming,
+        custom_decoders=TEST_CUSTOM_DECODERS,
     )
     assert result.discards == 0
     assert result.custom_counts['detectors_checked'] == 20000
@@ -324,10 +343,8 @@ def test_detector_counting(decoder: str, required_import: str, force_streaming:
     assert set(result.custom_counts.keys()) == {'detectors_checked', 'detection_events'}
 
 
-@pytest.mark.parametrize('decoder,required_import,force_streaming', DECODER_CASES)
-def test_decode_fails_correctly(decoder: str, required_import: str, force_streaming: Optional[bool]):
-    pytest.importorskip(required_import)
-
+@pytest.mark.parametrize('decoder,force_streaming', DECODER_CASES)
+def test_decode_fails_correctly(decoder: str, force_streaming: Optional[bool]):
     decoder_obj = BUILT_IN_DECODERS.get(decoder)
     with tempfile.TemporaryDirectory() as d:
         d = pathlib.Path(d)
@@ -344,7 +361,7 @@ def test_decode_fails_correctly(decoder: str, required_import: str, force_stream
         with open(d / 'bad_dets.b8', 'wb') as f:
             f.write(b'!')
 
-        if decoder != 'vacuous':
+        if 'vacuous' not in decoder:
             with pytest.raises(Exception):
                 decoder_obj.decode_via_files(
                     num_shots=1,
@@ -357,14 +374,14 @@ def test_decode_fails_correctly(decoder: str, required_import: str, force_stream
                 )
 
 
-@pytest.mark.parametrize('decoder,required_import,force_streaming', DECODER_CASES)
-def test_full_scale(decoder: str, required_import: str, force_streaming: Optional[bool]):
-    pytest.importorskip(required_import)
+@pytest.mark.parametrize('decoder', TEST_DECODER_NAMES)
+def test_full_scale(decoder: str):
     result, = sinter.collect(
         num_workers=2,
         tasks=[sinter.Task(circuit=stim.Circuit())],
         decoders=[decoder],
         max_shots=1000,
+        custom_decoders=TEST_CUSTOM_DECODERS,
     )
     assert result.discards == 0
     assert result.shots == 1000

{sinter-1.12.dev1690241034 → sinter-1.12.dev1690946907}/src/sinter.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sinter
-Version: 1.12.dev1690241034
+Version: 1.12.dev1690946907
 Summary: Samples stim circuits and decodes them using pymatching.
 Author: Craig Gidney
 Author-email: craig.gidney@gmail.com

{sinter-1.12.dev1690241034 → sinter-1.12.dev1690946907}/src/sinter.egg-info/SOURCES.txt

@@ -16,7 +16,6 @@ src/sinter/_decoding.py
 src/sinter/_decoding_all_built_in_decoders.py
 src/sinter/_decoding_decoder_class.py
 src/sinter/_decoding_fusion_blossom.py
-src/sinter/_decoding_internal.py
 src/sinter/_decoding_pymatching.py
 src/sinter/_decoding_test.py
 src/sinter/_decoding_vacuous.py

sinter-1.12.dev1690946907/src/sinter.egg-info/requires.txt

@@ -0,0 +1,4 @@
+matplotlib~=3.5
+numpy~=1.22
+stim~=1.9
+scipy~=1.9

sinter-1.12.dev1690241034/src/sinter/_decoding_internal.py

@@ -1,49 +0,0 @@
-import pathlib
-
-from sinter._decoding_decoder_class import Decoder, CompiledDecoder
-
-
-class InternalDecoder(Decoder):
-    """Use internal decoders to predict observables from detection events."""
-
-    def __init__(self, name: str):
-        self.name = name
-
-    def compile_decoder_for_dem(self, *, dem: 'stim.DetectorErrorModel') -> CompiledDecoder:
-        try:
-            import gqec  # Internal python wheel.
-        except ImportError as ex:
-            raise ImportError(
-                "The decoder 'internal*' isn't installed.\n"
-                "These decoders aren't publicly available.\n"
-            ) from ex
-
-        if not hasattr(gqec, 'compile_decoder_for_sinter'):
-            raise NotImplementedError()
-        return gqec.compile_decoder_for_sinter(dem)
-
-    def decode_via_files(self,
-                         *,
-                         num_shots: int,
-                         num_dets: int,
-                         num_obs: int,
-                         dem_path: pathlib.Path,
-                         dets_b8_in_path: pathlib.Path,
-                         obs_predictions_b8_out_path: pathlib.Path,
-                         tmp_dir: pathlib.Path,
-                       ) -> None:
-
-        try:
-            import gqec  # Internal python wheel.
-        except ImportError as ex:
-            raise ImportError(
-                "The decoder 'internal*' isn't installed.\n"
-                "These decoders aren't publicly available.\n"
-            ) from ex
-
-        if num_dets == 0:
-            with open(obs_predictions_b8_out_path, 'wb') as f:
-                f.write(b'\0' * (num_obs * num_shots))
-            return
-
-        gqec.run_for_sinter(str(dem_path), str(dets_b8_in_path), "b8", str(obs_predictions_b8_out_path), self.name)

sinter-1.12.dev1690241034/src/sinter.egg-info/requires.txt

@@ -1,4 +0,0 @@
-matplotlib
-numpy
-stim
-scipy