sinter 1.15.0__py3-none-any.whl

sinter/_command/_main_plot_test.py

@@ -0,0 +1,445 @@
+import contextlib
+import io
+import pathlib
+import tempfile
+
+import pytest
+from sinter._command._main import main
+from sinter._command._main_plot import _log_ticks, _sqrt_ticks
+
+
+def test_main_plot():
+    with tempfile.TemporaryDirectory() as d:
+        d = pathlib.Path(d)
+        with open(d / f'input.csv', 'w') as f:
+            print("""
+shots,errors,discards,seconds,decoder,strong_id,json_metadata
+300,1,20,1.0,pymatching,f256bab362f516ebe4d59a08ae67330ff7771ff738757cd738f4b30605ddccf6,"{""path"":""a.stim""}"
+300,100,200,2.0,pymatching,f256bab362f516ebe4d59a08ae67330ff7771ff738757cd738f4b30605ddccf6,"{""path"":""a.stim""}"
+9,5,4,6.0,pymatching,5fe5a6cd4226b1a910d57e5479d1ba6572e0b3115983c9516360916d1670000f,"{""path"":""b.stim""}"
+            """.strip(), file=f)
+
+        out = io.StringIO()
+        with contextlib.redirect_stdout(out):
+            main(command_line_args=[
+                "plot",
+                "--in",
+                str(d / "input.csv"),
+                "--out",
+                str(d / "output.png"),
+                "--x_func",
+                "int('a' in metadata['path'])",
+                "--group_func",
+                "decoder",
+                "--ymin",
+                "1e-3",
+                "--title",
+                "test_plot",
+            ])
+        assert (d / "output.png").exists()
+
+
+def test_main_plot_2():
+    with tempfile.TemporaryDirectory() as d:
+        d = pathlib.Path(d)
+        with open(d / f'input.csv', 'w') as f:
+            print("""
+shots,errors,discards,seconds,decoder,strong_id,json_metadata
+300,1,20,1.0,pymatching,f256bab362f516ebe4d59a08ae67330ff7771ff738757cd738f4b30605ddccf6,"{""path"":""a.stim""}"
+300,100,200,2.0,pymatching,f256bab362f516ebe4d59a08ae67330ff7771ff738757cd738f4b30605ddccf6,"{""path"":""a.stim""}"
+9,5,4,6.0,pymatching,5fe5a6cd4226b1a910d57e5479d1ba6572e0b3115983c9516360916d1670000f,"{""path"":""b.stim""}"
+            """.strip(), file=f)
+
+        out = io.StringIO()
+        with contextlib.redirect_stdout(out):
+            main(command_line_args=[
+                "plot",
+                "--in",
+                str(d / "input.csv"),
+                "--out",
+                str(d / "output.png"),
+                "--x_func",
+                "int('a' in metadata['path'])",
+                "--group_func",
+                "decoder",
+                "--plot_args_func",
+                "{'lw': 2, 'color': 'r' if decoder == 'never' else 'b'}",
+            ])
+        assert (d / "output.png").exists()
+
+
+def test_main_plot_failure_units():
+    with tempfile.TemporaryDirectory() as d:
+        d = pathlib.Path(d)
+        with open(d / f'input.csv', 'w') as f:
+            print("""
+shots,errors,discards,seconds,decoder,strong_id,json_metadata
+300,1,20,1.0,pymatching,f256bab362f516ebe4d59a08ae67330ff7771ff738757cd738f4b30605ddccf6,"{""r"":15,""d"":5}"
+300,100,200,2.0,pymatching,f256bab362f516ebe4d59a08ae67330ff7771ff738757cd738f4b30605ddccf7,"{""r"":9,""d"":3}"
+9,5,4,6.0,pymatching,5fe5a6cd4226b1a910d57e5479d1ba6572e0b3115983c9516360916d1670000f,"{""r"":6,""d"":2}"
+            """.strip(), file=f)
+
+        out = io.StringIO()
+        with pytest.raises(ValueError,  match="specified together"):
+            main(command_line_args=[
+                "plot",
+                "--in",
+                str(d / "input.csv"),
+                "--out",
+                str(d / "output.png"),
+                "--x_func",
+                "metadata['d']",
+                "--group_func",
+                "decoder",
+                "--failure_units_per_shot_func",
+                "metadata['r']",
+            ])
+        with pytest.raises(ValueError,  match="specified together"):
+            main(command_line_args=[
+                "plot",
+                "--in",
+                str(d / "input.csv"),
+                "--out",
+                str(d / "output.png"),
+                "--x_func",
+                "metadata['d']",
+                "--group_func",
+                "decoder",
+                "--failure_unit_name",
+                "Rounds",
+            ])
+        assert not (d / "output.png").exists()
+        with contextlib.redirect_stdout(out):
+            main(command_line_args=[
+                "plot",
+                "--in",
+                str(d / "input.csv"),
+                "--out",
+                str(d / "output.png"),
+                "--x_func",
+                "metadata['d']",
+                "--group_func",
+                "decoder",
+                "--failure_units_per_shot_func",
+                "metadata['r']",
+                "--failure_unit_name",
+                "Rounds",
+            ])
+        assert (d / "output.png").exists()
+
+
+def test_main_plot_xaxis():
+    with tempfile.TemporaryDirectory() as d:
+        d = pathlib.Path(d)
+        with open(d / f'input.csv', 'w') as f:
+            print("""
+shots,errors,discards,seconds,decoder,strong_id,json_metadata
+300,1,20,1.0,pymatching,f256bab362f516ebe4d59a08ae67330ff7771ff738757cd738f4b30605ddccf6,"{""r"":15,""d"":5}"
+300,100,200,2.0,pymatching,f256bab362f516ebe4d59a08ae67330ff7771ff738757cd738f4b30605ddccf7,"{""r"":9,""d"":3}"
+9,5,4,6.0,pymatching,5fe5a6cd4226b1a910d57e5479d1ba6572e0b3115983c9516360916d1670000f,"{""r"":6,""d"":2}"
+            """.strip(), file=f)
+
+        out = io.StringIO()
+        with contextlib.redirect_stdout(out):
+            main(command_line_args=[
+                "plot",
+                "--in",
+                str(d / "input.csv"),
+                "--out",
+                str(d / "output.png"),
+                "--x_func",
+                "metadata['d']",
+                "--xaxis",
+                "[sqrt]distance root",
+            ])
+        assert (d / "output.png").exists()
+
+        with contextlib.redirect_stdout(out):
+            main(command_line_args=[
+                "plot",
+                "--in",
+                str(d / "input.csv"),
+                "--out",
+                str(d / "output2.png"),
+                "--x_func",
+                "metadata['d']",
+                "--xaxis",
+                "[log]distance log",
+            ])
+        assert (d / "output2.png").exists()
+
+        with contextlib.redirect_stdout(out):
+            main(command_line_args=[
+                "plot",
+                "--in",
+                str(d / "input.csv"),
+                "--out",
+                str(d / "output3.png"),
+                "--x_func",
+                "metadata['d']",
+                "--xaxis",
+                "distance raw",
+            ])
+        assert (d / "output3.png").exists()
+
+
+def test_main_plot_custom_y_func():
+    with tempfile.TemporaryDirectory() as d:
+        d = pathlib.Path(d)
+        with open(d / f'input.csv', 'w') as f:
+            print("""
+shots,errors,discards,seconds,decoder,strong_id,json_metadata
+300,1,20,1.0,pymatching,f256bab362f516ebe4d59a08ae67330ff7771ff738757cd738f4b30605ddccf6,"{""r"":15,""d"":5}"
+300,100,200,2.0,pymatching,f256bab362f516ebe4d59a08ae67330ff7771ff738757cd738f4b30605ddccf7,"{""r"":9,""d"":3}"
+9,5,4,6.0,pymatching,5fe5a6cd4226b1a910d57e5479d1ba6572e0b3115983c9516360916d1670000f,"{""r"":6,""d"":2}"
+            """.strip(), file=f)
+
+        out = io.StringIO()
+        with pytest.raises(AttributeError,  match="secondsX"):
+            main(command_line_args=[
+                "plot",
+                "--in",
+                str(d / "input.csv"),
+                "--out",
+                str(d / "output.png"),
+                "--x_func",
+                "metadata['d']",
+                "--group_func",
+                "decoder",
+                "--y_func",
+                "stat.secondsX",
+                "--yaxis",
+                "test axis"
+            ])
+        assert not (d / "output.png").exists()
+        with contextlib.redirect_stdout(out):
+            main(command_line_args=[
+                "plot",
+                "--in",
+                str(d / "input.csv"),
+                "--out",
+                str(d / "output.png"),
+                "--x_func",
+                "metadata['d']",
+                "--group_func",
+                "decoder",
+                "--y_func",
+                "stat.seconds",
+                "--yaxis",
+                "test axis"
+            ])
+        assert (d / "output.png").exists()
+
+
+def test_log_ticks():
+    assert _log_ticks(12, 499) == (
+        10,
+        1000,
+        [10, 100, 1000],
+        [20, 30, 40, 50, 60, 70, 80, 90, 200, 300, 400, 500, 600, 700, 800, 900],
+    )
+
+    assert _log_ticks(1.2, 4.9) == (
+        1,
+        10,
+        [1, 10],
+        [2, 3, 4, 5, 6, 7, 8, 9],
+    )
+
+
+def test_sqrt_ticks():
+    assert _sqrt_ticks(12, 499) == (
+        0,
+        500,
+        [0, 100, 200, 300, 400, 500],
+        [10*k for k in range(51)],
+    )
+
+    assert _sqrt_ticks(105, 499) == (
+        100,
+        500,
+        [100, 200, 300, 400, 500],
+        [10*k for k in range(10, 51)],
+    )
+
+    assert _sqrt_ticks(305, 590) == (
+        300,
+        600,
+        [300, 350, 400, 450, 500, 550, 600],
+        [10*k for k in range(30, 61)],
+    )
+
+    assert _sqrt_ticks(305000, 590000) == (
+        300000,
+        600000,
+        [300000, 350000, 400000, 450000, 500000, 550000, 600000],
+        [10000*k for k in range(30, 61)],
+    )
+
+
+def test_main_plot_degenerate_data():
+    with tempfile.TemporaryDirectory() as d:
+        d = pathlib.Path(d)
+        with open(d / f'input.csv', 'w') as f:
+            print("""
+                shots,errors,discards,seconds,decoder,strong_id,json_metadata
+                  100,     0,       0,   1.00,magical,000000000,"{}"
+            """.strip(), file=f)
+
+        main(command_line_args=[
+            "plot",
+            "--in",
+            str(d / "input.csv"),
+            "--out",
+            str(d / "output.png"),
+        ])
+        assert (d / "output.png").exists()
+
+
+def test_main_plot_degenerate_data_sqrt_axis():
+    with tempfile.TemporaryDirectory() as d:
+        d = pathlib.Path(d)
+        with open(d / f'input.csv', 'w') as f:
+            print("""
+                shots,errors,discards,seconds,decoder,strong_id,json_metadata
+                  100,     0,       0,   1.00,magical,000000000,"{}"
+            """.strip(), file=f)
+
+        main(command_line_args=[
+            "plot",
+            "--in",
+            str(d / "input.csv"),
+            "--out",
+            str(d / "output.png"),
+            "--xaxis",
+            "[sqrt]x",
+        ])
+        assert (d / "output.png").exists()
+
+
+def test_failure_values_func():
+    with tempfile.TemporaryDirectory() as d:
+        d = pathlib.Path(d)
+        with open(d / f'input.csv', 'w') as f:
+            print("""
+                shots,errors,discards,seconds,decoder,strong_id,json_metadata
+                 1000,   400,       0,   1.00,magical,000000001,"{""f"":1}"
+                 1000,   400,       0,   1.00,magical,000000002,"{""f"":2}"
+                 1000,   400,       0,   1.00,magical,000000003,"{""f"":3}"
+                 1000,   400,       0,   1.00,magical,000000005,"{""f"":5}"
+            """.strip(), file=f)
+
+        main(command_line_args=[
+            "plot",
+            "--in",
+            str(d / "input.csv"),
+            "--out",
+            str(d / "output.png"),
+            "--xaxis",
+            "values",
+            "--x_func",
+            "metadata['f']",
+            "--subtitle",
+            "test",
+            "--failure_values_func",
+            "metadata['f']",
+            "--failure_units_per_shot_func",
+            "100",
+            "--failure_unit_name",
+            "rounds",
+        ])
+        assert (d / "output.png").exists()
+
+
+def test_m_fields():
+    with tempfile.TemporaryDirectory() as d:
+        d = pathlib.Path(d)
+        with open(d / f'input.csv', 'w') as f:
+            print("""
+                shots,errors,discards,seconds,decoder,strong_id,json_metadata
+                 1000,   400,       0,   1.00,magical,000000001,"{""f"":1}"
+                 1000,   400,       0,   1.00,magical,000000002,"{""f"":2}"
+                 1000,   400,       0,   1.00,magical,000000003,"{""f"":3}"
+                 1000,   400,       0,   1.00,magical,000000005,"{""f"":5}"
+            """.strip(), file=f)
+
+        main(command_line_args=[
+            "plot",
+            "--in",
+            str(d / "input.csv"),
+            "--out",
+            str(d / "output.png"),
+            "--xaxis",
+            "values",
+            "--x_func",
+            "m.f",
+            "--group_func",
+            "m.g",
+            "--subtitle",
+            "test",
+        ])
+        assert (d / "output.png").exists()
+
+
+def test_split_custom_counts():
+    with tempfile.TemporaryDirectory() as d:
+        d = pathlib.Path(d)
+        with open(d / f'input.csv', 'w') as f:
+            print("""
+                shots,errors,discards,seconds,decoder,strong_id,json_metadata,custom_counts
+                 1000,   400,       0,   1.00,magical,000000001,"{""f"":1}",
+                 1000,   400,       0,   1.00,magical,000000002,"{""f"":2}","{""a"":3}"
+                 1000,   400,       0,   1.00,magical,000000003,"{""f"":3}","{""b"":3,""c"":4}"
+                 1000,   400,       0,   1.00,magical,000000005,"{""f"":5}",
+            """.strip(), file=f)
+
+        main(command_line_args=[
+            "plot",
+            "--in",
+            str(d / "input.csv"),
+            "--out",
+            str(d / "output.png"),
+            "--xaxis",
+            "values",
+            "--x_func",
+            "m.f",
+            "--group_func",
+            "m.g",
+            "--subtitle",
+            "test",
+            "--custom_error_count_keys",
+            "a",
+            "b",
+        ])
+        assert (d / "output.png").exists()
+
+
+def test_line_fits():
+    with tempfile.TemporaryDirectory() as d:
+        d = pathlib.Path(d)
+        with open(d / f'input.csv', 'w') as f:
+            print("""
+                shots,errors,discards,seconds,decoder,strong_id,json_metadata,custom_counts
+                 1000,   400,       0,   1.00,magical,000000001,"{""a"":1,""b"":1}",
+                 1000,   400,       0,   1.00,magical,000000002,"{""a"":2,""b"":1}"
+            """.strip(), file=f)
+
+        main(command_line_args=[
+            "plot",
+            "--in",
+            str(d / "input.csv"),
+            "--out",
+            str(d / "output.png"),
+            "--xaxis",
+            "values",
+            "--x_func",
+            "m.a",
+            "--group_func",
+            "m.b",
+            "--xmin",
+            "0",
+            "--xmax",
+            "10",
+            "--line_fits"
+        ])
+        assert (d / "output.png").exists()

sinter/_command/_main_predict.py

@@ -0,0 +1,75 @@
+import argparse
+from typing import Any
+from typing import List
+
+from sinter._predict import predict_on_disk
+
+
+def parse_args(args: List[str]) -> Any:
+    parser = argparse.ArgumentParser(
+        description='Predict observable flips from detector data.',
+        prog='sinter predict',
+    )
+    parser.add_argument('--dets',
+                        type=str,
+                        required=True,
+                        help='File to read detection event data from.')
+    parser.add_argument('--dets_format',
+                        type=str,
+                        required=True,
+                        help='Format detection event data is stored in.\n'
+                             'For example: b8 or 01')
+    parser.add_argument('--dem',
+                        type=str,
+                        required=True,
+                        help='File to read detector error model from.')
+    parser.add_argument('--decoder',
+                        type=str,
+                        required=True,
+                        help='Decoder to use.')
+    parser.add_argument('--obs_out',
+                        type=str,
+                        required=True,
+                        help='Location to write predictions from decoder.')
+    parser.add_argument('--obs_out_format',
+                        type=str,
+                        required=True,
+                        help='Format to write predictions in.')
+
+    parser.add_argument('--postselect_detectors_with_non_zero_4th_coord',
+                        help='Turns on postselection. '
+                             'If any detector with a non-zero 4th coordinate fires, the shot is discarded.',
+                        action='store_true')
+    parser.add_argument('--discards_out',
+                        type=str,
+                        default=None,
+                        help='Location to write whether each shot should be discarded.'
+                             'Specified if and only if --postselect_detectors_with_non_zero_4th_coord.')
+    parser.add_argument('--discards_out_format',
+                        type=str,
+                        default=None,
+                        help='Format to write discard data in.'
+                             'Specified if and only if --postselect_detectors_with_non_zero_4th_coord.')
+    result = parser.parse_args(args)
+
+    if result.postselect_detectors_with_non_zero_4th_coord and result.discards_out is None:
+        raise ValueError("Must specify --discards_out to record results of --postselect_detectors_with_non_zero_4th_coord.")
+    if result.discards_out is not None and result.discards_out_format is None:
+        raise ValueError("Must specify --discards_out_format to specify how to record results of --discards_out.")
+
+    return result
+
+
+def main_predict(*, command_line_args: List[str]):
+    parsed = parse_args(command_line_args)
+    predict_on_disk(
+        decoder=parsed.decoder,
+        dem_path=parsed.dem,
+        dets_path=parsed.dets,
+        dets_format=parsed.dets_format,
+        obs_out_path=parsed.obs_out,
+        obs_out_format=parsed.obs_out_format,
+        postselect_detectors_with_non_zero_4th_coord=parsed.postselect_detectors_with_non_zero_4th_coord,
+        discards_out_path=parsed.discards_out,
+        discards_out_format=parsed.discards_out_format,
+    )

sinter/_command/_main_predict_test.py

@@ -0,0 +1,36 @@
+import pathlib
+import tempfile
+
+from sinter._command._main import main
+
+
+def test_main_predict():
+    with tempfile.TemporaryDirectory() as d:
+        d = pathlib.Path(d)
+        with open(d / f'input.dets', 'w') as f:
+            print("""
+shot D0
+shot
+            """, file=f)
+        with open(d / f'input.dem', 'w') as f:
+            print("""
+error(0.1) D0 L0
+            """, file=f)
+
+        main(command_line_args=[
+            "predict",
+            "--dets",
+            str(d / "input.dets"),
+            "--dem",
+            str(d / "input.dem"),
+            "--decoder",
+            "pymatching",
+            "--dets_format",
+            "dets",
+            "--obs_out",
+            str(d / "output.01"),
+            "--obs_out_format",
+            "01",
+        ])
+        with open(d / 'output.01') as f:
+            assert f.read() == '1\n0\n'

sinter/_data/__init__.py

@@ -0,0 +1,20 @@
+from sinter._data._anon_task_stats import (
+    AnonTaskStats,
+)
+from sinter._data._collection_options import (
+    CollectionOptions,
+)
+from sinter._data._csv_out import (
+    CSV_HEADER,
+)
+from sinter._data._existing_data import (
+    read_stats_from_csv_files,
+    stats_from_csv_files,
+    ExistingData,
+)
+from sinter._data._task import (
+    Task,
+)
+from sinter._data._task_stats import (
+    TaskStats,
+)

sinter/_data/_anon_task_stats.py

@@ -0,0 +1,89 @@
+import collections
+import dataclasses
+from typing import Counter, Union, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from sinter._data._task_stats import TaskStats
+
+
+@dataclasses.dataclass(frozen=True)
+class AnonTaskStats:
+    """Statistics sampled from an unspecified task.
+
+    Attributes:
+        shots: Number of times the task was sampled.
+        errors: Number of times a sample resulted in an error.
+        discards: Number of times a sample resulted in a discard. Note that
+            discarded a task is not an error.
+        seconds: The amount of CPU core time spent sampling the tasks, in
+            seconds.
+        custom_counts: A counter mapping string keys to integer values. Used for
+            tracking arbitrary values, such as per-observable error counts or
+            the number of times detectors fired. The meaning of the information
+            in the counts is not specified; the only requirement is that it
+            should be correct to add each key's counts when merging statistics.
+
+            Although this field is an editable object, it's invalid to edit the
+            counter after the stats object is initialized.
+    """
+
+    shots: int = 0
+    errors: int = 0
+    discards: int = 0
+    seconds: float = 0
+    custom_counts: Counter[str] = dataclasses.field(default_factory=collections.Counter)
+
+    def __post_init__(self):
+        assert isinstance(self.errors, int)
+        assert isinstance(self.shots, int)
+        assert isinstance(self.discards, int)
+        assert isinstance(self.seconds, (int, float))
+        assert isinstance(self.custom_counts, collections.Counter)
+        assert self.errors >= 0
+        assert self.discards >= 0
+        assert self.seconds >= 0
+        assert self.shots >= self.errors + self.discards
+        assert all(isinstance(k, str) and isinstance(v, int) for k, v in self.custom_counts.items())
+
+    def __repr__(self) -> str:
+        terms = []
+        if self.shots != 0:
+            terms.append(f'shots={self.shots!r}')
+        if self.errors != 0:
+            terms.append(f'errors={self.errors!r}')
+        if self.discards != 0:
+            terms.append(f'discards={self.discards!r}')
+        if self.seconds != 0:
+            terms.append(f'seconds={self.seconds!r}')
+        if self.custom_counts:
+            terms.append(f'custom_counts={self.custom_counts!r}')
+        return f'sinter.AnonTaskStats({", ".join(terms)})'
+
+    def __add__(self, other: 'AnonTaskStats') -> 'AnonTaskStats':
+        """Returns the sum of the statistics from both anonymous stats.
+
+        Adds the shots, the errors, the discards, and the seconds.
+
+        Examples:
+            >>> import sinter
+            >>> a = sinter.AnonTaskStats(
+            ...    shots=100,
+            ...    errors=20,
+            ... )
+            >>> b = sinter.AnonTaskStats(
+            ...    shots=1000,
+            ...    errors=200,
+            ... )
+            >>> a + b
+            sinter.AnonTaskStats(shots=1100, errors=220)
+        """
+        if isinstance(other, AnonTaskStats):
+            return AnonTaskStats(
+                shots=self.shots + other.shots,
+                errors=self.errors + other.errors,
+                discards=self.discards + other.discards,
+                seconds=self.seconds + other.seconds,
+                custom_counts=self.custom_counts + other.custom_counts,
+            )
+
+        return NotImplemented