We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
Partial[DTO] Exception: typing.ClassVar[bool] is not valid as type argument
**Describe the bug**
When creating a `Partial[DTO]`, I get the following exception: `Exception: typing.ClassVar[bool] is not valid as type argument`

The exception appears to be thrown in the `partials.py` file, from the 3rd line copied here:

```
if item not in cls._models:
    if is_class_and_subclass(item, BaseModel):
        cls._create_partial_pydantic_model(item=item)
```

**To Reproduce**
Here's a minimal example to reproduce.  I'm using Python 3.10.6.

```
from sqlalchemy import Column
from sqlalchemy.dialects.postgresql import (
    INTEGER,
    JSONB,
    TIMESTAMP,
)
from sqlalchemy.orm import declarative_base
from starlite import DTOFactory
from starlite.plugins.sql_alchemy import SQLAlchemyPlugin
from starlite.types.partial import Partial

Base = declarative_base()
dto_factory = DTOFactory(plugins=[SQLAlchemyPlugin()])

class DTO_ORM(Base):
    __tablename__ = "some_table"

    id = Column(INTEGER, primary_key=True)
    value = Column(JSONB)
    logs = Column(JSONB)
    timestamp = Column(TIMESTAMP)

DTO_MODEL = dto_factory("DTO_MODEL", DTO_ORM)

partial_dto = Partial[DTO_MODEL]
data = {"id": 789}
partial_dto(**data)
```

**Additional context**
I believe I've implemented this code correctly, but there aren't a lot of examples for how to use DTOs or Partials, so please let me know if something is wrong with the code. 

Docs: https://starlite-api.github.io/starlite/usage/11-data-transfer-objects/#partial-dtos

--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `starlite/types/partial.py`
Content:
```
1 from dataclasses import MISSING
2 from dataclasses import Field as DataclassField
3 from dataclasses import dataclass
4 from inspect import getmro
5 from typing import (
6     TYPE_CHECKING,
7     Any,
8     Dict,
9     Generic,
10     Optional,
11     Tuple,
12     Type,
13     TypeVar,
14     get_type_hints,
15 )
16 
17 from pydantic import BaseModel, create_model
18 from typing_extensions import TypedDict, get_args
19 
20 from starlite.exceptions import ImproperlyConfiguredException
21 from starlite.types.builtin_types import NoneType
22 from starlite.utils.predicates import (
23     is_class_and_subclass,
24     is_dataclass_class_typeguard,
25     is_typeddict_typeguard,
26 )
27 
28 try:
29     # python 3.9 changed these variable
30     from typing import _UnionGenericAlias as GenericAlias  # type: ignore
31 except ImportError:  # pragma: no cover
32     from typing import _GenericAlias as GenericAlias  # type: ignore
33 
34 if TYPE_CHECKING:
35     from typing import TypeAlias, Union  # noqa: F401  # nopycln: import
36 
37     from starlite.types.builtin_types import DataclassClass, TypedDictClass
38 
39 T = TypeVar("T")
40 
41 SupportedTypes: "TypeAlias" = "Union[DataclassClass, Type[BaseModel], TypedDictClass]"
42 """Types that are supported by [`Partial`][starlite.types.partial.Partial]"""
43 
44 
45 class Partial(Generic[T]):
46     """Type generation for PATCH routes.
47 
48     Partial is a special typing helper that takes a generic T, which must be a
49     [`TypedDict`][typing.TypedDict], dataclass or pydantic model class, and
50     returns to static type checkers a version of this T in which all fields -
51     and nested fields - are optional.
52     """
53 
54     _models: Dict[SupportedTypes, SupportedTypes] = {}
55 
56     def __class_getitem__(cls, item: Type[T]) -> Type[T]:
57         """Takes a pydantic model class, [`TypedDict`][typing.TypedDict] or a
58         dataclass and returns an all optional version of that class.
59 
60         Args:
61             item: A pydantic model, [`TypedDict`][typing.TypedDict] or dataclass class.
62 
63         Returns:
64             A pydantic model, [`TypedDict`][typing.TypedDict], or dataclass.
65         """
66 
67         if item not in cls._models:
68             if is_class_and_subclass(item, BaseModel):
69                 cls._create_partial_pydantic_model(item=item)
70             elif is_dataclass_class_typeguard(item):
71                 cls._create_partial_dataclass(item=item)
72             elif is_typeddict_typeguard(item):
73                 cls._create_partial_typeddict(item=item)
74             else:
75                 raise ImproperlyConfiguredException(
76                     "The type argument T passed to Partial[T] must be a `TypedDict`, dataclass or pydantic model class"
77                 )
78 
79         return cls._models[item]  # type:ignore[return-value]
80 
81     @classmethod
82     def _create_partial_pydantic_model(cls, item: Type[BaseModel]) -> None:
83         """Receives a pydantic model class and creates an all optional subclass
84         of it.
85 
86         Args:
87             item: A pydantic model class.
88         """
89         field_definitions: Dict[str, Tuple[Any, None]] = {}
90         for field_name, field_type in get_type_hints(item).items():
91             if not isinstance(field_type, GenericAlias) or NoneType not in field_type.__args__:
92                 field_definitions[field_name] = (Optional[field_type], None)
93             else:
94                 field_definitions[field_name] = (field_type, None)
95 
96         cls._models[item] = create_model(cls._create_partial_type_name(item), __base__=item, **field_definitions)  # type: ignore
97 
98     @classmethod
99     def _create_partial_dataclass(cls, item: "DataclassClass") -> None:
100         """Receives a dataclass class and creates an all optional subclass of
101         it.
102 
103         Args:
104             item: A dataclass class.
105         """
106         fields: Dict[str, DataclassField] = cls._create_optional_field_map(item)
107         partial_type: "DataclassClass" = dataclass(
108             type(cls._create_partial_type_name(item), (item,), {"__dataclass_fields__": fields})
109         )
110         annotated_ancestors = [a for a in getmro(partial_type) if hasattr(a, "__annotations__")]
111         for ancestor in annotated_ancestors:
112             for field_name, annotation in ancestor.__annotations__.items():
113                 if not isinstance(annotation, GenericAlias) or NoneType not in annotation.__args__:
114                     partial_type.__annotations__[field_name] = Optional[annotation]
115                 else:
116                     partial_type.__annotations__[field_name] = annotation
117 
118         cls._models[item] = partial_type
119 
120     @classmethod
121     def _create_partial_typeddict(cls, item: "TypedDictClass") -> None:
122         """Receives a typeddict class and creates a new type with all
123         attributes `Optional`.
124 
125         Args:
126             item: A [`TypedDict`][typing.TypeDict] class.
127         """
128         type_hints: Dict[str, Any] = {}
129         for key_name, value_type in get_type_hints(item).items():
130             if NoneType in get_args(value_type):
131                 type_hints[key_name] = value_type
132                 continue
133             type_hints[key_name] = Optional[value_type]
134         type_name = cls._create_partial_type_name(item)
135         cls._models[item] = TypedDict(type_name, type_hints, total=False)  # type:ignore
136 
137     @staticmethod
138     def _create_optional_field_map(item: "DataclassClass") -> Dict[str, DataclassField]:
139         """Creates a map of field name to optional dataclass Fields for a given
140         dataclass.
141 
142         Args:
143             item: A dataclass class.
144 
145         Returns:
146             A map of field name to optional dataclass fields.
147         """
148         fields: Dict[str, DataclassField] = {}
149         # https://github.com/python/typing/discussions/1056
150         for field_name, dataclass_field in item.__dataclass_fields__.items():  # pyright:ignore
151             if not isinstance(dataclass_field.type, GenericAlias) or NoneType not in dataclass_field.type.__args__:
152                 dataclass_field.type = Optional[dataclass_field.type]
153             if dataclass_field.default_factory is MISSING:
154                 dataclass_field.default = None if dataclass_field.default is MISSING else dataclass_field.default
155             fields[field_name] = dataclass_field
156         return fields
157 
158     @staticmethod
159     def _create_partial_type_name(item: SupportedTypes) -> str:
160         return f"Partial{item.__name__}"
161
```
--- 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/starlite/types/partial.py b/starlite/types/partial.py
--- a/starlite/types/partial.py
+++ b/starlite/types/partial.py
@@ -15,6 +15,7 @@
 )
 
 from pydantic import BaseModel, create_model
+from pydantic.typing import is_classvar
 from typing_extensions import TypedDict, get_args
 
 from starlite.exceptions import ImproperlyConfiguredException
@@ -88,6 +89,8 @@
         """
         field_definitions: Dict[str, Tuple[Any, None]] = {}
         for field_name, field_type in get_type_hints(item).items():
+            if is_classvar(field_type):
+                continue
             if not isinstance(field_type, GenericAlias) or NoneType not in field_type.__args__:
                 field_definitions[field_name] = (Optional[field_type], None)
             else:

{"golden_diff": "diff --git a/starlite/types/partial.py b/starlite/types/partial.py\n--- a/starlite/types/partial.py\n+++ b/starlite/types/partial.py\n@@ -15,6 +15,7 @@\n )\n \n from pydantic import BaseModel, create_model\n+from pydantic.typing import is_classvar\n from typing_extensions import TypedDict, get_args\n \n from starlite.exceptions import ImproperlyConfiguredException\n@@ -88,6 +89,8 @@\n         \"\"\"\n         field_definitions: Dict[str, Tuple[Any, None]] = {}\n         for field_name, field_type in get_type_hints(item).items():\n+            if is_classvar(field_type):\n+                continue\n             if not isinstance(field_type, GenericAlias) or NoneType not in field_type.__args__:\n                 field_definitions[field_name] = (Optional[field_type], None)\n             else:\n", "issue": "Partial[DTO] Exception: typing.ClassVar[bool] is not valid as type argument\n**Describe the bug**\r\nWhen creating a `Partial[DTO]`, I get the following exception: `Exception: typing.ClassVar[bool] is not valid as type argument`\r\n\r\nThe exception appears to be thrown in the `partials.py` file, from the 3rd line copied here:\r\n\r\n```\r\nif item not in cls._models:\r\n    if is_class_and_subclass(item, BaseModel):\r\n        cls._create_partial_pydantic_model(item=item)\r\n```\r\n\r\n**To Reproduce**\r\nHere's a minimal example to reproduce.  I'm using Python 3.10.6.\r\n\r\n```\r\nfrom sqlalchemy import Column\r\nfrom sqlalchemy.dialects.postgresql import (\r\n    INTEGER,\r\n    JSONB,\r\n    TIMESTAMP,\r\n)\r\nfrom sqlalchemy.orm import declarative_base\r\nfrom starlite import DTOFactory\r\nfrom starlite.plugins.sql_alchemy import SQLAlchemyPlugin\r\nfrom starlite.types.partial import Partial\r\n\r\nBase = declarative_base()\r\ndto_factory = DTOFactory(plugins=[SQLAlchemyPlugin()])\r\n\r\nclass DTO_ORM(Base):\r\n    __tablename__ = \"some_table\"\r\n\r\n    id = Column(INTEGER, primary_key=True)\r\n    value = Column(JSONB)\r\n    logs = Column(JSONB)\r\n    timestamp = Column(TIMESTAMP)\r\n\r\nDTO_MODEL = dto_factory(\"DTO_MODEL\", DTO_ORM)\r\n\r\npartial_dto = Partial[DTO_MODEL]\r\ndata = {\"id\": 789}\r\npartial_dto(**data)\r\n```\r\n\r\n**Additional context**\r\nI believe I've implemented this code correctly, but there aren't a lot of examples for how to use DTOs or Partials, so please let me know if something is wrong with the code. \r\n\r\nDocs: https://starlite-api.github.io/starlite/usage/11-data-transfer-objects/#partial-dtos\n", "before_files": [{"content": "from dataclasses import MISSING\nfrom dataclasses import Field as DataclassField\nfrom dataclasses import dataclass\nfrom inspect import getmro\nfrom typing import (\n    TYPE_CHECKING,\n    Any,\n    Dict,\n    Generic,\n    Optional,\n    Tuple,\n    Type,\n    TypeVar,\n    get_type_hints,\n)\n\nfrom pydantic import BaseModel, create_model\nfrom typing_extensions import TypedDict, get_args\n\nfrom starlite.exceptions import ImproperlyConfiguredException\nfrom starlite.types.builtin_types import NoneType\nfrom starlite.utils.predicates import (\n    is_class_and_subclass,\n    is_dataclass_class_typeguard,\n    is_typeddict_typeguard,\n)\n\ntry:\n    # python 3.9 changed these variable\n    from typing import _UnionGenericAlias as GenericAlias  # type: ignore\nexcept ImportError:  # pragma: no cover\n    from typing import _GenericAlias as GenericAlias  # type: ignore\n\nif TYPE_CHECKING:\n    from typing import TypeAlias, Union  # noqa: F401  # nopycln: import\n\n    from starlite.types.builtin_types import DataclassClass, TypedDictClass\n\nT = TypeVar(\"T\")\n\nSupportedTypes: \"TypeAlias\" = \"Union[DataclassClass, Type[BaseModel], TypedDictClass]\"\n\"\"\"Types that are supported by [`Partial`][starlite.types.partial.Partial]\"\"\"\n\n\nclass Partial(Generic[T]):\n    \"\"\"Type generation for PATCH routes.\n\n    Partial is a special typing helper that takes a generic T, which must be a\n    [`TypedDict`][typing.TypedDict], dataclass or pydantic model class, and\n    returns to static type checkers a version of this T in which all fields -\n    and nested fields - are optional.\n    \"\"\"\n\n    _models: Dict[SupportedTypes, SupportedTypes] = {}\n\n    def __class_getitem__(cls, item: Type[T]) -> Type[T]:\n        \"\"\"Takes a pydantic model class, [`TypedDict`][typing.TypedDict] or a\n        dataclass and returns an all optional version of that class.\n\n        Args:\n            item: A pydantic model, [`TypedDict`][typing.TypedDict] or dataclass class.\n\n        Returns:\n            A pydantic model, [`TypedDict`][typing.TypedDict], or dataclass.\n        \"\"\"\n\n        if item not in cls._models:\n            if is_class_and_subclass(item, BaseModel):\n                cls._create_partial_pydantic_model(item=item)\n            elif is_dataclass_class_typeguard(item):\n                cls._create_partial_dataclass(item=item)\n            elif is_typeddict_typeguard(item):\n                cls._create_partial_typeddict(item=item)\n            else:\n                raise ImproperlyConfiguredException(\n                    \"The type argument T passed to Partial[T] must be a `TypedDict`, dataclass or pydantic model class\"\n                )\n\n        return cls._models[item]  # type:ignore[return-value]\n\n    @classmethod\n    def _create_partial_pydantic_model(cls, item: Type[BaseModel]) -> None:\n        \"\"\"Receives a pydantic model class and creates an all optional subclass\n        of it.\n\n        Args:\n            item: A pydantic model class.\n        \"\"\"\n        field_definitions: Dict[str, Tuple[Any, None]] = {}\n        for field_name, field_type in get_type_hints(item).items():\n            if not isinstance(field_type, GenericAlias) or NoneType not in field_type.__args__:\n                field_definitions[field_name] = (Optional[field_type], None)\n            else:\n                field_definitions[field_name] = (field_type, None)\n\n        cls._models[item] = create_model(cls._create_partial_type_name(item), __base__=item, **field_definitions)  # type: ignore\n\n    @classmethod\n    def _create_partial_dataclass(cls, item: \"DataclassClass\") -> None:\n        \"\"\"Receives a dataclass class and creates an all optional subclass of\n        it.\n\n        Args:\n            item: A dataclass class.\n        \"\"\"\n        fields: Dict[str, DataclassField] = cls._create_optional_field_map(item)\n        partial_type: \"DataclassClass\" = dataclass(\n            type(cls._create_partial_type_name(item), (item,), {\"__dataclass_fields__\": fields})\n        )\n        annotated_ancestors = [a for a in getmro(partial_type) if hasattr(a, \"__annotations__\")]\n        for ancestor in annotated_ancestors:\n            for field_name, annotation in ancestor.__annotations__.items():\n                if not isinstance(annotation, GenericAlias) or NoneType not in annotation.__args__:\n                    partial_type.__annotations__[field_name] = Optional[annotation]\n                else:\n                    partial_type.__annotations__[field_name] = annotation\n\n        cls._models[item] = partial_type\n\n    @classmethod\n    def _create_partial_typeddict(cls, item: \"TypedDictClass\") -> None:\n        \"\"\"Receives a typeddict class and creates a new type with all\n        attributes `Optional`.\n\n        Args:\n            item: A [`TypedDict`][typing.TypeDict] class.\n        \"\"\"\n        type_hints: Dict[str, Any] = {}\n        for key_name, value_type in get_type_hints(item).items():\n            if NoneType in get_args(value_type):\n                type_hints[key_name] = value_type\n                continue\n            type_hints[key_name] = Optional[value_type]\n        type_name = cls._create_partial_type_name(item)\n        cls._models[item] = TypedDict(type_name, type_hints, total=False)  # type:ignore\n\n    @staticmethod\n    def _create_optional_field_map(item: \"DataclassClass\") -> Dict[str, DataclassField]:\n        \"\"\"Creates a map of field name to optional dataclass Fields for a given\n        dataclass.\n\n        Args:\n            item: A dataclass class.\n\n        Returns:\n            A map of field name to optional dataclass fields.\n        \"\"\"\n        fields: Dict[str, DataclassField] = {}\n        # https://github.com/python/typing/discussions/1056\n        for field_name, dataclass_field in item.__dataclass_fields__.items():  # pyright:ignore\n            if not isinstance(dataclass_field.type, GenericAlias) or NoneType not in dataclass_field.type.__args__:\n                dataclass_field.type = Optional[dataclass_field.type]\n            if dataclass_field.default_factory is MISSING:\n                dataclass_field.default = None if dataclass_field.default is MISSING else dataclass_field.default\n            fields[field_name] = dataclass_field\n        return fields\n\n    @staticmethod\n    def _create_partial_type_name(item: SupportedTypes) -> str:\n        return f\"Partial{item.__name__}\"\n", "path": "starlite/types/partial.py"}], "after_files": [{"content": "from dataclasses import MISSING\nfrom dataclasses import Field as DataclassField\nfrom dataclasses import dataclass\nfrom inspect import getmro\nfrom typing import (\n    TYPE_CHECKING,\n    Any,\n    Dict,\n    Generic,\n    Optional,\n    Tuple,\n    Type,\n    TypeVar,\n    get_type_hints,\n)\n\nfrom pydantic import BaseModel, create_model\nfrom pydantic.typing import is_classvar\nfrom typing_extensions import TypedDict, get_args\n\nfrom starlite.exceptions import ImproperlyConfiguredException\nfrom starlite.types.builtin_types import NoneType\nfrom starlite.utils.predicates import (\n    is_class_and_subclass,\n    is_dataclass_class_typeguard,\n    is_typeddict_typeguard,\n)\n\ntry:\n    # python 3.9 changed these variable\n    from typing import _UnionGenericAlias as GenericAlias  # type: ignore\nexcept ImportError:  # pragma: no cover\n    from typing import _GenericAlias as GenericAlias  # type: ignore\n\nif TYPE_CHECKING:\n    from typing import TypeAlias, Union  # noqa: F401  # nopycln: import\n\n    from starlite.types.builtin_types import DataclassClass, TypedDictClass\n\nT = TypeVar(\"T\")\n\nSupportedTypes: \"TypeAlias\" = \"Union[DataclassClass, Type[BaseModel], TypedDictClass]\"\n\"\"\"Types that are supported by [`Partial`][starlite.types.partial.Partial]\"\"\"\n\n\nclass Partial(Generic[T]):\n    \"\"\"Type generation for PATCH routes.\n\n    Partial is a special typing helper that takes a generic T, which must be a\n    [`TypedDict`][typing.TypedDict], dataclass or pydantic model class, and\n    returns to static type checkers a version of this T in which all fields -\n    and nested fields - are optional.\n    \"\"\"\n\n    _models: Dict[SupportedTypes, SupportedTypes] = {}\n\n    def __class_getitem__(cls, item: Type[T]) -> Type[T]:\n        \"\"\"Takes a pydantic model class, [`TypedDict`][typing.TypedDict] or a\n        dataclass and returns an all optional version of that class.\n\n        Args:\n            item: A pydantic model, [`TypedDict`][typing.TypedDict] or dataclass class.\n\n        Returns:\n            A pydantic model, [`TypedDict`][typing.TypedDict], or dataclass.\n        \"\"\"\n\n        if item not in cls._models:\n            if is_class_and_subclass(item, BaseModel):\n                cls._create_partial_pydantic_model(item=item)\n            elif is_dataclass_class_typeguard(item):\n                cls._create_partial_dataclass(item=item)\n            elif is_typeddict_typeguard(item):\n                cls._create_partial_typeddict(item=item)\n            else:\n                raise ImproperlyConfiguredException(\n                    \"The type argument T passed to Partial[T] must be a `TypedDict`, dataclass or pydantic model class\"\n                )\n\n        return cls._models[item]  # type:ignore[return-value]\n\n    @classmethod\n    def _create_partial_pydantic_model(cls, item: Type[BaseModel]) -> None:\n        \"\"\"Receives a pydantic model class and creates an all optional subclass\n        of it.\n\n        Args:\n            item: A pydantic model class.\n        \"\"\"\n        field_definitions: Dict[str, Tuple[Any, None]] = {}\n        for field_name, field_type in get_type_hints(item).items():\n            if is_classvar(field_type):\n                continue\n            if not isinstance(field_type, GenericAlias) or NoneType not in field_type.__args__:\n                field_definitions[field_name] = (Optional[field_type], None)\n            else:\n                field_definitions[field_name] = (field_type, None)\n\n        cls._models[item] = create_model(cls._create_partial_type_name(item), __base__=item, **field_definitions)  # type: ignore\n\n    @classmethod\n    def _create_partial_dataclass(cls, item: \"DataclassClass\") -> None:\n        \"\"\"Receives a dataclass class and creates an all optional subclass of\n        it.\n\n        Args:\n            item: A dataclass class.\n        \"\"\"\n        fields: Dict[str, DataclassField] = cls._create_optional_field_map(item)\n        partial_type: \"DataclassClass\" = dataclass(\n            type(cls._create_partial_type_name(item), (item,), {\"__dataclass_fields__\": fields})\n        )\n        annotated_ancestors = [a for a in getmro(partial_type) if hasattr(a, \"__annotations__\")]\n        for ancestor in annotated_ancestors:\n            for field_name, annotation in ancestor.__annotations__.items():\n                if not isinstance(annotation, GenericAlias) or NoneType not in annotation.__args__:\n                    partial_type.__annotations__[field_name] = Optional[annotation]\n                else:\n                    partial_type.__annotations__[field_name] = annotation\n\n        cls._models[item] = partial_type\n\n    @classmethod\n    def _create_partial_typeddict(cls, item: \"TypedDictClass\") -> None:\n        \"\"\"Receives a typeddict class and creates a new type with all\n        attributes `Optional`.\n\n        Args:\n            item: A [`TypedDict`][typing.TypeDict] class.\n        \"\"\"\n        type_hints: Dict[str, Any] = {}\n        for key_name, value_type in get_type_hints(item).items():\n            if NoneType in get_args(value_type):\n                type_hints[key_name] = value_type\n                continue\n            type_hints[key_name] = Optional[value_type]\n        type_name = cls._create_partial_type_name(item)\n        cls._models[item] = TypedDict(type_name, type_hints, total=False)  # type:ignore\n\n    @staticmethod\n    def _create_optional_field_map(item: \"DataclassClass\") -> Dict[str, DataclassField]:\n        \"\"\"Creates a map of field name to optional dataclass Fields for a given\n        dataclass.\n\n        Args:\n            item: A dataclass class.\n\n        Returns:\n            A map of field name to optional dataclass fields.\n        \"\"\"\n        fields: Dict[str, DataclassField] = {}\n        # https://github.com/python/typing/discussions/1056\n        for field_name, dataclass_field in item.__dataclass_fields__.items():  # pyright:ignore\n            if not isinstance(dataclass_field.type, GenericAlias) or NoneType not in dataclass_field.type.__args__:\n                dataclass_field.type = Optional[dataclass_field.type]\n            if dataclass_field.default_factory is MISSING:\n                dataclass_field.default = None if dataclass_field.default is MISSING else dataclass_field.default\n            fields[field_name] = dataclass_field\n        return fields\n\n    @staticmethod\n    def _create_partial_type_name(item: SupportedTypes) -> str:\n        return f\"Partial{item.__name__}\"\n", "path": "starlite/types/partial.py"}]}