Improve performance of convert_argument for list of primitives (#3773)

* Improve performance of `convert_argument` for list of primitives (scalars, optional scalars, enums)

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

* refactor bad naming

* refactor to _is_leaf_type, which is compatible to graphql-core wording

* refactor _is_optional_leaf_type to prevent nested type_.of_type.of_type

* Enhance test for optional elements in lists.

* Remove list

* backwards compat

* Lint

---------

Co-authored-by: blothmann <[email protected]>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: Patrick Arminio <[email protected]>

Author: 4 people

RELEASE.md

@@ -0,0 +1,3 @@
+Release type: patch
+
+This release improves performance of argument conversion for lists of primitives.

strawberry/types/arguments.py

@@ -144,12 +144,52 @@ def is_maybe(self) -> bool:
         return isinstance(self.type, StrawberryMaybe)
 
 
+def _is_leaf_type(
+    type_: Union[StrawberryType, type],
+    scalar_registry: Mapping[object, Union[ScalarWrapper, ScalarDefinition]],
+    skip_classes: tuple[type, ...] = (),
+) -> bool:
+    if type_ in skip_classes:
+        return False
+
+    if is_scalar(type_, scalar_registry):
+        return True
+
+    if isinstance(type_, EnumDefinition):
+        return True
+
+    if isinstance(type_, LazyType):
+        return _is_leaf_type(type_.resolve_type(), scalar_registry)
+
+    if hasattr(type_, "_enum_definition"):
+        enum_definition: EnumDefinition = type_._enum_definition
+        return _is_leaf_type(enum_definition, scalar_registry)
+
+    return False
+
+
+def _is_optional_leaf_type(
+    type_: Union[StrawberryType, type],
+    scalar_registry: Mapping[object, Union[ScalarWrapper, ScalarDefinition]],
+    skip_classes: tuple[type, ...] = (),
+) -> bool:
+    if type_ in skip_classes:
+        return False
+
+    if isinstance(type_, StrawberryOptional):
+        return _is_leaf_type(type_.of_type, scalar_registry, skip_classes)
+
+    return False
+
+
 def convert_argument(
     value: object,
     type_: Union[StrawberryType, type],
     scalar_registry: Mapping[object, Union[ScalarWrapper, ScalarDefinition]],
     config: StrawberryConfig,
 ) -> object:
+    from strawberry.relay.types import GlobalID
+
     # TODO: move this somewhere else and make it first class
     if isinstance(type_, StrawberryOptional):
         res = convert_argument(value, type_.of_type, scalar_registry, config)
@@ -164,22 +204,27 @@ def convert_argument(
 
     if isinstance(type_, StrawberryList):
         value_list = cast("Iterable", value)
+
+        if _is_leaf_type(
+            type_.of_type, scalar_registry, skip_classes=(GlobalID,)
+        ) or _is_optional_leaf_type(
+            type_.of_type, scalar_registry, skip_classes=(GlobalID,)
+        ):
+            return value_list
+
+        value_list = cast("Iterable", value)
+
         return [
             convert_argument(x, type_.of_type, scalar_registry, config)
             for x in value_list
         ]
 
-    if is_scalar(type_, scalar_registry):
-        from strawberry.relay.types import GlobalID
-
+    if _is_leaf_type(type_, scalar_registry):
         if type_ is GlobalID:
             return GlobalID.from_id(value)  # type: ignore
 
         return value
 
-    if isinstance(type_, EnumDefinition):
-        return value
-
     if isinstance(type_, LazyType):
         return convert_argument(value, type_.resolve_type(), scalar_registry, config)
 

tests/benchmarks/test_arguments.py

@@ -0,0 +1,21 @@
+import pytest
+from pytest_codspeed import BenchmarkFixture
+
+from strawberry.schema.config import StrawberryConfig
+from strawberry.schema.types.scalar import DEFAULT_SCALAR_REGISTRY
+from strawberry.types.arguments import convert_argument
+from strawberry.types.base import StrawberryList
+
+
+@pytest.mark.parametrize("ntypes", [2**k for k in range(14, 23, 2)])
+def test_convert_argument_large_list(benchmark: BenchmarkFixture, ntypes):
+    test_value = list(range(ntypes))
+    type_ = StrawberryList(int)
+
+    def run():
+        result = convert_argument(
+            test_value, type_, DEFAULT_SCALAR_REGISTRY, StrawberryConfig()
+        )
+        assert test_value == result
+
+    benchmark(run)

tests/utils/test_arguments_converter.py

@@ -56,6 +56,8 @@ def test_list():
     args = {
         "integerList": [1, 2],
         "stringList": ["abc", "cde"],
+        "optionalIntegerList": [1, 2],
+        "optionalStringList": ["abc", "cde", None],
     }
 
     arguments = [
@@ -69,6 +71,16 @@ def test_list():
             python_name="string_list",
             type_annotation=StrawberryAnnotation(list[str]),
         ),
+        StrawberryArgument(
+            graphql_name="optionalIntegerList",
+            python_name="optional_integer_list",
+            type_annotation=StrawberryAnnotation(list[Optional[int]]),
+        ),
+        StrawberryArgument(
+            graphql_name="optionalStringList",
+            python_name="optional_string_list",
+            type_annotation=StrawberryAnnotation(list[Optional[str]]),
+        ),
     ]
 
     assert convert_arguments(
@@ -79,6 +91,8 @@ def test_list():
     ) == {
         "integer_list": [1, 2],
         "string_list": ["abc", "cde"],
+        "optional_integer_list": [1, 2],
+        "optional_string_list": ["abc", "cde", None],
     }