Added Config inheritance workaround

classsettings/settings.py

@@ -24,10 +24,45 @@ def __init__(cls, name, bases, attrs):
 
 class ConfigMeta(type):
 
-    def __init__(cls, name, bases, attrs):
-        public_members, module = inspect_class(cls)
-        result = dict((name, value()) for (name, value) in public_members)
+    def __new__(cls, name, bases, attrs):
+        Class = super(ConfigMeta, cls).__new__(cls, name, bases, attrs)
+
+        if name == 'NewBase':
+            return Class
+
+        public_members, module = inspect_class(Class)
+        variables = ((k, val()) for (k, val) in public_members)
+        result = ConfigResult(variables, Class)
         setattr(module, name, result)
+        return result
+
+
+class ConfigResult(dict):
+    """
+    Dict-like object which adds inheritance support.
+    """
+    def __new__(cls, *args, **kwargs):
+        if len(args) == 2:
+            # Used to create dict object
+            return super(ConfigResult, cls).__new__(cls, *args, **kwargs)
+        else:
+            # Used as superclass
+            name, bases, attrs = args
+            bases = tuple(b.ConfigClass for b in bases if isinstance(b, ConfigResult))
+            return ConfigMeta(name, bases, attrs)
+
+    def __init__(self, *args, **kwargs):
+        if len(args) == 2:
+            # Is used as dict instance
+            dict_arg, self._ConfigClass = args
+            super(ConfigResult, self).__init__(dict_arg, **kwargs)
+        else:
+            # Is used as class
+            pass
+
+    @property
+    def ConfigClass(self):
+        return self._ConfigClass
 
 
 class Settings(six.with_metaclass(SettingsMeta)):
@@ -40,5 +75,5 @@ class Settings(six.with_metaclass(SettingsMeta)):
 class Config(six.with_metaclass(ConfigMeta)):
     """
     Calls each public method of class, constructs dictionary with `name-result`
-    pairs and injects it into module scope.
+    pairs and replaces class with it.
     """

tests.py

@@ -67,7 +67,7 @@ class MyConfig(Config): pass
         new_module_vars = set(globals())
         self.assertEqual(new_module_vars - old_module_vars,
                          set(('MyConfig',)))
-        self.assertEqual(globals()['MyConfig'], dict())
+        self.assertTrue(globals()['MyConfig'] == MyConfig == dict())
 
     def test_fields(self):
         class MyConfig(Config):
@@ -89,20 +89,22 @@ def _private_setting(self): return 1
     def test_inheritance(self):
         old_module_vars = set(globals())
         self.assertFalse('SuperConfig' in old_module_vars or
-                         'SubConfig' in old_module_vars)
+                         'Sub1Config' in old_module_vars)
 
         class SuperConfig(Config):
             def public_super(self): return 1
 
-        class SubConfig(SuperConfig):
-            def public_sub(self): return 2
+        class Sub1Config(SuperConfig):
+            def public_sub(self): return 2 * self.public_super()
+
+        class Sub2Config(Sub1Config):
+            def public_sub2(self): return 2 * self.public_sub()
 
         self.assertEqual(set(globals()) - old_module_vars,
-                         set(('SuperConfig', 'SubConfig')))
-        self.assertEqual(globals()['SuperConfig'],
-                         {'public_super': 1})
-        self.assertEqual(globals()['SubConfig'],
-                         {'public_super': 1, 'public_sub': 2})
+                         set(('SuperConfig', 'Sub1Config', 'Sub2Config')))
+        self.assertEqual(SuperConfig, dict(public_super=1))
+        self.assertEqual(Sub1Config,  dict(public_super=1, public_sub=2))
+        self.assertEqual(Sub2Config,  dict(public_super=1, public_sub=2, public_sub2=4))
 
 
 class FromEnvTestCase(unittest.TestCase):