schema.py

class Schema:
    """Class Schema
    """
    attrs = [
        ('attributes', {}),
        ('empty_request', None),
        ('model_class', None)
    ]

    class Meta:
        """Class Meta
        """
        attributes = {}
        empty_request = None
        model_class = None

    def __init__(self, sql_name: bool = False, many: bool = False) -> None:
        for attr in self.attrs:
            if not hasattr(self.Meta, attr[0]):
                setattr(self.Meta, attr[0], attr[1])

        self.sql_name = sql_name
        self.many = many

    def _response(self, value):
        return value

    def _serialiazer(self, value):
        return self._response(value)

    def _load_attributes(self):
        for item, nclass in self.__class__.__dict__.items():
            if not (item.startswith('_') or item.endswith('_')):
                self.Meta.attributes[item] = nclass

    def _format(self, data: dict = None) -> dict:
        """Method Format
        """
        self._load_attributes()
        data_class = {}

        for item in self.Meta.attributes:
            if hasattr(data, item):
                formatting_type = self.Meta.attributes.get(item)

                if formatting_type:
                    if self.sql_name:
                        column = getattr(self.Meta.model_class, item)
                        data_class[column.name] = formatting_type(getattr(data, item))
                    else:
                        data_class[item] = formatting_type(getattr(data, item))
        return data_class

    def dump_dict(self, data: dict = None) -> dict:
        """Method Dump Dict
        """
        if data:
            if self.many:
                list_data = []
                for item in data:
                    list_data.append(self._format(item))

                return self._serialiazer(list_data)

            return self._serialiazer(self._format(data))

        return self._serialiazer(self.Meta.empty_request)

    def dump_list(self, data: dict = None) -> list:
        """Method Dump List
        """
        if data:
            if self.many:
                list_data = []
                for item in data:
                    data_formated = self._format(item)
                    for field in data_formated:
                        list_data.append(data_formated.get(field))
                return self._serialiazer(list_data)

            data = self._format(data)
            return self._serialiazer([data.get(item) for item in data])

        return self._serialiazer(self.Meta.empty_request)