green_magic.data.interfaces

Complexity

Total Complexity

15

Size/Duplication

Total Lines	72
Duplicated Lines	0 %

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	TabularRetriever.row()	0	3	1
A	TabularRetriever.column()	0	3	1
A	TabularRetriever.nb_rows()	0	3	1
A	TabularRetriever.nb_columns()	0	3	1
A	TabularIterator.itercolumns()	0	3	1
A	TabularIterator.columnnames()	0	3	1
A	TabularRetriever.get_numerical_attributes()	0	3	1
A	TabularIterator.iterrows()	0	3	1
A	Normalization.__subclasshook__()	0	3	1
A	Encoding.encode()	0	3	1
A	TabularReporter.column_names()	0	3	1
A	Discretization.discretize()	0	3	1
A	Encoding.__subclasshook__()	0	3	1
A	Discretization.__subclasshook__()	0	3	1
A	Normalization.normalize()	0	3	1

from abc import ABCMeta, abstractmethod, ABC

__all__ = ['TabularIterator', 'TabularRetriever', 'TabularReporter', 'Normalization', 'Discretization', 'Encoding', 'Visitor', 'Component']


class TabularRetriever(ABC):
    @abstractmethod
    def column(self, identifier, data):
        raise NotImplementedError
    @abstractmethod
    def row(self, identifier, data):
        raise NotImplementedError
    @abstractmethod
    def nb_columns(self, data):
        raise NotImplementedError
    @abstractmethod
    def nb_rows(self, data):
        raise NotImplementedError
    @abstractmethod
    def get_numerical_attributes(self, data):
        raise NotImplementedError


class TabularIterator(ABC):
    @abstractmethod
    def iterrows(self, data):
        raise NotImplementedError
    @abstractmethod
    def itercolumns(self, data):
        raise NotImplementedError
    @abstractmethod
    def columnnames(self, data):
        raise NotImplementedError

class TabularReporter(ABC):
    @abstractmethod
    def column_names(self, data):
        raise NotImplementedError


class Normalization(metaclass=ABCMeta):

    @classmethod
    def __subclasshook__(cls, subclass):
        return hasattr(subclass, 'normalize') and callable(subclass.normalize)

    @abstractmethod
    def normalize(self, *args, **kwargs):
        raise NotImplementedError


class Discretization(metaclass=ABCMeta):

    @classmethod
    def __subclasshook__(cls, subclass):
        return hasattr(subclass, 'discretize') and callable(subclass.discretize)

    @abstractmethod
    def discretize(self, *args, **kwargs):
        raise NotImplementedError


class Encoding(metaclass=ABCMeta):

    @classmethod
    def __subclasshook__(cls, subclass):
        return hasattr(subclass, 'encode') and callable(subclass.encode)

    @abstractmethod
    def encode(self, *args, **kwargs):
        raise NotImplementedError