green_magic.data.features.features_set

Complexity

Total Complexity

15

Size/Duplication

Total Lines	58
Duplicated Lines	0 %

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	BaseFeatureSet.from_raw_extractors()	0	4	1
A	FeatureSet.not_encoded()	0	5	3
A	FeatureManager.feature_configuration()	0	3	1
A	FeatureSet.encoded()	0	5	3
A	FeatureSet.binnable()	0	5	3
A	BaseFeatureSet.__getitem__()	0	2	1
A	BaseFeatureSet.__len__()	0	2	1
A	BaseFeatureSet.__iter__()	0	2	1

import attr

from green_magic.data.variables.types import NominalVariableType
from green_magic.data.features.features import TrackingFeature


@attr.s
class BaseFeatureSet:
    features = attr.ib(init=True, default=[])

    def __len__(self):
        return len(self.features)

    def __getitem__(self, item):
        return self.features[item]

    def __iter__(self):
        return iter(self.features)

    @classmethod
    def from_raw_extractors(cls, data):
        """Create a Feature for each of the lists in the input data (list). Inner lists must satisfy 0 < len(l)"""
        return [TrackingFeature.from_callable(*args) for args in data]


class FeatureSet(BaseFeatureSet):

    @property
    def encoded(self):
        for feature in self.features:
            if str(feature.state) == 'encoded':
                yield feature

    @property
    def not_encoded(self):
        for feature in self.features:
            if str(feature.state) != 'encoded':
                yield feature

    @property
    def binnable(self):
        for feature in self.features:
            if not isinstance(feature.var_type, NominalVariableType):
                yield feature


@attr.s
class FeatureManager:
    _feature_configuration = attr.ib(init=True)

    @property
    def feature_configuration(self):
        return self._feature_configuration

    @feature_configuration.setter
    def feature_configuration(self, feature_configuration):
        self._feature_configuration = feature_configuration