Cast CamelCase to "underscore_case"

main_re.py

import re

def _camel_to_underscore_case(name):
    """
    >>> _camel_to_underscore_case('CamelCaseNames')
    'camel_case_names'
    """
    camel_boundry = '((?<=[a-z])[A-Z])'
    return re.sub(camel_boundry, '_\\1', name).lower()

def _underscore_to_camel_case(name, upper=True):
    """
    >>> _underscore_to_camel_case('camel_case_names', False)
    'camelCaseNames'
    >>> _underscore_to_camel_case('camel_case_names')
    'CamelCaseNames'
    """
    underscore_boundry = '(_(.))'
    result = re.sub(underscore_boundry, lambda x: x.group(2).upper(), name)
    if upper and len(result):
        return result[0].upper() + result[1:]
    return result

def convert_case(obj, converter, deep=True):
    if isinstance(obj, dict):
        return dict((converter(k),
                     convert_case(v, converter, deep) if deep else v)
        for k,v in obj.iteritems())
    elif deep and isinstance(obj, list):
        return map(lambda x: convert_case(x, converter, deep), obj)
    else:
        return obj

def camel_to_underscore_case(obj, deep=True):
    return convert_case(obj, lambda x: _camel_to_underscore_case(x), deep)

def underscore_to_camel_case(obj, deep=True, upper=True):
    return convert_case(obj, lambda x: _underscore_to_camel_case(x, upper), deep)

if __name__ == "__main__":

    import unittest

    class TestCamelToUnderscore(unittest.TestCase):

        def setUp(self):
            self.input = {'object': [
                    {"IsCustomer": True, "Obid": 12345},
                    {"isCustomer": True, "obid": 12345},
                    {"is_customer": True, "obid": 12345},
                    {"isCustomer": True, "Obid": 12345},
                    {"obj": {"isCustomer": True, "Obid": 12345}}
            ]}

        def test_conversion(self):
            output = camel_to_underscore_case(self.input)

            underscored = {"is_customer": True, "obid": 12345}
            expected = {'object': [underscored] * 4 + [{"obj": underscored}]}

            self.assertDictEqual(expected, output)

    class TestUnderscoreToCamel(unittest.TestCase):

        def setUp(self):
            self.input = {'object': [
                    {"IsCustomer": True, "obid": 12345},
                    {"isCustomer": True, "obid": 12345},
                    {"is_customer": True, "obid": 12345},
                    {"isCustomer": True, "Obid": 12345},
                    {"obj": {"is_customer": True, "obid": 12345}}
            ]}

        def test_conversion(self):
            output = underscore_to_camel_case(self.input)

            camelcased = {"IsCustomer": True, "Obid": 12345}
            expected = {'Object': [camelcased] * 4 + [{"Obj": camelcased}]}

            self.assertDictEqual(expected, output)

    unittest.main()