perf: Avoid lambdas

It improves performance on recent Hypothesis versions

Author: Stranger6667

src/hypothesis_graphql/_strategies/primitives.py

@@ -1,5 +1,5 @@
 """Strategies for simple types like scalars or enums."""
-from typing import Union
+from typing import Type, Union
 
 import graphql
 from hypothesis import strategies as st
@@ -26,33 +26,65 @@ def scalar(type_: graphql.GraphQLScalarType, nullable: bool = True) -> st.Search
 
 def enum(type_: graphql.GraphQLEnumType, nullable: bool = True) -> st.SearchStrategy[graphql.EnumValueNode]:
     value = st.sampled_from(list(type_.values))
-    return maybe_null(value.map(lambda v: graphql.EnumValueNode(value=v)), nullable)
+    return maybe_null(value.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(lambda v: graphql.IntValueNode(value=str(v))), nullable)
+    return maybe_null(value.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(lambda v: graphql.FloatValueNode(value=str(v))), nullable)
+    return maybe_null(value.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(lambda v: graphql.StringValueNode(value=v)), nullable)
+    return maybe_null(value.map(make_string_node), nullable)
 
 
 def id_(nullable: bool = True) -> st.SearchStrategy[Union[graphql.StringValueNode, graphql.IntValueNode]]:
     return string(nullable) | int_(nullable)
 
 
 def boolean(nullable: bool = True) -> st.SearchStrategy[graphql.BooleanValueNode]:
-    return maybe_null(st.booleans().map(lambda v: graphql.BooleanValueNode(value=v)), nullable)
+    return maybe_null(st.booleans().map(make_boolean_node), nullable)
 
 
 def maybe_null(strategy: st.SearchStrategy, nullable: bool) -> st.SearchStrategy:
     if nullable:
         strategy |= st.just(graphql.NullValueNode())
     return strategy
+
+
+# Separate functions to use in `map` and avoid costs of handling lambda
+# constructors are passed as locals to optimize the byte code a little
+
+
+def make_boolean_node(
+    value: bool, BooleanValueNode: Type[graphql.BooleanValueNode] = graphql.BooleanValueNode
+) -> graphql.BooleanValueNode:
+    return BooleanValueNode(value=value)
+
+
+def make_string_node(
+    value: str, StringValueNode: Type[graphql.StringValueNode] = graphql.StringValueNode
+) -> graphql.StringValueNode:
+    return StringValueNode(value=value)
+
+
+def make_float_node(
+    value: float, FloatValueNode: Type[graphql.FloatValueNode] = graphql.FloatValueNode
+) -> graphql.FloatValueNode:
+    return FloatValueNode(value=str(value))
+
+
+def make_int_node(value: int, IntValueNode: Type[graphql.IntValueNode] = graphql.IntValueNode) -> graphql.IntValueNode:
+    return IntValueNode(value=str(value))
+
+
+def make_enum_node(
+    value: str, EnumValueNode: Type[graphql.EnumValueNode] = graphql.EnumValueNode
+) -> graphql.EnumValueNode:
+    return EnumValueNode(value=value)

src/hypothesis_graphql/_strategies/selections.py

@@ -20,7 +20,16 @@ def selections(
     else:
         subset = object_type.fields
     # minimum 1 field, an empty query is not valid
-    return subset_of_fields(subset).flatmap(lambda f: list_of_nodes(context, f, strategy=field_nodes))
+    return subset_of_fields(subset).flatmap(list_of_nodes_factory(context, field_nodes))
+
+
+def list_of_nodes_factory(
+    context: Context, strategy: Callable[[Context, str, Field], st.SearchStrategy]
+) -> Callable[[List[Tuple]], st.SearchStrategy[List]]:
+    def factory(items: List[Tuple]) -> st.SearchStrategy[List]:
+        return list_of_nodes(context, items, strategy=strategy)
+
+    return factory
 
 
 def unwrap_field_type(field: Field) -> graphql.GraphQLNamedType:
@@ -34,12 +43,22 @@ def unwrap_field_type(field: Field) -> graphql.GraphQLNamedType:
 def field_nodes(context: Context, name: str, field: graphql.GraphQLField) -> st.SearchStrategy[graphql.FieldNode]:
     """Generate a single field node with optional children."""
     return st.tuples(list_of_arguments(context, field.args), selections_for_type(context, field)).map(
-        lambda tup: graphql.FieldNode(
+        field_node_factory(name)
+    )
+
+
+FieldNodeInput = Tuple[List[graphql.ArgumentNode], Optional[SelectionNodes]]
+
+
+def field_node_factory(name: str) -> Callable[[FieldNodeInput], graphql.FieldNode]:
+    def factory(tup: FieldNodeInput) -> graphql.FieldNode:
+        return graphql.FieldNode(
             name=graphql.NameNode(value=name),
             arguments=tup[0],
             selection_set=graphql.SelectionSetNode(kind="selection_set", selections=add_selection_aliases(tup[1])),
         )
-    )
+
+    return factory
 
 
 def add_selection_aliases(nodes: Optional[SelectionNodes]) -> Optional[SelectionNodes]:
@@ -209,14 +228,21 @@ def inline_fragment(
     context: Context, type_: graphql.GraphQLObjectType
 ) -> st.SearchStrategy[graphql.InlineFragmentNode]:
     """Build `InlineFragmentNode` for the given type."""
-    return selections(context, type_).map(
-        lambda sel: graphql.InlineFragmentNode(
+    return selections(context, type_).map(inline_fragment_node_factory(type_))
+
+
+def inline_fragment_node_factory(
+    type_: graphql.GraphQLObjectType,
+) -> Callable[[SelectionNodes], graphql.InlineFragmentNode]:
+    def factory(nodes: SelectionNodes) -> graphql.InlineFragmentNode:
+        return graphql.InlineFragmentNode(
             type_condition=graphql.NamedTypeNode(
                 name=graphql.NameNode(value=type_.name),
             ),
-            selection_set=graphql.SelectionSetNode(kind="selection_set", selections=sel),
+            selection_set=graphql.SelectionSetNode(kind="selection_set", selections=nodes),
         )
-    )
+
+    return factory
 
 
 def list_of_arguments(
@@ -231,16 +257,17 @@ def list_of_arguments(
             if not isinstance(argument.type, graphql.GraphQLNonNull):
                 continue
             raise TypeError("Non-nullable custom scalar types are not supported as arguments") from exc
-        args.append(
-            argument_strategy.map(
-                # Use `node_name` to prevent the lambda always using the last `name` value in this loop.
-                # See pylint W0640 (cell-var-from-loop)
-                lambda arg, node_name=name: graphql.ArgumentNode(name=graphql.NameNode(value=node_name), value=arg)
-            )
-        )
+        args.append(argument_strategy.map(argument_node_factory(name)))
     return fixed_lists(args)
 
 
+def argument_node_factory(name: str) -> Callable[[graphql.ValueNode], graphql.ArgumentNode]:
+    def factory(value: graphql.ValueNode) -> graphql.ArgumentNode:
+        return graphql.ArgumentNode(name=graphql.NameNode(value=name), value=value)
+
+    return factory
+
+
 def fixed_lists(args: Iterable[st.SearchStrategy[T]]) -> st.SearchStrategy[List[T]]:
     return st.tuples(*args).map(list)
 
@@ -295,17 +322,25 @@ def lists(
     """Generate a `graphql.ListValueNode`."""
     type_ = type_.of_type
     list_value = st.lists(value_nodes(context, type_))
-    return primitives.maybe_null(list_value.map(lambda values: graphql.ListValueNode(values=values)), nullable)
+    return primitives.maybe_null(list_value.map(make_list_value_node), nullable)
+
+
+def make_list_value_node(values: List[graphql.ValueNode]) -> graphql.ListValueNode:
+    return graphql.ListValueNode(values=values)
 
 
 def objects(
     context: Context, type_: graphql.GraphQLInputObjectType, nullable: bool = True
 ) -> st.SearchStrategy[graphql.ObjectValueNode]:
     """Generate a `graphql.ObjectValueNode`."""
     fields_value = subset_of_fields(type_.fields, force_required=True).flatmap(
-        lambda fields: list_of_nodes(context, fields, strategy=object_field_nodes)
+        list_of_nodes_factory(context, object_field_nodes)
     )
-    return primitives.maybe_null(fields_value.map(lambda fields: graphql.ObjectValueNode(fields=fields)), nullable)
+    return primitives.maybe_null(fields_value.map(make_object_value_node), nullable)
+
+
+def make_object_value_node(fields: List[graphql.ObjectFieldNode]) -> graphql.ObjectValueNode:
+    return graphql.ObjectValueNode(fields=fields)
 
 
 def subset_of_fields(
@@ -324,7 +359,7 @@ def subset_of_fields(
             else:
                 optional[name] = field
         if optional:
-            return subset_of_fields(optional).map(lambda p: p + required)
+            return subset_of_fields(optional).map(required.__add__)
         return st.just(required)
     # pairs are unique by field name
     return st.lists(st.sampled_from(field_pairs), min_size=1, unique_by=lambda x: x[0])
@@ -333,9 +368,14 @@ def subset_of_fields(
 def object_field_nodes(
     context: Context, name: str, field: graphql.GraphQLInputField
 ) -> st.SearchStrategy[graphql.ObjectFieldNode]:
-    return value_nodes(context, field.type).map(
-        lambda value: graphql.ObjectFieldNode(name=graphql.NameNode(value=name), value=value)
-    )
+    return value_nodes(context, field.type).map(object_field_node_factory(name))
+
+
+def object_field_node_factory(name: str) -> Callable[[graphql.ValueNode], graphql.ObjectFieldNode]:
+    def factory(value: graphql.ValueNode) -> graphql.ObjectFieldNode:
+        return graphql.ObjectFieldNode(name=graphql.NameNode(value=name), value=value)
+
+    return factory
 
 
 def list_of_nodes(