qLDPC 0.4.0__tar.gz → 0.4.2.dev20261004__tar.gz

{qldpc-0.4.0 → qldpc-0.4.2.dev20261004}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qldpc
-Version: 0.4.0
+Version: 0.4.2.dev20261004
 Summary: Tools for constructing and analyzing quantum low density parity check (qLDPC) codes.
 Keywords: LDPC,low density parity check codes,quantum computing,quantum error correction
 Author: Michael A. Perlin
@@ -32,6 +32,8 @@ Requires-Dist: sinter>=1.16
 Requires-Dist: stim>=1.16
 Requires-Dist: sympy>=1.12
 Requires-Dist: tqdm>=4
+Requires-Dist: qldpc[relay-bp] ; extra == 'decoders'
+Requires-Dist: qldpc[tesseract] ; (python_full_version < '3.15' and platform_machine == 'arm64' and sys_platform == 'darwin' and extra == 'decoders') or (python_full_version < '3.15' and platform_machine == 'x86_64' and sys_platform == 'linux' and extra == 'decoders')
 Requires-Dist: checks-superstaq>=0.5.67 ; extra == 'dev'
 Requires-Dist: jupyter>=1.1.1 ; extra == 'dev'
 Requires-Dist: pypandoc-binary>=1.13 ; extra == 'dev'
@@ -40,22 +42,25 @@ Requires-Dist: pytest>=8 ; extra == 'dev'
 Requires-Dist: pytest-randomly>=3.10 ; extra == 'dev'
 Requires-Dist: pytest-socket>=0.7 ; extra == 'dev'
 Requires-Dist: python-lsp-server[all]>=1.14 ; extra == 'dev'
-Requires-Dist: qldpc[docs,gap,relay-bp] ; extra == 'dev'
+Requires-Dist: qldpc[decoders,docs,gap] ; extra == 'dev'
 Requires-Dist: ipython>=8 ; extra == 'docs'
 Requires-Dist: nbsphinx>=0.9 ; extra == 'docs'
 Requires-Dist: sphinx>=7 ; extra == 'docs'
 Requires-Dist: sphinx-autoapi>=3 ; extra == 'docs'
 Requires-Dist: sphinx-rtd-theme>=2 ; extra == 'docs'
-Requires-Dist: passagemath-gap==10.8.12 ; python_full_version < '3.15' and sys_platform != 'win32' and extra == 'gap'
+Requires-Dist: passagemath-gap==10.8.12 ; python_full_version == '3.13.*' and sys_platform != 'win32' and extra == 'gap'
 Requires-Dist: relay-bp[stim]==0.2.2 ; extra == 'relay-bp'
+Requires-Dist: tesseract-decoder==0.1.1.dev20260910235247 ; python_full_version >= '3.12' and extra == 'tesseract'
 Requires-Python: >=3.11
 Project-URL: Documentation, https://qldpc.readthedocs.io/
 Project-URL: Issues, https://github.com/qLDPCOrg/qLDPC/issues
 Project-URL: Repository, https://github.com/qLDPCOrg/qLDPC
+Provides-Extra: decoders
 Provides-Extra: dev
 Provides-Extra: docs
 Provides-Extra: gap
 Provides-Extra: relay-bp
+Provides-Extra: tesseract
 Description-Content-Type: text/markdown
 
 # qLDPC
@@ -98,14 +103,25 @@ python -m pip install qldpc
 
 ### Optional extras
 
-#### Relay-BP decoder
+#### Decoders
 
-Install the optional Relay-BP decoder with:
+qLDPC installs `ldpc` and `pymatching` by default, which include a host of decoders.
+Install the optional decoder integrations published as qLDPC extras for your platform with:
+
+```bash
+python -m pip install 'qldpc[decoders]'
+```
+
+You can also use individual extras to install a specific optional decoder:
 
 ```bash
 python -m pip install 'qldpc[relay-bp]'
+python -m pip install 'qldpc[tesseract]'
 ```
 
+The [Tesseract](https://github.com/quantumlib/tesseract-decoder) decoder requires CPython 3.12–3.14 on macOS arm64 or Linux x86-64.
+[Frontier](https://github.com/aleverrier/frontier) is not published on PyPI and is not included in an extra; see the [decoder guide](https://qldpc.readthedocs.io/decoders.html) for availability and build-time installation guidance.
+
 #### GAP integration
 
 Some algebra tools, code lookups, and distance estimates require [GAP](https://www.gap-system.org).
@@ -115,10 +131,9 @@ For the recommended in-process integration, install qLDPC with its maintained li
 python -m pip install 'qldpc[gap]'
 ```
 
-qLDPC uses `passagemath-gap` when it is installed, so supported GAP operations do not launch a separate process.
-If the extra is unavailable, qLDPC still supports a GAP executable on `PATH` (`conda install -c conda-forge gap` is one option) and retains its documented manual copy/paste fallback.
-If a package such as GUAVA or QDistRnd is absent from the in-process binding, qLDPC asks for permission to install it through GAP's PackageManager.
-If that attempt fails and a separate GAP executable is available, qLDPC prints instructions for installing the package for libgap before using the executable instead.
+qLDPC uses `passagemath-gap` when available, so supported GAP operations do not launch a separate process.
+The in-process binding requires Python 3.13 on a non-Windows platform.
+If `passagemath-gap` is unavailable, qLDPC relies on a GAP executable in your `PATH` (possibly obtainable with `conda install -c conda-forge gap`), and a manual copy/paste fallback.
 GAP integration on Windows remains limited; see [issue #294](https://github.com/qLDPCOrg/qLDPC/issues/294).
 
 #### `sqetch` distance estimation
@@ -131,7 +146,7 @@ python -m pip install 'sqetch[gpu] @ git+https://github.com/a7b/yarn.git@e9ce9d0
 
 This command installs the upstream version of `sqetch` that qLDPC is tested against, with GPU support.
 `sqetch` is not published on PyPI, so it is not available as a qLDPC extra.
-For binary CSS codes, select it with `code.get_distance_bound(backend="sqetch")`.
+For binary CSS codes, you can select this backend with `code.get_distance_bound(backend="sqetch")`.
 
 ### Troubleshooting
 
@@ -167,11 +182,9 @@ print("physical qubits:", len(code))
 print("logical qubits:", code.dimension)
 ```
 
-That object is ready for more than a parameter check: inspect its parity checks and logical operators, choose a decoder, estimate a logical error rate, or use it in a memory experiment.
-
 ### Go deeper: a subsystem lifted-product code
 
-For a more technical taste, the next example builds a parity-check matrix over the group algebra `GF(2)[C₅]`, lifts each group-ring entry to a 5×5 binary block, and hands the result to `SLPCode`.
+The next example builds a parity-check matrix over the group algebra `GF(2)[C₅]`, lifts each group-ring entry to a 5×5 binary block, and hands the result to `SLPCode`.
 The [subsystem lifted-product construction](https://arxiv.org/abs/2404.18302) produces an 80-qubit CSS subsystem code with 5 logical qubits and 45 gauge qubits.
 
 ```python

{qldpc-0.4.0 → qldpc-0.4.2.dev20261004}/README.md

@@ -38,14 +38,25 @@ python -m pip install qldpc
 
 ### Optional extras
 
-#### Relay-BP decoder
+#### Decoders
 
-Install the optional Relay-BP decoder with:
+qLDPC installs `ldpc` and `pymatching` by default, which include a host of decoders.
+Install the optional decoder integrations published as qLDPC extras for your platform with:
+
+```bash
+python -m pip install 'qldpc[decoders]'
+```
+
+You can also use individual extras to install a specific optional decoder:
 
 ```bash
 python -m pip install 'qldpc[relay-bp]'
+python -m pip install 'qldpc[tesseract]'
 ```
 
+The [Tesseract](https://github.com/quantumlib/tesseract-decoder) decoder requires CPython 3.12–3.14 on macOS arm64 or Linux x86-64.
+[Frontier](https://github.com/aleverrier/frontier) is not published on PyPI and is not included in an extra; see the [decoder guide](https://qldpc.readthedocs.io/decoders.html) for availability and build-time installation guidance.
+
 #### GAP integration
 
 Some algebra tools, code lookups, and distance estimates require [GAP](https://www.gap-system.org).
@@ -55,10 +66,9 @@ For the recommended in-process integration, install qLDPC with its maintained li
 python -m pip install 'qldpc[gap]'
 ```
 
-qLDPC uses `passagemath-gap` when it is installed, so supported GAP operations do not launch a separate process.
-If the extra is unavailable, qLDPC still supports a GAP executable on `PATH` (`conda install -c conda-forge gap` is one option) and retains its documented manual copy/paste fallback.
-If a package such as GUAVA or QDistRnd is absent from the in-process binding, qLDPC asks for permission to install it through GAP's PackageManager.
-If that attempt fails and a separate GAP executable is available, qLDPC prints instructions for installing the package for libgap before using the executable instead.
+qLDPC uses `passagemath-gap` when available, so supported GAP operations do not launch a separate process.
+The in-process binding requires Python 3.13 on a non-Windows platform.
+If `passagemath-gap` is unavailable, qLDPC relies on a GAP executable in your `PATH` (possibly obtainable with `conda install -c conda-forge gap`), and a manual copy/paste fallback.
 GAP integration on Windows remains limited; see [issue #294](https://github.com/qLDPCOrg/qLDPC/issues/294).
 
 #### `sqetch` distance estimation
@@ -71,7 +81,7 @@ python -m pip install 'sqetch[gpu] @ git+https://github.com/a7b/yarn.git@e9ce9d0
 
 This command installs the upstream version of `sqetch` that qLDPC is tested against, with GPU support.
 `sqetch` is not published on PyPI, so it is not available as a qLDPC extra.
-For binary CSS codes, select it with `code.get_distance_bound(backend="sqetch")`.
+For binary CSS codes, you can select this backend with `code.get_distance_bound(backend="sqetch")`.
 
 ### Troubleshooting
 
@@ -107,11 +117,9 @@ print("physical qubits:", len(code))
 print("logical qubits:", code.dimension)
 ```
 
-That object is ready for more than a parameter check: inspect its parity checks and logical operators, choose a decoder, estimate a logical error rate, or use it in a memory experiment.
-
 ### Go deeper: a subsystem lifted-product code
 
-For a more technical taste, the next example builds a parity-check matrix over the group algebra `GF(2)[C₅]`, lifts each group-ring entry to a 5×5 binary block, and hands the result to `SLPCode`.
+The next example builds a parity-check matrix over the group algebra `GF(2)[C₅]`, lifts each group-ring entry to a 5×5 binary block, and hands the result to `SLPCode`.
 The [subsystem lifted-product construction](https://arxiv.org/abs/2404.18302) produces an 80-qubit CSS subsystem code with 5 logical qubits and 45 gauge qubits.
 
 ```python

{qldpc-0.4.0 → qldpc-0.4.2.dev20261004}/pyproject.toml

@@ -4,7 +4,7 @@ requires = ["uv-build>=0.9.18,<0.13"]
 
 [project]
 name = "qldpc"
-version = "0.4.0"
+version = "0.4.2.dev20261004"
 description = "Tools for constructing and analyzing quantum low density parity check (qLDPC) codes."
 readme = "README.md"
 keywords = [
@@ -53,6 +53,10 @@ name = "Michael A. Perlin"
 email = "mika.perlin@gmail.com"
 
 [project.optional-dependencies]
+decoders = [
+    "qldpc[relay-bp]",
+    "qldpc[tesseract]; ((sys_platform=='darwin' and platform_machine=='arm64') or (sys_platform=='linux' and platform_machine=='x86_64')) and python_version<'3.15'",
+]
 dev = [
     "checks-superstaq>=0.5.67",
     "jupyter>=1.1.1",
@@ -62,7 +66,7 @@ dev = [
     "pytest-randomly>=3.10",
     "pytest-socket>=0.7",
     "python-lsp-server[all]>=1.14",
-    "qldpc[docs,gap,relay-bp]",
+    "qldpc[decoders,docs,gap]",
 ]
 docs = [
     "ipython>=8",
@@ -71,8 +75,9 @@ docs = [
     "sphinx-autoapi>=3",
     "sphinx-rtd-theme>=2",
 ]
-gap = ["passagemath-gap==10.8.12; python_version<'3.15' and sys_platform!='win32'"]
+gap = ["passagemath-gap==10.8.12; python_version=='3.13' and sys_platform!='win32'"]
 relay-bp = ["relay-bp[stim]==0.2.2"]
+tesseract = ["tesseract-decoder==0.1.1.dev20260910235247; python_version>='3.12'"]
 
 [project.urls]
 Documentation = "https://qldpc.readthedocs.io/"
@@ -88,6 +93,11 @@ ci-lint = [
     "checks-superstaq>=0.5.67",
     "pyproject-fmt>=2",
 ]
+ci-notebooks = [
+    "jupyter>=1.1.1",
+    "matplotlib>=3.10",
+    "pip>=24",
+]
 ci-test = [
     "checks-superstaq>=0.5.67",
     "pytest>=8",
@@ -136,7 +146,10 @@ show_error_codes = true
 
 [tool.pytest.ini_options]
 addopts = "--disable-socket"
-filterwarnings = ["ignore:(?s).*The problem is either infeasible or unbounded.*:UserWarning"]
+filterwarnings = [
+    "error::DeprecationWarning",
+    "ignore:(?s).*The problem is either infeasible or unbounded.*:UserWarning",
+]
 
 [tool.coverage.run]
 include = ["./*"]

{qldpc-0.4.0 → qldpc-0.4.2.dev20261004}/pyproject.toml.orig

@@ -4,7 +4,7 @@ requires = [ "uv-build>=0.9.18,<0.13" ]
 
 [project]
 name = "qldpc"
-version = "0.4.0"
+version = "0.4.2.dev20261004"
 description = "Tools for constructing and analyzing quantum low density parity check (qLDPC) codes."
 readme = "README.md"
 keywords = [
@@ -45,6 +45,13 @@ dependencies = [
   "sympy>=1.12",
   "tqdm>=4",
 ]
+optional-dependencies.decoders = [
+  "qldpc[relay-bp]",
+  """\
+  qldpc[tesseract]; ((sys_platform=='darwin' and platform_machine=='arm64') or (sys_platform=='linux' and \
+  platform_machine=='x86_64')) and python_version<'3.15'\
+  """,
+]
 optional-dependencies.dev = [
   "checks-superstaq>=0.5.67",
   "jupyter>=1.1.1",
@@ -54,7 +61,7 @@ optional-dependencies.dev = [
   "pytest-randomly>=3.10",        # tests that need reproducibility read its randomly_seed option
   "pytest-socket>=0.7",           # implements the --disable-socket in [tool.pytest] addopts below
   "python-lsp-server[all]>=1.14",
-  "qldpc[docs,gap,relay-bp]",
+  "qldpc[decoders,docs,gap]",
 ]
 optional-dependencies.docs = [
   "ipython>=8",          # for nbsphinx's IPython.sphinxext.ipython_console_highlighting extension
@@ -64,9 +71,12 @@ optional-dependencies.docs = [
   "sphinx-rtd-theme>=2",
 ]
 optional-dependencies.gap = [
-  "passagemath-gap==10.8.12; python_version<'3.15' and sys_platform!='win32'",
+  "passagemath-gap==10.8.12; python_version=='3.13' and sys_platform!='win32'",
 ]
 optional-dependencies.relay-bp = [ "relay-bp[stim]==0.2.2" ]
+optional-dependencies.tesseract = [
+  "tesseract-decoder==0.1.1.dev20260910235247; python_version>='3.12'",
+]
 urls.Documentation = "https://qldpc.readthedocs.io/"
 urls.Issues = "https://github.com/qLDPCOrg/qLDPC/issues"
 urls.Repository = "https://github.com/qLDPCOrg/qLDPC"
@@ -80,6 +90,11 @@ ci-lint = [
   "checks-superstaq>=0.5.67",
   "pyproject-fmt>=2",
 ]
+ci-notebooks = [
+  "jupyter>=1.1.1",
+  "matplotlib>=3.10",
+  "pip>=24",
+]
 ci-test = [
   "checks-superstaq>=0.5.67",
   "pytest>=8",
@@ -126,6 +141,7 @@ show_error_codes = true
 [tool.pytest]
 ini_options.addopts = "--disable-socket"  # forbid tests from making network calls
 ini_options.filterwarnings = [
+  "error::DeprecationWarning",                                                # tests use the modern API
   "ignore:(?s).*The problem is either infeasible or unbounded.*:UserWarning", # from cvxpy
 ]
 

qldpc-0.4.2.dev20261004/src/qldpc/cache.py

@@ -0,0 +1,139 @@
+# SPDX-License-Identifier: Apache-2.0
+
+"""Helper function(s) for caching results."""
+
+from __future__ import annotations
+
+import functools
+import pathlib
+import sys
+import warnings
+from collections.abc import Callable, Hashable
+from typing import Generic, ParamSpec, TypeVar, cast
+
+import diskcache
+import platformdirs
+
+Params = ParamSpec("Params")
+Result = TypeVar("Result")
+
+
+class CachedFunction(Generic[Params, Result]):
+    """A function whose results are cached to disk.
+
+    Calling the function retrieves its result from the cache if available, and otherwise computes
+    and caches the result.  Calling CachedFunction.refresh ignores any existing cache entry,
+    recomputes the result, and saves the new result to the cache.
+    """
+
+    __wrapped__: Callable[Params, Result]
+
+    def __init__(
+        self,
+        function: Callable[Params, Result],
+        cache_name: str,
+        *,
+        cache_dir: pathlib.Path | str | None = None,
+        key_func: Callable[..., Hashable] | None = None,
+    ) -> None:
+        self._function = function
+        self._cache_name = cache_name
+        self._cache_dir = cache_dir
+        self._key_func = key_func
+        functools.update_wrapper(self, function)
+
+    def __call__(self, *args: Params.args, **kwargs: Params.kwargs) -> Result:
+        """Retrieve a result from the cache if available, and otherwise compute and cache it."""
+        cache = get_disk_cache(self._cache_name, cache_dir=self._cache_dir)
+        key = self._get_key(*args, **kwargs)
+        if key in cache:
+            return cast(Result, cache[key])
+        result = self._function(*args, **kwargs)
+        cache[key] = result
+        return result
+
+    def refresh(self, *args: Params.args, **kwargs: Params.kwargs) -> Result:
+        """Recompute the result for these arguments and overwrite the cached value."""
+        cache = get_disk_cache(self._cache_name, cache_dir=self._cache_dir)
+        key = self._get_key(*args, **kwargs)
+        result = self._function(*args, **kwargs)
+        cache[key] = result
+        return result
+
+    def _get_key(self, *args: Params.args, **kwargs: Params.kwargs) -> Hashable:
+        """Get the cache key for the given arguments."""
+        if self._key_func is not None:
+            return self._key_func(*args, **kwargs)
+        key = args + tuple(kwargs.items())
+        return key if len(key) != 1 else key[0]  # unpack length-1 tuples
+
+    def __reduce__(self) -> str:
+        """Pickle by reference to the module-level name of the decorated function."""
+        return self._function.__qualname__
+
+
+def get_disk_cache_path(
+    cache_name: str, *, cache_dir: pathlib.Path | str | None = None
+) -> pathlib.Path:
+    """Retrieve the path of a cache."""
+    cache_dir = cache_dir or pathlib.Path(platformdirs.user_cache_dir()) / "qldpc"
+    return pathlib.Path(cache_dir) / cache_name
+
+
+def get_disk_cache(
+    cache_name: str, *, cache_dir: pathlib.Path | str | None = None
+) -> diskcache.Cache:
+    """Retrieve a dictionary-like cache object."""
+    if running_with_pytest():
+        return {}
+    return diskcache.Cache(get_disk_cache_path(cache_name, cache_dir=cache_dir))
+
+
+def use_disk_cache(
+    cache_name: str,
+    *,
+    cache_dir: pathlib.Path | str | None = None,
+    key_func: Callable[..., Hashable] | None = None,
+) -> Callable[[Callable[Params, Result]], CachedFunction[Params, Result]]:
+    """Decorator to cache results to disk.
+
+    By default, the cache key is the tuple of positional arguments followed by (keyword, value)
+    pairs, unpacked if this tuple has length 1.  A custom key_func, called with the same arguments
+    as the decorated function, overrides this default.
+
+    The decorated function has a .refresh method with the same signature, which ignores any
+    existing cache entry, recomputes the result, and saves the new result to the cache.  Refreshing
+    only affects this cache, and does not clear other caches used internally by the function.
+
+    The decorator is intended for module-level functions: a decorated function is pickled by
+    reference to its qualified name, and it does not bind as a method.
+
+    Disk caching is bypassed when running with pytest.
+    """
+
+    def decorator(function: Callable[Params, Result]) -> CachedFunction[Params, Result]:
+        return CachedFunction(function, cache_name, cache_dir=cache_dir, key_func=key_func)
+
+    return decorator
+
+
+def running_with_pytest() -> bool:
+    """Are we currently running with pytest?"""
+    return "pytest" in sys.modules
+
+
+def clear_entry(
+    cache_name: str, key: Hashable, *, cache_dir: pathlib.Path | str | None = None
+) -> None:
+    """Clear an entry from a local cache."""
+    cache = get_disk_cache(cache_name, cache_dir=cache_dir)
+    if key in cache:
+        del cache[key]
+    else:
+        cache_path = get_disk_cache_path(cache_name, cache_dir=cache_dir)
+        warnings.warn(
+            f"Attempted to delete the entry '{key}' from the cache '{cache_name}'"
+            + ("" if cache_dir is None else f" (located at '{cache_path}')")
+            + ", but this entry does not exist.",
+            stacklevel=2,
+        )

qldpc-0.4.2.dev20261004/src/qldpc/cache_test.py

@@ -0,0 +1,121 @@
+# SPDX-License-Identifier: Apache-2.0
+
+"""Unit tests for cache.py."""
+
+from __future__ import annotations
+
+import copy
+import pathlib
+import pickle
+import unittest.mock
+from collections.abc import Hashable
+
+import pytest
+
+import qldpc.cache
+import qldpc.external.codes
+
+
+def test_pytest() -> None:
+    """Disk caching is bypassed when running under pytest."""
+    assert qldpc.cache.running_with_pytest()
+    assert qldpc.cache.get_disk_cache("test") == {}
+
+    calls = []
+
+    @qldpc.cache.use_disk_cache("test")
+    def test_func(value: int) -> int:
+        """Test docstring."""
+        calls.append(value)
+        return value
+
+    assert test_func.__doc__ == "Test docstring."
+    assert test_func(1) == test_func(1) == test_func.refresh(1) == 1
+    assert calls == [1, 1, 1]
+
+
+def test_use_disk_cache(tmp_path: pathlib.Path) -> None:
+    """Cache function outputs."""
+
+    cache: dict[Hashable, int] = {}
+    with (
+        unittest.mock.patch("qldpc.cache.running_with_pytest", return_value=False),
+        unittest.mock.patch("diskcache.Cache", return_value=cache),
+    ):
+
+        @qldpc.cache.use_disk_cache("test_name")
+        def get_five(_: str) -> int:
+            return 5
+
+        # use cache to save/retrieve results
+        get_five("test_arg")  # save results to cache
+        assert cache == {"test_arg": 5}
+        assert cache["test_arg"] == get_five("test_arg")
+
+        # post-process inputs to determine the cache key
+        @qldpc.cache.use_disk_cache("test_name", key_func=lambda _: None)
+        def get_six(_: str) -> int:
+            return 6
+
+        assert get_six("test_arg") == 6
+        assert cache == {"test_arg": 5, None: 6}
+
+        # delete an entry from the cache
+        qldpc.cache.clear_entry("test_name", None)
+        assert cache == {"test_arg": 5}
+
+        # raise a warning if trying to delete an entry that does not exist in the cache
+        with pytest.warns(UserWarning, match="entry does not exist"):
+            qldpc.cache.clear_entry("test_name", "some_key")
+        with pytest.warns(UserWarning, match="located at"):
+            qldpc.cache.clear_entry("test_name", "some_key", cache_dir=tmp_path)
+
+
+def test_refresh() -> None:
+    """Refresh cached function outputs."""
+
+    cache: dict[Hashable, int] = {}
+    with (
+        unittest.mock.patch("qldpc.cache.running_with_pytest", return_value=False),
+        unittest.mock.patch("diskcache.Cache", return_value=cache),
+    ):
+        calls: list[tuple[int, int]] = []
+
+        @qldpc.cache.use_disk_cache("test_name")
+        def count(value: int, *, offset: int = 0) -> int:
+            calls.append((value, offset))
+            return len(calls)
+
+        # the first call computes a result, and the second call retrieves it from the cache
+        assert count(1) == count(1) == 1
+        assert calls == [(1, 0)]
+
+        # refreshing recomputes the result and overwrites the cache entry
+        assert count.refresh(1) == 2
+        assert cache == {1: 2}
+        assert count(1) == 2
+        assert calls == [(1, 0), (1, 0)]
+
+        # refreshing a missing entry computes and saves a result without warnings
+        assert count.refresh(2, offset=3) == 3
+        assert cache == {1: 2, (2, ("offset", 3)): 3}
+
+        # refreshing uses the custom cache key
+        @qldpc.cache.use_disk_cache("test_name", key_func=lambda value: f"key-{value}")
+        def double(value: int) -> int:
+            calls.append((value, 0))
+            return 2 * value
+
+        cache["key-4"] = 0
+        assert double(4) == 0
+        assert double.refresh(4) == 8
+        assert cache["key-4"] == 8
+        assert double(4) == 8
+
+
+def test_pickle() -> None:
+    """Cached module-level functions are pickled by reference."""
+    function = qldpc.external.codes.get_classical_code
+    assert pickle.dumps(function)
+    assert copy.deepcopy(function) is function
+    assert function.__wrapped__.__name__ == "get_classical_code"

{qldpc-0.4.0 → qldpc-0.4.2.dev20261004}/src/qldpc/circuits/benchmarking_test.py

@@ -176,9 +176,7 @@ def test_erasure_counts_as_a_discard() -> None:
 
     # every error of weight one is decoded exactly, and every heavier error is erased, so the
     # logical error rate is exactly zero and the discard rate is 1 - 0.8**7 - 7 * 0.2 * 0.8**6
-    decoder = decoders.SinterDecoder(
-        decoder=decoders.lookup_table(max_weight=1, add_erasure_bit=True)
-    )
+    decoder = decoders.SinterDecoder(decoder=decoders.lookup(max_weight=1, add_erasure_bit=True))
     logical_error_rate, discard_rate = circuits.get_logical_error_and_discard_rate(
         circuit, sinter_decoder=decoder, num_samples=1000
     )
@@ -191,9 +189,9 @@ def test_erasure_counts_as_a_discard() -> None:
 
         def compile_decoder_for_dem(
             self, dem: stim.DetectorErrorModel
-        ) -> decoders.CompiledSinterDecoder:
+        ) -> decoders.sinter.CompiledSinterDecoder:
             compiled = super().compile_decoder_for_dem(dem)
-            assert isinstance(compiled, decoders.CompiledTrivialDecoder)
+            assert isinstance(compiled, decoders.sinter.CompiledTrivialDecoder)
             compiled.packed_observable_size += 2
             return compiled
 

{qldpc-0.4.0 → qldpc-0.4.2.dev20261004}/src/qldpc/circuits/transversal.py

@@ -386,7 +386,10 @@ def _tableaus_are_equivalent_mod_paulis(tableau_1: stim.Tableau, tableau_2: stim
 
 @cache.use_disk_cache(
     "group_intersection",
-    key_func=lambda xx, yy: (xx.hashable_generators(), yy.hashable_generators()),
+    key_func=lambda group_a, group_b: (
+        group_a.hashable_generators(),
+        group_b.hashable_generators(),
+    ),
 )
 def _sympy_group_intersection_generators(
     group_a: abstract.Group, group_b: abstract.Group

{qldpc-0.4.0 → qldpc-0.4.2.dev20261004}/src/qldpc/circuits/transversal_test.py

@@ -107,6 +107,17 @@ def test_transversal_group_degree() -> None:
     assert len(circuits.get_transversal_ops(code, ["H"])) == 0
 
 
+def test_group_intersection_keywords() -> None:
+    """The cache key of a group intersection supports keyword arguments."""
+    group_a = abstract.SymmetricGroup(3)
+    group_b = abstract.CyclicGroup(3)
+    generators = transversal._sympy_group_intersection_generators(group_a, group_b)
+    assert generators  # the cyclic group is a nontrivial subgroup of the symmetric group
+    assert generators == transversal._sympy_group_intersection_generators(
+        group_a=group_a, group_b=group_b
+    )
+
+
 def test_finding_circuit(
     pytestconfig: pytest.Config, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
 ) -> None: