DotDict

class DotDict[source]

Subclass of dict, with “dot” (attribute) access to keys, a pretty-printed repr, which indents and truncates large containers, and a JSON repr for Jupyter Lab.

Any dicts stored in DotDict are returned as DotDicts, to allow chained attribute access. Any lists stored in DotDict are returned as DotLists, which return any contained dict items as DotDicts, allowing chained attribute access past list indexing.

The repr() of a DotDict is truncated for readability, but str() is not.

Example

>>> d = DotDict(a=1, b=[{"foo": "bar"}])
>>> d.a
    1
>>> d["a"]
    1
>>> d.b
    [
      {
        'foo': 'bar'
      }
    ]
>>> d.b[0].foo
    'bar'
asdict() → a deep copy of D, where any DotDicts or DotLists contained are converted to plain types.[source]

Raises RuntimeError if the container is recursive (contains itself as a value).

get(k[, d]) → D[k] if k in D, else d. d defaults to None.[source]

Values that are dicts or lists are cast to DotDicts and DotLists.

items()[source]

Equivalent to dict.items in this Python version. Values that are plain dicts or lists are returned as DotDicts or DotLists.

iteritems() → an iterator over the (key, value) items of D[source]

Values that are dicts or lists are cast to DotDicts and DotLists. Only implemented in Python 2.

itervalues() → an iterator over the values of D[source]

Values that are dicts or lists are cast to DotDicts and DotLists. Only implemented in Python 2.

pop(k[, d]) → v, remove specified key and return the corresponding value.[source]

If key is not found, d is returned if given, otherwise KeyError is raised. If v is a dict or list, it is returned as a DotDict or DotList.

popitem() → (k, v), remove and return some (key, value) pair as a[source]

2-tuple; but raise KeyError if D is empty. If v is a dict or list, it is returned as a DotDict or DotList.

setdefault(k[, d]) → D.get(k,d), also set D[k]=d if k not in D[source]

If d is a dict or list, it is returned as a DotDict or DotList.

values()[source]

Equivalent to dict.values in this Python version. Values that are plain dicts or lists are returned as DotDicts or DotLists.

class DotDict_items(dotdict)[source]

Wrapper around a dict_values object that yields dicts and lists as DotDicts and DotLists when iterated.

isdisjoint(iterable)[source]

Return True if the view and the given iterable have a null intersection.

class DotDict_values(dotdict)[source]

Wrapper around a dict_values object that yields dicts and lists as DotDicts and DotLists when iterated.

class DotDict_view(dotdict)[source]

Wrapper around a dictionary view object that yields dicts and lists as DotDicts and DotLists when iterated.

class DotList[source]

Returns contained dicts as DotDicts (and contained lists as DotLists), soley to allow attribute access past list indexing

aslist() → a deep copy of L, where any DotDicts or DotLists contained are converted to plain types.[source]

Raises RuntimeError if the container is recursive (contains itself as a value).

pop([index]) → item -- remove and return item at index (default last).[source]

If item is a dict or list, it is returned as a DotDict or DotList. Raises IndexError if list is empty or index is out of range.

Properties

class GenericProperties[source]

A wrapper object to allow constructing filter expressions using properties.

You can construct filter expression using the ==, !=, <, >, <= and >= operators as well as the like() method. You cannot use the boolean keywords and and or because of Python language limitations; instead you can combine filter expressions with & (boolean “and”) and | (boolean “or”).

class Properties(*args)[source]

A wrapper object to allow constructing filter expressions using properties

class Property(name, parts=None)[source]

A wrapper object for a single property

like(other)[source]

Compare against a wildcard string.

This allows for wildcards, e.g. like("bar%foo") where any string that starts with 'bar' and ends with 'foo' will be matched.

This uses the SQL LIKE syntax with single character wildcard '_' and arbitrary character wildcard '%'.

To escape either of these wilcard characters prepend it with a backslash, which becomes a double backslash in the python string, i.e. use like("bar\\%foo") to match exactly 'bar%foo'.