Update utils.camelize to update string based in settings

Author: gripep

drf_simple_api_errors/formatter.py

@@ -1,3 +1,17 @@
+"""
+This module provides functionality to format API exceptions into a structured error response.
+
+It defines the `APIErrorResponse` class, which represents
+the structure of the error response, and the `format_exc` function, which
+formats exceptions into this structure according to the type of exception, its detail,
+and any additional settings defined in the settings.
+
+Functions:
+    - `format_exc`:
+        Formats the given exception into a structured API error response.
+        Used by the exception handler to return a consistent error format.
+"""
+
 import copy
 import logging
 from dataclasses import asdict, dataclass, field as dataclass_field
@@ -7,9 +21,9 @@
 from rest_framework import exceptions
 from rest_framework.settings import api_settings as drf_api_settings
 
+from drf_simple_api_errors import utils
 from drf_simple_api_errors.settings import api_settings
 from drf_simple_api_errors.types import APIErrorResponseDict
-from drf_simple_api_errors.utils import camelize, flatten_dict
 
 logger = logging.getLogger(__name__)
 
@@ -46,9 +60,8 @@ def to_dict(self) -> APIErrorResponseDict:
         """Convert the APIErrorResponse instance to a dictionary."""
         response_dict = asdict(self)
 
-        if api_settings.CAMELIZE:
-            for key in list(response_dict.keys()):
-                response_dict[camelize(key)] = response_dict.pop(key)
+        for key in list(response_dict.keys()):
+            response_dict[utils.camelize(key)] = response_dict.pop(key)
 
         return response_dict
 
@@ -112,7 +125,7 @@ def _format_exc_detail_dict(
     # Start by flattening the exc dict.
     # This is necessary as the exception detail can be nested and
     # we want to flatten it to a single level dict as part of this library design.
-    exc_detail = flatten_dict(copy.deepcopy(exc_detail))
+    exc_detail = utils.flatten_dict(copy.deepcopy(exc_detail))
 
     # Track the invalid params.
     # This represents the fields that are invalid and have errors associated with them.
@@ -136,7 +149,7 @@ def _format_exc_detail_dict(
             # N.B. If the error is a string, we will convert it to a list
             # to keep the consistency with the InvalidParamDict type.
             invalid_param = InvalidParam(
-                name=field if not api_settings.CAMELIZE else camelize(field),
+                name=utils.camelize(field),
                 reason=error if isinstance(error, list) else [error],
             )
             invalid_params.append(invalid_param)

drf_simple_api_errors/utils.py

@@ -3,8 +3,16 @@
 from drf_simple_api_errors.settings import api_settings
 
 
-def camelize(field: str) -> str:
-    """Convert a snake_case string to camelCase."""
+def camelize(s: str) -> str:
+    """
+    Convert a snake_case string to camelCase according to
+    the CAMELIZE setting (default to `False`).
+
+    Args:
+        s (str): The string to convert.
+    Returns:
+        str: The camelCase version of the string, or the original if CAMELIZE is `False`.
+    """
 
     def underscore_to_camel(match: re.Match) -> str:
         group = match.group()
@@ -13,14 +21,25 @@ def underscore_to_camel(match: re.Match) -> str:
         else:
             return group[1].upper()
 
+    if not api_settings.CAMELIZE:
+        return s
+
     camelize_re = re.compile(r"[a-z0-9]?_[a-z0-9]")
-    return re.sub(camelize_re, underscore_to_camel, field)
+    return re.sub(camelize_re, underscore_to_camel, s)
 
 
 def flatten_dict(data: dict, parent_key: str = "") -> dict:
     """
     Flatten a nested dictionary into a single-level dictionary according to
-    the specified FIELDS_SEPARATOR in your settings (default to '.').
+    the specified FIELDS_SEPARATOR setting (default to `'.'`).
+
+    Args:
+        data (dict): The dictionary to flatten.
+        parent_key (str):
+            The base key to prepend to each key in the flattened dictionary.
+            This is used for recursive calls to maintain the hierarchy.
+    Returns:
+        dict: A flattened dictionary with keys joined by the FIELDS_SEPARATOR.
     """
     sep = api_settings.FIELDS_SEPARATOR
 

test_project/test_app/tests.py

@@ -517,16 +517,35 @@ def test_validation_error_ok(self, book_model_serializer, faker, mocker, user):
 
 class TestUtils:
     @pytest.mark.parametrize(
-        "field_input, expected_output",
+        "field_input, expected_output, camelize_enabled",
         [
-            ("", ""),
-            ("name", "name"),
-            ("first_name", "firstName"),
-            ("family_tree_name", "familyTreeName"),
-            ("very_long_last_name_and_first_name", "veryLongLastNameAndFirstName"),
+            ("", "", True),
+            ("name", "name", True),
+            ("first_name", "firstName", True),
+            ("family_tree_name", "familyTreeName", True),
+            (
+                "very_long_last_name_and_first_name",
+                "veryLongLastNameAndFirstName",
+                True,
+            ),
+            ("", "", False),
+            ("name", "name", False),
+            ("first_name", "first_name", False),
+            ("family_tree_name", "family_tree_name", False),
+            (
+                "very_long_last_name_and_first_name",
+                "very_long_last_name_and_first_name",
+                False,
+            ),
         ],
     )
-    def test_camelize(self, field_input, expected_output):
+    def test_camelize_with_settings_set(
+        self, mocker, field_input, expected_output, camelize_enabled
+    ):
+        mocker.patch(
+            "drf_simple_api_errors.settings.api_settings.CAMELIZE", camelize_enabled
+        )
+
         assert utils.camelize(field_input) == expected_output
 
     @pytest.mark.parametrize(