A warning/error should be given if an element has the key "items"

[Tomen]

Suppose you have

parent:
  items:
    - a```

Then items cannot be accessed, since it is used for the internal Python iterator. A warning might be appropriate.

[jr-b-reiterer]

The same problem appears when an item has the key 'values'.

[ferdnyc]

That's going to be a problem with a name that overlaps any Munch instance method... or even class methods, for that matter:

>>> import munch
>>> d = {'fromDict': 1, 'a': 2}
>>> m = munch.Munch.fromDict(d)
>>> m.fromDict
<bound method Munch.fromDict of <class 'munch.Munch'>>
>>> # Everything listed here (except m.a) is off limits
>>> m.<tab><tab>
m.a            m.fromJSON(    m.items()      m.setdefault(  m.update(      
m.clear()      m.fromYAML(    m.keys()       m.toDict()     m.values()     
m.copy()       m.fromkeys(    m.pop(         m.toJSON(                     
m.fromDict(    m.get(         m.popitem()    m.toYAML(                     

Those members can actually be accessed, though, using either subscript notation or the .get() method instead of attribute notation:

>>> m.update({'values': 3, 'items': 4})
>>> m
Munch({'fromDict': 1, 'a': 2, 'values': 3, 'items': 4})
>>> m['values']
3
>>> m.get('items')
4

Given that the members can still be accessed, and given that dotted notation access is always intentional, and never programmatic (meaning, you can't ever have generated code that will try to access m.values, you have to write that yourself), I'm not sure if a warning is really necessary.

Anyone who works with Python dicts should know that if they have a dictionary member called values, or items, or any other reserved method, then they won't be able to use dotted attribute notation to access those members.

The docs also give this example of creating new keys by setting reserved attribute names, which works but causes its own set of problems:

>>> m = munch.Munch(a=1, b=2)
>>> m
Munch({'a': 1, 'b': 2})
>>> m.values = 3
>>> m
Munch({'a': 1, 'b': 2})
>>> m.values
3
>>> m.values()
Traceback (most recent call last):
  File "<python-input-42>", line 1, in <module>
    m.values()
    ~~~~~~~~^^
TypeError: 'int' object is not callable

(And, again, that could never happen unless a developer actually wrote that code themselves, so the fact that it breaks is just an indication — not that one was really needed — that we shouldn't do that.)

Really there are a lot of ways to construct a Munch with keys that can't be accessed directly as dotted attributes. Not that it won't still create them! Another example they use a lot in the docs is with_spaces, something like this:

>>> import munch
>>> m = munch.Munch({'a b': 1, 'c!d': 2})
>>> m
Munch({'a b': 1, 'c!d': 2})
>>> m.<tab><tab>
m.a b          m.fromDict(    m.get(         m.popitem()    m.toYAML(      
m.c!d          m.fromJSON(    m.items()      m.setdefault(  m.update(      
m.clear()      m.fromYAML(    m.keys()       m.toDict()     m.values()     
m.copy()       m.fromkeys(    m.pop(         m.toJSON(                     
>>> # Whaaaaaaa?
>>> getattr(m, 'a b') is m['a b']
True
>>> getattr(m, 'c!d') is m['c!d']
True
>>> # (Just don't try to type m.a b or m.c!d, you're not gonna get far)

[ferdnyc]

Oh, I forgot to mention, with this one...

>>> m = munch.Munch(a=1, b=2)
>>> m
Munch({'a': 1, 'b': 2})
>>> m.values = 3
>>> m
Munch({'a': 1, 'b': 2})
>>> m.values
3
>>> m.values()
Traceback (most recent call last):
  File "<python-input-42>", line 1, in <module>
    m.values()
    ~~~~~~~~^^
TypeError: 'int' object is not callable

You can also call the overridden methods via the dict class, instead of the instance — though it will still be missing the reserved members:

>>> m
Munch({'a': 1, 'b': 2})
>>> m.values
3
>>> dict.values(m)
dict_values([1, 2])