Example #1
0
    def configure(self, *args, **kwargs):
        """
    Called to manually configure the settings. The 'default_settings'
    parameter sets where to retrieve any unspecified values from (its
    argument should be a :class:`dict`).

    Arguments
    ---------
    *args :
        Passed along to :class:`Settings`
    **kwargs :
        Passed along to :class:`Settings`

    Raises
    ------
    ImproperlyConfigured
        If settings is already configured, will throw this exception
    """
        if self._wrapped is not None:
            raise ImproperlyConfigured('Settings already configured.')
        logger.debug2('Pre settings configure')
        self._wrapped = Settings(*args, **kwargs)

        for pattern, settings in global_templates:
            if nested_in_dict(pattern, self._wrapped):
                # Not the most efficient way to do this, but insignificant "preupdate"
                d = {}
                nested_update(d, settings)
                nested_update(d, self._wrapped)
                # Nested update and run patch code
                self._wrapped.update(d)

        def read_json(json_file):
            # In case json_file is an @settings_property function
            if getattr(json_file, 'settings_property', None):
                json_file = json_file(settings)

            return Settings(json_load(json_file))

        nested_patch_inplace(
            self._wrapped, lambda key, value:
            (isinstance(key, str) and (isinstance(value, str) or getattr(
                value, 'settings_property', False)) and
             any(key.endswith(pattern) for pattern in json_include_suffixes)),
            lambda key, value: read_json(value))

        # Importing these here is intentional, it guarantees the signals are
        # connected so that executor and computes can setup logging if need be
        import terra.executor  # noqa
        import terra.compute  # noqa

        from terra.core.signals import post_settings_configured
        post_settings_configured.send(sender=self)
        logger.debug2('Post settings configure')
Example #2
0
    def test_nested_update_dervied(self):
        class FooDict(dict):
            pass

        foo = FooDict({'a': 15, 'b': FooDict({'c': 14, 'f': 18})})
        bar = {'a': 16, 'd': {'e': 17}, 'b': {'c': 24}}
        nested_update(foo, bar)
        ans = {'a': 16, 'd': {'e': 17}, 'b': {'c': 24, 'f': 18}}
        self.assertEqual(foo, ans)
        self.assertIsInstance(foo, FooDict)
        self.assertIsInstance(foo['b'], FooDict)
        self.assertIsInstance(foo['d'], FooDict)
Example #3
0
    def test_nested_update(self):
        x = {"a": 1, "b": {"c": 2, "d": 3}, "d": 4}

        # Normal update
        y = {"a": 11, "b": {"c": 22, "e": 33}}
        ans = {"a": 11, "b": {"c": 22, "d": 3, "e": 33}, "d": 4}
        z = copy.deepcopy(x)
        nested_update(z, y)
        self.assertEqual(z, ans)

        # Keys not there before + replace dict with int
        y = {"b": 5, "e": {"c": 22, "e": 33}, "f": 6}
        ans = {"a": 1, "b": 5, "e": {"c": 22, "e": 33}, "d": 4, "f": 6}
        z = copy.deepcopy(x)
        nested_update(z, y)
        self.assertEqual(z, ans)

        y = {"a": {"g": 15}}
        z = copy.deepcopy(x)
        # No longer a type error
        # with self.assertRaises(TypeError):
        nested_update(z, y)
        ans = {'a': {'g': 15}, 'b': {'c': 2, 'd': 3}, 'd': 4}
        self.assertEqual(z, ans)

        z = {'foo': 13, 'bar': 12, 'far': 14, 'boo': {}}
        z2 = copy.deepcopy(z)
        nested_update(z2,
                      foo={},
                      bar={'x': 11},
                      far={'y': {}},
                      boo=[11, 22, 33])
        ans = {
            'foo': {},
            'bar': {
                'x': 11
            },
            'far': {
                'y': {}
            },
            'boo': [11, 22, 33]
        }
        self.assertEqual(z2, ans)

        nested_update(z2, foo=13, bar=12, far=14, boo={})
        self.assertEqual(z, z2)
Example #4
0
    def test_nested_update(self):
        x = {"a": 1, "b": {"c": 2, "d": 3}, "d": 4}

        # Normal update
        y = {"a": 11, "b": {"c": 22, "e": 33}}
        ans = {"a": 11, "b": {"c": 22, "d": 3, "e": 33}, "d": 4}
        z = x.copy()
        nested_update(z, y)
        self.assertEqual(z, ans)

        # Keys not there before + replace dict with int
        y = {"b": 5, "e": {"c": 22, "e": 33}, "f": 6}
        ans = {"a": 1, "b": 5, "e": {"c": 22, "e": 33}, "d": 4, "f": 6}
        z = x.copy()
        nested_update(z, y)
        self.assertEqual(z, ans)

        y = {"a": {"g": 15}}
        z = x.copy()
        with self.assertRaises(TypeError):
            nested_update(z, y)
Example #5
0
    def update(self, *args, **kwargs):
        """ Supported """

        nested_update(self, *args, **kwargs)