make max_size required for draw_string and draw_bytes

Author: tybug

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

@@ -111,12 +111,12 @@ class FloatKWargs(TypedDict):
 class StringKWargs(TypedDict):
     intervals: IntervalSet
     min_size: int
-    max_size: Optional[int]
+    max_size: int
 
 
 class BytesKWargs(TypedDict):
     min_size: int
-    max_size: Optional[int]
+    max_size: int
 
 
 class BooleanKWargs(TypedDict):
@@ -1317,7 +1317,7 @@ def draw_string(
         intervals: IntervalSet,
         *,
         min_size: int = 0,
-        max_size: Optional[int] = None,
+        max_size: int = COLLECTION_DEFAULT_MAX_SIZE,
         forced: Optional[str] = None,
         fake_forced: bool = False,
     ) -> str:
@@ -1326,8 +1326,8 @@ def draw_string(
     @abc.abstractmethod
     def draw_bytes(
         self,
-        min_size: int,
-        max_size: Optional[int],
+        min_size: int = 0,
+        max_size: int = COLLECTION_DEFAULT_MAX_SIZE,
         *,
         forced: Optional[bytes] = None,
         fake_forced: bool = False,
@@ -1614,14 +1614,10 @@ def draw_string(
         intervals: IntervalSet,
         *,
         min_size: int = 0,
-        max_size: Optional[int] = None,
+        max_size: int = COLLECTION_DEFAULT_MAX_SIZE,
         forced: Optional[str] = None,
         fake_forced: bool = False,
     ) -> str:
-        if max_size is None:
-            max_size = COLLECTION_DEFAULT_MAX_SIZE
-
-        assert forced is None or min_size <= len(forced) <= max_size
         assert self._cd is not None
 
         average_size = min(
@@ -1672,16 +1668,12 @@ def draw_string(
 
     def draw_bytes(
         self,
-        min_size: int,
-        max_size: Optional[int],
+        min_size: int = 0,
+        max_size: int = COLLECTION_DEFAULT_MAX_SIZE,
         *,
         forced: Optional[bytes] = None,
         fake_forced: bool = False,
     ) -> bytes:
-        if max_size is None:
-            max_size = COLLECTION_DEFAULT_MAX_SIZE
-
-        assert forced is None or min_size <= len(forced) <= max_size
         assert self._cd is not None
 
         buf = bytearray()
@@ -2251,12 +2243,12 @@ def draw_string(
         intervals: IntervalSet,
         *,
         min_size: int = 0,
-        max_size: Optional[int] = None,
+        max_size: int = COLLECTION_DEFAULT_MAX_SIZE,
         forced: Optional[str] = None,
         fake_forced: bool = False,
         observe: bool = True,
     ) -> str:
-        assert forced is None or min_size <= len(forced)
+        assert forced is None or min_size <= len(forced) <= max_size
         assert min_size >= 0
 
         kwargs: StringKWargs = self._pooled_kwargs(
@@ -2291,14 +2283,14 @@ def draw_string(
 
     def draw_bytes(
         self,
-        min_size: int,
-        max_size: Optional[int],
+        min_size: int = 0,
+        max_size: int = COLLECTION_DEFAULT_MAX_SIZE,
         *,
         forced: Optional[bytes] = None,
         fake_forced: bool = False,
         observe: bool = True,
     ) -> bytes:
-        assert forced is None or min_size <= len(forced)
+        assert forced is None or min_size <= len(forced) <= max_size
         assert min_size >= 0
 
         kwargs: BytesKWargs = self._pooled_kwargs(

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

@@ -147,8 +147,6 @@ def _repr_pretty_(self, p, cycle):
 
 
 def compute_max_children(ir_type, kwargs):
-    from hypothesis.internal.conjecture.data import COLLECTION_DEFAULT_MAX_SIZE
-
     if ir_type == "integer":
         min_value = kwargs["min_value"]
         max_value = kwargs["max_value"]
@@ -181,9 +179,6 @@ def compute_max_children(ir_type, kwargs):
         min_size = kwargs["min_size"]
         max_size = kwargs["max_size"]
 
-        if max_size is None:
-            max_size = COLLECTION_DEFAULT_MAX_SIZE
-
         definitely_too_large = max_size * math.log(2**8) > math.log(
             MAX_CHILDREN_EFFECTIVELY_INFINITE
         )
@@ -196,9 +191,6 @@ def compute_max_children(ir_type, kwargs):
         max_size = kwargs["max_size"]
         intervals = kwargs["intervals"]
 
-        if max_size is None:
-            max_size = COLLECTION_DEFAULT_MAX_SIZE
-
         if len(intervals) == 0:
             # Special-case the empty alphabet to avoid an error in math.log(0).
             # Only possibility is the empty string.

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

@@ -16,6 +16,7 @@
 
 from hypothesis.errors import HypothesisWarning, InvalidArgument
 from hypothesis.internal import charmap
+from hypothesis.internal.conjecture.data import COLLECTION_DEFAULT_MAX_SIZE
 from hypothesis.internal.filtering import max_len, min_len
 from hypothesis.internal.intervalsets import IntervalSet
 from hypothesis.internal.reflection import get_pretty_function_description
@@ -158,7 +159,13 @@ def do_draw(self, data):
         elems = unwrap_strategies(self.element_strategy)
         if isinstance(elems, OneCharStringStrategy):
             return data.draw_string(
-                elems.intervals, min_size=self.min_size, max_size=self.max_size
+                elems.intervals,
+                min_size=self.min_size,
+                max_size=(
+                    COLLECTION_DEFAULT_MAX_SIZE
+                    if self.max_size == float("inf")
+                    else self.max_size
+                ),
             )
         return "".join(super().do_draw(data))
 
@@ -338,7 +345,9 @@ def _identifier_characters():
 class BytesStrategy(SearchStrategy):
     def __init__(self, min_size: int, max_size: Optional[int]):
         self.min_size = min_size
-        self.max_size = max_size if max_size is not None else float("inf")
+        self.max_size = (
+            max_size if max_size is not None else COLLECTION_DEFAULT_MAX_SIZE
+        )
 
     def do_draw(self, data):
         return data.draw_bytes(self.min_size, self.max_size)

hypothesis-python/tests/conjecture/common.py

@@ -15,7 +15,12 @@
 from hypothesis.control import current_build_context
 from hypothesis.errors import InvalidArgument
 from hypothesis.internal.conjecture import engine as engine_module
-from hypothesis.internal.conjecture.data import ConjectureData, IRNode, Status
+from hypothesis.internal.conjecture.data import (
+    COLLECTION_DEFAULT_MAX_SIZE,
+    ConjectureData,
+    IRNode,
+    Status,
+)
 from hypothesis.internal.conjecture.engine import BUFFER_SIZE, ConjectureRunner
 from hypothesis.internal.conjecture.utils import calc_label_from_name
 from hypothesis.internal.entropy import deterministic_PRNG
@@ -172,7 +177,7 @@ def draw_integer_kwargs(
 @st.composite
 def _collection_kwargs(draw, *, forced, use_min_size=True, use_max_size=True):
     min_size = 0
-    max_size = None
+    max_size = COLLECTION_DEFAULT_MAX_SIZE
     # collections are quite expensive in entropy. cap to avoid overruns.
     cap = 50
 

hypothesis-python/tests/conjecture/test_alt_backend.py

@@ -24,6 +24,7 @@
 from hypothesis.internal.compat import int_to_bytes
 from hypothesis.internal.conjecture.data import (
     AVAILABLE_PROVIDERS,
+    COLLECTION_DEFAULT_MAX_SIZE,
     ConjectureData,
     PrimitiveProvider,
 )
@@ -132,7 +133,7 @@ def draw_string(
         intervals: IntervalSet,
         *,
         min_size: int = 0,
-        max_size: Optional[int] = None,
+        max_size: int = COLLECTION_DEFAULT_MAX_SIZE,
         forced: Optional[str] = None,
         fake_forced: bool = False,
     ) -> str:
@@ -145,8 +146,8 @@ def draw_string(
 
     def draw_bytes(
         self,
-        min_size: int,
-        max_size: Optional[int],
+        min_size: int = 0,
+        max_size: int = COLLECTION_DEFAULT_MAX_SIZE,
         *,
         forced: Optional[bytes] = None,
         fake_forced: bool = False,

hypothesis-python/tests/conjecture/test_ir.py

@@ -17,6 +17,7 @@
 from hypothesis import assume, example, given, strategies as st
 from hypothesis.errors import StopTest
 from hypothesis.internal.conjecture.data import (
+    COLLECTION_DEFAULT_MAX_SIZE,
     ConjectureData,
     IRNode,
     Status,
@@ -88,7 +89,7 @@ def test_compute_max_children_is_positive(ir_type_and_kwargs):
             "string",
             {
                 "min_size": 0,
-                "max_size": None,
+                "max_size": COLLECTION_DEFAULT_MAX_SIZE,
                 "intervals": IntervalSet.from_string("a"),
             },
             MAX_CHILDREN_EFFECTIVELY_INFINITE,
@@ -114,7 +115,7 @@ def test_compute_max_children_is_positive(ir_type_and_kwargs):
             "bytes",
             {
                 "min_size": 0,
-                "max_size": None,
+                "max_size": COLLECTION_DEFAULT_MAX_SIZE,
             },
             MAX_CHILDREN_EFFECTIVELY_INFINITE,
         ),
@@ -363,7 +364,7 @@ def test_ir_nodes(random):
             kwargs={
                 "intervals": IntervalSet.from_string("abcd"),
                 "min_size": 0,
-                "max_size": None,
+                "max_size": COLLECTION_DEFAULT_MAX_SIZE,
             },
             was_forced=True,
         ),
@@ -476,7 +477,7 @@ def test_data_with_changed_forced_value(node):
         kwargs={
             "intervals": IntervalSet.from_string("bcda"),
             "min_size": 4,
-            "max_size": None,
+            "max_size": COLLECTION_DEFAULT_MAX_SIZE,
         },
         was_forced=True,
     )
@@ -680,7 +681,7 @@ def test_forced_nodes_are_trivial(node):
             kwargs={
                 "intervals": IntervalSet.from_string("abcd"),
                 "min_size": 0,
-                "max_size": None,
+                "max_size": COLLECTION_DEFAULT_MAX_SIZE,
             },
             was_forced=False,
         ),
@@ -690,7 +691,7 @@ def test_forced_nodes_are_trivial(node):
             kwargs={
                 "intervals": IntervalSet.from_string("bcda"),
                 "min_size": 4,
-                "max_size": None,
+                "max_size": COLLECTION_DEFAULT_MAX_SIZE,
             },
             was_forced=False,
         ),
@@ -703,7 +704,7 @@ def test_forced_nodes_are_trivial(node):
         IRNode(
             ir_type="bytes",
             value=bytes(2),
-            kwargs={"min_size": 2, "max_size": None},
+            kwargs={"min_size": 2, "max_size": COLLECTION_DEFAULT_MAX_SIZE},
             was_forced=False,
         ),
         IRNode(
@@ -834,7 +835,7 @@ def values(draw):
             kwargs={
                 "intervals": IntervalSet.from_string("abcd"),
                 "min_size": 1,
-                "max_size": None,
+                "max_size": COLLECTION_DEFAULT_MAX_SIZE,
             },
             was_forced=False,
         ),
@@ -847,7 +848,7 @@ def values(draw):
         IRNode(
             ir_type="bytes",
             value=bytes(1),
-            kwargs={"min_size": 0, "max_size": None},
+            kwargs={"min_size": 0, "max_size": COLLECTION_DEFAULT_MAX_SIZE},
             was_forced=False,
         ),
         IRNode(

hypothesis-python/tests/cover/test_filter_rewriting.py

@@ -20,14 +20,15 @@
 
 from hypothesis import HealthCheck, given, settings, strategies as st
 from hypothesis.errors import HypothesisWarning, Unsatisfiable
+from hypothesis.internal.conjecture.data import COLLECTION_DEFAULT_MAX_SIZE
 from hypothesis.internal.filtering import max_len, min_len
 from hypothesis.internal.floats import next_down, next_up
 from hypothesis.internal.reflection import get_pretty_function_description
 from hypothesis.strategies._internal.core import data
 from hypothesis.strategies._internal.lazy import LazyStrategy, unwrap_strategies
 from hypothesis.strategies._internal.numbers import FloatStrategy, IntegersStrategy
 from hypothesis.strategies._internal.strategies import FilteredStrategy, MappedStrategy
-from hypothesis.strategies._internal.strings import TextStrategy
+from hypothesis.strategies._internal.strings import BytesStrategy, TextStrategy
 
 from tests.common.debug import check_can_generate_examples
 from tests.common.utils import fails_with
@@ -505,6 +506,10 @@ def test_filter_rewriting_text_lambda_len(data, strategy, predicate, start, end)
     if isinstance(unwrapped.filtered_strategy, MappedStrategy):
         unwrapped = unwrapped.filtered_strategy.mapped_strategy
 
+    # binary() has a finite-but-effectively-infinite cap instead.
+    if isinstance(unwrapped_nofilter, BytesStrategy) and end == math.inf:
+        end = COLLECTION_DEFAULT_MAX_SIZE
+
     assert unwrapped.filtered_strategy.min_size == start
     assert unwrapped.filtered_strategy.max_size == end
     value = data.draw(s)