AttrDict

2.0.1 · deprecated · verified Sun Apr 12

AttrDict is an MIT-licensed Python library (version 2.0.1) providing mapping objects that allow their elements to be accessed both as keys (like a standard dict) and as attributes. It aims to simplify the creation of hierarchical data structures, particularly useful for configuration objects. The project's last release was in 2019, and its GitHub repository was archived in the same year, indicating it is no longer actively maintained.

Warnings

breaking The `attrdict` library is incompatible with Python 3.10 and newer versions. It relies on `from collections import Mapping`, which was removed in Python 3.10. Attempting to install or run `attrdict` on Python 3.10+ will result in an `ImportError`.
Fix: Consider using alternative libraries like `addict` or implementing similar functionality with `types.SimpleNamespace` for Python 3.10+ environments. The project is unmaintained.
deprecated The `attrdict` project is no longer actively maintained. Its GitHub repository was archived in February 2019, and it has not received updates since then. It is not recommended for new projects.
Fix: For new projects, evaluate actively maintained alternatives like `addict` or `pydantic` for configuration management.
gotcha When accessing nested dictionaries via attribute access (e.g., `attr.foo.bar`), `AttrDict` recursively converts internal dictionaries to `AttrDict` (or `AttrMap`) instances. Crucially, non-string sequence types (like lists) are *automatically converted to tuples* by default when accessed as an attribute.
Fix: Be aware of this implicit type conversion. If you need to retain lists, consider using `AttrMap` and setting `sequence_type=None` or accessing via item notation (`attr['foo']['bar']`).
gotcha The `copy()` method of an `AttrDict` instance returns a standard Python `dict`, not another `AttrDict` instance.
Fix: If you require a shallow copy that remains an `AttrDict`, you must explicitly convert the result: `new_attrdict = AttrDict(old_attrdict.copy())`.
gotcha Unlike a standard `dict`, `AttrDict` does not clone the input dictionary upon creation. It uses the same dictionary instance internally. Modifying the original dictionary after creating an `AttrDict` from it will affect the `AttrDict` instance.
Fix: If you need a decoupled instance, pass a copy of your dictionary: `settings = AttrDict(data.copy())`.

Install

pip install attrdict Install stable version

Imports

AttrDict
```
from attrdict import AttrDict
```
AttrMap
```
from attrdict import AttrMap
```
An alternative MutableMapping that offers more control over recursive conversions and does not inherit directly from `dict`.
AttrDefault
```
from attrdict import AttrDefault
```
Provides `defaultdict`-style automatic creation of attributes.

Quickstart

Initialize an `AttrDict` from a dictionary and access its elements using attribute-style notation. Demonstrates both valid access and the `AttributeError` for non-existent attributes.

from attrdict import AttrDict

# Create an AttrDict from a regular dictionary
data = {'server': {'host': 'localhost', 'port': 8000}, 'debug': True}
settings = AttrDict(data)

# Access elements using attribute notation
print(f"Host: {settings.server.host}")
print(f"Port: {settings.server.port}")

# Attribute access for non-existent keys raises AttributeError
try:
    print(settings.non_existent)
except AttributeError as e:
    print(f"Error accessing non_existent attribute: {e}")

# Item access (like dict) still works
print(f"Debug setting: {settings['debug']}")

view raw JSON →