Skip to content

Abc

abstract base classes for the API models

BaseModel

Bases: ABC

base model this model is a base for all other ClashOfClans API response models can be inherited from

Source code in pyclasher/api/models/abc.py 
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
class BaseModel(ABC):
    def __new__(cls, data=None):
        if data is MISSING:
            return MISSING
        return super().__new__(cls)

    def __init__(self, data=None):
        if data is not None:
            self._data = data
        return

    def to_dict(self):
        return self._data

    def _get_properties(self):
        if isinstance(self._data, dict):
            return {
                name: prop.__get__(self)
                for name, prop in vars(type(self)).items()
                if isinstance(prop, property)
            }
        return self._data

    def _get_data(self, item):
        if self._data is None:
            return None
        if self._data is MISSING:
            raise RequestNotDone
        if item in self._data:
            return self._data[item]
        else:
            return MISSING

    def __str__(self):
        if self._data is MISSING:
            return f"{self.__class__.__name__}(RequestNotDone)"
        return f"{self.__class__.__name__}()"

    def __repr__(self):
        props = ', '.join(
            ('='.join((key, str(value)))
             for key, value in self._get_properties().items())
        )
        return f"{self.__class__.__name__}({props})"

__init__(data=None)

initialisation of the base model

:param data: the data dictionary, None or MISSING :return: None :rtype: None

Source code in pyclasher/api/models/abc.py 
13
14
15
16
def __init__(self, data=None):
    if data is not None:
        self._data = data
    return

to_dict()

method that returns the response as a dict

:return: response as a dict :rtype: dict | None | Missing

Source code in pyclasher/api/models/abc.py 
18
19
def to_dict(self):
    return self._data

IterBaseModel

Bases: ABC

iterative base model this model is an iterative base model for the ClashOfClans API response models can be inherited from

:ivar _len: length of the iterative data :type _len: int :ivar _data: a list of dicts containing the data :type _data: list[dict] | None

Source code in pyclasher/api/models/abc.py 
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
class IterBaseModel(ABC):
    _iter_rtype: Any

    def __new__(cls, data):
        if data is MISSING:
            return MISSING
        return super().__new__(cls)

    def __init__(self, data):
        self._data = data
        self._len = len(self._data) if self._data is not None else None
        return

    def to_dict_list(self):
        return self._data

    def __len__(self):
        if self._len is None and self._data is not None:
            self._len = len(self._data)
        return self._len

    def __getitem__(self, item):
        if self._data is MISSING:
            raise RequestNotDone
        if self._data is None:
            return None
        if isinstance(item, int):
            return self._iter_rtype(self._data[item])
        if isinstance(item, slice):
            return (self._iter_rtype(self._data[i])
                    for i in range(*item.indices(len(self._data))))
        raise NotImplementedError(f"there is no implementation for type "
                                  f"{item.__class__.__name__} in "
                                  f"{self.__class__.__name__}.__getitem__()")

    def __iter__(self):
        self._iter = iter(self._data)
        return self

    def __next__(self):
        return self._iter_rtype(next(self._iter))

    def __contains__(self, item):
        if isinstance(item, (self._iter_rtype, str)):
            for item_ in self:
                if item_ == item:
                    return True
            return False
        return NotImplemented

    def __str__(self):
        return f"{self.__class__.__name__}()"

    def __repr__(self):
        return (f"{self.__class__.__name__}(len={self._len}, type="
                f"{self._iter_rtype.__name__}, {list(self)})")

__init__(data)

initialisation of the iterative base model

:param data: a list of dicts containing the data :type data: list[dict] | None :return: None :rtype: None

Source code in pyclasher/api/models/abc.py 
61
62
63
64
def __init__(self, data):
    self._data = data
    self._len = len(self._data) if self._data is not None else None
    return

to_dict_list()

method that returns the response as a list of dicts

:return: response as a list of dicts :rtype: list[dict] | None | Missing

Source code in pyclasher/api/models/abc.py 
66
67
def to_dict_list(self):
    return self._data