Suppose I have this:

from munch import munchify


def gen_dict():
    return munchify({'foo': 'bar', 'id': 123})    

What is the recommended way to type annotate the return value of gen_dict()? Simply munch.Munch?

What are wheels? Wheels are the new standard of Python distribution and are intended to replace eggs. Support is offered in pip >= 1.4 and setuptools >= 0.8.

Advantages of wheels Faster installation for pure Python and native C extension packages. Avoids arbitrary code execution for installation. (Avoids setup.py) Installation of a C extension does not require a compiler on Windows or macOS. Allows better caching for testing and continuous integration. Creates .pyc files as part of installation to ensure they match the Python interpreter used. More consistent installs across platforms and machines.

https://pythonwheels.com/

Must appreciated!

I'm not sure if this is the best way to go about it, but I need Munch to munchify any dicts it is assigned:

>>> from munch import *
>>> m = Munch()
>>> m.foo = {'bar':'baz'}
>>> m
Munch({'foo': Munch({'bar': 'baz'})})
>>> m.foo.bar
'baz'

Added a subclass of Munch: DefaultMunch, which returns a user-defined value when a requested key is not in the collection. The interface and behaviour is similar to collections.defaultdict, except that:

• Only a constant value is returned; there is no default_factory method.
• Retrieval of a missing value does not change the size of the collection.

DefaultMuch.__default__ is a special attribute that won't be stored in the dictionary.

The construction signature is based on defaultdict, where the default value is the first argument:

b = DefaultMunch(default, {})

This seemed cleaner than having a special keyword argument like _default=foo or so. However, the signature of fromDict is different, since it didn't already take any keyword arguments:

b = DefaultMunch.fromDict({}, default=default)

This PR supercedes #15. To get similar behaviour to undefined, a sentinel can be used as the default value of DefaultMunch.

from munch import Munch

d = {'hello_world': {'cooldown': 30,
                 'items_per_replica': 3,
                 'replicas': {'max': 6, 'min': 3}},
 }
m = Munch(d)
m.hello_world.replicas.min

Traceback (most recent call last):
  File "test.py", line 8, in <module>
    m.hello_world.replicas.min
AttributeError: 'dict' object has no attribute 'replicas'

Added a sub-class of Munch, UMunch, which returns undefined for missing attributes. You can use it like this:

b = UMunch()
b.foo = 1
assert b.foo == 1
assert b.bar is undefined

# This does not raise an exception:
if b.bar == 2:
     ...

munchify has been changed to take an optional factory argument, which defaults to Munch. Munch.fromDict is now a class method, and returns the appropriate type (i.e. UMunch.fromDict returns a UMunch object). Tests have been updated.

The behaviour of __getitem__ has not been changed. It could be made to return undefined for missing keys; I don't feel strongly about it either way.

I'm not sure if this feature is welcome, but I'm happy to discuss it.

For people who have "bunch" spread all over the codebase from the library, this adds the old Bunch/bunchify/unbunchify names that call Munch/munchify/unmunchify respectively. This allows having the change in code when switching to munch be restricted just to a library name change.

Hi,

I felt the need to have a RecursiveMunch class, which is similar to DefaultFactoryMunch, except that it creates an instance of itself to generate values for missing keys, instead of a user-specified function.

Regards,

Guillaume Rochette

It would be great if the standard python vars(obj) and the __dict__ attributes are respected, so that Munch instances could be used in a standard way.

The toDict() syntax is not standard, and causes the implementation to leak through abstraction layers.

Thanks for this library!

If I define an object that inherits from Munch:

class Foo(Munch): def init(self, bar): self.bar = bar

and then do:

myfoo = Foo("mybar")

the resulting myfoo object has no dict attribute, so while I can do myfoo.toDict(), I can't do myfoo.dict which would be nice to allow it to be treated like any other object.

@property def dict(self): return self.toDict()

would allow myfoo.dict to work the same way as toDict()

I am trying to create an Munch object and when I serialize it to JSON and deserialize it, I am getting an dict, rather than an object.

a = Munch(status_code= 200, text= {'code': '1234'})

a.status_code # result 200

a_js=json.dumps(a)

json.loads(a_js).status_code # AttributeError: 'dict' object has no attribute 'status_code'

Here is a minimal working example, which is broken. Is this already fixed?

munchify((1,2,[{'A': 'B'}])) Result: (1, 2, [Munch({'A': 'B'}), Munch({'A': 'B'})]) Expected: (1, 2, [Munch({'A': 'B'})])

Authenticate the munch Pypi page as an official distribution by mentioning it / linking to it in the readme.

Another way to make the pypi namespace evident would be to add an Installation section that says pip install munch

This creates easy confidence that pip's 'munch' is this munch, reducing concerns as we worry more about the providence of our dependencies.

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.

I think these should read namedtuple:

https://github.com/Infinidat/munch/blob/d0aeb06/munch/init.py#L461 https://github.com/Infinidat/munch/blob/d0aeb06/munch/init.py#L523

Currently, if a custom class inherits from tuple and an instance ends up with a _make attribute, munch will call it when the __dict__ attribute is accessed. Unlikely to happen by chance, but munch also inserts itself into SafeLoader, so it should probably err on the defensive side.

On a system without Setuptools pre-installed, munch fails on import:

~ $ pip-run munch -- -c "import munch"
Collecting munch
  Using cached munch-2.5.0-py2.py3-none-any.whl (10 kB)
Collecting six
  Using cached six-1.15.0-py2.py3-none-any.whl (10 kB)
Installing collected packages: six, munch
Successfully installed munch-2.5.0 six-1.15.0
Traceback (most recent call last):
  File "<string>", line 1, in <module>
  File "/var/folders/c6/v7hnmq453xb6p2dbz1gqc6rr0000gn/T/pip-run-y4m51iwb/munch/__init__.py", line 24, in <module>
    import pkg_resources
ModuleNotFoundError: No module named 'pkg_resources'

The project should remove use of pkg_resources or declare the dependency on setuptools.