any-case 0.1.6

any_case

When developing a web application, you often have to choose the case format (snake_case/camelCase) will be used for the input and the output json data. If the backend is written in Python, the easiest option is to choose snake_case. On the one hand, this is good, because we have an obvious consistency, but on the other hand, the main consumers of the API (mobile and browser) prefer to use camelCase.

If we care about our consumers, we will change the case format to camelCase. And it’s good if we think about it in advance, before publishing API. But if this happens in an existing application, it becomes much more difficult to do so because there are consumers using the existing API. We have two options here:

• introduce a new version of the api

• send data in two cases at once

The second option increases the size of the data, and the first option forces us to support two versions of the API without serious need. These options complicate the support and development of API.

Things get a little more complicated when we have consumers who natively use snake_case, and using camelCase for them is not an option at all.

As you can see, the use of one notation does not improve, but may worsen the situation.

But why do we have to choose for the customer which case format they use? Why customers do not send and not receive data in the format, which would be more convenient to them?

That’s what this library is for. Consumers choose in what case they expect the data. If they specified an incorrect case or made a request without specifying a case, the data will be given as is.

This approach allows existing consumers to work without changes with existing API, and for those consumers who want to use a single format, allows granular rewriting of the application.

Installation

pip install any_case

Usage

For converting dict or list use converts_keys function:

>>> from any_case import converts_keys
>>> data = {'camelCaseKey': 'value'}
>>> converts_keys(data, case='snake')
{'camel_case_key': 'value'}
>>> data = {'snake_case': 'camelCase'}
>>> converts_keys(data, case='camel')
{'snakeCase': 'camelCase'}

For converting any_case uses compiled regex and stack for objects traversal instead of recursion.

To convert existing data without producing new one, use inplace param:

>>> data = {'snake_case': 'camelCase'}
>>> converts_keys(data, case='camel', inplace=True)
{'snakeCase': 'camelCase'}
>>> data
{'snakeCase': 'camelCase'}

Some tricky cases could happen when works with keys which contains numbers:

>>> data = {'camelCase12': 'camelCase'}
>>> converts_keys(data, case='snake')
{'camel_case12': 'camelCase'}

To adjust this logic use sep_numbers params:

>>> converts_keys(data, case='snake', sep_numbers=True)
{'camel_case_12': 'camelCase'}

To convert text, use to_snake_case or to_camel_case:

>>> from any_case import to_snake_case, to_camel_case
>>> to_snake_case('snakeCase')
'snake_case'
>>> to_camel_case('snake_case')
'snakeCase'

More examples see at tests folder.

Integrations

MIDDLEWARE = [
    'django.contrib.sessions.middleware.SessionMiddleware',
    ...
    'any_case.contrib.django.middleware.KeysConverterMiddleware'
]

def view(request):
    data = request.json
    ...

REST_FRAMEWORK = {
    'DEFAULT_RENDERER_CLASSES': (
        'any_case.contrib.rest_framework.AnyCaseJSONParser',
        ...
    ),
    'DEFAULT_PARSER_CLASSES': (
        'any_case.contrib.rest_framework.AnyCaseJSONRenderer',
        ...
    )
}

ANY_CASE = {
    'HEADER_KEY': 'Accept-Json-Case',
    'QUERY_KEY': None,
    'BODY_KEY': None,
    'CONVERT_INPUT_JSON': True,
    'SEP_NUMBERS_TO_CAMEL': False,
    'SEP_NUMBERS_TO_SNAKE': False,
}

ANY_CASE = {
    'HEADER_KEY': None,
    'QUERY_KEY': None,
    'BODY_KEY': None,
}

ANY_CASE = {
    'CONVERT_INPUT_JSON': False
}