easydotdict 1.0.0__tar.gz

easydotdict-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 draganoxfool
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

easydotdict-1.0.0/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: easydotdict
+Version: 1.0.0
+Summary: Effortless nested dictionary access — dot notation, safe missing keys, auto-vivification, and more
+Author-email: draganoxfool <draganogaming1@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/draganoxfool/Easydotdict
+Project-URL: Source, https://github.com/draganoxfool/Easydotdict
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# easydotdict
+
+Make nested dictionaries effortless — dot-notation access, safe missing-key handling, auto-vivification, deep path operations, and pretty-printing. Pure Python, no dependencies.
+
+```python
+from easydotdict import EasyDict
+
+d = EasyDict({'user': {'profile': {'name': 'Alice'}}})
+print(d.user.profile.name)       # Alice
+print(d['user'].profile.name)    # same
+print(d.user.email)              # None (safe, no error)
+
+d.config.database.host = 'localhost'  # auto-creates path
+d.put('server.port', 8080)            # or use path string
+print(d.dig('user.name'))             # Alice (deep path getter)
+
+flat = d.flatten()                    # {'user.profile.name': 'Alice', ...}
+restored = EasyDict.unflatten(flat)   # reverse
+
+d.merge({'settings': {'debug': True}})  # deep merge
+print(d)                                # indented JSON
+```
+
+## Features
+
+- **Dot notation** — `d.user.profile.name` instead of `d['user']['profile']['name']`
+- **Dual access** — dot and bracket notation work interchangeably
+- **Safe access** — `d.missing` returns `None`, no `KeyError`/`AttributeError`
+- **Auto-vivification** — `d.a.b.c = value` auto-creates intermediate structures
+- **Deep path operations** — `dig`, `put`, `has` with dot-separated strings
+- **Flatten / Unflatten** — recursive flatten and restore with `flatten()` and `unflatten()`
+- **Deep merge** — `update()` and `merge()` merge recursively, preserving existing keys
+- **Clone** — `clone()` returns a deep independent copy
+- **Empty check** — `is_empty()` checks if the dict has no keys
+- **Auto-conversion** — nested `dict`s and `list`s containing `dict`s are wrapped automatically
+- **Pretty-print** — `print(d)` outputs indented JSON
+- **`to_dict()`** — recursively converts back to plain `dict`s and `list`s
+- **Pure Python** — standard library only, Python 3.8+
+
+## Install
+
+```bash
+pip install easydotdict
+```
+
+## Documentation
+
+See [docs.md](docs.md) for full API reference, edge cases, and examples.
+
+## License
+
+MIT

easydotdict-1.0.0/README.md

@@ -0,0 +1,52 @@
+# easydotdict
+
+Make nested dictionaries effortless — dot-notation access, safe missing-key handling, auto-vivification, deep path operations, and pretty-printing. Pure Python, no dependencies.
+
+```python
+from easydotdict import EasyDict
+
+d = EasyDict({'user': {'profile': {'name': 'Alice'}}})
+print(d.user.profile.name)       # Alice
+print(d['user'].profile.name)    # same
+print(d.user.email)              # None (safe, no error)
+
+d.config.database.host = 'localhost'  # auto-creates path
+d.put('server.port', 8080)            # or use path string
+print(d.dig('user.name'))             # Alice (deep path getter)
+
+flat = d.flatten()                    # {'user.profile.name': 'Alice', ...}
+restored = EasyDict.unflatten(flat)   # reverse
+
+d.merge({'settings': {'debug': True}})  # deep merge
+print(d)                                # indented JSON
+```
+
+## Features
+
+- **Dot notation** — `d.user.profile.name` instead of `d['user']['profile']['name']`
+- **Dual access** — dot and bracket notation work interchangeably
+- **Safe access** — `d.missing` returns `None`, no `KeyError`/`AttributeError`
+- **Auto-vivification** — `d.a.b.c = value` auto-creates intermediate structures
+- **Deep path operations** — `dig`, `put`, `has` with dot-separated strings
+- **Flatten / Unflatten** — recursive flatten and restore with `flatten()` and `unflatten()`
+- **Deep merge** — `update()` and `merge()` merge recursively, preserving existing keys
+- **Clone** — `clone()` returns a deep independent copy
+- **Empty check** — `is_empty()` checks if the dict has no keys
+- **Auto-conversion** — nested `dict`s and `list`s containing `dict`s are wrapped automatically
+- **Pretty-print** — `print(d)` outputs indented JSON
+- **`to_dict()`** — recursively converts back to plain `dict`s and `list`s
+- **Pure Python** — standard library only, Python 3.8+
+
+## Install
+
+```bash
+pip install easydotdict
+```
+
+## Documentation
+
+See [docs.md](docs.md) for full API reference, edge cases, and examples.
+
+## License
+
+MIT

easydotdict-1.0.0/easydotdict/__init__.py

@@ -0,0 +1,4 @@
+from .easydotdict import EasyDict
+
+__version__ = "1.0.0"
+__all__ = ["EasyDict", "__version__"]

easydotdict-1.0.0/easydotdict/easydotdict.py

@@ -0,0 +1,251 @@
+import json
+
+
+class _Missing:
+    def __init__(self, parent, key):
+        object.__setattr__(self, '_parent', parent)
+        object.__setattr__(self, '_key', key)
+
+    def __getattr__(self, key):
+        if key.startswith('_'):
+            raise AttributeError(key)
+        return _Missing(self, key)
+
+    def __setattr__(self, key, value):
+        if key.startswith('_'):
+            object.__setattr__(self, key, value)
+        else:
+            self._materialize().__setitem__(key, value)
+
+    def __setitem__(self, key, value):
+        self._materialize().__setitem__(key, value)
+
+    def __delattr__(self, key):
+        self._materialize().__delitem__(key)
+
+    def __bool__(self):
+        return False
+
+    def __eq__(self, other):
+        if other is None:
+            return True
+        return NotImplemented
+
+    def __ne__(self, other):
+        if other is None:
+            return False
+        return NotImplemented
+
+    def __repr__(self):
+        return 'None'
+
+    def __str__(self):
+        return 'None'
+
+    def _materialize(self):
+        path = []
+        obj = self
+        while isinstance(obj, _Missing):
+            path.append(obj._key)
+            obj = obj._parent
+        current = obj
+        for key in reversed(path):
+            if key not in current:
+                current[key] = EasyDict()
+            current = current[key]
+        return current
+
+
+def _wrap(value):
+    if isinstance(value, dict) and not isinstance(value, EasyDict):
+        return EasyDict(value)
+    elif isinstance(value, list):
+        return _convert_list(value)
+    return value
+
+
+def _convert_list(lst):
+    result = []
+    for item in lst:
+        if isinstance(item, dict) and not isinstance(item, EasyDict):
+            result.append(EasyDict(item))
+        elif isinstance(item, list):
+            result.append(_convert_list(item))
+        else:
+            result.append(item)
+    return result
+
+
+def _deep_merge(target, source):
+    for key, value in source.items():
+        if key in target and isinstance(target[key], EasyDict) and isinstance(value, dict):
+            _deep_merge(target[key], value)
+        else:
+            target[key] = value
+
+
+class EasyDict(dict):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        for key, value in list(super().items()):
+            if isinstance(value, dict) and not isinstance(value, EasyDict):
+                super().__setitem__(key, EasyDict(value))
+            elif isinstance(value, list):
+                super().__setitem__(key, _convert_list(value))
+
+    def __getattribute__(self, key):
+        if key.startswith('_'):
+            return super().__getattribute__(key)
+        try:
+            return dict.__getitem__(self, key)
+        except KeyError:
+            return super().__getattribute__(key)
+
+    def __getattr__(self, key):
+        return _Missing(self, key)
+
+    def __setattr__(self, key, value):
+        dict.__setitem__(self, key, _wrap(value))
+
+    def __delattr__(self, key):
+        try:
+            dict.__delitem__(self, key)
+        except KeyError:
+            raise AttributeError(key)
+
+    def __getitem__(self, key):
+        try:
+            return dict.__getitem__(self, key)
+        except KeyError:
+            return None
+
+    def __setitem__(self, key, value):
+        dict.__setitem__(self, key, _wrap(value))
+
+    def __repr__(self):
+        return json.dumps(self.to_dict(), indent=2, default=str)
+
+    def __str__(self):
+        return self.__repr__()
+
+    def to_dict(self):
+        result = {}
+        for key, value in self.items():
+            if isinstance(value, EasyDict):
+                result[key] = value.to_dict()
+            elif isinstance(value, list):
+                result[key] = [
+                    item.to_dict() if isinstance(item, EasyDict) else item
+                    for item in value
+                ]
+            else:
+                result[key] = value
+        return result
+
+    def copy(self):
+        return self.clone()
+
+    def clone(self):
+        return EasyDict(self.to_dict())
+
+    def update(self, other=None, **kwargs):
+        if other is not None:
+            if hasattr(other, 'items'):
+                _deep_merge(self, other)
+            else:
+                for k, v in other:
+                    self[k] = v
+        for k, v in kwargs.items():
+            _deep_merge_items = {k: v}
+            _deep_merge(self, _deep_merge_items)
+
+    def merge(self, other):
+        _deep_merge(self, other)
+        return self
+
+    def get(self, key, default=None):
+        if key in self:
+            return dict.__getitem__(self, key)
+        return default
+
+    def dig(self, path):
+        keys = path.split('.')
+        current = self
+        for key in keys:
+            if isinstance(current, dict):
+                try:
+                    current = dict.__getitem__(current, key)
+                except KeyError:
+                    return None
+            else:
+                return None
+        return current
+
+    def put(self, path, value):
+        keys = path.split('.')
+        current = self
+        for key in keys[:-1]:
+            if key not in current:
+                current[key] = EasyDict()
+            current = current[key]
+        current[keys[-1]] = value
+
+    def has(self, path):
+        keys = path.split('.')
+        current = self
+        for key in keys:
+            if isinstance(current, dict) and key in current:
+                current = dict.__getitem__(current, key)
+            else:
+                return False
+        return True
+
+    def flatten(self, prefix=''):
+        result = {}
+        for key, value in self.items():
+            full_key = f'{prefix}.{key}' if prefix else str(key)
+            if isinstance(value, EasyDict):
+                result.update(value.flatten(prefix=full_key))
+            elif isinstance(value, list):
+                for i, item in enumerate(value):
+                    item_key = f'{full_key}.{i}'
+                    if isinstance(item, EasyDict):
+                        result.update(item.flatten(prefix=item_key))
+                    else:
+                        result[item_key] = item
+            else:
+                result[full_key] = value
+        return result
+
+    @classmethod
+    def unflatten(cls, data):
+        root = {}
+        for dotted_key, value in data.items():
+            parts = dotted_key.split('.')
+            current = root
+            for i, part in enumerate(parts):
+                is_last = (i == len(parts) - 1)
+                if is_last:
+                    current[part] = value
+                else:
+                    if part not in current:
+                        current[part] = {}
+                    current = current[part]
+        return cls(cls._lists_from_dict(root))
+
+    @staticmethod
+    def _lists_from_dict(d):
+        if not isinstance(d, dict):
+            return d
+        keys = list(d.keys())
+        if keys and all(isinstance(k, str) and k.isdigit() for k in keys):
+            max_idx = max(int(k) for k in keys)
+            lst = [None] * (max_idx + 1)
+            for k in keys:
+                idx = int(k)
+                lst[idx] = EasyDict._lists_from_dict(d[k])
+            return lst
+        return {k: EasyDict._lists_from_dict(v) for k, v in d.items()}
+
+    def is_empty(self):
+        return len(self) == 0

easydotdict-1.0.0/easydotdict.egg-info/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: easydotdict
+Version: 1.0.0
+Summary: Effortless nested dictionary access — dot notation, safe missing keys, auto-vivification, and more
+Author-email: draganoxfool <draganogaming1@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/draganoxfool/Easydotdict
+Project-URL: Source, https://github.com/draganoxfool/Easydotdict
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# easydotdict
+
+Make nested dictionaries effortless — dot-notation access, safe missing-key handling, auto-vivification, deep path operations, and pretty-printing. Pure Python, no dependencies.
+
+```python
+from easydotdict import EasyDict
+
+d = EasyDict({'user': {'profile': {'name': 'Alice'}}})
+print(d.user.profile.name)       # Alice
+print(d['user'].profile.name)    # same
+print(d.user.email)              # None (safe, no error)
+
+d.config.database.host = 'localhost'  # auto-creates path
+d.put('server.port', 8080)            # or use path string
+print(d.dig('user.name'))             # Alice (deep path getter)
+
+flat = d.flatten()                    # {'user.profile.name': 'Alice', ...}
+restored = EasyDict.unflatten(flat)   # reverse
+
+d.merge({'settings': {'debug': True}})  # deep merge
+print(d)                                # indented JSON
+```
+
+## Features
+
+- **Dot notation** — `d.user.profile.name` instead of `d['user']['profile']['name']`
+- **Dual access** — dot and bracket notation work interchangeably
+- **Safe access** — `d.missing` returns `None`, no `KeyError`/`AttributeError`
+- **Auto-vivification** — `d.a.b.c = value` auto-creates intermediate structures
+- **Deep path operations** — `dig`, `put`, `has` with dot-separated strings
+- **Flatten / Unflatten** — recursive flatten and restore with `flatten()` and `unflatten()`
+- **Deep merge** — `update()` and `merge()` merge recursively, preserving existing keys
+- **Clone** — `clone()` returns a deep independent copy
+- **Empty check** — `is_empty()` checks if the dict has no keys
+- **Auto-conversion** — nested `dict`s and `list`s containing `dict`s are wrapped automatically
+- **Pretty-print** — `print(d)` outputs indented JSON
+- **`to_dict()`** — recursively converts back to plain `dict`s and `list`s
+- **Pure Python** — standard library only, Python 3.8+
+
+## Install
+
+```bash
+pip install easydotdict
+```
+
+## Documentation
+
+See [docs.md](docs.md) for full API reference, edge cases, and examples.
+
+## License
+
+MIT

easydotdict-1.0.0/easydotdict.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+easydotdict/__init__.py
+easydotdict/easydotdict.py
+easydotdict.egg-info/PKG-INFO
+easydotdict.egg-info/SOURCES.txt
+easydotdict.egg-info/dependency_links.txt
+easydotdict.egg-info/top_level.txt

easydotdict-1.0.0/easydotdict.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

easydotdict-1.0.0/easydotdict.egg-info/top_level.txt

@@ -0,0 +1 @@
+easydotdict

easydotdict-1.0.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "easydotdict"
+version = "1.0.0"
+description = "Effortless nested dictionary access — dot notation, safe missing keys, auto-vivification, and more"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.8"
+
+authors = [
+  {name = "draganoxfool", email = "draganogaming1@gmail.com"},
+]
+
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.urls]
+Homepage = "https://github.com/draganoxfool/Easydotdict"
+Source = "https://github.com/draganoxfool/Easydotdict"
+
+[tool.setuptools.packages.find]
+include = ["easydotdict*"]

easydotdict-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+