Mappable

Complexity

Total Complexity

16

Size/Duplication

Total Lines	77
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	7
Bugs	0	Features	0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__setattr__()	0	3	1
A	__delitem__()	0	3	1
A	__iter__()	0	3	1
A	insert()	0	4	1
A	remove()	0	4	1
A	__getattribute__()	0	3	1
A	popitem()	0	4	1
A	clear()	0	3	1
A	__getitem__()	0	3	1
A	__setitem__()	0	3	1
A	reverse()	0	4	1
A	pop()	0	4	1
A	sort()	0	4	1
A	update()	0	4	1
A	extend()	0	4	1
A	append()	0	4	1

"""Base classes for mapping."""

import abc
import functools
import logging

from .. import common

log = logging.getLogger(__name__)

_LOAD_BEFORE_METHODS = set()
_STORE_AFTER_METHODS = set()


def load_before(method):

This code seems to be duplicated in your project.

    """Decorator for methods that should load before call."""

    if getattr(method, '_load_before', False):
        return method

    _LOAD_BEFORE_METHODS.add(method.__name__)

    @functools.wraps(method)
    def wrapped(self, *args, **kwargs):
        """Decorated method."""
        if not _private_call(method, args):
            mapper = common.get_mapper(self)
            if mapper and mapper.modified:
                log.debug("Loading before call: %s", method.__name__)
                mapper.load()
                if mapper.auto_save_after_load:
                    mapper.save()
                    mapper.modified = False

        return method(self, *args, **kwargs)

    setattr(wrapped, '_load_before', True)

    return wrapped


def save_after(method):

This code seems to be duplicated in your project.

    """Decorator for methods that should save after call."""

    if getattr(method, '_save_after', False):
        return method

    _STORE_AFTER_METHODS.add(method.__name__)

    @functools.wraps(method)
    def wrapped(self, *args, **kwargs):
        """Decorated method."""
        result = method(self, *args, **kwargs)

        if not _private_call(method, args):
            mapper = common.get_mapper(self)
            if mapper and mapper.auto_save:
                log.debug("Saving after call: %s", method.__name__)
                mapper.save()

        return result

    setattr(wrapped, '_save_after', True)

    return wrapped


def _private_call(method, args, prefix='_'):
    """Determine if a call's first argument is a private variable name."""
    if method.__name__ in ('__getattribute__', '__setattr__'):
        assert isinstance(args[0], str)
        return args[0].startswith(prefix)
    else:
        return False


class Mappable(metaclass=abc.ABCMeta):
    """Base class for objects with attributes mapped to file."""

    # pylint: disable=no-member

    @load_before
    def __getattribute__(self, name):
        return object.__getattribute__(self, name)

    @save_after
    def __setattr__(self, name, value):
        super().__setattr__(name, value)

    @load_before
    def __iter__(self):
        return super().__iter__()

    @load_before
    def __getitem__(self, key):
        return super().__getitem__(key)

    @save_after
    def __setitem__(self, key, value):
        super().__setitem__(key, value)

    @save_after
    def __delitem__(self, key):
        super().__delitem__(key)

    @load_before
    @save_after
    def append(self, *args, **kwargs):

This method could be written as a function/class method.

        super().append(*args, **kwargs)

    @load_before
    @save_after
    def extend(self, *args, **kwargs):

This method could be written as a function/class method.

        super().extend(*args, **kwargs)

    @load_before
    @save_after
    def insert(self, *args, **kwargs):

This method could be written as a function/class method.

        super().insert(*args, **kwargs)

    @load_before
    @save_after
    def remove(self, *args, **kwargs):

This method could be written as a function/class method.

        super().remove(*args, **kwargs)

    @load_before
    @save_after
    def pop(self, *args, **kwargs):

This method could be written as a function/class method.

        super().pop(*args, **kwargs)

    @save_after
    def clear(self, *args, **kwargs):

This method could be written as a function/class method.

        super().clear(*args, **kwargs)

    @load_before
    @save_after
    def sort(self, *args, **kwargs):

This method could be written as a function/class method.

        super().sort(*args, **kwargs)

    @load_before
    @save_after
    def reverse(self, *args, **kwargs):

This method could be written as a function/class method.

        super().reverse(*args, **kwargs)

    @load_before
    @save_after
    def popitem(self, *args, **kwargs):

This method could be written as a function/class method.

        super().popitem(*args, **kwargs)

    @load_before
    @save_after
    def update(self, *args, **kwargs):

This method could be written as a function/class method.

        super().update(*args, **kwargs)


def patch_methods(instance):
    log.debug("Patching methods on: %r", instance)
    cls = instance.__class__

    for name in _LOAD_BEFORE_METHODS:
        try:
            method = getattr(cls, name)
        except AttributeError:
            log.trace("No method: %s", name)
        else:
            modified_method = load_before(method)
            setattr(cls, name, modified_method)
            log.trace("Patched to load before call: %s", name)

    for name in _STORE_AFTER_METHODS:
        try:
            method = getattr(cls, name)
        except AttributeError:
            log.trace("No method: %s", name)
        else:
            modified_method = save_after(method)
            setattr(cls, name, modified_method)
            log.trace("Patched to save after call: %s", name)