perf: Minor improvements

Author: Stranger6667

docs/changelog.rst

@@ -4,6 +4,10 @@ Changelog
 `Unreleased`_ - TBD
 -------------------
 
+**Performance**
+
+- Improve performance on recent Hypothesis versions.
+
 `0.6.0`_ - 2022-04-25
 ---------------------
 

src/hypothesis_graphql/_strategies/primitives.py

@@ -9,39 +9,42 @@
 MIN_INT = -(2**31)
 MAX_INT = 2**31 - 1
 
+TEXT_STRATEGY = st.text(alphabet=st.characters(blacklist_categories=("Cs",), max_codepoint=0xFFFF))
+
 
 def scalar(type_: graphql.GraphQLScalarType, nullable: bool = True) -> st.SearchStrategy[ScalarValueNode]:
-    if type_.name == "Int":
+    type_name = type_.name
+    if type_name == "Int":
         return int_(nullable)
-    if type_.name == "Float":
+    if type_name == "Float":
         return float_(nullable)
-    if type_.name == "String":
+    if type_name == "String":
         return string(nullable)
-    if type_.name == "ID":
+    if type_name == "ID":
         return id_(nullable)
-    if type_.name == "Boolean":
+    if type_name == "Boolean":
         return boolean(nullable)
     raise TypeError("Custom scalar types are not supported")
 
 
 def enum(type_: graphql.GraphQLEnumType, nullable: bool = True) -> st.SearchStrategy[graphql.EnumValueNode]:
-    value = st.sampled_from(list(type_.values))
-    return maybe_null(value.map(make_enum_node), nullable)
+    values = st.sampled_from(list(type_.values))
+    return maybe_null(values.map(make_enum_node), nullable)
 
 
 def int_(nullable: bool = True) -> st.SearchStrategy[graphql.IntValueNode]:
-    value = st.integers(min_value=MIN_INT, max_value=MAX_INT)
-    return maybe_null(value.map(make_int_node), nullable)
+    values = st.integers(min_value=MIN_INT, max_value=MAX_INT)
+    return maybe_null(values.map(make_int_node), nullable)
 
 
 def float_(nullable: bool = True) -> st.SearchStrategy[graphql.FloatValueNode]:
-    value = st.floats(allow_infinity=False, allow_nan=False)
-    return maybe_null(value.map(make_float_node), nullable)
+    values = st.floats(allow_infinity=False, allow_nan=False)
+    return maybe_null(values.map(make_float_node), nullable)
 
 
 def string(nullable: bool = True) -> st.SearchStrategy[graphql.StringValueNode]:
-    value = st.text(alphabet=st.characters(blacklist_categories=("Cs",), max_codepoint=0xFFFF))
-    return maybe_null(value.map(make_string_node), nullable)
+    values = st.text(alphabet=st.characters(blacklist_categories=("Cs",), max_codepoint=0xFFFF))
+    return maybe_null(values.map(make_string_node), nullable)
 
 
 def id_(nullable: bool = True) -> st.SearchStrategy[Union[graphql.StringValueNode, graphql.IntValueNode]]:

src/hypothesis_graphql/_strategies/selections.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable, Dict, Generator, Iterable, List, Optional, Tuple, TypeVar, Union
+import operator
+from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, TypeVar
 
 import graphql
 from graphql import is_equal_type
@@ -114,14 +115,17 @@ def selections_for_type(
         if not implementations:
             # Shortcut when there are no implementations - take fields from the interface itself
             return selections(context, field_type)
-        return unique_by(implementations, lambda v: v.name).flatmap(lambda t: interfaces(context, field_type, t))
+        return unique_by(implementations, BY_NAME).flatmap(lambda t: interfaces(context, field_type, t))
     if isinstance(field_type, graphql.GraphQLUnionType):
         # A union is a set of object types - take a subset of them and generate inline fragments
-        return unique_by(field_type.types, lambda m: m.name).flatmap(lambda m: inline_fragments(context, m))
+        return unique_by(field_type.types, BY_NAME).flatmap(lambda m: inline_fragments(context, m))
     # Other types don't have fields
     return st.none()
 
 
+BY_NAME = operator.attrgetter("name")
+
+
 def interfaces(
     context: Context, interface: graphql.GraphQLInterfaceType, implementations: List[InterfaceOrObject]
 ) -> st.SearchStrategy[SelectionNodes]:
@@ -132,18 +136,16 @@ def interfaces(
     if overlapping_fields:
         return compose_interfaces_with_filter(selections(context, interface), strategies, implementations)
     # No overlapping - safe to choose any subset of fields within the interface itself and any fragment
-    return st.tuples(selections(context, interface), *strategies).map(flatten).map(list)  # type: ignore
+    return st.tuples(selections(context, interface), *strategies).map(flatten)  # type: ignore
 
 
 T = TypeVar("T")
 
 
-def flatten(items: Tuple[Union[T, List[T]], ...]) -> Generator[T, None, None]:
-    for item in items:
-        if isinstance(item, list):
-            yield from item
-        else:
-            yield item
+def flatten(items: Tuple[List[T], T]) -> List[T]:
+    output = items[0]
+    output.extend(items[1:])
+    return output
 
 
 def inline_fragments(context: Context, items: List[graphql.GraphQLObjectType]) -> st.SearchStrategy[SelectionNodes]: