Yesterday I was coding some stuff in Python and I was searching for something that is doing a deep merge of two native dictionaries, and I found this https://www.xormedia.com/recursively-merge-dictionaries-in-python/

Is working awesomely and is doing exactly what jQuery.extend() is doing also. Are you going to merge this awesome stuff in your library as well? The only that I missed while I was reading the README was exactly this.

I'm pretty much sure that this will make it more and more awesome :) Thanks in advice!

Added support for recursively merging dict-like stuff into a Dict instance.

old = Dict()
old.foo.a = 1
old.foo.b = 2
old.bar = 42

new = Dict()
new.foo.b = 3
new.foo.c = 'new kid on the block'
new.bar.asd = 42

old.update(new)

print old

… gives:

{'foo': {'a': 1, 'c': 'new kid on the block', 'b': 3}, 'bar': {'asd': 42}}

Hi folks, great library! I really need the ability to specify a default value when I request a key that doesn't exist, instead of getting an empty Dict as a result. Would this be possible? I'm happy to contribute the code myself if this seems like something you'd want. None, empty string, or anything like that would be great. The other tools I'm using (mongoengine) are barfing because they don't know how to cast an empty Dict to any other type.

Thanks!

Hi @mewwts,

can you please tag the 1.0.0 release commit 2ef6ab8e50df023984e76f9f3b404285afc4954d?

I am preparing the https://github.com/conda-forge/staged-recipes/pull/1104 to add addict to the conda-forge and they request a tag.

Based on my reading of #121, it's clear that the need for .freeze() arises from the desire for KeyErrors, so that typos can be caught quickly. Keeping this in mind, I've tried to make minimal additions.

The Basics

When an addict.Dict is frozen, accessing a missing key will raise a KeyError. This is true for nested addict.Dict instances too.

Allowing Key Addition

In some sense, a plain Python dict is already frozen, as it always raises KeyErrors. Note that plain dicts allow the addition of new keys. Thus, it should make sense to allow the addition to new keys to frozen addicts, but only at the top level. That is:

• frozenDicty.newKey = 1 should work as expected, but
• frozenDicty.missingKey.newKey = 1 should raise a KeyError.

Unfreezing is a Shorthand

As .freeze() and .unfreeze() are very similar, differing only in a boolean flag, it made sense to implement .unfreeze() as a shorthand for .freeze(False). Specifically:

• .freeze() is equivalent to .freeze(True), and
• .unfreeze() is a shorthand for .freeze(False).

No Frozen Initialization

Thought about adding a __frozen param to __init__(), but decided against it. If required, such functionality can easily be added later. And while a such a parameter is mentioned in #121, in favoring explicit vs implicit, it may be best to require the user to explicitly call .freeze().

No Return Value

Currently, .freeze() (including .unfreeze()) returns None, not an addict.Dict. This is similar to Python's built-in dict.update(). While #121 suggests making .freeze() return a frozen addict.Dict, retaining parity with dict.update() may be desirable.

from addict import Dict
a = Dict()
a.items = 'foo'
for k,v in a.items():
    print k,v

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object is not callable

The following patch addresses issues 110 (and closely related 117) and 121 This is my first pull request! be indulgent!

#110 Deep setattr and gettattr when attribute names contain '.' the patch enables d=Dict() var keypath='path.to.nested.key' d[ keypath ]='test' print(d [ keypass] )

#121 Is it possible to forbid accessing missing keys? adict returns an empty dict when trying to access non existing keys d=Dict() assert d.a.b.c == {} the patch introduces d.freeze() and d.unfreeze(). When the dict is frozen, you cannot create new keys (keyError raised) but you can modify existing ones The patch overrides default get method to

• get frozen/unfrozen state
• freeze dict
• return d[key] if key exists otherwise default -restore frozen/unfrozen state

It would be stellar if Addict had type annotations (maybe in a .pyi file next to addict.py?) such that we could use this in projects using pyre, mypy, pyright, pytype etc.

I imagine this would be pretty simple to make since the functions so closely resemble a Dict's in the first place, but I don't know the best way to distribute these types (typeshed? .pyi?).

If this is something you're open to, I can write the types later and PR them or look more into how best to distribute them

Python 2.7.9 and Python 3.4.2

>>> a = Dict()
>>> a.  #hit tab
>>> a
{'trait_names': {}, '_getAttributeNames': {}}

I think there's similar behaviour in the interactive console in PyCharm.

Defining __add__ allows Dict to be used as a dynamic nested counter. Consider this list of dicts and say you want to count the # of red and the # of blue by month.

data = [
    {'month': '2015-01', 'color': 'red'},
    {'month': '2015-01', 'color': 'blue'},
    {'month': '2015-01', 'color': 'red'},
    {'month': '2015-02', 'color': 'blue'},
    {'month': '2015-02', 'color': 'blue'},
    {'month': '2015-02', 'color': 'red'}
]

Prior to this PR, you need to do:

from addict import Dict

counter = Dict()

for x in data:
    month = x['month']
    color = x['color']

    if month in counter:
        if color in counter[month]:
            counter[month][color] += 1
        else:
            counter[month][color] = 1
    else:
        counter[month][color] = 1

print counter

{'2015-02': {'blue': 2, 'red': 1}, '2015-01': {'blue': 1, 'red': 2}}

After this PR, you can simply do:

from addict import Dict

counter = Dict()

for x in data:
    month = x['month']
    color = x['color']
    counter[month][color] += 1

print counter

{'2015-02': {'blue': 2, 'red': 1}, '2015-01': {'blue': 1, 'red': 2}}

This of course becomes very powerful and convenient when you want to count things nested by many levels.

Here is a rough idea of the code I'm running:

from addict import Dict
def get_dictionary(self, orig_dict):
    new_dict = Dict({'default_key':'default_value'})
    if(orig_dict["code"]==0):
        new_dict.other_key = "Double Quoted String"
    elif(orig_dict["code"]==1):
        new_dict.other_key = "Different Double Quoted String"
    return new_dict

and eventually when I use it with Django's render_to_string("xml_template.xml",dictionary=context_dictionary) into this template:

<ParentTag>
    <MyFirstTag>{{new_dict.default_key}}</MyFirstTag>
    <MySecondTag>{{new_dict.other_key}}</MySecondTag>
</ParentTag>

And it renders as:

<ParentTag>
    <MyFirstTag>default_value</MyFirstTag>
    <MySecondTag>{&#39;__unicode__&#39;: {}</MySecondTag>
</ParentTag>

I think that (for some reason) addict is returning an empty dictionary, but the output is being mangled. I know the docs say you can use to_dict() but it implies you don't need to.

Any idea why this happens?

https://github.com/mewwts/addict/issues/127 introduces merge operators. However, the current implementation has two problems:

1. Since Dict is a subclass of dict, is it necessary to check by isinstance(other, (Dict, dict))? Wouldn't isinstance(other, dict) be enough?
2. | and |= always return Dict instances, even if the operands may be instances of subclasses. To expatiate, consider the following snippet:

from addict import Dict
class MyDict(Dict):
    def func(self):
        print(self)
a = MyDict()
b = MyDict()
c = a | b
c.func()  # TypeError: 'Dict' object is not callable

Intuitively, we would expect that c is an instance of MyDict but is actually of type Dict. Moreover, since Dict does not have a method called func, when looking up c.func, it returns a new empty Dict, causing the error message to be very misleading.

Will it be possible to return an instance of type self.__class__ in Dict.__or__ and Dict.__ror__?

Hello,

I'm trying to use Dict with MaskedNode objects used in the optax library which are class that are empty and inherit from NamedTuple: https://github.com/deepmind/optax/blob/master/optax/_src/wrappers.py

It is possible to create dict with those objects but the Dict construction is failing, here is a minimal example:

from addict import Dict
from typing import NamedTuple

class MyNamedTuple(NamedTuple):
    """
    """

mn_dict = dict(mn=MyNamedTuple())
print(mn_dict)
mn_Dict = Dict(mn=MyNamedTuple()) 

Would it be possible to include this case and match dict constructor? Thank you very much,

Mayalen

See below; keys that start with __ can't be referenced inside an object with dotted notation. If I defined missing() I get "KeyError: '_Stuff__metadata'".

Thanks for this awesome piece of software BTW -- makes my life much better.

-- cut here -- import addict from pprint import pformat

data = { 'foo': 7, 'bar': { 'metadata': {'text': 'this works', 'value': True}, '__metadata': {'text': 'this works', 'value': False} } } dotted = addict.Dict(data)

class Stuff(object): def init(self): pass

def run(self):
    assert pformat(data['bar']) == pformat(dotted.bar), 'text representation does not work'
    assert dotted.bar.metadata.text == dotted.bar['__metadata'].text, 'mixed reference broken inside an object'
    assert dotted.bar.metadata.text == dotted.bar.__metadata.text, 'dotted reference broken inside an object'

assert dotted.bar.metadata.text == dotted.bar.__metadata.text, 'broken outside an object' Stuff().run()

Today this minimal code:

$ cat /tmp/test.py
from addict import Dict

a = Dict()

can not be included in a fully typed project:

$ mypy /tmp/test.py
/tmp/test.py:1: error: Skipping analyzing "addict": module is installed, but missing library stubs or py.typed marker
/tmp/test.py:1: note: See https://mypy.readthedocs.io/en/stable/running_mypy.html#missing-imports
Found 1 error in 1 file (checked 1 source file)
$

The library gives incorrect behavior with getattr:

>>> from addict import Dict
>>> body = Dict(a=1)
>>> body.freeze()
>>> getattr(body, 'missing', 2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File ".../addict/addict.py", line 67, in __getattr__
    return self.__getitem__(item)
  File ".../addict/addict.py", line 71, in __missing__
    raise KeyError(name)
KeyError: 'missing'

The expected result should be 2 (when the attribute does not exist, the default value 2 should be returned).

The error type for missing attributes is not consistent with Python standards:

>>> body = Dict()
>>> body.freeze()
>>> body.missing_key
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File ".../addict/addict.py", line 67, in __getattr__
    return self.__getitem__(item)
  File ".../addict/addict.py", line 71, in __missing__
    raise KeyError(name)
KeyError: 'missing_key'

The correct error type should be AttributeError.

These issues are all from the same root cause: when the Dict object is frozen and a missing attribute is accessed, AttributeError should be raised (instead of KeyError). getattr uses AttributeError to detect if the default value should be supplied. When KeyError is raised instead, getattr will not supply the default value.

This pull request fixes these issues and adds related tests.

In more detail, the changes are:

Error for body.missing_key

Before:

>>> body = Dict()
>>> body.freeze()
>>> body.missing_key
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File ".../addict/addict.py", line 67, in __getattr__
    return self.__getitem__(item)
  File ".../addict/addict.py", line 71, in __missing__
    raise KeyError(name)
KeyError: 'missing_key'

However, the error type should be AttributeError instead. This pull request fixes this issue by catching it and throwing the correct error type:

>>> body = Dict()
>>> body.freeze()
>>> body.missing_key
Traceback (most recent call last):
  File ".../addict/addict/addict.py", line 74, in __getattr__
    return self.__getitem__(item)
  File ".../addict/addict/addict.py", line 82, in __missing__
    raise KeyError(name)
KeyError: 'missing_key'

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File ".../addict/addict/addict.py", line 77, in __getattr__
    raise AttributeError("'{}' object has no attribute '{}'".format(
AttributeError: 'Dict' object has no attribute 'missing_key'

Error for body["missing_key"]

The error type for missing key access is still the same as before (KeyError) as this is the correct behavior:

>>> body["missing_key"]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File ".../addict/addict/addict.py", line 82, in __missing__
    raise KeyError(name)
KeyError: 'missing_key'

getattr

Before:

>>> body = Dict(a=1)
>>> body.freeze()
>>> getattr(body, 'missing', 2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File ".../addict/addict.py", line 67, in __getattr__
    return self.__getitem__(item)
  File ".../addict/addict.py", line 71, in __missing__
    raise KeyError(name)
KeyError: 'missing'

The expected result should be 2. This pull request fixes the issue:

>>> body = Dict(a=1)
>>> body.freeze()
>>> getattr(body, 'missing', 2)
2

Note: This pull request is to replace #145 with a better implementation: #145 throws AttributeError for missing key access (body['missing_key']), but this pull request throws KeyError to be consistent with Python standards.