Merge pull request #4137 from Zac-HD/filter-rewrites-3

Filter-rewriting for more efficient `from_type(pydantic.types.condate)`

Author: Zac-HD

hypothesis-python/RELEASE.rst

@@ -0,0 +1,5 @@
+RELEASE_TYPE: patch
+
+This patch improves the performance of :func:`~hypothesis.strategies.from_type` with
+`pydantic.types.condate <https://docs.pydantic.dev/latest/api/types/#pydantic.types.condate>`__
+(:issue:`4000`).

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

@@ -236,9 +236,9 @@ def get_numeric_predicate_bounds(predicate: Predicate) -> ConstructivePredicate:
         options = {
             # We're talking about op(arg, x) - the reverse of our usual intuition!
             operator.lt: {"min_value": arg, "exclude_min": True},  # lambda x: arg < x
-            operator.le: {"min_value": arg},  # lambda x: arg <= x
-            operator.eq: {"min_value": arg, "max_value": arg},  # lambda x: arg == x
-            operator.ge: {"max_value": arg},  # lambda x: arg >= x
+            operator.le: {"min_value": arg},  #                      lambda x: arg <= x
+            operator.eq: {"min_value": arg, "max_value": arg},  #    lambda x: arg == x
+            operator.ge: {"max_value": arg},  #                      lambda x: arg >= x
             operator.gt: {"max_value": arg, "exclude_max": True},  # lambda x: arg > x
             # Special-case our default predicates for length bounds
             min_len: {"min_value": arg, "len": True},

hypothesis-python/src/hypothesis/provisional.py

@@ -19,6 +19,7 @@
 # https://tools.ietf.org/html/rfc3696
 
 import string
+from functools import lru_cache
 from importlib import resources
 from typing import Optional
 
@@ -31,15 +32,17 @@
 FRAGMENT_SAFE_CHARACTERS = URL_SAFE_CHARACTERS | {"?", "/"}
 
 
-# This file is sourced from http://data.iana.org/TLD/tlds-alpha-by-domain.txt
-# The file contains additional information about the date that it was last updated.
-traversable = resources.files("hypothesis.vendor") / "tlds-alpha-by-domain.txt"
-_comment, *_tlds = traversable.read_text(encoding="utf-8").splitlines()
-assert _comment.startswith("#")
+@lru_cache(maxsize=1)
+def get_top_level_domains() -> tuple[str, ...]:
+    # This file is sourced from http://data.iana.org/TLD/tlds-alpha-by-domain.txt
+    # The file contains additional information about the date that it was last updated.
+    traversable = resources.files("hypothesis.vendor") / "tlds-alpha-by-domain.txt"
+    _comment, *_tlds = traversable.read_text(encoding="utf-8").splitlines()
+    assert _comment.startswith("#")
 
-# Remove special-use domain names from the list. For more discussion
-# see https://github.com/HypothesisWorks/hypothesis/pull/3572
-TOP_LEVEL_DOMAINS = ["COM", *sorted((d for d in _tlds if d != "ARPA"), key=len)]
+    # Remove special-use domain names from the list. For more discussion
+    # see https://github.com/HypothesisWorks/hypothesis/pull/3572
+    return ("COM", *sorted((d for d in _tlds if d != "ARPA"), key=len))
 
 
 class DomainNameStrategy(st.SearchStrategy):
@@ -101,7 +104,7 @@ def do_draw(self, data):
         # prevent us from generating at least a 1 character subdomain.
         # 3 - Randomize the TLD between upper and lower case characters.
         domain = data.draw(
-            st.sampled_from(TOP_LEVEL_DOMAINS)
+            st.sampled_from(get_top_level_domains())
             .filter(lambda tld: len(tld) + 2 <= self.max_length)
             .flatmap(
                 lambda tld: st.tuples(

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

@@ -9,17 +9,18 @@
 # obtain one at https://mozilla.org/MPL/2.0/.
 
 import datetime as dt
+import operator as op
 import zoneinfo
 from calendar import monthrange
-from functools import lru_cache
+from functools import lru_cache, partial
 from importlib import resources
 from pathlib import Path
 from typing import Optional
 
 from hypothesis.errors import InvalidArgument
 from hypothesis.internal.validation import check_type, check_valid_interval
 from hypothesis.strategies._internal.core import sampled_from
-from hypothesis.strategies._internal.misc import just, none
+from hypothesis.strategies._internal.misc import just, none, nothing
 from hypothesis.strategies._internal.strategies import SearchStrategy
 from hypothesis.strategies._internal.utils import defines_strategy
 
@@ -267,6 +268,37 @@ def do_draw(self, data):
             **draw_capped_multipart(data, self.min_value, self.max_value, DATENAMES)
         )
 
+    def filter(self, condition):
+        if (
+            isinstance(condition, partial)
+            and len(args := condition.args) == 1
+            and not condition.keywords
+            and isinstance(arg := args[0], dt.date)
+            and condition.func in (op.lt, op.le, op.eq, op.ge, op.gt)
+        ):
+            try:
+                arg += dt.timedelta(days={op.lt: 1, op.gt: -1}.get(condition.func, 0))
+            except OverflowError:  # gt date.max, or lt date.min
+                return nothing()
+            lo, hi = {
+                # We're talking about op(arg, x) - the reverse of our usual intuition!
+                op.lt: (arg, self.max_value),  # lambda x: arg < x
+                op.le: (arg, self.max_value),  # lambda x: arg <= x
+                op.eq: (arg, arg),  #            lambda x: arg == x
+                op.ge: (self.min_value, arg),  # lambda x: arg >= x
+                op.gt: (self.min_value, arg),  # lambda x: arg > x
+            }[condition.func]
+            lo = max(lo, self.min_value)
+            hi = min(hi, self.max_value)
+            print(lo, hi)
+            if hi < lo:
+                return nothing()
+            if lo <= self.min_value and self.max_value <= hi:
+                return self
+            return dates(lo, hi)
+
+        return super().filter(condition)
+
 
 @defines_strategy(force_reusable_values=True)
 def dates(

hypothesis-python/tests/cover/test_filter_rewriting.py

@@ -8,6 +8,7 @@
 # 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 datetime as dt
 import decimal
 import math
 import operator
@@ -624,3 +625,20 @@ def test_regex_filter_rewriting(data, strategy, pattern, method):
 @given(st.text().filter(re.compile("abc").sub))
 def test_error_on_method_which_requires_multiple_args(_):
     pass
+
+
+def test_dates_filter_rewriting():
+    today = dt.date.today()
+
+    assert st.dates().filter(partial(operator.lt, dt.date.max)).is_empty
+    assert st.dates().filter(partial(operator.gt, dt.date.min)).is_empty
+    assert st.dates(min_value=today).filter(partial(operator.gt, today)).is_empty
+    assert st.dates(max_value=today).filter(partial(operator.lt, today)).is_empty
+
+    bare = unwrap_strategies(st.dates())
+    assert bare.filter(partial(operator.ge, dt.date.max)) is bare
+    assert bare.filter(partial(operator.le, dt.date.min)) is bare
+
+    new = bare.filter(partial(operator.le, today))
+    assert not new.is_empty
+    assert new is not bare