Merge branch 'master' into refactor

Author: tybug

.github/workflows/main.yml

@@ -223,17 +223,17 @@ jobs:
     - name: Run tests
       run: TASK=${{ matrix.task }} ./build.sh
 
-  # See https://pyodide.org/en/stable/development/building-and-testing-packages.html#testing-packages-against-pyodide
+  # See https://pyodide.org/en/stable/usage/building-and-testing-packages.html
   # and https://github.com/numpy/numpy/blob/9a650391651c8486d8cb8b27b0e75aed5d36033e/.github/workflows/emscripten.yml
   test-pyodide:
     runs-on: ubuntu-latest
     env:
-      NODE_VERSION: 18
-      # Note that the versions below must be updated in sync; we've automated
-      # that with `update_pyodide_versions()` in our weekly cronjob.
-      PYODIDE_VERSION: 0.27.3
+      NODE_VERSION: 22
+      # Note that the versions below are updated by `update_pyodide_versions()` in our weekly cronjob.
+      # The versions of pyodide-build and the Pyodide runtime may differ.
+      PYODIDE_VERSION: 0.27.5
+      PYODIDE_BUILD_VERSION: 0.30.0
       PYTHON_VERSION: 3.12.7
-      EMSCRIPTEN_VERSION: 3.1.58
     steps:
       - uses: actions/checkout@v3
         with:
@@ -246,17 +246,10 @@ jobs:
         uses: actions/setup-node@b39b52d1213e96004bfcb1c61a8a6fa8ab84f3e8 # v4.0.1
         with:
           node-version: ${{ env.NODE_VERSION }}
-      - name: Set up Emscripten
-        uses: mymindstorm/setup-emsdk@6ab9eb1bda2574c4ddb79809fc9247783eaf9021 # v14
-        with:
-          version: ${{ env.EMSCRIPTEN_VERSION }}
-      - name: Build
+      - name: Install pyodide-build and Pyodide cross-build environment
         run: |
-          # TODO remove https://github.com/pyodide/pyodide/issues/5585
-          pip install -U wheel==0.45.1
-          pip install pyodide-build==$PYODIDE_VERSION
-          cd hypothesis-python/
-          CFLAGS=-g2 LDFLAGS=-g2 pyodide build
+          pip install pyodide-build==$PYODIDE_BUILD_VERSION
+          pyodide xbuildenv install $PYODIDE_VERSION
       - name: Set up Pyodide venv and install dependencies
         run: |
           pip install --upgrade setuptools pip wheel build

AUTHORS.rst

@@ -14,6 +14,7 @@ their individual contributions.
 * `Adam Sven Johnson <https://www.github.com/pkqk>`_
 * `Afrida Tabassum <https://github.com/oxfordhalfblood>`_ ([email protected])
 * `Afonso Silva <https://github.com/ajcerejeira>`_ ([email protected])
+* `Agriya Khetarpal <https://github.com/agriyakhetarpal>`_
 * `Agustín Covarrubias <https://github.com/agucova>`_ ([email protected])
 * `Akash Suresh <https://www.github.com/akash-suresh>`_ ([email protected])
 * `Alex Gaynor <https://github.com/alex>`_

hypothesis-python/RELEASE.rst

@@ -18,6 +18,22 @@ Hypothesis 6.x
 
     .. include:: ../RELEASE.rst
 
+.. _v6.130.12:
+
+---------------------
+6.130.12 - 2025-04-09
+---------------------
+
+Lays some groundwork for future work on collecting interesting literals from the code being tested, for increased bug-finding power (:issue:`3127`). There is no user-visible change (yet!)
+
+.. _v6.130.11:
+
+---------------------
+6.130.11 - 2025-04-08
+---------------------
+
+Fix the caching behavior of |st.sampled_from|, which in rare cases led to failing an internal assertion (:issue:`4339`).
+
 .. _v6.130.10:
 
 ---------------------

hypothesis-python/docs/changelog.rst

@@ -540,28 +540,30 @@ def explain(self) -> None:
                 attempt = choices[:start] + tuple(replacement) + choices[end:]
                 result = self.engine.cached_test_function(attempt, extend="full")
 
-                # Turns out this was a variable-length part, so grab the infix...
                 if result.status is Status.OVERRUN:
                     continue  # pragma: no cover  # flakily covered
                 result = cast(ConjectureResult, result)
                 if not (
                     len(attempt) == len(result.choices)
                     and endswith(result.nodes, nodes[end:])
                 ):
-                    for ex, res in zip(shrink_target.spans, result.spans):
-                        assert ex.start == res.start
-                        assert ex.start <= start
-                        assert ex.label == res.label
-                        if start == ex.start and end == ex.end:
-                            res_end = res.end
+                    # Turns out this was a variable-length part, so grab the infix...
+                    for span1, span2 in zip(shrink_target.spans, result.spans):
+                        assert span1.start == span2.start
+                        assert span1.start <= start
+                        assert span1.label == span2.label
+                        if span1.start == start and span1.end == end:
+                            result_end = span2.end
                             break
                     else:
                         raise NotImplementedError("Expected matching prefixes")
 
                     attempt = (
-                        choices[:start] + result.choices[start:res_end] + choices[end:]
+                        choices[:start]
+                        + result.choices[start:result_end]
+                        + choices[end:]
                     )
-                    chunks[(start, end)].append(result.choices[start:res_end])
+                    chunks[(start, end)].append(result.choices[start:result_end])
                     result = self.engine.cached_test_function(attempt)
 
                     if result.status is Status.OVERRUN:

hypothesis-python/src/hypothesis/internal/conjecture/shrinker.py

@@ -104,6 +104,9 @@ def calc_is_cacheable(self, recur: RecurT) -> bool:
                     return False
         return True
 
+    def calc_label(self) -> int:
+        return self.wrapped_strategy.label
+
     @property
     def wrapped_strategy(self) -> SearchStrategy[Ex]:
         if self.__wrapped_strategy is None:
@@ -176,7 +179,3 @@ def __repr__(self) -> str:
 
     def do_draw(self, data: ConjectureData) -> Ex:
         return data.draw(self.wrapped_strategy)
-
-    @property
-    def label(self) -> int:
-        return self.wrapped_strategy.label

hypothesis-python/src/hypothesis/strategies/_internal/lazy.py

@@ -564,14 +564,53 @@ def __repr__(self) -> str:
         )
 
     def calc_label(self) -> int:
-        return combine_labels(
-            self.class_label,
-            *(
-                (calc_label_from_hash(self.elements),)
-                if is_hashable(self.elements)
-                else ()
-            ),
-        )
+        # strategy.label is effectively an under-approximation of structural
+        # equality (i.e., some strategies may have the same label when they are not
+        # structurally identical). More importantly for calculating the
+        # SampledFromStrategy label, we might have hash(s1) != hash(s2) even
+        # when s1 and s2 are structurally identical. For instance:
+        #
+        #   s1 = st.sampled_from([st.none()])
+        #   s2 = st.sampled_from([st.none()])
+        #   assert hash(s1) != hash(s2)
+        #
+        # (see also test cases in test_labels.py).
+        #
+        # We therefore use the labels of any component strategies when calculating
+        # our label, and only use the hash if it is not a strategy.
+        #
+        # That's the ideal, anyway. In reality the logic is more complicated than
+        # necessary in order to be efficient in the presence of (very) large sequences:
+        # * add an unabashed special case for range, to avoid iteration over an
+        #   enormous range when we know it is entirely integers.
+        # * if there is at least one strategy in self.elements, use strategy label,
+        #   and the element hash otherwise.
+        # * if there are no strategies in self.elements, take the hash of the
+        #   entire sequence. This prevents worst-case performance of hashing each
+        #   element when a hash of the entire sequence would have sufficed.
+        #
+        # The worst case performance of this scheme is
+        # itertools.chain(range(2**100), [st.none()]), where it degrades to
+        # hashing every int in the range.
+
+        if isinstance(self.elements, range) or (
+            is_hashable(self.elements)
+            and not any(isinstance(e, SearchStrategy) for e in self.elements)
+        ):
+            return combine_labels(self.class_label, calc_label_from_hash(self.elements))
+
+        labels = [self.class_label]
+        for element in self.elements:
+            if not is_hashable(element):
+                continue
+
+            labels.append(
+                element.label
+                if isinstance(element, SearchStrategy)
+                else calc_label_from_hash(element)
+            )
+
+        return combine_labels(*labels)
 
     def calc_has_reusable_values(self, recur: RecurT) -> bool:
         # Because our custom .map/.filter implementations skip the normal

hypothesis-python/src/hypothesis/strategies/_internal/strategies.py

@@ -8,5 +8,5 @@
 # v. 2.0. If a copy of the MPL was not distributed with this file, You can
 # obtain one at https://mozilla.org/MPL/2.0/.
 
-__version_info__ = (6, 130, 10)
+__version_info__ = (6, 130, 12)
 __version__ = ".".join(map(str, __version_info__))

hypothesis-python/src/hypothesis/version.py

@@ -8,6 +8,8 @@
 # v. 2.0. If a copy of the MPL was not distributed with this file, You can
 # obtain one at https://mozilla.org/MPL/2.0/.
 
+import pytest
+
 from hypothesis import strategies as st
 
 
@@ -47,3 +49,23 @@ def test_lists_label_by_element():
 def test_label_of_deferred_strategy_is_well_defined():
     recursive = st.deferred(lambda: st.lists(recursive))
     recursive.label
+
+
+@pytest.mark.parametrize(
+    "strategy",
+    [
+        lambda: [st.none()],
+        lambda: [st.integers()],
+        lambda: [st.lists(st.floats())],
+        lambda: [st.none(), st.integers(), st.lists(st.floats())],
+    ],
+)
+def test_sampled_from_label_with_strategies_does_not_change(strategy):
+    s1 = st.sampled_from(strategy())
+    s2 = st.sampled_from(strategy())
+    assert s1.label == s2.label
+
+
+def test_label_of_enormous_sampled_range():
+    # this should not take forever.
+    st.sampled_from(range(2**30)).label

hypothesis-python/tests/nocover/test_labels.py

@@ -10,7 +10,7 @@
 
 import pytest
 
-from hypothesis import given, strategies as st
+from hypothesis import given, settings, strategies as st
 from hypothesis._settings import note_deprecation
 from hypothesis.errors import HypothesisDeprecationWarning
 
@@ -66,3 +66,20 @@ def test_unique_floats_with_nan_is_not_flaky_3926(ls):
 @given(st.integers(min_value=0, max_value=1 << 25_000))
 def test_overrun_during_datatree_simulation_3874(n):
     pass
+
+
+def test_explain_phase_label_assertion_4339():
+    # st.composite causes a re-creation of the SampledFromStrategy each time
+    # (one_of is implemented using sampled_from internally), which previously
+    # had different labels which triggered an assertion in the explain code.
+    @st.composite
+    def g(draw):
+        draw(st.none() | st.booleans())
+
+    @given(g(), st.none() | st.booleans())
+    @settings(database=None)
+    def f(a, b):
+        raise ValueError("marker")
+
+    with pytest.raises(ValueError, match="marker"):
+        f()

hypothesis-python/tests/nocover/test_regressions.py

@@ -403,31 +403,65 @@ def update_django_versions():
 
 
 def update_pyodide_versions():
+
+    def version_tuple(v: str) -> tuple[int, int, int]:
+        return tuple(int(x) for x in v.split("."))  # type: ignore
+
     vers_re = r"(\d+\.\d+\.\d+)"
-    all_versions = re.findall(
+    all_pyodide_build_versions = re.findall(
         f"pyodide_build-{vers_re}-py3-none-any.whl",  # excludes pre-releases
         requests.get("https://pypi.org/simple/pyodide-build/").text,
     )
-    for pyodide_version in sorted(
+    pyodide_build_version = max(
         # Don't just pick the most recent version; find the highest stable version.
-        set(all_versions),
-        key=lambda version: tuple(int(x) for x in version.split(".")),
-        reverse=True,
-    ):
-        makefile_url = f"https://raw.githubusercontent.com/pyodide/pyodide/{pyodide_version}/Makefile.envs"
-        match = re.search(
-            rf"export PYVERSION \?= {vers_re}\nexport PYODIDE_EMSCRIPTEN_VERSION \?= {vers_re}\n",
-            requests.get(makefile_url).text,
+        set(all_pyodide_build_versions),
+        key=version_tuple,
+    )
+
+    cross_build_environments_url = "https://raw.githubusercontent.com/pyodide/pyodide/refs/heads/main/pyodide-cross-build-environments.json"
+    cross_build_environments_data = requests.get(cross_build_environments_url).json()
+
+    # Find the latest stable release for the Pyodide runtime/xbuildenv that is compatible
+    # with the pyodide-build version we found
+    stable_releases = [
+        release
+        for release in cross_build_environments_data["releases"].values()
+        if re.fullmatch(vers_re, release["version"])
+    ]
+
+    compatible_releases = []
+    for release in stable_releases:  # sufficiently large values
+        min_build_version = release.get("min_pyodide_build_version", "0.0.0")
+        max_build_version = release.get("max_pyodide_build_version", "999.999.999")
+
+        # Perform version comparisons to avoid getting an incompatible pyodide-build version
+        # with the Pyodide runtime
+        if (
+            version_tuple(min_build_version)
+            <= version_tuple(pyodide_build_version)
+            <= version_tuple(max_build_version)
+        ):
+            compatible_releases.append(release)
+
+    if not compatible_releases:
+        raise RuntimeError(
+            f"No compatible Pyodide release found for pyodide-build {pyodide_build_version}"
         )
-        if match is not None:
-            python_version, emscripten_version = match.groups()
-            break
+
+    pyodide_release = max(
+        compatible_releases,
+        key=lambda release: version_tuple(release["version"]),
+    )
+
+    pyodide_version = pyodide_release["version"]
+    python_version = pyodide_release["python_version"]
+
     ci_file = tools.ROOT / ".github/workflows/main.yml"
     config = ci_file.read_text(encoding="utf-8")
     for name, var in [
         ("PYODIDE", pyodide_version),
+        ("PYODIDE_BUILD", pyodide_build_version),
         ("PYTHON", python_version),
-        ("EMSCRIPTEN", emscripten_version),
     ]:
         config = re.sub(f"{name}_VERSION: {vers_re}", f"{name}_VERSION: {var}", config)
     ci_file.write_text(config, encoding="utf-8")