SerializableAttributesHolder

Complexity

Total Complexity

21

Size/Duplication

Total Lines	56
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
C	as_dict()	0	12	8
B	conv()	0	9	6
B	from_dict()	0	15	6
A	_select_class()	0	3	1
A	as_json()	0	3	1
A	deserialize_attribute()	0	3	1
A	_test_can_import_json()	0	4	1
A	from_json()	0	8	3

import json

from .attributesholder import AttributesHolder

class SerializableAttributesHolder(AttributesHolder):
    """AttributesHolder with methods handling serialization and
    deserialization according to the PPP datamodel specification."""
    def as_dict(self):
        """Returns a JSON-serializeable object representing this tree."""
        def conv(v):
            if isinstance(v, SerializableAttributesHolder):
                return v.as_dict()
            elif isinstance(v, list):
                return [conv(x) for x in v]
            elif isinstance(v, dict):
                return {x:conv(y) for (x,y) in v.items()}
            else:
                return v
        return {k.replace('_', '-'): conv(v) for (k, v) in self._attributes.items()}
    def as_json(self):
        """Return a JSON dump of the object."""
        return json.dumps(self.as_dict())

    @staticmethod
    def _test_can_import_json(data):
        """Sanity check on input JSON data"""
        pass

    @classmethod
    def from_json(cls, data):
        """Decode a JSON string and inflate a node instance."""
        # Decode JSON string
        assert isinstance(data, str)
        data = json.loads(data)
        assert isinstance(data, dict)
        return cls.from_dict(data)

    @classmethod
    def from_dict(cls, data):
        cls._test_can_import_json(data)

        # Find a class that will deserialize the dict as specifically
        # as possible
        while True:
            cls2 = cls._select_class(data)
            if cls is cls2:
                break
            cls = cls2
        conv = (lambda k,v: cls.deserialize_attribute(k, v)
                            if isinstance(v, dict) else v)
        data = {k.replace('-', '_'): conv(k,v) for (k, v) in data.items()}
        return cls(**data)

    @classmethod
    def deserialize_attribute(cls, key, value):
        return cls.from_dict(value)

    @classmethod
    def _select_class(cls, data):
        return cls