Skip to content

honeyhive.utils.dotdict

DotDict implementation for attribute-style dictionary access.

DotDict

Bases: dict

Dictionary with dot notation access.

Example

d = DotDict({'foo': {'bar': 'baz'}}) d.foo.bar 'baz' d.foo.bar = 'qux' d['foo']['bar'] 'qux'

Source code in src/honeyhive/utils/dotdict.py 
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
class DotDict(dict):
    """Dictionary with dot notation access.

    Example:
        >>> d = DotDict({'foo': {'bar': 'baz'}})
        >>> d.foo.bar
        'baz'
        >>> d.foo.bar = 'qux'
        >>> d['foo']['bar']
        'qux'
    """

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        """Initialize the dotdict."""
        super().__init__(*args, **kwargs)
        # Convert nested dictionaries to dotdict
        for key, value in self.items():
            if isinstance(value, dict):
                self[key] = DotDict(value)

    def __getattr__(self, key: str) -> Any:
        """Get attribute using dot notation."""
        try:
            return self[key]
        except KeyError as exc:
            raise AttributeError(
                f"'{type(self).__name__}' object has no attribute '{key}'"
            ) from exc

    def __setattr__(self, key: str, value: Any) -> None:
        """Set attribute using dot notation."""
        if isinstance(value, dict):
            value = DotDict(value)
        self[key] = value

    def __delattr__(self, key: str) -> None:
        """Delete attribute using dot notation."""
        try:
            del self[key]
        except KeyError as exc:
            raise AttributeError(
                f"'{type(self).__name__}' object has no attribute '{key}'"
            ) from exc

    def __getitem__(self, key: str) -> Any:
        """Get item with dot notation support."""
        if "." in key:
            keys = key.split(".")
            value = self
            for k in keys:
                value = value[k]
            return value
        return super().__getitem__(key)

    def __setitem__(self, key: str, value: Any) -> None:
        """Set item with dot notation support."""
        if "." in key:
            keys = key.split(".")
            target = self
            for k in keys[:-1]:
                if k not in target:
                    target[k] = DotDict()
                target = target[k]
            target[keys[-1]] = value
        else:
            if isinstance(value, dict):
                value = DotDict(value)
            super().__setitem__(key, value)

    def get(self, key: str, default: Any = None) -> Any:
        """Get item with default value, supporting dot notation."""
        try:
            return self[key]
        except (KeyError, AttributeError):
            return default

    def setdefault(self, key: str, default: Any = None) -> Any:
        """Set default value for key, supporting dot notation."""
        if "." in key:
            keys = key.split(".")
            target = self
            for k in keys[:-1]:
                if k not in target:
                    target[k] = DotDict()
                target = target[k]
            if keys[-1] not in target:
                target[keys[-1]] = default
            return target[keys[-1]]

        return super().setdefault(key, default)

    def update(self, other: Any = None, /, **kwargs: Any) -> None:
        """Update dictionary with dot notation support."""
        if other is not None:
            for key, value in other.items():
                self[key] = value
        for key, value in kwargs.items():
            self[key] = value

    def to_dict(self) -> Dict[str, Any]:
        """Convert dotdict back to regular dictionary."""
        result = {}
        for key, value in self.items():
            if isinstance(value, DotDict):
                result[key] = value.to_dict()
            else:
                result[key] = value
        return result

    def copy(self) -> "DotDict":
        """Create a shallow copy."""
        return DotDict(super().copy())

    def deepcopy(self) -> "DotDict":
        """Create a deep copy."""
        return copy.deepcopy(self)

get 

get(key: str, default: Any = None) -> Any

Get item with default value, supporting dot notation.

Source code in src/honeyhive/utils/dotdict.py 
76
77
78
79
80
81
def get(self, key: str, default: Any = None) -> Any:
    """Get item with default value, supporting dot notation."""
    try:
        return self[key]
    except (KeyError, AttributeError):
        return default

setdefault 

setdefault(key: str, default: Any = None) -> Any

Set default value for key, supporting dot notation.

Source code in src/honeyhive/utils/dotdict.py 
83
84
85
86
87
88
89
90
91
92
93
94
95
96
def setdefault(self, key: str, default: Any = None) -> Any:
    """Set default value for key, supporting dot notation."""
    if "." in key:
        keys = key.split(".")
        target = self
        for k in keys[:-1]:
            if k not in target:
                target[k] = DotDict()
            target = target[k]
        if keys[-1] not in target:
            target[keys[-1]] = default
        return target[keys[-1]]

    return super().setdefault(key, default)

update 

update(other: Any = None, /, **kwargs: Any) -> None

Update dictionary with dot notation support.

Source code in src/honeyhive/utils/dotdict.py 
 98
 99
100
101
102
103
104
def update(self, other: Any = None, /, **kwargs: Any) -> None:
    """Update dictionary with dot notation support."""
    if other is not None:
        for key, value in other.items():
            self[key] = value
    for key, value in kwargs.items():
        self[key] = value

to_dict 

to_dict() -> Dict[str, Any]

Convert dotdict back to regular dictionary.

Source code in src/honeyhive/utils/dotdict.py 
106
107
108
109
110
111
112
113
114
def to_dict(self) -> Dict[str, Any]:
    """Convert dotdict back to regular dictionary."""
    result = {}
    for key, value in self.items():
        if isinstance(value, DotDict):
            result[key] = value.to_dict()
        else:
            result[key] = value
    return result

copy 

copy() -> DotDict

Create a shallow copy.

Source code in src/honeyhive/utils/dotdict.py 
116
117
118
def copy(self) -> "DotDict":
    """Create a shallow copy."""
    return DotDict(super().copy())

deepcopy 

deepcopy() -> DotDict

Create a deep copy.

Source code in src/honeyhive/utils/dotdict.py 
120
121
122
def deepcopy(self) -> "DotDict":
    """Create a deep copy."""
    return copy.deepcopy(self)