Metadata-Version: 1.1
Name: mo-dots
Version: 1.5.17206
Summary: More Dots! Dot-access to Python dicts like Javascript
Home-page: https://github.com/klahnakoski/mo-dots
Author: Kyle Lahnakoski
Author-email: kyle@lahnakoski.com
License: MPL 2.0
Description: More Dots!
        ==========
        
        Defines a ``Data`` class that is much like ``dict`` but with
        dot-property accessors, and a few other features:
        
        Quick Overview
        --------------
        
        This library defines a ``Data`` class that can serve as a replacement
        for ``dict``, with additional features.
        
        ::
        
            >>> from mo_dots import wrap, Data
        
        See the `full
        documentation <https://github.com/klahnakoski/mo-dots/tree/dev/docs>`__
        for all the features of Mo-Dots.
        
        Easy Definition
        ~~~~~~~~~~~~~~~
        
        Define ``Data`` using named parameters
        
        ::
        
            >>> Data(b=42, c="hello world")
            Data({'b': 42, 'c': 'hello world'})
        
        or wrap existing ``dict``\ s so they can be used like ``Data``
        
        ::
        
            >>> wrap({'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 = wrap({"b": {"c": 42}})
            >>> a["b.c"] == 42
            True
        
        Safe Access
        ~~~~~~~~~~~
        
        If a property does not exist then return ``Null`` rather than raising an
        error.
        
        ::
        
            >>> a = Data()
            a == {}
            >>> a.b == None
            True
            >>> a.b.c == None
            True
            >>> a[None] == None
            True
        
        Path assignment
        ~~~~~~~~~~~~~~~
        
        No need to make intermediate objects
        
        ::
        
            >>> a = Data()
            a == {}
            >>> 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]}}
        
        Transforming JSON Data in Python
        --------------------------------
        
        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.
        
        `Full
        documentation <https://github.com/klahnakoski/mo-dots/tree/dev/docs>`__
        
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Topic :: Software Development :: Libraries
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
