estruttura 1.0.1

Abstract data structures.

Overview

estruttura provides abstract data structures.

Motivation

estruttura was born out of the need for a similar interface between the datta and objetto packages.

Relationship

estruttura provides a Relationship class that contains information about the values stored in the Structures, such as typing (with support for runtime type checking), serialization, validation, conversion, etc.

>>> from six import string_types
>>> from estruttura import Relationship, exceptions
>>> def converter(value):
...     if isinstance(value, string_types) and "." in value:
...         return float(value)
...     elif not isinstance(value, float):
...         return int(value)
...
>>> def validator(value):
...     if value > 10:
...         raise exceptions.ValidationError(value)
...
>>> relationship = Relationship(types=(int, float), converter=converter, validator=validator)
>>> relationship.process_value("3.3")
3.3

Structures

estruttura offers all the class combinations of the concepts described below.

Private Structure

Holds data internally and only allow for changes privately.

User Structure

Allows for changing of the data by external clients (public).

Proxy Structure

Wraps another structure and acts as a view of its data. Proxy structures can even point to other proxy structures.

>>> from estruttura import ProxyMutableListStructure
>>> from estruttura.examples import MutableList
>>> l = MutableList(range(3))
>>> p = ProxyMutableListStructure(l)
>>> list(p) == [0, 1, 2]
True
>>> l.append(3)
>>> list(p) == [0, 1, 2, 3]
True

Immutable Structure

Only allows data changes through copying. Immutable structures are hashable.

>>> from estruttura.examples import ImmutableList
>>> l_a = ImmutableList()
>>> l_b = l_a.extend(range(3))
>>> list(l_b) == [0, 1, 2]
True

Mutable Structure

Allows in-place data changes. Mutable structures are not hashable.

>>> from estruttura.examples import MutableList
>>> l = MutableList()
>>> l.extend(range(3))
>>> list(l) == [0, 1, 2]
True

Dict Structure

Dictionary-like data structure class.

>>> from estruttura import Relationship
>>> from estruttura.examples import MutableDict
>>> class StrIntDict(MutableDict):
...     key_relationship = Relationship(converter=str)
...     relationship = Relationship(converter=int)
...
>>> StrIntDict({1: "1"})
StrIntDict({'1': 1})

List Structure

List-like data structure class.

>>> from estruttura import Relationship
>>> from estruttura.examples import MutableList
>>> class IntList(MutableList):
...     relationship = Relationship(converter=int)
...
>>> IntList(["1", 1, 1.0])
IntList([1, 1, 1])

Set Structure

Set-like data structure class.

>>> from estruttura import Relationship
>>> from estruttura.examples import MutableSet
>>> class IntSet(MutableSet):
...     relationship = Relationship(converter=int)
...
>>> IntSet({"1", 1, 1.0})
IntSet({1})

Structure

Dataclass-like structure class that has a schema defined by attributes.

>>> import math
>>> from estruttura import Attribute, Relationship, getter
>>> from estruttura.examples import ImmutableClass
>>> class Point(ImmutableClass):
...     x = Attribute()
...     y = Attribute()
...     d = Attribute(serializable=True)
...     @getter(d, dependencies=(x, y))
...     def _(self):
...         return math.sqrt(self.x**2 + self.y**2)
...
>>> Point(3, 4)
Point(3, 4, <d=5.0>)
>>> Point(3, 4).serialize() == {"x": 3, "y": 4, "d": 5.0}
True
>>> Point.deserialize({"x": 3, "y": 4})
Point(3, 4, <d=5.0>)