We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
Mypy 0.940 x Python 3.10 `scalar`overload
```
$ mypy strawberry/scalars.py
strawberry/scalars.py:9: error: No overload variant of "scalar" matches argument types "NewType", "str", "str", "Callable[[Any], Any]", "Callable[[Any], Any]"  [call-overload]
strawberry/scalars.py:9: note: Possible overload variants:
strawberry/scalars.py:9: note:     def scalar(*, name: Optional[str] = ..., description: Optional[str] = ..., specified_by_url: Optional[str] = ..., serialize: Callable[..., Any] = ..., parse_value: Optional[Callable[..., Any]] = ..., parse_literal: Optional[Callable[..., Any]] = ...) -> Callable[[_T], _T]
strawberry/scalars.py:9: note:     def [_T <: type] scalar(cls: _T, *, name: Optional[str] = ..., description: Optional[str] = ..., specified_by_url: Optional[str] = ..., serialize: Callable[..., Any] = ..., parse_value: Optional[Callable[..., Any]] = ..., parse_literal: Optional[Callable[..., Any]] = ...) -> _T
strawberry/scalars.py:23: error: No overload variant of "scalar" matches argument types "NewType", "str", "str", "Callable[[Any], str]", "Callable[[Any], bytes]"  [call-overload]
strawberry/scalars.py:23: note: Possible overload variants:
strawberry/scalars.py:23: note:     def scalar(*, name: Optional[str] = ..., description: Optional[str] = ..., specified_by_url: Optional[str] = ..., serialize: Callable[..., Any] = ..., parse_value: Optional[Callable[..., Any]] = ..., parse_literal: Optional[Callable[..., Any]] = ...) -> Callable[[_T], _T]
strawberry/scalars.py:23: note:     def [_T <: type] scalar(cls: _T, *, name: Optional[str] = ..., description: Optional[str] = ..., specified_by_url: Optional[str] = ..., serialize: Callable[..., Any] = ..., parse_value: Optional[Callable[..., Any]] = ..., parse_literal: Optional[Callable[..., Any]] = ...) -> _T
strawberry/scalars.py:31: error: No overload variant of "scalar" matches argument types "NewType", "str", "str", "Callable[[Any], str]", "Callable[[Any], bytes]"  [call-overload]
strawberry/scalars.py:31: note: Possible overload variants:
strawberry/scalars.py:31: note:     def scalar(*, name: Optional[str] = ..., description: Optional[str] = ..., specified_by_url: Optional[str] = ..., serialize: Callable[..., Any] = ..., parse_value: Optional[Callable[..., Any]] = ..., parse_literal: Optional[Callable[..., Any]] = ...) -> Callable[[_T], _T]
strawberry/scalars.py:31: note:     def [_T <: type] scalar(cls: _T, *, name: Optional[str] = ..., description: Optional[str] = ..., specified_by_url: Optional[str] = ..., serialize: Callable[..., Any] = ..., parse_value: Optional[Callable[..., Any]] = ..., parse_literal: Optional[Callable[..., Any]] = ...) -> _T
strawberry/scalars.py:41: error: No overload variant of "scalar" matches argument types "NewType", "str", "str", "Callable[[Any], str]", "Callable[[Any], bytes]"  [call-overload]
strawberry/scalars.py:41: note: Possible overload variants:
strawberry/scalars.py:41: note:     def scalar(*, name: Optional[str] = ..., description: Optional[str] = ..., specified_by_url: Optional[str] = ..., serialize: Callable[..., Any] = ..., parse_value: Optional[Callable[..., Any]] = ..., parse_literal: Optional[Callable[..., Any]] = ...) -> Callable[[_T], _T]
strawberry/scalars.py:41: note:     def [_T <: type] scalar(cls: _T, *, name: Optional[str] = ..., description: Optional[str] = ..., specified_by_url: Optional[str] = ..., serialize: Callable[..., Any] = ..., parse_value: Optional[Callable[..., Any]] = ..., parse_literal: Optional[Callable[..., Any]] = ...) -> _T
Found 4 errors in 1 file (checked 1 source file)
```


In 3.10, `NewType` is a [class rather than a function](https://docs.python.org/3/library/typing.html#newtype), I guess that's what is different with <= 3.9.

--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `strawberry/custom_scalar.py`
Content:
```
1 from dataclasses import dataclass
2 from typing import Any, Callable, Mapping, Optional, Type, TypeVar, Union, overload
3 
4 from graphql import GraphQLScalarType
5 
6 from strawberry.type import StrawberryType
7 
8 from .utils.str_converters import to_camel_case
9 
10 
11 _T = TypeVar("_T", bound=type)
12 
13 
14 def identity(x):
15     return x
16 
17 
18 @dataclass
19 class ScalarDefinition(StrawberryType):
20     name: str
21     description: Optional[str]
22     specified_by_url: Optional[str]
23     serialize: Optional[Callable]
24     parse_value: Optional[Callable]
25     parse_literal: Optional[Callable]
26 
27     # Optionally store the GraphQLScalarType instance so that we don't get
28     # duplicates
29     implementation: Optional[GraphQLScalarType] = None
30 
31     def copy_with(
32         self, type_var_map: Mapping[TypeVar, Union[StrawberryType, type]]
33     ) -> Union[StrawberryType, type]:
34         return super().copy_with(type_var_map)
35 
36     @property
37     def is_generic(self) -> bool:
38         return False
39 
40 
41 class ScalarWrapper:
42     _scalar_definition: ScalarDefinition
43 
44     def __init__(self, wrap):
45         self.wrap = wrap
46 
47     def __call__(self, *args, **kwargs):
48         return self.wrap(*args, **kwargs)
49 
50 
51 def _process_scalar(
52     cls: Type[_T],
53     *,
54     name: Optional[str] = None,
55     description: Optional[str] = None,
56     specified_by_url: Optional[str] = None,
57     serialize: Optional[Callable] = None,
58     parse_value: Optional[Callable] = None,
59     parse_literal: Optional[Callable] = None,
60 ):
61     name = name or to_camel_case(cls.__name__)
62 
63     wrapper = ScalarWrapper(cls)
64     wrapper._scalar_definition = ScalarDefinition(
65         name=name,
66         description=description,
67         specified_by_url=specified_by_url,
68         serialize=serialize,
69         parse_literal=parse_literal,
70         parse_value=parse_value,
71     )
72 
73     return wrapper
74 
75 
76 @overload
77 def scalar(
78     *,
79     name: Optional[str] = None,
80     description: Optional[str] = None,
81     specified_by_url: Optional[str] = None,
82     serialize: Callable = identity,
83     parse_value: Optional[Callable] = None,
84     parse_literal: Optional[Callable] = None,
85 ) -> Callable[[_T], _T]:
86     ...
87 
88 
89 @overload
90 def scalar(
91     cls: _T,
92     *,
93     name: Optional[str] = None,
94     description: Optional[str] = None,
95     specified_by_url: Optional[str] = None,
96     serialize: Callable = identity,
97     parse_value: Optional[Callable] = None,
98     parse_literal: Optional[Callable] = None,
99 ) -> _T:
100     ...
101 
102 
103 # FIXME: We are tricking pyright into thinking that we are returning the given type
104 # here or else it won't let us use any custom scalar to annotate attributes in
105 # dataclasses/types. This should be properly solved when implementing StrawberryScalar
106 def scalar(
107     cls=None,
108     *,
109     name: Optional[str] = None,
110     description: Optional[str] = None,
111     specified_by_url: Optional[str] = None,
112     serialize: Callable = identity,
113     parse_value: Optional[Callable] = None,
114     parse_literal: Optional[Callable] = None,
115 ) -> Any:
116     """Annotates a class or type as a GraphQL custom scalar.
117 
118     Example usages:
119 
120     >>> strawberry.scalar(
121     >>>     datetime.date,
122     >>>     serialize=lambda value: value.isoformat(),
123     >>>     parse_value=datetime.parse_date
124     >>> )
125 
126     >>> Base64Encoded = strawberry.scalar(
127     >>>     NewType("Base64Encoded", bytes),
128     >>>     serialize=base64.b64encode,
129     >>>     parse_value=base64.b64decode
130     >>> )
131 
132     >>> @strawberry.scalar(
133     >>>     serialize=lambda value: ",".join(value.items),
134     >>>     parse_value=lambda value: CustomList(value.split(","))
135     >>> )
136     >>> class CustomList:
137     >>>     def __init__(self, items):
138     >>>         self.items = items
139 
140     """
141 
142     if parse_value is None:
143         parse_value = cls
144 
145     def wrap(cls):
146         return _process_scalar(
147             cls,
148             name=name,
149             description=description,
150             specified_by_url=specified_by_url,
151             serialize=serialize,
152             parse_value=parse_value,
153             parse_literal=parse_literal,
154         )
155 
156     if cls is None:
157         return wrap
158 
159     return wrap(cls)
160
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/strawberry/custom_scalar.py b/strawberry/custom_scalar.py
--- a/strawberry/custom_scalar.py
+++ b/strawberry/custom_scalar.py
@@ -1,5 +1,16 @@
+import sys
 from dataclasses import dataclass
-from typing import Any, Callable, Mapping, Optional, Type, TypeVar, Union, overload
+from typing import (
+    Any,
+    Callable,
+    Mapping,
+    NewType,
+    Optional,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
 
 from graphql import GraphQLScalarType
 
@@ -8,7 +19,11 @@
 from .utils.str_converters import to_camel_case
 
 
-_T = TypeVar("_T", bound=type)
+# in python 3.10+ NewType is a class
+if sys.version_info >= (3, 10):
+    _T = TypeVar("_T", bound=Union[type, NewType])
+else:
+    _T = TypeVar("_T", bound=type)
 
 
 def identity(x):

{"golden_diff": "diff --git a/strawberry/custom_scalar.py b/strawberry/custom_scalar.py\n--- a/strawberry/custom_scalar.py\n+++ b/strawberry/custom_scalar.py\n@@ -1,5 +1,16 @@\n+import sys\n from dataclasses import dataclass\n-from typing import Any, Callable, Mapping, Optional, Type, TypeVar, Union, overload\n+from typing import (\n+    Any,\n+    Callable,\n+    Mapping,\n+    NewType,\n+    Optional,\n+    Type,\n+    TypeVar,\n+    Union,\n+    overload,\n+)\n \n from graphql import GraphQLScalarType\n \n@@ -8,7 +19,11 @@\n from .utils.str_converters import to_camel_case\n \n \n-_T = TypeVar(\"_T\", bound=type)\n+# in python 3.10+ NewType is a class\n+if sys.version_info >= (3, 10):\n+    _T = TypeVar(\"_T\", bound=Union[type, NewType])\n+else:\n+    _T = TypeVar(\"_T\", bound=type)\n \n \n def identity(x):\n", "issue": "Mypy 0.940 x Python 3.10 `scalar`overload\n```\r\n$ mypy strawberry/scalars.py\r\nstrawberry/scalars.py:9: error: No overload variant of \"scalar\" matches argument types \"NewType\", \"str\", \"str\", \"Callable[[Any], Any]\", \"Callable[[Any], Any]\"  [call-overload]\r\nstrawberry/scalars.py:9: note: Possible overload variants:\r\nstrawberry/scalars.py:9: note:     def scalar(*, name: Optional[str] = ..., description: Optional[str] = ..., specified_by_url: Optional[str] = ..., serialize: Callable[..., Any] = ..., parse_value: Optional[Callable[..., Any]] = ..., parse_literal: Optional[Callable[..., Any]] = ...) -> Callable[[_T], _T]\r\nstrawberry/scalars.py:9: note:     def [_T <: type] scalar(cls: _T, *, name: Optional[str] = ..., description: Optional[str] = ..., specified_by_url: Optional[str] = ..., serialize: Callable[..., Any] = ..., parse_value: Optional[Callable[..., Any]] = ..., parse_literal: Optional[Callable[..., Any]] = ...) -> _T\r\nstrawberry/scalars.py:23: error: No overload variant of \"scalar\" matches argument types \"NewType\", \"str\", \"str\", \"Callable[[Any], str]\", \"Callable[[Any], bytes]\"  [call-overload]\r\nstrawberry/scalars.py:23: note: Possible overload variants:\r\nstrawberry/scalars.py:23: note:     def scalar(*, name: Optional[str] = ..., description: Optional[str] = ..., specified_by_url: Optional[str] = ..., serialize: Callable[..., Any] = ..., parse_value: Optional[Callable[..., Any]] = ..., parse_literal: Optional[Callable[..., Any]] = ...) -> Callable[[_T], _T]\r\nstrawberry/scalars.py:23: note:     def [_T <: type] scalar(cls: _T, *, name: Optional[str] = ..., description: Optional[str] = ..., specified_by_url: Optional[str] = ..., serialize: Callable[..., Any] = ..., parse_value: Optional[Callable[..., Any]] = ..., parse_literal: Optional[Callable[..., Any]] = ...) -> _T\r\nstrawberry/scalars.py:31: error: No overload variant of \"scalar\" matches argument types \"NewType\", \"str\", \"str\", \"Callable[[Any], str]\", \"Callable[[Any], bytes]\"  [call-overload]\r\nstrawberry/scalars.py:31: note: Possible overload variants:\r\nstrawberry/scalars.py:31: note:     def scalar(*, name: Optional[str] = ..., description: Optional[str] = ..., specified_by_url: Optional[str] = ..., serialize: Callable[..., Any] = ..., parse_value: Optional[Callable[..., Any]] = ..., parse_literal: Optional[Callable[..., Any]] = ...) -> Callable[[_T], _T]\r\nstrawberry/scalars.py:31: note:     def [_T <: type] scalar(cls: _T, *, name: Optional[str] = ..., description: Optional[str] = ..., specified_by_url: Optional[str] = ..., serialize: Callable[..., Any] = ..., parse_value: Optional[Callable[..., Any]] = ..., parse_literal: Optional[Callable[..., Any]] = ...) -> _T\r\nstrawberry/scalars.py:41: error: No overload variant of \"scalar\" matches argument types \"NewType\", \"str\", \"str\", \"Callable[[Any], str]\", \"Callable[[Any], bytes]\"  [call-overload]\r\nstrawberry/scalars.py:41: note: Possible overload variants:\r\nstrawberry/scalars.py:41: note:     def scalar(*, name: Optional[str] = ..., description: Optional[str] = ..., specified_by_url: Optional[str] = ..., serialize: Callable[..., Any] = ..., parse_value: Optional[Callable[..., Any]] = ..., parse_literal: Optional[Callable[..., Any]] = ...) -> Callable[[_T], _T]\r\nstrawberry/scalars.py:41: note:     def [_T <: type] scalar(cls: _T, *, name: Optional[str] = ..., description: Optional[str] = ..., specified_by_url: Optional[str] = ..., serialize: Callable[..., Any] = ..., parse_value: Optional[Callable[..., Any]] = ..., parse_literal: Optional[Callable[..., Any]] = ...) -> _T\r\nFound 4 errors in 1 file (checked 1 source file)\r\n```\r\n\r\n\r\nIn 3.10, `NewType` is a [class rather than a function](https://docs.python.org/3/library/typing.html#newtype), I guess that's what is different with <= 3.9.\n", "before_files": [{"content": "from dataclasses import dataclass\nfrom typing import Any, Callable, Mapping, Optional, Type, TypeVar, Union, overload\n\nfrom graphql import GraphQLScalarType\n\nfrom strawberry.type import StrawberryType\n\nfrom .utils.str_converters import to_camel_case\n\n\n_T = TypeVar(\"_T\", bound=type)\n\n\ndef identity(x):\n    return x\n\n\n@dataclass\nclass ScalarDefinition(StrawberryType):\n    name: str\n    description: Optional[str]\n    specified_by_url: Optional[str]\n    serialize: Optional[Callable]\n    parse_value: Optional[Callable]\n    parse_literal: Optional[Callable]\n\n    # Optionally store the GraphQLScalarType instance so that we don't get\n    # duplicates\n    implementation: Optional[GraphQLScalarType] = None\n\n    def copy_with(\n        self, type_var_map: Mapping[TypeVar, Union[StrawberryType, type]]\n    ) -> Union[StrawberryType, type]:\n        return super().copy_with(type_var_map)\n\n    @property\n    def is_generic(self) -> bool:\n        return False\n\n\nclass ScalarWrapper:\n    _scalar_definition: ScalarDefinition\n\n    def __init__(self, wrap):\n        self.wrap = wrap\n\n    def __call__(self, *args, **kwargs):\n        return self.wrap(*args, **kwargs)\n\n\ndef _process_scalar(\n    cls: Type[_T],\n    *,\n    name: Optional[str] = None,\n    description: Optional[str] = None,\n    specified_by_url: Optional[str] = None,\n    serialize: Optional[Callable] = None,\n    parse_value: Optional[Callable] = None,\n    parse_literal: Optional[Callable] = None,\n):\n    name = name or to_camel_case(cls.__name__)\n\n    wrapper = ScalarWrapper(cls)\n    wrapper._scalar_definition = ScalarDefinition(\n        name=name,\n        description=description,\n        specified_by_url=specified_by_url,\n        serialize=serialize,\n        parse_literal=parse_literal,\n        parse_value=parse_value,\n    )\n\n    return wrapper\n\n\n@overload\ndef scalar(\n    *,\n    name: Optional[str] = None,\n    description: Optional[str] = None,\n    specified_by_url: Optional[str] = None,\n    serialize: Callable = identity,\n    parse_value: Optional[Callable] = None,\n    parse_literal: Optional[Callable] = None,\n) -> Callable[[_T], _T]:\n    ...\n\n\n@overload\ndef scalar(\n    cls: _T,\n    *,\n    name: Optional[str] = None,\n    description: Optional[str] = None,\n    specified_by_url: Optional[str] = None,\n    serialize: Callable = identity,\n    parse_value: Optional[Callable] = None,\n    parse_literal: Optional[Callable] = None,\n) -> _T:\n    ...\n\n\n# FIXME: We are tricking pyright into thinking that we are returning the given type\n# here or else it won't let us use any custom scalar to annotate attributes in\n# dataclasses/types. This should be properly solved when implementing StrawberryScalar\ndef scalar(\n    cls=None,\n    *,\n    name: Optional[str] = None,\n    description: Optional[str] = None,\n    specified_by_url: Optional[str] = None,\n    serialize: Callable = identity,\n    parse_value: Optional[Callable] = None,\n    parse_literal: Optional[Callable] = None,\n) -> Any:\n    \"\"\"Annotates a class or type as a GraphQL custom scalar.\n\n    Example usages:\n\n    >>> strawberry.scalar(\n    >>>     datetime.date,\n    >>>     serialize=lambda value: value.isoformat(),\n    >>>     parse_value=datetime.parse_date\n    >>> )\n\n    >>> Base64Encoded = strawberry.scalar(\n    >>>     NewType(\"Base64Encoded\", bytes),\n    >>>     serialize=base64.b64encode,\n    >>>     parse_value=base64.b64decode\n    >>> )\n\n    >>> @strawberry.scalar(\n    >>>     serialize=lambda value: \",\".join(value.items),\n    >>>     parse_value=lambda value: CustomList(value.split(\",\"))\n    >>> )\n    >>> class CustomList:\n    >>>     def __init__(self, items):\n    >>>         self.items = items\n\n    \"\"\"\n\n    if parse_value is None:\n        parse_value = cls\n\n    def wrap(cls):\n        return _process_scalar(\n            cls,\n            name=name,\n            description=description,\n            specified_by_url=specified_by_url,\n            serialize=serialize,\n            parse_value=parse_value,\n            parse_literal=parse_literal,\n        )\n\n    if cls is None:\n        return wrap\n\n    return wrap(cls)\n", "path": "strawberry/custom_scalar.py"}], "after_files": [{"content": "import sys\nfrom dataclasses import dataclass\nfrom typing import (\n    Any,\n    Callable,\n    Mapping,\n    NewType,\n    Optional,\n    Type,\n    TypeVar,\n    Union,\n    overload,\n)\n\nfrom graphql import GraphQLScalarType\n\nfrom strawberry.type import StrawberryType\n\nfrom .utils.str_converters import to_camel_case\n\n\n# in python 3.10+ NewType is a class\nif sys.version_info >= (3, 10):\n    _T = TypeVar(\"_T\", bound=Union[type, NewType])\nelse:\n    _T = TypeVar(\"_T\", bound=type)\n\n\ndef identity(x):\n    return x\n\n\n@dataclass\nclass ScalarDefinition(StrawberryType):\n    name: str\n    description: Optional[str]\n    specified_by_url: Optional[str]\n    serialize: Optional[Callable]\n    parse_value: Optional[Callable]\n    parse_literal: Optional[Callable]\n\n    # Optionally store the GraphQLScalarType instance so that we don't get\n    # duplicates\n    implementation: Optional[GraphQLScalarType] = None\n\n    def copy_with(\n        self, type_var_map: Mapping[TypeVar, Union[StrawberryType, type]]\n    ) -> Union[StrawberryType, type]:\n        return super().copy_with(type_var_map)\n\n    @property\n    def is_generic(self) -> bool:\n        return False\n\n\nclass ScalarWrapper:\n    _scalar_definition: ScalarDefinition\n\n    def __init__(self, wrap):\n        self.wrap = wrap\n\n    def __call__(self, *args, **kwargs):\n        return self.wrap(*args, **kwargs)\n\n\ndef _process_scalar(\n    cls: Type[_T],\n    *,\n    name: Optional[str] = None,\n    description: Optional[str] = None,\n    specified_by_url: Optional[str] = None,\n    serialize: Optional[Callable] = None,\n    parse_value: Optional[Callable] = None,\n    parse_literal: Optional[Callable] = None,\n):\n    name = name or to_camel_case(cls.__name__)\n\n    wrapper = ScalarWrapper(cls)\n    wrapper._scalar_definition = ScalarDefinition(\n        name=name,\n        description=description,\n        specified_by_url=specified_by_url,\n        serialize=serialize,\n        parse_literal=parse_literal,\n        parse_value=parse_value,\n    )\n\n    return wrapper\n\n\n@overload\ndef scalar(\n    *,\n    name: Optional[str] = None,\n    description: Optional[str] = None,\n    specified_by_url: Optional[str] = None,\n    serialize: Callable = identity,\n    parse_value: Optional[Callable] = None,\n    parse_literal: Optional[Callable] = None,\n) -> Callable[[_T], _T]:\n    ...\n\n\n@overload\ndef scalar(\n    cls: _T,\n    *,\n    name: Optional[str] = None,\n    description: Optional[str] = None,\n    specified_by_url: Optional[str] = None,\n    serialize: Callable = identity,\n    parse_value: Optional[Callable] = None,\n    parse_literal: Optional[Callable] = None,\n) -> _T:\n    ...\n\n\n# FIXME: We are tricking pyright into thinking that we are returning the given type\n# here or else it won't let us use any custom scalar to annotate attributes in\n# dataclasses/types. This should be properly solved when implementing StrawberryScalar\ndef scalar(\n    cls=None,\n    *,\n    name: Optional[str] = None,\n    description: Optional[str] = None,\n    specified_by_url: Optional[str] = None,\n    serialize: Callable = identity,\n    parse_value: Optional[Callable] = None,\n    parse_literal: Optional[Callable] = None,\n) -> Any:\n    \"\"\"Annotates a class or type as a GraphQL custom scalar.\n\n    Example usages:\n\n    >>> strawberry.scalar(\n    >>>     datetime.date,\n    >>>     serialize=lambda value: value.isoformat(),\n    >>>     parse_value=datetime.parse_date\n    >>> )\n\n    >>> Base64Encoded = strawberry.scalar(\n    >>>     NewType(\"Base64Encoded\", bytes),\n    >>>     serialize=base64.b64encode,\n    >>>     parse_value=base64.b64decode\n    >>> )\n\n    >>> @strawberry.scalar(\n    >>>     serialize=lambda value: \",\".join(value.items),\n    >>>     parse_value=lambda value: CustomList(value.split(\",\"))\n    >>> )\n    >>> class CustomList:\n    >>>     def __init__(self, items):\n    >>>         self.items = items\n\n    \"\"\"\n\n    if parse_value is None:\n        parse_value = cls\n\n    def wrap(cls):\n        return _process_scalar(\n            cls,\n            name=name,\n            description=description,\n            specified_by_url=specified_by_url,\n            serialize=serialize,\n            parse_value=parse_value,\n            parse_literal=parse_literal,\n        )\n\n    if cls is None:\n        return wrap\n\n    return wrap(cls)\n", "path": "strawberry/custom_scalar.py"}]}