mo-dots 10.614.24125

More Dots! Dot-access to Python dicts like Javascript

More Dots!

Changes in version 10.x.x

• Data now navigates @dataclass and namedtuple instances. All other types must be registered to be treated as data, otherwise they are assumed to be atoms.

  class MyType:
      ...
    
  register_type(MyType)
  

• Removed datawrap. It is now object_to_data

• Comparision with None no longer works in all cases.

  Instead of

  FlatList() == None  
  

  you now use

  FlatList() == Null
  

  or

  is_missing(FlatList())
  

Changes in version 9.x.x

Escaping a literal dot (.) is no longer (\\.) rather double-dot (..). Escaping a literal dot can still be done with bell (\b)

Changes in version 5.x.x

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)

Overview

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

Create instances

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 box an existing dicts 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'})

Dot Access

Access properties with attribute dots: a.b == a["b"]. You have probably seen this before.

Path Access

Access properties by dot-delimited path.

>>> a = to_data({"b": {"c": 42}})
>>> a["b.c"] == 42
True

Null-Safe Access

If a property does not exist then return Null rather than raising an error.

>>> a = Data()
>>> a.b == Null
True
>>> a.b.c == Null
True
>>> a[None] == Null
True

Path assignment

No need to make intermediate dicts

>>> a = Data()
>>> a["b.c"] = 42   # same as a.b.c = 42
a == {"b": {"c": 42}}

Path accumulation

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]}}

Serializing to JSON

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.

Summary

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 also solves Python's lack of consistency (lack of closure) under the dot (.) and slice [::] operators when operating on data objects.

Full documentation