Escaping a literal dot (.
) is no longer (\\.
) rather double-dot (..
). Escaping a literal dot can still be done with bell (\b
)
The Data()
constructor only accepts keyword parameters. It no longer accepts a dict, nor does it attempt to clean the input. Replace Data(my_var)
with to_data(my_var)
This library defines a Data
class that can serve as a replacement for dict
, and acts much like a null-safe dataclass.
See the full documentation for all the features of
mo-dots
Define Data
using named parameters, just like you would a dict
>>> from mo_dots import Data
>>> Data(b=42, c="hello world")
Data({'b': 42, 'c': 'hello world'})
You can also wrap existing dict
s so they can be used like Data
>>> from mo_dots import to_data
>>> to_data({'b': 42, 'c': 'hello world'})
Data({'b': 42, 'c': 'hello world'})
Access properties with attribute dots: a.b == a["b"]
. You have probably seen this before.
Access properties by dot-delimited path.
>>> a = to_data({"b": {"c": 42}})
>>> a["b.c"] == 42
True
If a property does not exist then return Null
rather than raising an error.
>>> a = Data()
>>> a.b == None
True
>>> a.b.c == None
True
>>> a[None] == None
True
No need to make intermediate dicts
>>> a = Data()
>>> a["b.c"] = 42 # same as a.b.c = 42
a == {"b": {"c": 42}}
Use +=
to add to a property; default zero (0
)
>>> a = Data()
a == {}
>>> a.b.c += 1
a == {"b": {"c": 1}}
>>> a.b.c += 42
a == {"b": {"c": 43}}
Use +=
with a list ([]
) to append to a list; default empty list ([]
)
>>> a = Data()
a == {}
>>> a.b.c += [1]
a == {"b": {"c": [1]}}
>>> a.b.c += [42]
a == {"b": {"c": [1, 42]}}
The standard Python JSON library does not recognize Data
as serializable. You may overcome this by providing default=from_data
; which converts the data structures in this module into Python primitives of the same.
from mo_dots import from_data, to_data
s = to_data({"a": ["b", 1]})
result = json.dumps(s, default=from_data)
Alternatively, you may consider mo-json which has a function value2json
that converts a larger number of data structures into JSON.
This library is the basis for a data transformation algebra: We want a succinct way of transforming data in Python. We want operations on data to result in yet more data. We do not want data operations to raise exceptions. This library is solves Python's lack of consistency (lack of closure) under the dot (.
) and slice [::]
operators when operating on data objects.