We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
Bug: Annotated Types not being rendered in OpenAPI schema
### Description

I've got a `msgspec.Struct` request object that uses an `typing.Annotated` type as one of it's field types.

When viewing routes request object, I'm only seeing a str or null allowed but no mention of the max length piece.  This also happens when I exclude the `| None` from the type declaration as well.

### URL to code causing the issue

_No response_

### MCVE

```python
from typing import Annotated
import msgspec

IDType = Annotated[str, msgspec.Meta(max_length=16)]

class Lookup(msgspec.Struct):
    id:  IDType | None
```


### Steps to reproduce

```bash
1. Create route with the above request object.
2. View the route in the /schema endpoint.
```


### Screenshots

_No response_

### Logs

_No response_

### Litestar Version

2.0.0a5

### Platform

- [X] Linux
- [ ] Mac
- [ ] Windows
- [ ] Other (Please specify in the description above)

--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `litestar/_signature/field.py`
Content:
```
1 from __future__ import annotations
2 
3 from dataclasses import dataclass
4 from typing import Any, Literal
5 
6 from typing_extensions import get_args, get_origin
7 
8 from litestar.constants import UNDEFINED_SENTINELS
9 from litestar.params import BodyKwarg, DependencyKwarg, ParameterKwarg
10 from litestar.types import Empty
11 from litestar.utils.predicates import (
12     is_any,
13     is_generic,
14     is_mapping,
15     is_non_string_iterable,
16     is_non_string_sequence,
17     is_optional_union,
18     is_union,
19 )
20 from litestar.utils.typing import make_non_optional_union
21 
22 __all__ = ("SignatureField",)
23 
24 
25 @dataclass(unsafe_hash=True, frozen=True)
26 class SignatureField:
27     """Abstraction representing a model field. This class is meant to replace equivalent datastructures from other
28     libraries, for example, pydantic or msgspec.
29     """
30 
31     __slots__ = (
32         "children",
33         "default_value",
34         "extra",
35         "field_type",
36         "kwarg_model",
37         "name",
38     )
39 
40     children: tuple[SignatureField, ...] | None
41     """A mapping of subtypes, if any."""
42     default_value: Any
43     """Field name."""
44     extra: dict[str, Any]
45     """A mapping of extra values."""
46     field_type: Any
47     """The type of the kwarg."""
48     kwarg_model: ParameterKwarg | BodyKwarg | DependencyKwarg | None
49     """Kwarg Parameter."""
50     name: str
51     """Field name."""
52 
53     @property
54     def is_empty(self) -> bool:
55         """Check if the default value is an empty type.
56 
57         Returns:
58             True if the default_value is Empty or Ellipsis otherwise False.
59         """
60         return self.default_value is Empty or self.default_value is Ellipsis
61 
62     @property
63     def is_optional(self) -> bool:
64         """Check if the field type is an Optional union.
65 
66         Returns:
67             True if the field_type is an Optional union otherwise False.
68         """
69         return is_optional_union(self.field_type)
70 
71     @property
72     def is_mapping(self) -> bool:
73         """Check if the field type is a Mapping."""
74         return is_mapping(self.field_type)
75 
76     @property
77     def is_non_string_iterable(self) -> bool:
78         """Check if the field type is an Iterable.
79 
80         If ``self.field_type`` is an optional union, only the non-optional members of the union are evaluated.
81 
82         See: https://github.com/litestar-org/litestar/issues/1106
83         """
84         field_type = self.field_type
85         if self.is_optional:
86             field_type = make_non_optional_union(field_type)
87         return is_non_string_iterable(field_type)
88 
89     @property
90     def is_non_string_sequence(self) -> bool:
91         """Check if the field type is a non-string Sequence.
92 
93         If ``self.field_type`` is an optional union, only the non-optional members of the union are evaluated.
94 
95         See: https://github.com/litestar-org/litestar/issues/1106
96         """
97         field_type = self.field_type
98         if self.is_optional:
99             field_type = make_non_optional_union(field_type)
100         return is_non_string_sequence(field_type)
101 
102     @property
103     def is_any(self) -> bool:
104         """Check if the field type is Any."""
105         return is_any(self.field_type)
106 
107     @property
108     def is_union(self) -> bool:
109         """Check if the field type is a Union."""
110         return is_union(self.field_type)
111 
112     @property
113     def is_generic(self) -> bool:
114         """Check if the field type is a custom class extending Generic."""
115         return is_generic(self.field_type)
116 
117     @property
118     def is_simple_type(self) -> bool:
119         """Check if the field type is a singleton value (e.g. int, str etc.)."""
120         return not (
121             self.is_generic or self.is_optional or self.is_union or self.is_mapping or self.is_non_string_iterable
122         )
123 
124     @property
125     def is_parameter_field(self) -> bool:
126         """Check if the field type is a parameter kwarg value."""
127         return self.kwarg_model is not None and isinstance(self.kwarg_model, ParameterKwarg)
128 
129     @property
130     def is_const(self) -> bool:
131         """Check if the field is defined as constant value."""
132         return bool(self.kwarg_model and getattr(self.kwarg_model, "const", False))
133 
134     @property
135     def is_required(self) -> bool:
136         """Check if the field should be marked as a required parameter."""
137         if isinstance(self.kwarg_model, ParameterKwarg) and self.kwarg_model.required is not None:
138             return self.kwarg_model.required
139 
140         return not (self.is_optional or self.is_any) and (self.is_empty or self.default_value is None)
141 
142     @property
143     def is_literal(self) -> bool:
144         """Check if the field type is Literal."""
145         return get_origin(self.field_type) is Literal
146 
147     @classmethod
148     def create(
149         cls,
150         field_type: Any,
151         name: str = "",
152         default_value: Any = Empty,
153         children: tuple[SignatureField, ...] | None = None,
154         kwarg_model: ParameterKwarg | BodyKwarg | DependencyKwarg | None = None,
155         extra: dict[str, Any] | None = None,
156     ) -> SignatureField:
157         """Create a new SignatureModel instance.
158 
159         Args:
160             field_type: The type of the kwarg.
161             name: Field name.
162             default_value: A default value.
163             children: A mapping of subtypes, if any.
164             kwarg_model: Kwarg Parameter.
165             extra: A mapping of extra values.
166 
167         Returns:
168             SignatureField instance.
169         """
170         if kwarg_model and default_value is Empty:
171             default_value = kwarg_model.default
172 
173         if not children and get_origin(field_type) and (type_args := get_args(field_type)):
174             children = tuple(SignatureField.create(arg) for arg in type_args)
175 
176         return SignatureField(
177             name=name,
178             field_type=field_type if field_type is not Empty else Any,
179             default_value=default_value if default_value not in UNDEFINED_SENTINELS else Empty,
180             children=children,
181             kwarg_model=kwarg_model,
182             extra=extra or {},
183         )
184
```
--- 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/litestar/_signature/field.py b/litestar/_signature/field.py
--- a/litestar/_signature/field.py
+++ b/litestar/_signature/field.py
@@ -3,7 +3,8 @@
 from dataclasses import dataclass
 from typing import Any, Literal
 
-from typing_extensions import get_args, get_origin
+from msgspec import Meta
+from typing_extensions import Annotated, get_args, get_origin
 
 from litestar.constants import UNDEFINED_SENTINELS
 from litestar.params import BodyKwarg, DependencyKwarg, ParameterKwarg
@@ -22,6 +23,26 @@
 __all__ = ("SignatureField",)
 
 
+def _create_metadata_from_type(
+    value: Any, model: type[ParameterKwarg] | type[BodyKwarg], field_type: Any
+) -> ParameterKwarg | BodyKwarg | None:
+    if isinstance(value, Meta):
+        is_sequence_container = is_non_string_sequence(field_type)
+        return model(
+            gt=value.gt,
+            ge=value.ge,
+            lt=value.lt,
+            le=value.le,
+            multiple_of=value.multiple_of,
+            regex=value.pattern,
+            min_length=value.min_length if not is_sequence_container else None,
+            max_length=value.max_length if not is_sequence_container else None,
+            min_items=value.min_length if is_sequence_container else None,
+            max_items=value.max_length if is_sequence_container else None,
+        )
+    return None
+
+
 @dataclass(unsafe_hash=True, frozen=True)
 class SignatureField:
     """Abstraction representing a model field. This class is meant to replace equivalent datastructures from other
@@ -170,8 +191,17 @@
         if kwarg_model and default_value is Empty:
             default_value = kwarg_model.default
 
-        if not children and get_origin(field_type) and (type_args := get_args(field_type)):
-            children = tuple(SignatureField.create(arg) for arg in type_args)
+        origin = get_origin(field_type)
+
+        if not children and origin and (type_args := get_args(field_type)):
+            if origin is Annotated:
+                field_type = type_args[0]
+                if not kwarg_model:
+                    kwarg_model = _create_metadata_from_type(
+                        type_args[1], BodyKwarg if name == "data" else ParameterKwarg, field_type=field_type
+                    )
+            else:
+                children = tuple(SignatureField.create(arg) for arg in type_args)
 
         return SignatureField(
             name=name,

{"golden_diff": "diff --git a/litestar/_signature/field.py b/litestar/_signature/field.py\n--- a/litestar/_signature/field.py\n+++ b/litestar/_signature/field.py\n@@ -3,7 +3,8 @@\n from dataclasses import dataclass\n from typing import Any, Literal\n \n-from typing_extensions import get_args, get_origin\n+from msgspec import Meta\n+from typing_extensions import Annotated, get_args, get_origin\n \n from litestar.constants import UNDEFINED_SENTINELS\n from litestar.params import BodyKwarg, DependencyKwarg, ParameterKwarg\n@@ -22,6 +23,26 @@\n __all__ = (\"SignatureField\",)\n \n \n+def _create_metadata_from_type(\n+    value: Any, model: type[ParameterKwarg] | type[BodyKwarg], field_type: Any\n+) -> ParameterKwarg | BodyKwarg | None:\n+    if isinstance(value, Meta):\n+        is_sequence_container = is_non_string_sequence(field_type)\n+        return model(\n+            gt=value.gt,\n+            ge=value.ge,\n+            lt=value.lt,\n+            le=value.le,\n+            multiple_of=value.multiple_of,\n+            regex=value.pattern,\n+            min_length=value.min_length if not is_sequence_container else None,\n+            max_length=value.max_length if not is_sequence_container else None,\n+            min_items=value.min_length if is_sequence_container else None,\n+            max_items=value.max_length if is_sequence_container else None,\n+        )\n+    return None\n+\n+\n @dataclass(unsafe_hash=True, frozen=True)\n class SignatureField:\n     \"\"\"Abstraction representing a model field. This class is meant to replace equivalent datastructures from other\n@@ -170,8 +191,17 @@\n         if kwarg_model and default_value is Empty:\n             default_value = kwarg_model.default\n \n-        if not children and get_origin(field_type) and (type_args := get_args(field_type)):\n-            children = tuple(SignatureField.create(arg) for arg in type_args)\n+        origin = get_origin(field_type)\n+\n+        if not children and origin and (type_args := get_args(field_type)):\n+            if origin is Annotated:\n+                field_type = type_args[0]\n+                if not kwarg_model:\n+                    kwarg_model = _create_metadata_from_type(\n+                        type_args[1], BodyKwarg if name == \"data\" else ParameterKwarg, field_type=field_type\n+                    )\n+            else:\n+                children = tuple(SignatureField.create(arg) for arg in type_args)\n \n         return SignatureField(\n             name=name,\n", "issue": "Bug: Annotated Types not being rendered in OpenAPI schema\n### Description\n\nI've got a `msgspec.Struct` request object that uses an `typing.Annotated` type as one of it's field types.\r\n\r\nWhen viewing routes request object, I'm only seeing a str or null allowed but no mention of the max length piece.  This also happens when I exclude the `| None` from the type declaration as well.\n\n### URL to code causing the issue\n\n_No response_\n\n### MCVE\n\n```python\nfrom typing import Annotated\r\nimport msgspec\r\n\r\nIDType = Annotated[str, msgspec.Meta(max_length=16)]\r\n\r\nclass Lookup(msgspec.Struct):\r\n    id:  IDType | None\n```\n\n\n### Steps to reproduce\n\n```bash\n1. Create route with the above request object.\r\n2. View the route in the /schema endpoint.\n```\n\n\n### Screenshots\n\n_No response_\n\n### Logs\n\n_No response_\n\n### Litestar Version\n\n2.0.0a5\n\n### Platform\n\n- [X] Linux\n- [ ] Mac\n- [ ] Windows\n- [ ] Other (Please specify in the description above)\n", "before_files": [{"content": "from __future__ import annotations\n\nfrom dataclasses import dataclass\nfrom typing import Any, Literal\n\nfrom typing_extensions import get_args, get_origin\n\nfrom litestar.constants import UNDEFINED_SENTINELS\nfrom litestar.params import BodyKwarg, DependencyKwarg, ParameterKwarg\nfrom litestar.types import Empty\nfrom litestar.utils.predicates import (\n    is_any,\n    is_generic,\n    is_mapping,\n    is_non_string_iterable,\n    is_non_string_sequence,\n    is_optional_union,\n    is_union,\n)\nfrom litestar.utils.typing import make_non_optional_union\n\n__all__ = (\"SignatureField\",)\n\n\n@dataclass(unsafe_hash=True, frozen=True)\nclass SignatureField:\n    \"\"\"Abstraction representing a model field. This class is meant to replace equivalent datastructures from other\n    libraries, for example, pydantic or msgspec.\n    \"\"\"\n\n    __slots__ = (\n        \"children\",\n        \"default_value\",\n        \"extra\",\n        \"field_type\",\n        \"kwarg_model\",\n        \"name\",\n    )\n\n    children: tuple[SignatureField, ...] | None\n    \"\"\"A mapping of subtypes, if any.\"\"\"\n    default_value: Any\n    \"\"\"Field name.\"\"\"\n    extra: dict[str, Any]\n    \"\"\"A mapping of extra values.\"\"\"\n    field_type: Any\n    \"\"\"The type of the kwarg.\"\"\"\n    kwarg_model: ParameterKwarg | BodyKwarg | DependencyKwarg | None\n    \"\"\"Kwarg Parameter.\"\"\"\n    name: str\n    \"\"\"Field name.\"\"\"\n\n    @property\n    def is_empty(self) -> bool:\n        \"\"\"Check if the default value is an empty type.\n\n        Returns:\n            True if the default_value is Empty or Ellipsis otherwise False.\n        \"\"\"\n        return self.default_value is Empty or self.default_value is Ellipsis\n\n    @property\n    def is_optional(self) -> bool:\n        \"\"\"Check if the field type is an Optional union.\n\n        Returns:\n            True if the field_type is an Optional union otherwise False.\n        \"\"\"\n        return is_optional_union(self.field_type)\n\n    @property\n    def is_mapping(self) -> bool:\n        \"\"\"Check if the field type is a Mapping.\"\"\"\n        return is_mapping(self.field_type)\n\n    @property\n    def is_non_string_iterable(self) -> bool:\n        \"\"\"Check if the field type is an Iterable.\n\n        If ``self.field_type`` is an optional union, only the non-optional members of the union are evaluated.\n\n        See: https://github.com/litestar-org/litestar/issues/1106\n        \"\"\"\n        field_type = self.field_type\n        if self.is_optional:\n            field_type = make_non_optional_union(field_type)\n        return is_non_string_iterable(field_type)\n\n    @property\n    def is_non_string_sequence(self) -> bool:\n        \"\"\"Check if the field type is a non-string Sequence.\n\n        If ``self.field_type`` is an optional union, only the non-optional members of the union are evaluated.\n\n        See: https://github.com/litestar-org/litestar/issues/1106\n        \"\"\"\n        field_type = self.field_type\n        if self.is_optional:\n            field_type = make_non_optional_union(field_type)\n        return is_non_string_sequence(field_type)\n\n    @property\n    def is_any(self) -> bool:\n        \"\"\"Check if the field type is Any.\"\"\"\n        return is_any(self.field_type)\n\n    @property\n    def is_union(self) -> bool:\n        \"\"\"Check if the field type is a Union.\"\"\"\n        return is_union(self.field_type)\n\n    @property\n    def is_generic(self) -> bool:\n        \"\"\"Check if the field type is a custom class extending Generic.\"\"\"\n        return is_generic(self.field_type)\n\n    @property\n    def is_simple_type(self) -> bool:\n        \"\"\"Check if the field type is a singleton value (e.g. int, str etc.).\"\"\"\n        return not (\n            self.is_generic or self.is_optional or self.is_union or self.is_mapping or self.is_non_string_iterable\n        )\n\n    @property\n    def is_parameter_field(self) -> bool:\n        \"\"\"Check if the field type is a parameter kwarg value.\"\"\"\n        return self.kwarg_model is not None and isinstance(self.kwarg_model, ParameterKwarg)\n\n    @property\n    def is_const(self) -> bool:\n        \"\"\"Check if the field is defined as constant value.\"\"\"\n        return bool(self.kwarg_model and getattr(self.kwarg_model, \"const\", False))\n\n    @property\n    def is_required(self) -> bool:\n        \"\"\"Check if the field should be marked as a required parameter.\"\"\"\n        if isinstance(self.kwarg_model, ParameterKwarg) and self.kwarg_model.required is not None:\n            return self.kwarg_model.required\n\n        return not (self.is_optional or self.is_any) and (self.is_empty or self.default_value is None)\n\n    @property\n    def is_literal(self) -> bool:\n        \"\"\"Check if the field type is Literal.\"\"\"\n        return get_origin(self.field_type) is Literal\n\n    @classmethod\n    def create(\n        cls,\n        field_type: Any,\n        name: str = \"\",\n        default_value: Any = Empty,\n        children: tuple[SignatureField, ...] | None = None,\n        kwarg_model: ParameterKwarg | BodyKwarg | DependencyKwarg | None = None,\n        extra: dict[str, Any] | None = None,\n    ) -> SignatureField:\n        \"\"\"Create a new SignatureModel instance.\n\n        Args:\n            field_type: The type of the kwarg.\n            name: Field name.\n            default_value: A default value.\n            children: A mapping of subtypes, if any.\n            kwarg_model: Kwarg Parameter.\n            extra: A mapping of extra values.\n\n        Returns:\n            SignatureField instance.\n        \"\"\"\n        if kwarg_model and default_value is Empty:\n            default_value = kwarg_model.default\n\n        if not children and get_origin(field_type) and (type_args := get_args(field_type)):\n            children = tuple(SignatureField.create(arg) for arg in type_args)\n\n        return SignatureField(\n            name=name,\n            field_type=field_type if field_type is not Empty else Any,\n            default_value=default_value if default_value not in UNDEFINED_SENTINELS else Empty,\n            children=children,\n            kwarg_model=kwarg_model,\n            extra=extra or {},\n        )\n", "path": "litestar/_signature/field.py"}], "after_files": [{"content": "from __future__ import annotations\n\nfrom dataclasses import dataclass\nfrom typing import Any, Literal\n\nfrom msgspec import Meta\nfrom typing_extensions import Annotated, get_args, get_origin\n\nfrom litestar.constants import UNDEFINED_SENTINELS\nfrom litestar.params import BodyKwarg, DependencyKwarg, ParameterKwarg\nfrom litestar.types import Empty\nfrom litestar.utils.predicates import (\n    is_any,\n    is_generic,\n    is_mapping,\n    is_non_string_iterable,\n    is_non_string_sequence,\n    is_optional_union,\n    is_union,\n)\nfrom litestar.utils.typing import make_non_optional_union\n\n__all__ = (\"SignatureField\",)\n\n\ndef _create_metadata_from_type(\n    value: Any, model: type[ParameterKwarg] | type[BodyKwarg], field_type: Any\n) -> ParameterKwarg | BodyKwarg | None:\n    if isinstance(value, Meta):\n        is_sequence_container = is_non_string_sequence(field_type)\n        return model(\n            gt=value.gt,\n            ge=value.ge,\n            lt=value.lt,\n            le=value.le,\n            multiple_of=value.multiple_of,\n            regex=value.pattern,\n            min_length=value.min_length if not is_sequence_container else None,\n            max_length=value.max_length if not is_sequence_container else None,\n            min_items=value.min_length if is_sequence_container else None,\n            max_items=value.max_length if is_sequence_container else None,\n        )\n    return None\n\n\n@dataclass(unsafe_hash=True, frozen=True)\nclass SignatureField:\n    \"\"\"Abstraction representing a model field. This class is meant to replace equivalent datastructures from other\n    libraries, for example, pydantic or msgspec.\n    \"\"\"\n\n    __slots__ = (\n        \"children\",\n        \"default_value\",\n        \"extra\",\n        \"field_type\",\n        \"kwarg_model\",\n        \"name\",\n    )\n\n    children: tuple[SignatureField, ...] | None\n    \"\"\"A mapping of subtypes, if any.\"\"\"\n    default_value: Any\n    \"\"\"Field name.\"\"\"\n    extra: dict[str, Any]\n    \"\"\"A mapping of extra values.\"\"\"\n    field_type: Any\n    \"\"\"The type of the kwarg.\"\"\"\n    kwarg_model: ParameterKwarg | BodyKwarg | DependencyKwarg | None\n    \"\"\"Kwarg Parameter.\"\"\"\n    name: str\n    \"\"\"Field name.\"\"\"\n\n    @property\n    def is_empty(self) -> bool:\n        \"\"\"Check if the default value is an empty type.\n\n        Returns:\n            True if the default_value is Empty or Ellipsis otherwise False.\n        \"\"\"\n        return self.default_value is Empty or self.default_value is Ellipsis\n\n    @property\n    def is_optional(self) -> bool:\n        \"\"\"Check if the field type is an Optional union.\n\n        Returns:\n            True if the field_type is an Optional union otherwise False.\n        \"\"\"\n        return is_optional_union(self.field_type)\n\n    @property\n    def is_mapping(self) -> bool:\n        \"\"\"Check if the field type is a Mapping.\"\"\"\n        return is_mapping(self.field_type)\n\n    @property\n    def is_non_string_iterable(self) -> bool:\n        \"\"\"Check if the field type is an Iterable.\n\n        If ``self.field_type`` is an optional union, only the non-optional members of the union are evaluated.\n\n        See: https://github.com/litestar-org/litestar/issues/1106\n        \"\"\"\n        field_type = self.field_type\n        if self.is_optional:\n            field_type = make_non_optional_union(field_type)\n        return is_non_string_iterable(field_type)\n\n    @property\n    def is_non_string_sequence(self) -> bool:\n        \"\"\"Check if the field type is a non-string Sequence.\n\n        If ``self.field_type`` is an optional union, only the non-optional members of the union are evaluated.\n\n        See: https://github.com/litestar-org/litestar/issues/1106\n        \"\"\"\n        field_type = self.field_type\n        if self.is_optional:\n            field_type = make_non_optional_union(field_type)\n        return is_non_string_sequence(field_type)\n\n    @property\n    def is_any(self) -> bool:\n        \"\"\"Check if the field type is Any.\"\"\"\n        return is_any(self.field_type)\n\n    @property\n    def is_union(self) -> bool:\n        \"\"\"Check if the field type is a Union.\"\"\"\n        return is_union(self.field_type)\n\n    @property\n    def is_generic(self) -> bool:\n        \"\"\"Check if the field type is a custom class extending Generic.\"\"\"\n        return is_generic(self.field_type)\n\n    @property\n    def is_simple_type(self) -> bool:\n        \"\"\"Check if the field type is a singleton value (e.g. int, str etc.).\"\"\"\n        return not (\n            self.is_generic or self.is_optional or self.is_union or self.is_mapping or self.is_non_string_iterable\n        )\n\n    @property\n    def is_parameter_field(self) -> bool:\n        \"\"\"Check if the field type is a parameter kwarg value.\"\"\"\n        return self.kwarg_model is not None and isinstance(self.kwarg_model, ParameterKwarg)\n\n    @property\n    def is_const(self) -> bool:\n        \"\"\"Check if the field is defined as constant value.\"\"\"\n        return bool(self.kwarg_model and getattr(self.kwarg_model, \"const\", False))\n\n    @property\n    def is_required(self) -> bool:\n        \"\"\"Check if the field should be marked as a required parameter.\"\"\"\n        if isinstance(self.kwarg_model, ParameterKwarg) and self.kwarg_model.required is not None:\n            return self.kwarg_model.required\n\n        return not (self.is_optional or self.is_any) and (self.is_empty or self.default_value is None)\n\n    @property\n    def is_literal(self) -> bool:\n        \"\"\"Check if the field type is Literal.\"\"\"\n        return get_origin(self.field_type) is Literal\n\n    @classmethod\n    def create(\n        cls,\n        field_type: Any,\n        name: str = \"\",\n        default_value: Any = Empty,\n        children: tuple[SignatureField, ...] | None = None,\n        kwarg_model: ParameterKwarg | BodyKwarg | DependencyKwarg | None = None,\n        extra: dict[str, Any] | None = None,\n    ) -> SignatureField:\n        \"\"\"Create a new SignatureModel instance.\n\n        Args:\n            field_type: The type of the kwarg.\n            name: Field name.\n            default_value: A default value.\n            children: A mapping of subtypes, if any.\n            kwarg_model: Kwarg Parameter.\n            extra: A mapping of extra values.\n\n        Returns:\n            SignatureField instance.\n        \"\"\"\n        if kwarg_model and default_value is Empty:\n            default_value = kwarg_model.default\n\n        origin = get_origin(field_type)\n\n        if not children and origin and (type_args := get_args(field_type)):\n            if origin is Annotated:\n                field_type = type_args[0]\n                if not kwarg_model:\n                    kwarg_model = _create_metadata_from_type(\n                        type_args[1], BodyKwarg if name == \"data\" else ParameterKwarg, field_type=field_type\n                    )\n            else:\n                children = tuple(SignatureField.create(arg) for arg in type_args)\n\n        return SignatureField(\n            name=name,\n            field_type=field_type if field_type is not Empty else Any,\n            default_value=default_value if default_value not in UNDEFINED_SENTINELS else Empty,\n            children=children,\n            kwarg_model=kwarg_model,\n            extra=extra or {},\n        )\n", "path": "litestar/_signature/field.py"}]}