wbolster/sanest

sane nested dictionaries and lists for python

sanest

sane nested dictionaries and lists

sanest is a python (3+) library that makes it easy to work with nested dictionaries and lists, such as those commonly used in json formats, without losing your sanity.

• Documentation: https://sanest.readthedocs.io/
• Python Package Index (PyPI): https://pypi.python.org/pypi/sanest/
• Source code and issue tracker: https://github.com/wbolster/sanest

sanest's Issues

nested walk helpers dict.walk() and list.walk()

support complex types in dict.__contains__

['b', [int]] in d should work

weakref support

it is not possible to create a (direct) weak reference to a sanest.dict or sanest.list. this is just like their built-in dict and list counterparts.

for the built-in types, this can be "fixed" using a subclass, as outlined in the weakref docs:

Several built-in types such as list and dict do not directly support weak references but can add support through subclassing:

  class Dict(dict):
      pass
  obj = Dict(red=1, green=2, blue=3)   # this object is weak referenceable

since sanest.dict and sanest.list prevent subclassing, this trick won't work for us.

it is unclear to me whether this is a problem at all. feel free to chime in if you have valid use cases.

helper to delete all None values from a (nested) dictionary

null (None) values in dictionaries are typically unwanted. a helper to recursively clean those would be nice, e.g. .clean(deep=True) (better name?)

nested path support in list.pop()

path support for list.pop seems not very useful, but it should be there for completeness anyway.

other (or no) validations to make sanest work with non-json data models

backport to python 2?

perhaps it makes sense, depending on demand.

(for the initial version(s) i wanted to avoid the complexity.)

typed list.__contains__

there should be a way to do a containment check on a list while also specifying the expected type. both the value and the type to be checked against come from the caller.

perhaps

l = sanest.list(['foo', 'bar'])
['foo', str] in l  # True
['foo', int] in l  # true

Provide .deepcopy() method instead of .copy(deep=True)

It's a bit cleaner as an API.

add .deepcopy()

prevent subclassing?

it is a bad idea to subclass sanest containers, since it is very easy to complety break functionality and implied invariants, so perhaps it should just not be allowed. even consenting adults should adhere to it. ;)

comparison to similar projects in docs

read-only dict/list

it may be a nice idea to have a read-only version of a (nested) dict/list to avoid unintended modifications.

something like this perhaps?

d = sanest.dict(...)
ro = d.read_only()

ro would be a read-only view on d. (cf. types.MappingProxy from the stdlib).