openapi-python-client 0.21.4__tar.gz → 0.21.6__tar.gz

{openapi_python_client-0.21.4 → openapi_python_client-0.21.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openapi-python-client
-Version: 0.21.4
+Version: 0.21.6
 Summary: Generate modern Python clients from OpenAPI
 Project-URL: repository, https://github.com/openapi-generators/openapi-python-client
 Author-email: Dylan Anthony <contact@dylananthony.com>
@@ -16,6 +16,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Code Generators
 Classifier: Typing :: Typed
 Requires-Python: <4.0,>=3.8.1
@@ -26,7 +27,7 @@ Requires-Dist: jinja2<4.0.0,>=3.0.0
 Requires-Dist: pydantic<3.0.0,>=2.1.1
 Requires-Dist: python-dateutil<3.0.0,>=2.8.1
 Requires-Dist: ruamel-yaml<0.19.0,>=0.18.6
-Requires-Dist: ruff<0.7,>=0.2
+Requires-Dist: ruff<0.8,>=0.2
 Requires-Dist: shellingham<2.0.0,>=1.3.2
 Requires-Dist: typer<0.13,>0.6
 Requires-Dist: typing-extensions<5.0.0,>=4.8.0
@@ -131,6 +132,17 @@ class_overrides:
 
 The easiest way to find what needs to be overridden is probably to generate your client and go look at everything in the `models` folder.
 
+### literal_enums
+
+By default, `openapi-python-client` generates classes inheriting for `Enum` for enums. It can instead use `Literal` 
+values for enums by setting this to `true`:
+
+```yaml
+literal_enums: true
+```
+
+This is especially useful if enum values, when transformed to their Python names, end up conflicting due to case sensitivity or special symbols.
+
 ### project_name_override and package_name_override
 
 Used to change the name of generated client library project/package. If the project name is changed but an override for the package name

{openapi_python_client-0.21.4 → openapi_python_client-0.21.6}/README.md

@@ -97,6 +97,17 @@ class_overrides:
 
 The easiest way to find what needs to be overridden is probably to generate your client and go look at everything in the `models` folder.
 
+### literal_enums
+
+By default, `openapi-python-client` generates classes inheriting for `Enum` for enums. It can instead use `Literal` 
+values for enums by setting this to `true`:
+
+```yaml
+literal_enums: true
+```
+
+This is especially useful if enum values, when transformed to their Python names, end up conflicting due to case sensitivity or special symbols.
+
 ### project_name_override and package_name_override
 
 Used to change the name of generated client library project/package. If the project name is changed but an override for the package name

{openapi_python_client-0.21.4 → openapi_python_client-0.21.6}/openapi_python_client/__init__.py

@@ -20,6 +20,7 @@ from openapi_python_client import utils
 from .config import Config, MetaType
 from .parser import GeneratorData, import_string_from_class
 from .parser.errors import ErrorLevel, GeneratorError
+from .parser.properties import LiteralEnumProperty
 
 __version__ = version(__package__)
 
@@ -227,9 +228,12 @@ class Project:
         # Generate enums
         str_enum_template = self.env.get_template("str_enum.py.jinja")
         int_enum_template = self.env.get_template("int_enum.py.jinja")
+        literal_enum_template = self.env.get_template("literal_enum.py.jinja")
         for enum in self.openapi.enums:
             module_path = models_dir / f"{enum.class_info.module_name}.py"
-            if enum.value_type is int:
+            if isinstance(enum, LiteralEnumProperty):
+                module_path.write_text(literal_enum_template.render(enum=enum), encoding=self.config.file_encoding)
+            elif enum.value_type is int:
                 module_path.write_text(int_enum_template.render(enum=enum), encoding=self.config.file_encoding)
             else:
                 module_path.write_text(str_enum_template.render(enum=enum), encoding=self.config.file_encoding)

{openapi_python_client-0.21.4 → openapi_python_client-0.21.6}/openapi_python_client/config.py

@@ -43,6 +43,7 @@ class ConfigFile(BaseModel):
     post_hooks: Optional[List[str]] = None
     field_prefix: str = "field_"
     http_timeout: int = 5
+    literal_enums: bool = False
 
     @staticmethod
     def load_from_path(path: Path) -> "ConfigFile":
@@ -70,6 +71,7 @@ class Config:
     post_hooks: List[str]
     field_prefix: str
     http_timeout: int
+    literal_enums: bool
     document_source: Union[Path, str]
     file_encoding: str
     content_type_overrides: Dict[str, str]
@@ -109,6 +111,7 @@ class Config:
             post_hooks=post_hooks,
             field_prefix=config_file.field_prefix,
             http_timeout=config_file.http_timeout,
+            literal_enums=config_file.literal_enums,
             document_source=document_source,
             file_encoding=file_encoding,
             overwrite=overwrite,

{openapi_python_client-0.21.4 → openapi_python_client-0.21.6}/openapi_python_client/parser/openapi.py

@@ -15,6 +15,7 @@ from .errors import GeneratorError, ParseError, PropertyError
 from .properties import (
     Class,
     EnumProperty,
+    LiteralEnumProperty,
     ModelProperty,
     Parameters,
     Property,
@@ -155,7 +156,7 @@ class Endpoint:
                     ParseError(
                         detail=(
                             f"Invalid response status code {code} (not a valid HTTP "
-                            f"status code), response will be ommitted from generated "
+                            f"status code), response will be omitted from generated "
                             f"client"
                         )
                     )
@@ -175,7 +176,7 @@ class Endpoint:
                     ParseError(
                         detail=(
                             f"Cannot parse response for status code {status_code}{detail_suffix}, "
-                            f"response will be ommitted from generated client"
+                            f"response will be omitted from generated client"
                         ),
                         data=response.data,
                     )
@@ -488,7 +489,7 @@ class GeneratorData:
     models: Iterator[ModelProperty]
     errors: List[ParseError]
     endpoint_collections_by_tag: Dict[utils.PythonIdentifier, EndpointCollection]
-    enums: Iterator[EnumProperty]
+    enums: Iterator[Union[EnumProperty, LiteralEnumProperty]]
 
     @staticmethod
     def from_dict(data: Dict[str, Any], *, config: Config) -> Union["GeneratorData", GeneratorError]:
@@ -517,7 +518,9 @@ class GeneratorData:
             data=openapi.paths, schemas=schemas, parameters=parameters, request_bodies=request_bodies, config=config
         )
 
-        enums = (prop for prop in schemas.classes_by_name.values() if isinstance(prop, EnumProperty))
+        enums = (
+            prop for prop in schemas.classes_by_name.values() if isinstance(prop, (EnumProperty, LiteralEnumProperty))
+        )
         models = (prop for prop in schemas.classes_by_name.values() if isinstance(prop, ModelProperty))
 
         return GeneratorData(

{openapi_python_client-0.21.4 → openapi_python_client-0.21.6}/openapi_python_client/parser/properties/__init__.py

@@ -4,6 +4,7 @@ __all__ = [
     "AnyProperty",
     "Class",
     "EnumProperty",
+    "LiteralEnumProperty",
     "ModelProperty",
     "Parameters",
     "Property",
@@ -30,6 +31,7 @@ from .file import FileProperty
 from .float import FloatProperty
 from .int import IntProperty
 from .list_property import ListProperty
+from .literal_enum_property import LiteralEnumProperty
 from .model_property import ModelProperty, process_model
 from .none import NoneProperty
 from .property import Property
@@ -44,11 +46,12 @@ from .schemas import (
 )
 from .string import StringProperty
 from .union import UnionProperty
+from .uuid import UuidProperty
 
 
 def _string_based_property(
     name: str, required: bool, data: oai.Schema, config: Config
-) -> StringProperty | DateProperty | DateTimeProperty | FileProperty | PropertyError:
+) -> StringProperty | DateProperty | DateTimeProperty | FileProperty | UuidProperty | PropertyError:
     """Construct a Property from the type "string" """
     string_format = data.schema_format
     python_name = utils.PythonIdentifier(value=name, prefix=config.field_prefix)
@@ -79,11 +82,19 @@ def _string_based_property(
             description=data.description,
             example=data.example,
         )
+    if string_format == "uuid":
+        return UuidProperty.build(
+            name=name,
+            required=required,
+            default=data.default,
+            python_name=python_name,
+            description=data.description,
+            example=data.example,
+        )
     return StringProperty.build(
         name=name,
         default=data.default,
         required=required,
-        pattern=data.pattern,
         python_name=python_name,
         description=data.description,
         example=data.example,
@@ -185,6 +196,15 @@ def property_from_data(  # noqa: PLR0911, PLR0912
             schemas,
         )
     if data.enum:
+        if config.literal_enums:
+            return LiteralEnumProperty.build(
+                data=data,
+                name=name,
+                required=required,
+                schemas=schemas,
+                parent_name=parent_name,
+                config=config,
+            )
         return EnumProperty.build(
             data=data,
             name=name,
@@ -281,7 +301,7 @@ def property_from_data(  # noqa: PLR0911, PLR0912
         AnyProperty.build(
             name=name,
             required=required,
-            default=None,
+            default=data.default,
             python_name=utils.PythonIdentifier(value=name, prefix=config.field_prefix),
             description=data.description,
             example=data.example,

{openapi_python_client-0.21.4 → openapi_python_client-0.21.6}/openapi_python_client/parser/properties/any.py

@@ -33,9 +33,13 @@ class AnyProperty(PropertyProtocol):
 
     @classmethod
     def convert_value(cls, value: Any) -> Value | None:
-        if value is None or isinstance(value, Value):
+        from .string import StringProperty
+
+        if value is None:
             return value
-        return Value(str(value))
+        if isinstance(value, str):
+            return StringProperty.convert_value(value)
+        return Value(python_code=str(value), raw_value=value)
 
     name: str
     required: bool

{openapi_python_client-0.21.4 → openapi_python_client-0.21.6}/openapi_python_client/parser/properties/boolean.py

@@ -59,9 +59,9 @@ class BooleanProperty(PropertyProtocol):
             return value
         if isinstance(value, str):
             if value.lower() == "true":
-                return Value("True")
+                return Value(python_code="True", raw_value=value)
             elif value.lower() == "false":
-                return Value("False")
+                return Value(python_code="False", raw_value=value)
         if isinstance(value, bool):
-            return Value(str(value))
+            return Value(python_code=str(value), raw_value=value)
         return PropertyError(f"Invalid boolean value: {value}")

{openapi_python_client-0.21.4 → openapi_python_client-0.21.6}/openapi_python_client/parser/properties/const.py

@@ -63,13 +63,13 @@ class ConstProperty(PropertyProtocol):
         return prop
 
     def convert_value(self, value: Any) -> Value | None | PropertyError:
-        if isinstance(value, Value):
-            return value
         value = self._convert_value(value)
         if value is None:
             return value
         if value != self.value:
-            return PropertyError(detail=f"Invalid value for const {self.name}; {value} != {self.value}")
+            return PropertyError(
+                detail=f"Invalid value for const {self.name}; {value.raw_value} != {self.value.raw_value}"
+            )
         return value
 
     @staticmethod
@@ -85,11 +85,9 @@ class ConstProperty(PropertyProtocol):
     def _convert_value(value: Any) -> Value | None:
         if value is None or isinstance(value, Value):
             return value
-        if isinstance(value, Value):
-            return value  # pragma: no cover
         if isinstance(value, str):
             return StringProperty.convert_value(value)
-        return Value(str(value))
+        return Value(python_code=str(value), raw_value=value)
 
     def get_type_string(
         self,
@@ -99,7 +97,7 @@ class ConstProperty(PropertyProtocol):
         multipart: bool = False,
         quoted: bool = False,
     ) -> str:
-        lit = f"Literal[{self.value}]"
+        lit = f"Literal[{self.value.python_code}]"
         if not no_optional and not self.required:
             return f"Union[{lit}, Unset]"
         return lit

{openapi_python_client-0.21.4 → openapi_python_client-0.21.6}/openapi_python_client/parser/properties/date.py

@@ -57,7 +57,7 @@ class DateProperty(PropertyProtocol):
                 isoparse(value).date()  # make sure it's a valid value
             except ValueError as e:
                 return PropertyError(f"Invalid date: {e}")
-            return Value(f"isoparse({value!r}).date()")
+            return Value(python_code=f"isoparse({value!r}).date()", raw_value=value)
         return PropertyError(f"Cannot convert {value} to a date")
 
     def get_imports(self, *, prefix: str) -> set[str]:

{openapi_python_client-0.21.4 → openapi_python_client-0.21.6}/openapi_python_client/parser/properties/datetime.py

@@ -59,7 +59,7 @@ class DateTimeProperty(PropertyProtocol):
                 isoparse(value)  # make sure it's a valid value
             except ValueError as e:
                 return PropertyError(f"Invalid datetime: {e}")
-            return Value(f"isoparse({value!r})")
+            return Value(python_code=f"isoparse({value!r})", raw_value=value)
         return PropertyError(f"Cannot convert {value} to a datetime")
 
     def get_imports(self, *, prefix: str) -> set[str]:

{openapi_python_client-0.21.4 → openapi_python_client-0.21.6}/openapi_python_client/parser/properties/enum_property.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-__all__ = ["EnumProperty"]
+__all__ = ["EnumProperty", "ValueType"]
 
 from typing import Any, ClassVar, List, Union, cast
 
@@ -121,7 +121,7 @@ class EnumProperty(PropertyProtocol):
         if parent_name:
             class_name = f"{utils.pascal_case(parent_name)}{utils.pascal_case(class_name)}"
         class_info = Class.from_string(string=class_name, config=config)
-        values = EnumProperty.values_from_list(value_list)
+        values = EnumProperty.values_from_list(value_list, class_info)
 
         if class_info.name in schemas.classes_by_name:
             existing = schemas.classes_by_name[class_info.name]
@@ -159,7 +159,7 @@ class EnumProperty(PropertyProtocol):
         if isinstance(value, self.value_type):
             inverse_values = {v: k for k, v in self.values.items()}
             try:
-                return Value(f"{self.class_info.name}.{inverse_values[value]}")
+                return Value(python_code=f"{self.class_info.name}.{inverse_values[value]}", raw_value=value)
             except KeyError:
                 return PropertyError(detail=f"Value {value} is not valid for enum {self.name}")
         return PropertyError(detail=f"Cannot convert {value} to enum {self.name} of type {self.value_type}")
@@ -183,7 +183,7 @@ class EnumProperty(PropertyProtocol):
         return imports
 
     @staticmethod
-    def values_from_list(values: list[str] | list[int]) -> dict[str, ValueType]:
+    def values_from_list(values: list[str] | list[int], class_info: Class) -> dict[str, ValueType]:
         """Convert a list of values into dict of {name: value}, where value can sometimes be None"""
         output: dict[str, ValueType] = {}
 
@@ -200,7 +200,10 @@ class EnumProperty(PropertyProtocol):
             else:
                 key = f"VALUE_{i}"
             if key in output:
-                raise ValueError(f"Duplicate key {key} in Enum")
+                raise ValueError(
+                    f"Duplicate key {key} in enum {class_info.module_name}.{class_info.name}; "
+                    f"consider setting literal_enums in your config"
+                )
             sanitized_key = utils.snake_case(key).upper()
             output[sanitized_key] = utils.remove_string_escapes(value)
         return output

{openapi_python_client-0.21.4 → openapi_python_client-0.21.6}/openapi_python_client/parser/properties/float.py

@@ -61,11 +61,11 @@ class FloatProperty(PropertyProtocol):
         if isinstance(value, str):
             try:
                 parsed = float(value)
-                return Value(str(parsed))
+                return Value(python_code=str(parsed), raw_value=value)
             except ValueError:
                 return PropertyError(f"Invalid float value: {value}")
         if isinstance(value, float):
-            return Value(str(value))
+            return Value(python_code=str(value), raw_value=value)
         if isinstance(value, int) and not isinstance(value, bool):
-            return Value(str(float(value)))
+            return Value(python_code=str(float(value)), raw_value=value)
         return PropertyError(f"Cannot convert {value} to a float")

{openapi_python_client-0.21.4 → openapi_python_client-0.21.6}/openapi_python_client/parser/properties/int.py

@@ -58,12 +58,16 @@ class IntProperty(PropertyProtocol):
     def convert_value(cls, value: Any) -> Value | None | PropertyError:
         if value is None or isinstance(value, Value):
             return value
-        if isinstance(value, str):
+        converted = value
+        if isinstance(converted, str):
             try:
-                int(value)
+                converted = float(converted)
             except ValueError:
-                return PropertyError(f"Invalid int value: {value}")
-            return Value(value)
-        if isinstance(value, int) and not isinstance(value, bool):
-            return Value(str(value))
+                return PropertyError(f"Invalid int value: {converted}")
+        if isinstance(converted, float):
+            as_int = int(converted)
+            if converted == as_int:
+                converted = as_int
+        if isinstance(converted, int) and not isinstance(converted, bool):
+            return Value(python_code=str(converted), raw_value=value)
         return PropertyError(f"Invalid int value: {value}")

{openapi_python_client-0.21.4 → openapi_python_client-0.21.6}/openapi_python_client/parser/properties/list_property.py

@@ -58,12 +58,28 @@ class ListProperty(PropertyProtocol):
         """
         from . import property_from_data
 
-        if data.items is None:
-            return PropertyError(data=data, detail="type array must have items defined"), schemas
+        if data.items is None and not data.prefixItems:
+            return (
+                PropertyError(
+                    data=data,
+                    detail="type array must have items or prefixItems defined",
+                ),
+                schemas,
+            )
+
+        items = data.prefixItems or []
+        if data.items:
+            items.append(data.items)
+
+        if len(items) == 1:
+            inner_schema = items[0]
+        else:
+            inner_schema = oai.Schema(anyOf=items)
+
         inner_prop, schemas = property_from_data(
             name=f"{name}_item",
             required=True,
-            data=data.items,
+            data=inner_schema,
             schemas=schemas,
             parent_name=parent_name,
             config=config,

openapi_python_client-0.21.6/openapi_python_client/parser/properties/literal_enum_property.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+__all__ = ["LiteralEnumProperty"]
+
+from typing import Any, ClassVar, List, Union, cast
+
+from attr import evolve
+from attrs import define
+
+from ... import Config, utils
+from ... import schema as oai
+from ...schema import DataType
+from ..errors import PropertyError
+from .none import NoneProperty
+from .protocol import PropertyProtocol, Value
+from .schemas import Class, Schemas
+from .union import UnionProperty
+
+ValueType = Union[str, int]
+
+
+@define
+class LiteralEnumProperty(PropertyProtocol):
+    """A property that should use a literal enum"""
+
+    name: str
+    required: bool
+    default: Value | None
+    python_name: utils.PythonIdentifier
+    description: str | None
+    example: str | None
+    values: set[ValueType]
+    class_info: Class
+    value_type: type[ValueType]
+
+    template: ClassVar[str] = "literal_enum_property.py.jinja"
+
+    _allowed_locations: ClassVar[set[oai.ParameterLocation]] = {
+        oai.ParameterLocation.QUERY,
+        oai.ParameterLocation.PATH,
+        oai.ParameterLocation.COOKIE,
+        oai.ParameterLocation.HEADER,
+    }
+
+    @classmethod
+    def build(  # noqa: PLR0911
+        cls,
+        *,
+        data: oai.Schema,
+        name: str,
+        required: bool,
+        schemas: Schemas,
+        parent_name: str,
+        config: Config,
+    ) -> tuple[LiteralEnumProperty | NoneProperty | UnionProperty | PropertyError, Schemas]:
+        """
+        Create a LiteralEnumProperty from schema data.
+
+        Args:
+            data: The OpenAPI Schema which defines this enum.
+            name: The name to use for variables which receive this Enum's value (e.g. model property name)
+            required: Whether or not this Property is required in the calling context
+            schemas: The Schemas which have been defined so far (used to prevent naming collisions)
+            parent_name: The context in which this LiteralEnumProperty is defined, used to create more specific class names.
+            config: The global config for this run of the generator
+
+        Returns:
+            A tuple containing either the created property or a PropertyError AND update schemas.
+        """
+
+        enum = data.enum or []  # The outer function checks for this, but mypy doesn't know that
+
+        # OpenAPI allows for null as an enum value, but it doesn't make sense with how enums are constructed in Python.
+        # So instead, if null is a possible value, make the property nullable.
+        # Mypy is not smart enough to know that the type is right though
+        unchecked_value_list = [value for value in enum if value is not None]  # type: ignore
+
+        # It's legal to have an enum that only contains null as a value, we don't bother constructing an enum for that
+        if len(unchecked_value_list) == 0:
+            return (
+                NoneProperty.build(
+                    name=name,
+                    required=required,
+                    default="None",
+                    python_name=utils.PythonIdentifier(value=name, prefix=config.field_prefix),
+                    description=None,
+                    example=None,
+                ),
+                schemas,
+            )
+
+        value_types = {type(value) for value in unchecked_value_list}
+        if len(value_types) > 1:
+            return PropertyError(
+                header="Enum values must all be the same type", detail=f"Got {value_types}", data=data
+            ), schemas
+        value_type = next(iter(value_types))
+        if value_type not in (str, int):
+            return PropertyError(header=f"Unsupported enum type {value_type}", data=data), schemas
+        value_list = cast(
+            Union[List[int], List[str]], unchecked_value_list
+        )  # We checked this with all the value_types stuff
+
+        if len(value_list) < len(enum):  # Only one of the values was None, that becomes a union
+            data.oneOf = [
+                oai.Schema(type=DataType.NULL),
+                data.model_copy(update={"enum": value_list, "default": data.default}),
+            ]
+            data.enum = None
+            return UnionProperty.build(
+                data=data,
+                name=name,
+                required=required,
+                schemas=schemas,
+                parent_name=parent_name,
+                config=config,
+            )
+
+        class_name = data.title or name
+        if parent_name:
+            class_name = f"{utils.pascal_case(parent_name)}{utils.pascal_case(class_name)}"
+        class_info = Class.from_string(string=class_name, config=config)
+        values: set[str | int] = set(value_list)
+
+        if class_info.name in schemas.classes_by_name:
+            existing = schemas.classes_by_name[class_info.name]
+            if not isinstance(existing, LiteralEnumProperty) or values != existing.values:
+                return (
+                    PropertyError(
+                        detail=f"Found conflicting enums named {class_info.name} with incompatible values.", data=data
+                    ),
+                    schemas,
+                )
+
+        prop = LiteralEnumProperty(
+            name=name,
+            required=required,
+            class_info=class_info,
+            values=values,
+            value_type=value_type,
+            default=None,
+            python_name=utils.PythonIdentifier(value=name, prefix=config.field_prefix),
+            description=data.description,
+            example=data.example,
+        )
+        checked_default = prop.convert_value(data.default)
+        if isinstance(checked_default, PropertyError):
+            checked_default.data = data
+            return checked_default, schemas
+        prop = evolve(prop, default=checked_default)
+
+        schemas = evolve(schemas, classes_by_name={**schemas.classes_by_name, class_info.name: prop})
+        return prop, schemas
+
+    def convert_value(self, value: Any) -> Value | PropertyError | None:
+        if value is None or isinstance(value, Value):
+            return value
+        if isinstance(value, self.value_type):
+            if value in self.values:
+                return Value(python_code=repr(value), raw_value=value)
+            else:
+                return PropertyError(detail=f"Value {value} is not valid for enum {self.name}")
+        return PropertyError(detail=f"Cannot convert {value} to enum {self.name} of type {self.value_type}")
+
+    def get_base_type_string(self, *, quoted: bool = False) -> str:
+        return self.class_info.name
+
+    def get_base_json_type_string(self, *, quoted: bool = False) -> str:
+        return self.value_type.__name__
+
+    def get_instance_type_string(self) -> str:
+        return self.value_type.__name__
+
+    def get_imports(self, *, prefix: str) -> set[str]:
+        """
+        Get a set of import strings that should be included when this property is used somewhere
+
+        Args:
+            prefix: A prefix to put before any relative (local) module names. This should be the number of . to get
+            back to the root of the generated client.
+        """
+        imports = super().get_imports(prefix=prefix)
+        imports.add("from typing import cast")
+        imports.add(f"from {prefix}models.{self.class_info.module_name} import {self.class_info.name}")
+        imports.add(
+            f"from {prefix}models.{self.class_info.module_name} import check_{self.get_class_name_snake_case()}"
+        )
+        return imports
+
+    def get_class_name_snake_case(self) -> str:
+        return utils.snake_case(self.class_info.name)