Allow case sensitive enum values

Author: expobrain

openapi_python_client/config.py

@@ -35,6 +35,7 @@ class Config(BaseModel):
     ]
     field_prefix: str = "field_"
     http_timeout: int = 5
+    case_sensitive_enums: bool = False
 
     @staticmethod
     def load_from_path(path: Path) -> "Config":

openapi_python_client/parser/properties/__init__.py

@@ -404,7 +404,7 @@ def build_enum_property(
             ),
             schemas,
         )
-    values = EnumProperty.values_from_list(value_list)
+    values = EnumProperty.values_from_list(value_list, case_sensitive_enums=config.case_sensitive_enums)
 
     if class_info.name in schemas.classes_by_name:
         existing = schemas.classes_by_name[class_info.name]

openapi_python_client/parser/properties/enum_property.py

@@ -1,6 +1,6 @@
 __all__ = ["EnumProperty"]
 
-from typing import Any, ClassVar, Dict, List, Optional, Set, Type, Union, cast
+from typing import Any, ClassVar, Dict, Optional, Sequence, Set, Type, Union
 
 import attr
 
@@ -50,24 +50,30 @@ def get_imports(self, *, prefix: str) -> Set[str]:
         return imports
 
     @staticmethod
-    def values_from_list(values: Union[List[str], List[int]]) -> Dict[str, ValueType]:
+    def values_from_list(
+        values: Union[Sequence[str], Sequence[int]], case_sensitive_enums: bool = False
+    ) -> Dict[str, ValueType]:
         """Convert a list of values into dict of {name: value}, where value can sometimes be None"""
         output: Dict[str, ValueType] = {}
 
-        for i, value in enumerate(values):
-            value = cast(Union[str, int], value)
+        for value in values:
             if isinstance(value, int):
                 if value < 0:
                     output[f"VALUE_NEGATIVE_{-value}"] = value
                 else:
                     output[f"VALUE_{value}"] = value
                 continue
-            if value and value[0].isalpha():
-                key = value.upper()
+
+            if case_sensitive_enums:
+                sanitized_key = utils.case_insensitive_snake_case(value)
             else:
-                key = f"VALUE_{i}"
-            if key in output:
-                raise ValueError(f"Duplicate key {key} in Enum")
-            sanitized_key = utils.snake_case(key).upper()
+                sanitized_key = utils.snake_case(value.lower()).upper()
+            if not value or not value[0].isalpha():
+                sanitized_key = f"LITERAL_{sanitized_key}"
+
+            if sanitized_key in output:
+                raise ValueError(f"Duplicate key {sanitized_key} in Enum")
+
             output[sanitized_key] = utils.remove_string_escapes(value)
+
         return output

openapi_python_client/utils.py

@@ -66,10 +66,19 @@ def fix_reserved_words(value: str) -> str:
     return value
 
 
+def case_insensitive_snake_case(value: str) -> str:
+    """Converts to snake_case, but preserves capitalization of acronyms"""
+    words = split_words(sanitize(value))
+    value = "_".join(words)
+
+    return value
+
+
 def snake_case(value: str) -> str:
     """Converts to snake_case"""
-    words = split_words(sanitize(value))
-    return "_".join(words).lower()
+    value = case_insensitive_snake_case(value).lower()
+
+    return value
 
 
 def pascal_case(value: str) -> str:

tests/test_config.py

@@ -37,6 +37,7 @@ def test_load_from_path(tmp_path: Path, filename, dump, relative):
         "project_name_override": "project-name",
         "package_name_override": "package_name",
         "package_version_override": "package_version",
+        "case_sensitive_enums": True,
     }
     yml_file.write_text(dump(data))
 
@@ -47,3 +48,4 @@ def test_load_from_path(tmp_path: Path, filename, dump, relative):
     assert config.project_name_override == "project-name"
     assert config.package_name_override == "package_name"
     assert config.package_version_override == "package_version"
+    assert config.case_sensitive_enums == True

tests/test_parser/test_properties/test_init.py

@@ -383,13 +383,32 @@ def test_values_from_list(self):
 
         assert result == {
             "ABC": "abc",
-            "VALUE_1": "123",
+            "LITERAL_123": "123",
             "A23": "a23",
-            "VALUE_3": "1bc",
+            "LITERAL_1BC": "1bc",
             "VALUE_4": 4,
             "VALUE_NEGATIVE_3": -3,
             "A_THING_WITH_SPACES": "a Thing WIth spaces",
-            "VALUE_7": "",
+            "LITERAL_": "",
+        }
+
+    def test_values_from_list_with_case_sesitive(self):
+        from openapi_python_client.parser.properties import EnumProperty
+
+        data = ["abc", "Abc", "123", "a23", "1bc", 4, -3, "a Thing WIth spaces", ""]
+
+        result = EnumProperty.values_from_list(data, case_sensitive_enums=True)
+
+        assert result == {
+            "abc": "abc",
+            "Abc": "Abc",
+            "LITERAL_123": "123",
+            "a23": "a23",
+            "LITERAL_1bc": "1bc",
+            "VALUE_4": 4,
+            "VALUE_NEGATIVE_3": -3,
+            "a_Thing_W_Ith_spaces": "a Thing WIth spaces",
+            "LITERAL_": "",
         }
 
     def test_values_from_list_duplicate(self):