openapi-python-client 0.28.4__py3-none-any.whl → 0.29.1__py3-none-any.whl

openapi_python_client/strings.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+import builtins
+import json
+import re
+import unicodedata
+from dataclasses import dataclass
+from email.message import Message
+from keyword import iskeyword
+from typing import Any
+
+from .config import Config
+from .schema.untrusted_string import UntrustedString
+
+DELIMITERS = r"\. _-"
+
+
+@dataclass(frozen=True, repr=False, slots=True)
+class PythonCode:
+    """
+    A snippet of Python source code generated from `UnstrustedString`s.
+
+    It's safe to treat as code, but _may not_ be safe to place in docstrings, f-strings, etc.
+    """
+
+    _code: str
+
+    def as_unembedded_code(self) -> str:
+        """
+        Return the raw source code with no transformations.
+
+        DO NOT use this inside a string context (docstrings, string literals, f-string literal text).
+        Pass this through the appropriate escaping function first (e.g. `safe_for_docstring`).
+        """
+        return self._code
+
+
+class PythonIdentifier(str):
+    """A snake_case string which has been validated / transformed into a valid identifier for Python"""
+
+    def __new__(cls, value: UntrustedString | str, prefix: str, skip_snake_case: bool = False) -> PythonIdentifier:
+        if isinstance(value, UntrustedString):
+            value = value.get_untrusted_value()
+        safe_value = sanitize(value)
+        leading_underscore = safe_value.startswith("_")
+        if skip_snake_case:
+            # Keep the name as close to the original as possible (to disambiguate conflicts);
+            # only strip the delimiters sanitize() preserved, as they aren't valid in identifiers
+            safe_value = re.sub(r"[^\w]+", "", safe_value)
+        else:
+            safe_value = snake_case(safe_value)
+        safe_value = fix_reserved_words(safe_value)
+
+        if not safe_value.isidentifier() or leading_underscore:
+            safe_value = f"{prefix}{safe_value}"
+        return str.__new__(cls, safe_value)
+
+    def __deepcopy__(self, _: Any) -> PythonIdentifier:
+        return self
+
+
+class ClassName(str):
+    """A PascalCase string which has been validated / transformed into a valid class name for Python"""
+
+    def __new__(cls, value: UntrustedString | str, prefix: str) -> ClassName:
+        safe_value = fix_reserved_words(pascal_case(value))
+
+        if not safe_value.isidentifier():
+            safe_value = f"{prefix}{safe_value}"
+            safe_value = fix_reserved_words(pascal_case(safe_value))
+        return str.__new__(cls, safe_value)
+
+    def __deepcopy__(self, _: Any) -> ClassName:
+        return self
+
+
+def sanitize(value: str) -> str:
+    """Removes every character that isn't 0-9, A-Z, a-z, or a known delimiter"""
+    return "".join(c for c in value if c.isidentifier() or c.isdecimal() or c in DELIMITERS)
+
+
+def split_words(value: str) -> list[str]:
+    """Split a string on words and known delimiters"""
+    if any(c.isupper() for c in value):
+        value = " ".join(re.split("([A-Z]?[a-z]+)", value))
+    return re.findall(rf"[^{re.escape(DELIMITERS)}]+", value)
+
+
+RESERVED_WORDS = (set(dir(builtins)) | {"self", "true", "false", "datetime"}) - {
+    "id",
+}
+
+
+def fix_reserved_words(value: str) -> str:
+    """
+    Using reserved Python words as identifiers in generated code causes problems, so this function renames them.
+
+    Args:
+        value: The identifier to-be that should be renamed if it's a reserved word.
+
+    Returns:
+        `value` suffixed with `_` if it was a reserved word.
+    """
+    if value in RESERVED_WORDS or iskeyword(value):
+        return f"{value}_"
+    return value
+
+
+def snake_case(value: str | UntrustedString) -> str:
+    """Converts to snake_case identifier, stripping all non-alphanumeric characters"""
+    if isinstance(value, UntrustedString):
+        value = value.get_untrusted_value()
+    words = split_words(sanitize(value))
+    return "_".join(words).lower()
+
+
+def pascal_case(value: str | UntrustedString) -> str:
+    """Converts to PascalCase identifier, stripping all non-alphanumeric characters"""
+    if isinstance(value, UntrustedString):
+        value = value.get_untrusted_value()
+    words = split_words(sanitize(value))
+    capitalized_words = (word.capitalize() if not word.isupper() else word for word in words)
+    return "".join(capitalized_words)
+
+
+def kebab_case(value: str | UntrustedString) -> str:
+    """Converts to kebab-case identifier, stripping all non-alphanumeric characters"""
+    if isinstance(value, UntrustedString):
+        value = value.get_untrusted_value()
+    words = split_words(sanitize(value))
+    return "-".join(words).lower()
+
+
+#: Escaped words in docstring content are kept shorter than this so the ``wordwrap`` filter
+#: never hard-splits inside an escape sequence (the narrowest wordwrap width in templates is 90).
+_MAX_ESCAPED_WORD_LENGTH = 76
+
+
+def _split_long_word_safely(word: str) -> str:
+    """Insert newlines into an over-long escaped word where they can't interrupt an escape sequence.
+
+    wordwrap hard-splits words longer than its width at arbitrary positions. A split between the
+    backslashes of ``\\\\`` leaves a lone backslash at the start of the next line, where it forms an
+    invalid escape (``\\ `` warns today and will error in a future Python) or even a ``SyntaxError``
+    (``\\U`` + non-hex is a truncated escape). Splits right after an even number of backslashes are
+    always safe: the prefix ends with complete escapes and the suffix can't start a dangling one.
+    """
+    chunks: list[str] = []
+    start = 0
+    while len(word) - start > _MAX_ESCAPED_WORD_LENGTH:
+        end = start + _MAX_ESCAPED_WORD_LENGTH
+        run = 0
+        while end > start and word[end - 1] == "\\":
+            end -= 1
+            run += 1
+        # Keep an even number of trailing backslashes in this chunk. Odd runs only occur right
+        # before an escaped quote, so the one left behind always forms a valid `\"`.
+        end += run - (run % 2)
+        chunks.append(word[start:end])
+        start = end
+    chunks.append(word[start:])
+    return "\n".join(chunks)
+
+
+def safe_for_docstring(value: Any) -> str:
+    """
+    Remove any risky escapes from docstring content.
+
+    The output is safe to run through the ``wordwrap`` filter at any width greater than
+    ``_MAX_ESCAPED_WORD_LENGTH``: over-long words containing escape sequences are pre-split where
+    no escape sequence is interrupted, so wordwrap's hard-splitting can't create invalid escapes.
+    """
+    if isinstance(value, UntrustedString):
+        value = value.get_untrusted_value()
+    if isinstance(value, PythonCode):
+        value = value.as_unembedded_code()
+    if not isinstance(value, str):
+        value = str(value)
+    # Strip control characters which are illegal in Python source (e.g. null bytes)
+    value = "".join(c for c in value if unicodedata.category(c) != "Cc" or c in "\n\r\t")
+
+    value = value.replace("\\", "\\\\").replace('"""', '\\"\\"\\"')
+    # Words without backslashes can be hard-split anywhere safely, so leave them alone
+    return re.sub(
+        r"\S+",
+        lambda match: _split_long_word_safely(match.group()) if "\\" in match.group() else match.group(),
+        value,
+    )
+
+
+def in_double_quote_literal(value: UntrustedString | PythonCode | str) -> str:
+    """Escape a string so it can be safely embedded inside a double-quoted string literal.
+
+    The result does NOT include surrounding quotes; the caller is expected to place it inside its own `"..."`
+    (e.g. a Python string literal or a TOML string in generated code). JSON encoding is used for the escaping,
+    which is valid inside both Python and TOML double-quoted strings.
+    """
+    if isinstance(value, UntrustedString):
+        value = value.get_untrusted_value()
+    if isinstance(value, PythonCode):
+        value = value.as_unembedded_code()
+    value = "".join(
+        character
+        for character in value
+        if (character in "\b\t\f" or not unicodedata.category(character).startswith("C"))
+        and unicodedata.category(character) not in {"Zl", "Zp"}
+    )
+    return json.dumps(value, ensure_ascii=False)[1:-1]
+
+
+def in_f_string_literal(value: UntrustedString | PythonCode | str) -> str:
+    """Escape a string so it can be safely embedded as literal text inside a double-quoted f-string.
+
+    In addition to the double-quoted-string escaping (quotes, backslashes), this escapes `{` and `}` as
+    `{{` and `}}` so the value cannot be interpreted as an f-string replacement field or format specifier.
+    Without this, an untrusted value could inject arbitrary expressions into the generated f-string.
+    """
+    return in_double_quote_literal(value).replace("{", "{{").replace("}", "}}")
+
+
+def remove_string_escapes(value: str) -> str:
+    """Used when parsing string-literal defaults to prevent escaping the string to write arbitrary Python
+
+    **REMOVING OR CHANGING THE USAGE OF THIS FUNCTION HAS SECURITY IMPLICATIONS**
+
+    See Also:
+        - https://github.com/openapi-generators/openapi-python-client/security/advisories/GHSA-9x4c-63pf-525f
+    """
+    return value.replace("\\", "\\\\").replace('"', r"\"")
+
+
+def get_content_type(content_type: str, config: Config) -> str | None:
+    """
+    Given a string representing a content type with optional parameters, returns the content type only
+    """
+    content_type = config.content_type_overrides.get(content_type, content_type)
+    message = Message()
+    message.add_header("Content-Type", content_type)
+
+    parsed_content_type = message.get_content_type()
+    if not content_type.startswith(parsed_content_type):
+        # Always defaults to `text/plain` if it's not recognized. We want to return an error, not default.
+        return None
+
+    return parsed_content_type

openapi_python_client/templates/README.md.jinja

@@ -1,5 +1,5 @@
 # {{ project_name }}
-{{ package_description }}
+{{ package_description.get_untrusted_value() }}
 
 ## Usage
 First, create a client:
@@ -47,7 +47,7 @@ By default, when you're calling an HTTPS API it will attempt to verify that SSL
 
 ```python
 client = AuthenticatedClient(
-    base_url="https://internal_api.example.com", 
+    base_url="https://internal_api.example.com",
     token="SuperSecretToken",
     verify_ssl="/path/to/certificate_bundle.pem",
 )
@@ -57,7 +57,7 @@ You can also disable certificate validation altogether, but beware that **this i
 
 ```python
 client = AuthenticatedClient(
-    base_url="https://internal_api.example.com", 
+    base_url="https://internal_api.example.com",
     token="SuperSecretToken", 
     verify_ssl=False
 )

openapi_python_client/templates/client.py.jinja

@@ -1,5 +1,5 @@
 import ssl
-from typing import Any
+from typing import Any, Self
 
 from attrs import define, field, evolve
 import httpx
@@ -98,7 +98,7 @@ class Client:
         return evolve(self, timeout=timeout)
 {% endmacro %}{{ builders("Client") }}
 {% macro httpx_stuff(name, custom_constructor=None) %}
-    def set_httpx_client(self, client: httpx.Client) -> "{{ name }}":
+    def set_httpx_client(self, client: httpx.Client) -> Self:
         """Manually set the underlying httpx.Client
 
         **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
@@ -123,7 +123,7 @@ class Client:
             )
         return self._client
 
-    def __enter__(self) -> "{{ name }}":
+    def __enter__(self) -> Self:
         """Enter a context manager for self.client—you cannot enter twice (see httpx docs)"""
         self.get_httpx_client().__enter__()
         return self
@@ -132,7 +132,7 @@ class Client:
         """Exit a context manager for internal httpx.Client (see httpx docs)"""
         self.get_httpx_client().__exit__(*args, **kwargs)
 
-    def set_async_httpx_client(self, async_client: httpx.AsyncClient) -> "{{ name }}":
+    def set_async_httpx_client(self, async_client: httpx.AsyncClient) -> Self:
         """Manually set the underlying httpx.AsyncClient
 
         **NOTE**: This will override any other settings on the client, including cookies, headers, and timeout.
@@ -157,7 +157,7 @@ class Client:
             )
         return self._async_client
 
-    async def __aenter__(self) -> "{{ name }}":
+    async def __aenter__(self) -> Self:
         """Enter a context manager for underlying httpx.AsyncClient—you cannot enter twice (see httpx docs)"""
         await self.get_async_httpx_client().__aenter__()
         return self

openapi_python_client/templates/endpoint_macros.py.jinja

@@ -1,5 +1,5 @@
 {% from "property_templates/helpers.jinja" import guarded_statement %}
-{% from "helpers.jinja" import safe_docstring %}
+{% from "helpers.jinja" import docstring as _docstring %}
 
 {% macro header_params(endpoint) %}
 {% if endpoint.header_parameters or endpoint.bodies | length > 0 %}
@@ -12,7 +12,7 @@ headers: dict[str, Any] = {}
         {% else %}
             {% set expression = parameter.python_name %}
         {% endif %}
-        {% set statement = 'headers["' +  parameter.name + '"]' + " = " + expression %}
+        {% set statement = 'headers["' + (parameter.name | in_double_quote_literal) + '"]' + " = " + expression %}
 {{ guarded_statement(parameter, parameter.python_name, statement) }}
     {% endfor %}
 {% endif %}
@@ -24,10 +24,10 @@ headers: dict[str, Any] = {}
 cookies = {}
     {% for parameter in endpoint.cookie_parameters %}
         {% if parameter.required %}
-cookies["{{ parameter.name}}"] = {{ parameter.python_name }}
+cookies["{{ parameter.name | in_double_quote_literal }}"] = {{ parameter.python_name }}
         {% else %}
 if {{ parameter.python_name }} is not UNSET:
-    cookies["{{ parameter.name}}"] = {{ parameter.python_name }}
+    cookies["{{ parameter.name | in_double_quote_literal }}"] = {{ parameter.python_name }}
         {% endif %}
 
     {% endfor %}
@@ -47,7 +47,7 @@ params: dict[str, Any] = {}
 {{ prop_template.transform(property, property.python_name, destination) }}
     {% endif %}
     {%- if not property.json_is_dict %}
-params["{{ property.name }}"] = {{ destination }}
+params["{{ property.name | in_double_quote_literal }}"] = {{ destination }}
     {% else %}
 {{ guarded_statement(property, destination, "params.update(" + destination + ")") }}
     {% endif %}
@@ -105,7 +105,7 @@ if not isinstance({{property.python_name}}, Unset):
 {% macro arguments(endpoint, include_client=True) %}
 {# path parameters #}
 {% for parameter in endpoint.path_parameters %}
-{{ parameter.to_string() }},
+{{ parameter.to_string() | as_unembedded_code }},
 {% endfor %}
 {% if include_client or ((endpoint.list_all_parameters() | length) > (endpoint.path_parameters | length)) %}
 *,
@@ -120,24 +120,24 @@ client: AuthenticatedClient | Client,
 {% endif %}
 {# Any allowed bodies #}
 {% if endpoint.bodies | length == 1 %}
-body: {{ endpoint.bodies[0].prop.get_type_string() }}{% if not endpoint.bodies[0].prop.required %} = UNSET{% endif %},
+body: {{ endpoint.bodies[0].prop.get_type_string() | as_unembedded_code }}{% if not endpoint.bodies[0].prop.required %} = UNSET{% endif %},
 {% elif endpoint.bodies | length > 1 %}
 body:
     {%- for body in endpoint.bodies -%}{% set body_required = body_required and body.prop.required %}
-    {{ body.prop.get_type_string(no_optional=True) }} {% if not loop.last %} | {% endif %}
+    {{ body.prop.get_type_string(no_optional=True) | as_unembedded_code }} {% if not loop.last %} | {% endif %}
     {%- endfor -%}{% if not body_required %} | Unset = UNSET{% endif %}
 ,
 {% endif %}
 {# query parameters #}
 {% for parameter in endpoint.query_parameters %}
-{{ parameter.to_string() }},
+{{ parameter.to_string() | as_unembedded_code }},
 {% endfor %}
 {% for parameter in endpoint.header_parameters %}
-{{ parameter.to_string() }},
+{{ parameter.to_string() | as_unembedded_code }},
 {% endfor %}
 {# cookie parameters #}
 {% for parameter in endpoint.cookie_parameters %}
-{{ parameter.to_string() }},
+{{ parameter.to_string() | as_unembedded_code }},
 {% endfor %}
 {% endmacro %}
 
@@ -164,10 +164,10 @@ body=body,
 {% endmacro %}
 
 {% macro docstring_content(endpoint, return_string, is_detailed) %}
-{% if endpoint.summary %}{{ endpoint.summary | wordwrap(100)}}
+{% if endpoint.summary %}{{ endpoint.summary | safe_for_docstring | wordwrap(100)}}
 
 {% endif -%}
-{%- if endpoint.description %} {{ endpoint.description | wordwrap(100) }}
+{%- if endpoint.description %} {{ endpoint.description | safe_for_docstring | wordwrap(100) }}
 
 {% endif %}
 {% if not endpoint.summary and not endpoint.description %}
@@ -188,24 +188,24 @@ Raises:
 
 Returns:
 {% if is_detailed %}
-    Response[{{ return_string }}]
+    Response[{{ return_string | safe_for_docstring }}]
 {% else %}
-    {{ return_string }}
+    {{ return_string | safe_for_docstring }}
 {% endif %}
 {% endmacro %}
 
 {% macro docstring(endpoint, return_string, is_detailed) %}
-{{ safe_docstring(docstring_content(endpoint, return_string, is_detailed)) }}
+{{ _docstring(docstring_content(endpoint, return_string, is_detailed)) }}
 {% endmacro %}
 
 {% macro parse_response(parsed_responses, response) %}
 {% if parsed_responses %}{% import "property_templates/" + response.prop.template as prop_template %}
 {% if prop_template.construct %}
 {{ prop_template.construct(response.prop, response.source.attribute) }}
-{% elif response.source.return_type == response.prop.get_type_string()  %}
+{% elif response.source.return_type == response.prop.get_type_string() | as_unembedded_code  %}
 {{ response.prop.python_name }} = {{ response.source.attribute }}
 {% else %}
-{{ response.prop.python_name }} = cast({{ response.prop.get_type_string() }}, {{ response.source.attribute }})
+{{ response.prop.python_name }} = cast({{ response.prop.get_type_string() | as_unembedded_code }}, {{ response.source.attribute }})
 {% endif %}
 return {{ response.prop.python_name }}
 {% else %}

openapi_python_client/templates/endpoint_module.py.jinja

@@ -16,7 +16,7 @@ from ... import errors
     arguments, client, kwargs, parse_response, docstring, body_to_kwarg %}
 
 {% set return_string = endpoint.response_type() %}
-{% set parsed_responses = (endpoint.responses | length > 0) and return_string != "Any" %}
+{% set parsed_responses = (endpoint.responses | length > 0) and return_string != PythonCode("Any") %}
 
 def _get_kwargs(
     {{ arguments(endpoint, include_client=False) | indent(4) }}
@@ -30,13 +30,13 @@ def _get_kwargs(
     _kwargs: dict[str, Any] = {
         "method": "{{ endpoint.method }}",
         {% if endpoint.path_parameters %}
-        "url": "{{ endpoint.path }}".format(
+        "url": "{{ endpoint.path | in_double_quote_literal }}".format(
         {%- for parameter in endpoint.path_parameters -%}
         {{parameter.python_name}}=quote(str({{parameter.python_name}}), safe=""),
         {%- endfor -%}
         ),
         {% else %}
-        "url": "{{ endpoint.path }}",
+        "url": "{{ endpoint.path | in_double_quote_literal }}",
         {% endif %}
         {% if endpoint.query_parameters %}
         "params": params,
@@ -48,15 +48,21 @@ def _get_kwargs(
 
 {% if endpoint.bodies | length > 1 %}
 {% for body in endpoint.bodies %}
-    if isinstance(body, {{body.prop.get_type_string(no_optional=True) }}):
+    if isinstance(body, {{body.prop.get_type_string(no_optional=True) | as_unembedded_code }}):
         {{ body_to_kwarg(body) | indent(8) }}
-        headers["Content-Type"] = "{{ body.content_type }}"
+        {%- if body.content_type == "multipart/form-data" %}
+        headers["Content-Type"] = "multipart/form-data; boundary=+++"
+        {% else %}
+        headers["Content-Type"] = "{{ body.content_type | in_double_quote_literal }}"
+        {% endif %}
 {% endfor %}
 {% elif endpoint.bodies | length == 1 %}
 {% set body = endpoint.bodies[0] %}
     {{ body_to_kwarg(body) | indent(4) }}
-    {% if body.content_type != "multipart/form-data" %}{# Need httpx to set the boundary automatically #}
-    headers["Content-Type"] = "{{ body.content_type }}"
+    {%- if body.content_type == "multipart/form-data" %}
+    headers["Content-Type"] = "multipart/form-data; boundary=+++"
+    {% else %}
+    headers["Content-Type"] = "{{ body.content_type | in_double_quote_literal }}"
     {% endif %}
 {% endif %}
 
@@ -66,9 +72,9 @@ def _get_kwargs(
     return _kwargs
 
 {% if endpoint.responses.default %}
-    {% set return_type = return_string %}
+    {% set return_type = return_string | as_unembedded_code %}
 {% else %}
-    {% set return_type = return_string + " | None" %}
+    {% set return_type = (return_string | as_unembedded_code) + " | None" %}
 {% endif %}
 
 
@@ -92,7 +98,7 @@ def _parse_response(*, client: AuthenticatedClient | Client, response: httpx.Res
     {% endif %}
 
 
-def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[{{ return_string }}]:
+def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Response) -> Response[{{ return_string | as_unembedded_code }}]:
     return Response(
         status_code=HTTPStatus(response.status_code),
         content=response.content,
@@ -103,7 +109,7 @@ def _build_response(*, client: AuthenticatedClient | Client, response: httpx.Res
 
 def sync_detailed(
     {{ arguments(endpoint) | indent(4) }}
-) -> Response[{{ return_string }}]:
+) -> Response[{{ return_string | as_unembedded_code }}]:
     {{ docstring(endpoint, return_string, is_detailed=true) | indent(4) }}
 
     kwargs = _get_kwargs(
@@ -119,7 +125,7 @@ def sync_detailed(
 {% if parsed_responses %}
 def sync(
     {{ arguments(endpoint) | indent(4) }}
-) -> {{ return_string }} | None:
+) -> {{ return_string | as_unembedded_code }} | None:
     {{ docstring(endpoint, return_string, is_detailed=false) | indent(4) }}
 
     return sync_detailed(
@@ -129,7 +135,7 @@ def sync(
 
 async def asyncio_detailed(
     {{ arguments(endpoint) | indent(4) }}
-) -> Response[{{ return_string }}]:
+) -> Response[{{ return_string | as_unembedded_code }}]:
     {{ docstring(endpoint, return_string, is_detailed=true) | indent(4) }}
 
     kwargs = _get_kwargs(
@@ -145,7 +151,7 @@ async def asyncio_detailed(
 {% if parsed_responses %}
 async def asyncio(
     {{ arguments(endpoint) | indent(4) }}
-) -> {{ return_string }} | None:
+) -> {{ return_string | as_unembedded_code }} | None:
     {{ docstring(endpoint, return_string, is_detailed=false) | indent(4) }}
 
     return (await asyncio_detailed(

openapi_python_client/templates/helpers.jinja

@@ -1,10 +1,6 @@
-{% macro safe_docstring(content, omit_if_empty=False) %}
-{# This macro returns the provided content as a docstring, set to a raw string if it contains a backslash #}
-{% if (not omit_if_empty) or (content | trim) %}
-{% if '\\' in content -%}
-r""" {{ content }} """
-{%- else -%}
+{% macro docstring(content) %}
+{# This macro returns the provided content as a docstring unless it's empty, then it emits nothing. #}
+{% if (content | trim) %}
 """ {{ content }} """
 {%- endif -%}
-{% endif %}
 {% endmacro %}

openapi_python_client/templates/literal_enum.py.jinja

@@ -1,10 +1,10 @@
-from typing import Literal, cast
+from typing import Literal
 
 {{ enum.class_info.name }} = Literal{{ "%r" | format(enum.values|list|sort) }}
 
 {{ enum.get_class_name_snake_case() | upper }}_VALUES: set[{{ enum.class_info.name }}] = { {% for v in enum.values|list|sort %}{{"%r"|format(v)}}, {% endfor %} }
 
-def check_{{ enum.get_class_name_snake_case() }}(value: {{ enum.get_instance_type_string() }}) -> {{ enum.class_info.name}}:
+def check_{{ enum.get_class_name_snake_case() }}(value: {{ enum.get_instance_type_string() | as_unembedded_code }}) -> {{ enum.class_info.name}}:
     if value in {{ enum.get_class_name_snake_case() | upper }}_VALUES:
-        return cast({{enum.class_info.name}}, value)
+        return value
     raise TypeError(f"Unexpected value {value!r}. Expected one of {{"{"}}{{ enum.get_class_name_snake_case() | upper }}_VALUES!r}")