Migrate DataTree to the new IR

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

@@ -20,7 +20,7 @@
     random_selection_order,
 )
 from hypothesis.internal.conjecture.data import (
-    DRAW_FLOAT_LABEL,
+    DRAW_FLOAT_INNER_LABEL,
     ConjectureData,
     ConjectureResult,
     Status,
@@ -1201,7 +1201,7 @@ def minimize_floats(self, chooser):
         ex = chooser.choose(
             self.examples,
             lambda ex: (
-                ex.label == DRAW_FLOAT_LABEL
+                ex.label == DRAW_FLOAT_INNER_LABEL
                 and len(ex.children) == 2
                 and ex.children[1].length == 8
             ),

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

@@ -81,14 +81,6 @@ def check_sample(
     return tuple(values)
 
 
-def choice(
-    data: "ConjectureData", values: Sequence[T], *, forced: Optional[T] = None
-) -> T:
-    forced_i = None if forced is None else values.index(forced)
-    i = data.draw_integer(0, len(values) - 1, forced=forced_i)
-    return values[i]
-
-
 class Sampler:
     """Sampler based on Vose's algorithm for the alias method. See
     http://www.keithschwarz.com/darts-dice-coins/ for a good explanation.
@@ -109,13 +101,12 @@ class Sampler:
 
     table: List[Tuple[int, int, float]]  # (base_idx, alt_idx, alt_chance)
 
-    def __init__(self, weights: Sequence[float]):
-        n = len(weights)
+    def __init__(self, weights: Sequence[float], *, observe: bool = True):
+        self.observe = observe
 
+        n = len(weights)
         table: "list[list[int | float | None]]" = [[i, None, None] for i in range(n)]
-
         total = sum(weights)
-
         num_type = type(total)
 
         zero = num_type(0)  # type: ignore
@@ -182,11 +173,13 @@ def sample(self, data: "ConjectureData", forced: Optional[int] = None) -> int:
             if forced is None
             else next((b, a, a_c) for (b, a, a_c) in self.table if forced in (b, a))
         )
-        base, alternate, alternate_chance = choice(
-            data, self.table, forced=forced_choice
+        base, alternate, alternate_chance = data.choice(
+            self.table, forced=forced_choice, observe=self.observe
         )
         use_alternate = data.draw_boolean(
-            alternate_chance, forced=None if forced is None else forced == alternate
+            alternate_chance,
+            forced=None if forced is None else forced == alternate,
+            observe=self.observe,
         )
         data.stop_example()
         if use_alternate:
@@ -198,7 +191,7 @@ def sample(self, data: "ConjectureData", forced: Optional[int] = None) -> int:
 
 
 INT_SIZES = (8, 16, 32, 64, 128)
-INT_SIZES_SAMPLER = Sampler((4.0, 8.0, 1.0, 1.0, 0.5))
+INT_SIZES_SAMPLER = Sampler((4.0, 8.0, 1.0, 1.0, 0.5), observe=False)
 
 
 class many:
@@ -221,6 +214,7 @@ def __init__(
         average_size: Union[int, float],
         *,
         forced: Optional[int] = None,
+        observe=True,
     ) -> None:
         assert 0 <= min_size <= average_size <= max_size
         assert forced is None or min_size <= forced <= max_size
@@ -231,20 +225,14 @@ def __init__(
         self.p_continue = _calc_p_continue(average_size - min_size, max_size - min_size)
         self.count = 0
         self.rejections = 0
-        self.drawn = False
         self.force_stop = False
         self.rejected = False
+        self.observe = observe
 
     def more(self) -> bool:
         """Should I draw another element to add to the collection?"""
-        if self.drawn:
-            self.data.stop_example(discard=self.rejected)
-
-        self.drawn = True
         self.rejected = False
 
-        self.data.start_example(ONE_FROM_MANY_LABEL)
-
         if self.min_size == self.max_size:
             # if we have to hit an exact size, draw unconditionally until that
             # point, and no further.
@@ -263,14 +251,13 @@ def more(self) -> bool:
             elif self.forced_size is not None:
                 forced_result = self.count < self.forced_size
             should_continue = self.data.draw_boolean(
-                self.p_continue, forced=forced_result
+                self.p_continue, forced=forced_result, observe=self.observe
             )
 
         if should_continue:
             self.count += 1
             return True
         else:
-            self.data.stop_example()
             return False
 
     def reject(self, why: Optional[str] = None) -> None:

hypothesis-python/src/hypothesis/internal/intervalsets.py

@@ -99,6 +99,9 @@ def __sub__(self, other):
     def __and__(self, other):
         return self.intersection(other)
 
+    def __eq__(self, other):
+        return isinstance(other, IntervalSet) and (other.intervals == self.intervals)
+
     def union(self, other):
         """Merge two sequences of intervals into a single tuple of intervals.
 

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

@@ -586,7 +586,7 @@ def do_filtered_draw(self, data):
         # The speculative index didn't work out, but at this point we've built
         # and can choose from the complete list of allowed indices and elements.
         if allowed:
-            i, element = cu.choice(data, allowed)
+            i, element = data.choice(allowed)
             data.draw_integer(0, len(self.elements) - 1, forced=i)
             return element
         # If there are no allowed indices, the filter couldn't be satisfied.

hypothesis-python/tests/common/debug.py

@@ -22,15 +22,20 @@ class Timeout(BaseException):
 
 
 def minimal(definition, condition=lambda x: True, settings=None, timeout_after=10):
+    definition.validate()
+    runtime = None
+    result = None
+
     def wrapped_condition(x):
+        nonlocal runtime
         if timeout_after is not None:
             if runtime:
-                runtime[0] += TIME_INCREMENT
-                if runtime[0] >= timeout_after:
+                runtime += TIME_INCREMENT
+                if runtime >= timeout_after:
                     raise Timeout
         result = condition(x)
         if result and not runtime:
-            runtime.append(0.0)
+            runtime = 0.0
         return result
 
     if settings is None:
@@ -51,16 +56,14 @@ def wrapped_condition(x):
     )
     def inner(x):
         if wrapped_condition(x):
-            result[:] = [x]
+            nonlocal result
+            result = x
             raise Found
 
-    definition.validate()
-    runtime = []
-    result = []
     try:
         inner()
     except Found:
-        return result[0]
+        return result
     raise Unsatisfiable(
         "Could not find any examples from %r that satisfied %s"
         % (definition, get_pretty_function_description(condition))