Post History

A class to access dicts using attribute syntax

I've written a class that allows to access dictionary entries of arbitrary dicts with appropriate string keys through attribute access syntax on an instance of the class.

My questions are:

 1. Is this class a good idea to begin with?

 2. Is there anything that should be done differently?

Here's the class:

```python
class DictProxy: 
    """
    Allow to access a dictionary through attribute access syntax.

    Obviously only dictionary entries whose keys are strings
    conforming to identifier rules can be accessed this way; also,
    identifiers starting with underscore are not delegated to the
    dictionary (thus dictionary entries whose key starts with
    underscore cannot be accessed this way).
    """

    def __init__(self, dictionary):
        """
        Initialize the DictProxy with a dictionary
        """
        self._dictionary = dictionary


    def __setattr__(self, name, value):
        """
        Redirect non-underscore attribute assignments to dictionary updates
        """
        if name[0] == "_":
            super().__setattr__(name, value)
        else:
            self._dictionary[name] = value


    def __getattr__(self, name):
        """
        Redirect non-underscore attribute reads to dictionary reads
        """
        if name[0] == "_":
            return super().__getattr__(name)
        else:
            try:
                return self._dictionary[name]
            except KeyError as error:
                # hasattr fails if the exception isn't an AttributeError
                raise AttributeError(error)


    def __delattr__(self, name):
        """
        Redirect non-underscore attribute deletes to dictionary deletes
        """
        # the actual code
        if name[0] == "_":
            return super().__delete__(name)
        else:
            del self._dictionary[name]


def test():
    dictionary = { "a": 1, "b": 2, "c": 3 }
    proxy = DictProxy(dictionary)

    assert(hasattr(proxy, "a"))
    assert(hasattr(proxy, "b"))
    assert(hasattr(proxy, "c"))
    assert(not hasattr(proxy, "d"))

    assert(proxy.a == 1)
    assert(proxy.b == 2)
    assert(proxy.c == 3)

    proxy.a = 4

    assert(proxy.a == 4)
    assert(dictionary["a"] == 4)

    proxy.d = 5

    assert(hasattr(proxy, "d"))
    assert(proxy.d == 5)
    assert("d" in dictionary)
    assert(dictionary["d"] == 5)

    del proxy.a

    assert(not hasattr(proxy, "a"))
    assert(not "a" in dictionary)

    delattr(proxy, "b")

    assert(not hasattr(proxy, "b"))
    assert(not "b" in dictionary)

    dictionary["a"] = 6

    assert(hasattr(proxy, "a"))
    assert(proxy.a == 6)

    del dictionary["c"]

    assert(not hasattr(proxy, "c"))


if __name__ == '__main__':
    test()
```