Camel Converter

In JSON keys are frequently in camelCase format, while variable names in Python are typically snake_case. The purpose of this package is to help convert between the two formats.

Usage

• To convert from camel case to snake case:

  from camel_converter import to_snake
  
  snake = to_snake("myString")
  

  This will convert myString into my_string

• To convert a dictionary's keys from camel case to snake case:

  from camel_converter import dict_to_snake
  
  snake = dict_to_snake({"myString": "val 1"})
  

  This will convert {"myString": "val 1"} into {"my_string": "val 1"}. Non-string keys will be left unchanged.

  This is also available as a decorator for functions that return a dictionary.

  from camel_converter.decorators import dict_to_snake
  
  
  @dict_to_snake
  def my_func() -> dict[str, str]:
      return {"myString": "val 1"}
  
  
  snake = my_func()
  

  my_func will return {"my_string": "val 1"}. Non-string keys will be left unchanged.

• To convert from snake case to camel case:

  from camel_converter import to_camel
  
  camel = to_camel("my_string")
  

  This will convert my_string into myString

• To convert from a dictionary's keys from snake case to camel case:

  from camel_converter import dict_to_camel
  
  camel = dict_to_camel({"my_string": "val 1"})
  

  This will convert {"my_string": "val 1"} into {"myString": "val 1"} Non-string keys will be left unchanged.

  This is also available as a decorator for functions that return a dictionary.

  from camel_converter.decorators import dict_to_camel
  
  
  @dict_to_camel
  def my_func() -> dict[str, str]:
      return {"my_string": "val 1"}
  
  
  camel = my_func()
  

  my_func will return {"myString": "val 1"}. Non-string keys will be left unchanged.

• To convert from snake to pascal case:

  from camel_converter import to_pascal
  
  pascal = to_pascal("my_string")
  

  This will convert my_string into MyString

• To convert from a dictionary's keys from snake case to pascal case:

  from camel_converter import dict_to_pascal
  
  pascal = dict_to_pascal({"my_string": "val 1"})
  

  This will convert {"my_string": "val 1"} into {"MyString": "val 1"} Non-string keys will be left unchanged.

  This is also available as a decorator for functions that return a dictionary.

  from camel_converter.decorators import dict_to_pascal
  
  
  @dict_to_pascal
  def my_func() -> dict[str, str]:
      return {"my_string": "val 1"}
  
  
  pascal = my_func()
  

  my_func will return {"MyString": "val 1"}. Non-string keys will be left unchanged.

• Class base model to add methods

Inheriting the Converter adds to_camel and from_camel methods to your class

from camel_converter import Converter


class SomeClass(Converter):
    some_value = "some value"

    def __init__(self) -> None:
        self.another_value = "another value"


example = SomeClass()
print(example.to_camel())

This will print {"someValue": "some value", "anotherValue": "another value"}

from camel_converter import Converter


class SomeClass(Converter):
    def __init__(self, some_value: str) -> None:
        self.some_value = some_value


example = SomeClass.from_camel({"someValue": "some value"})
print(example.some_value)

This will print some value

Optional Extras

An optional extra is provided for Pydantic that provides a base class to automatically convert between snake case and camel case. To use this Pydantic class install camel converter with:

pip install camel-converter[pydantic]

Then your Pydantic classes can inherit from CamelBase.

from camel_converter.pydantic_base import CamelBase


class MyModel(CamelBase):
    test_field: str


my_data = MyModel(**{"testField": "my value"})
print(my_data.test_field)

will result in my value being printed.

With setting up your model in this way myField from the source, i.e. JSON data, will map to my_field in your model.

Contributing

If you are interested in contributing to this project please see our contributing guide