hypothesis 6.135.12__tar.gz → 6.135.14__tar.gz

{hypothesis-6.135.12 → hypothesis-6.135.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypothesis
-Version: 6.135.12
+Version: 6.135.14
 Summary: A library for property-based testing
 Author-email: "David R. MacIver and Zac Hatfield-Dodds" <david@drmaciver.com>
 License-Expression: MPL-2.0

{hypothesis-6.135.12 → hypothesis-6.135.14}/src/hypothesis/extra/ghostwriter.py

@@ -687,9 +687,11 @@ def _valid_syntax_repr(strategy):
                     elems.append(s)
                     seen.add(repr(s))
             strategy = st.one_of(elems or st.nothing())
-        # Trivial special case because the wrapped repr for text() is terrible.
+        # hardcode some special cases for nicer reprs
         if strategy == st.text().wrapped_strategy:
             return set(), "text()"
+        if strategy == st.from_type(type):
+            return set(), "from_type(type)"
         # Remove any typevars; we don't exploit them so they're just clutter here
         if (
             isinstance(strategy, LazyStrategy)

{hypothesis-6.135.12 → hypothesis-6.135.14}/src/hypothesis/internal/reflection.py

@@ -453,7 +453,7 @@ def get_pretty_function_description(f: object) -> str:
         return pretty(f)
     if not hasattr(f, "__name__"):
         return repr(f)
-    name = f.__name__  # type: ignore # validated by hasattr above
+    name = f.__name__  # type: ignore
     if name == "<lambda>":
         return extract_lambda_source(f)
     elif isinstance(f, (types.MethodType, types.BuiltinMethodType)):

{hypothesis-6.135.12 → hypothesis-6.135.14}/src/hypothesis/stateful.py

@@ -504,8 +504,12 @@ class Rule:
         self.bundles = tuple(bundles)
 
     def __repr__(self) -> str:
-        rep = get_pretty_function_description
-        bits = [f"{k}={rep(v)}" for k, v in dataclasses.asdict(self).items() if v]
+        bits = [
+            f"{field.name}="
+            f"{get_pretty_function_description(getattr(self, field.name))}"
+            for field in dataclasses.fields(self)
+            if getattr(self, field.name)
+        ]
         return f"{self.__class__.__name__}({', '.join(bits)})"
 
 

{hypothesis-6.135.12 → hypothesis-6.135.14}/src/hypothesis/strategies/_internal/core.py

@@ -196,13 +196,17 @@ def sampled_from(
     that behaviour, use ``sampled_from(seq) if seq else nothing()``.
     """
     values = check_sample(elements, "sampled_from")
-    try:
-        if isinstance(elements, type) and issubclass(elements, enum.Enum):
-            repr_ = f"sampled_from({elements.__module__}.{elements.__name__})"
-        else:
-            repr_ = f"sampled_from({elements!r})"
-    except Exception:  # pragma: no cover
-        repr_ = None
+    force_repr = None
+    # check_sample converts to tuple unconditionally, but we want to preserve
+    # square braces for list reprs.
+    # This will not cover custom sequence implementations which return different
+    # braces (or other, more unusual things) for their reprs, but this is a tradeoff
+    # between repr accuracy and greedily-evaluating all sequence reprs (at great
+    # cost for large sequences).
+    force_repr_braces = ("[", "]") if isinstance(elements, list) else None
+    if isinstance(elements, type) and issubclass(elements, enum.Enum):
+        force_repr = f"sampled_from({elements.__module__}.{elements.__name__})"
+
     if isclass(elements) and issubclass(elements, enum.Flag):
         # Combinations of enum.Flag members (including empty) are also members.  We generate these
         # dynamically, because static allocation takes O(2^n) memory.  LazyStrategy is used for the
@@ -237,7 +241,7 @@ def sampled_from(
                 .flatmap(lambda r: sets(sampled_from(flags), min_size=r, max_size=r))
                 .map(lambda s: elements(reduce(operator.or_, s))),
             ]
-        return LazyStrategy(one_of, args=inner, kwargs={}, force_repr=repr_)
+        return LazyStrategy(one_of, args=inner, kwargs={}, force_repr=force_repr)
     if not values:
         if (
             isinstance(elements, type)
@@ -253,7 +257,9 @@ def sampled_from(
         raise InvalidArgument("Cannot sample from a length-zero sequence.")
     if len(values) == 1:
         return just(values[0])
-    return SampledFromStrategy(values, repr_)
+    return SampledFromStrategy(
+        values, force_repr=force_repr, force_repr_braces=force_repr_braces
+    )
 
 
 @cacheable

{hypothesis-6.135.12 → hypothesis-6.135.14}/src/hypothesis/strategies/_internal/strategies.py

@@ -537,7 +537,9 @@ class SampledFromStrategy(SearchStrategy[Ex]):
     def __init__(
         self,
         elements: Sequence[Ex],
-        repr_: Optional[str] = None,
+        *,
+        force_repr: Optional[str] = None,
+        force_repr_braces: Optional[tuple[str, str]] = None,
         transformations: tuple[
             tuple[Literal["filter", "map"], Callable[[Ex], Any]],
             ...,
@@ -546,13 +548,17 @@ class SampledFromStrategy(SearchStrategy[Ex]):
         super().__init__()
         self.elements = cu.check_sample(elements, "sampled_from")
         assert self.elements
-        self.repr_ = repr_
+        self.force_repr = force_repr
+        self.force_repr_braces = force_repr_braces
         self._transformations = transformations
 
+        self._cached_repr: Optional[str] = None
+
     def map(self, pack: Callable[[Ex], T]) -> SearchStrategy[T]:
         s = type(self)(
             self.elements,
-            repr_=self.repr_,
+            force_repr=self.force_repr,
+            force_repr_braces=self.force_repr_braces,
             transformations=(*self._transformations, ("map", pack)),
         )
         # guaranteed by the ("map", pack) transformation
@@ -561,20 +567,30 @@ class SampledFromStrategy(SearchStrategy[Ex]):
     def filter(self, condition: Callable[[Ex], Any]) -> SearchStrategy[Ex]:
         return type(self)(
             self.elements,
-            repr_=self.repr_,
+            force_repr=self.force_repr,
+            force_repr_braces=self.force_repr_braces,
             transformations=(*self._transformations, ("filter", condition)),
         )
 
-    def __repr__(self) -> str:
-        return (
-            self.repr_
-            or "sampled_from(["
-            + ", ".join(map(get_pretty_function_description, self.elements))
-            + "])"
-        ) + "".join(
-            f".{name}({get_pretty_function_description(f)})"
-            for name, f in self._transformations
-        )
+    def __repr__(self):
+        if self._cached_repr is None:
+            rep = get_pretty_function_description
+            elements_s = (
+                ", ".join(rep(v) for v in self.elements[:512]) + ", ..."
+                if len(self.elements) > 512
+                else ", ".join(rep(v) for v in self.elements)
+            )
+            braces = self.force_repr_braces or ("(", ")")
+            instance_s = (
+                self.force_repr or f"sampled_from({braces[0]}{elements_s}{braces[1]})"
+            )
+            transforms_s = "".join(
+                f".{name}({get_pretty_function_description(f)})"
+                for name, f in self._transformations
+            )
+            repr_s = instance_s + transforms_s
+            self._cached_repr = repr_s
+        return self._cached_repr
 
     def calc_label(self) -> int:
         # strategy.label is effectively an under-approximation of structural

{hypothesis-6.135.12 → hypothesis-6.135.14}/src/hypothesis/version.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, 135, 12)
+__version_info__ = (6, 135, 14)
 __version__ = ".".join(map(str, __version_info__))

{hypothesis-6.135.12 → hypothesis-6.135.14}/src/hypothesis.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypothesis
-Version: 6.135.12
+Version: 6.135.14
 Summary: A library for property-based testing
 Author-email: "David R. MacIver and Zac Hatfield-Dodds" <david@drmaciver.com>
 License-Expression: MPL-2.0