arekit 0.24.0__py3-none-any.whl

arekit/common/entities/base.py

@@ -0,0 +1,51 @@
+class Entity(object):
+
+    def __init__(self, value, e_type, childs=None, display_value=None, group_index=None):
+        assert(isinstance(value, str) and len(value) > 0)
+        assert(isinstance(e_type, str) or e_type is None)
+        assert(isinstance(display_value, str) or display_value is None)
+        assert(isinstance(group_index, int) or group_index is None)
+        assert(isinstance(childs, list) or childs is None)
+        self.__value = value
+        self.__type = e_type
+        self.__display_value = display_value
+        self.__group_index = group_index
+        self.__childs = childs
+
+    @property
+    def GroupIndex(self):
+        return self.__group_index
+
+    @property
+    def Value(self):
+        return self.__value
+
+    @property
+    def DisplayValue(self):
+        """ Now, we consider the default value in case
+            of the undefined caption, and display_value otherwise.
+        """
+        return self.__value if self.__display_value is None else self.__display_value
+
+    @property
+    def Type(self):
+        return self.__type
+
+    def set_display_value(self, caption):
+        """ Caption allows to customize the original value.
+            Required for optional value modification.
+        """
+        assert(isinstance(caption, str))
+        self.__display_value = caption
+
+    def set_group_index(self, value):
+        assert(isinstance(value, int) and value >= -1)
+        assert(self.__group_index is None)
+        self.__group_index = value
+
+    def iter_childs(self):
+        if self.__childs is None:
+            return
+            yield
+        for child in self.__childs:
+            yield child

arekit/common/entities/collection.py

@@ -0,0 +1,72 @@
+class EntityCollection(object):
+    """ Collection of annotated entities
+    """
+
+    class KeyType:
+        BY_SYNONYMS = 0
+        BY_VALUE = 1
+
+    def __init__(self, entities, value_to_group_id_func):
+        assert(isinstance(entities, list))
+        assert(callable(value_to_group_id_func))
+
+        self.__entities = entities
+        self.__value_to_group_id_func = value_to_group_id_func
+
+        self.__by_value = self.create_index(entities=entities,
+                                            key_func=lambda e: e.Value)
+
+        self.__by_synonyms = self.create_index(
+            entities=entities,
+            key_func=lambda e: value_to_group_id_func(e.Value))
+
+    @staticmethod
+    def __value_or_none(d, key):
+        return d[key] if key in d else None
+
+    # region protected methods
+
+    def _sort_entities(self, key):
+        assert(callable(key))
+        self.__entities.sort(key=key)
+
+    # endregion
+
+    # region public methods
+
+    @staticmethod
+    def create_index(entities, key_func):
+        index = {}
+        for e in entities:
+            key = key_func(e)
+            if key in index:
+                index[key].append(e)
+            else:
+                index[key] = [e]
+        return index
+
+    def get_entity_by_index(self, index):
+        assert(isinstance(index, int))
+        return self.__entities[index]
+
+    def try_get_entities(self, value, group_key):
+        assert(isinstance(value, str))
+
+        if group_key == self.KeyType.BY_SYNONYMS:
+            key = self.__value_to_group_id_func(value)
+            return self.__value_or_none(self.__by_synonyms, key)
+        if group_key == self.KeyType.BY_VALUE:
+            return self.__value_or_none(self.__by_value, value)
+
+    # endregion
+
+    # region base methods
+
+    def __len__(self):
+        return len(self.__entities)
+
+    def __iter__(self):
+        for entity in self.__entities:
+            yield entity
+
+    # endregion

arekit/common/entities/str_fmt.py

@@ -0,0 +1,8 @@
+from arekit.common.entities.types import OpinionEntityType
+
+
+class StringEntitiesFormatter(object):
+
+    def to_string(self, original_value, entity_type):
+        assert(isinstance(entity_type, OpinionEntityType))
+        raise NotImplementedError()

arekit/common/entities/types.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class OpinionEntityType(Enum):
+    Object = 1
+    Subject = 2
+    SynonymSubject = 3
+    SynonymObject = 4
+    Other = 5

arekit/common/experiment/api/base_samples_io.py

@@ -0,0 +1,20 @@
+class BaseSamplesIO(object):
+    """ Represents base experiment utils for input/output for:
+        samples -- data that utilized for experiments;
+        results -- evaluation of experiments.
+    """
+
+    @property
+    def Reader(self):
+        raise NotImplementedError()
+
+    @property
+    def Writer(self):
+        """ For serialization
+        """
+        raise NotImplementedError()
+
+    def create_target(self, data_type):
+        """ Path for reaiding/viewing
+        """
+        raise NotImplementedError()

arekit/common/experiment/data_type.py

@@ -0,0 +1,17 @@
+from enum import Enum
+
+
+class DataType(Enum):
+    """
+    Describes collection types that supportes in
+    current implementation, and provides by collections.
+    """
+
+    Train = 1
+
+    Test = 2
+
+    Dev = 3
+
+    Etalon = 4
+

arekit/common/frames/connotations/descriptor.py

@@ -0,0 +1,17 @@
+class FrameConnotationDescriptor(object):
+    """
+    Polarity description between source (Agent) towards dest (Theme)
+    The latter is related to the roles of frame polarity.
+    """
+
+    @property
+    def Source(self):
+        raise NotImplementedError()
+
+    @property
+    def Destination(self):
+        raise NotImplementedError()
+
+    @property
+    def Label(self):
+        raise NotImplementedError()

arekit/common/frames/connotations/provider.py

@@ -0,0 +1,4 @@
+class FrameConnotationProvider(object):
+
+    def try_provide(self, frame_id):
+        raise NotImplementedError()

arekit/common/frames/text_variant.py

@@ -0,0 +1,43 @@
+from arekit.common.frames.variants.base import FrameVariant
+
+
+class TextFrameVariant(object):
+    """
+    FrameVariant in a text, i.e. related object provides position in text.
+    """
+
+    def __init__(self, variant):
+        assert(isinstance(variant, FrameVariant))
+        self.__variant = variant
+        self.__is_negated = False
+
+    # region properties
+
+    @property
+    def Variant(self):
+        return self.__variant
+
+    @property
+    def IsNegated(self):
+        return self.__is_negated
+
+    # endregion
+
+    # region public methods
+
+    def iter_terms(self):
+        for term in self.__variant.iter_terms():
+            yield term
+
+    def set_is_negated(self, value):
+        assert(isinstance(value, bool))
+        self.__is_negated = value
+
+    # endregion
+
+    # region overriden
+
+    def __len__(self):
+        return len(self.__variant)
+
+    # endregion

arekit/common/frames/variants/base.py

@@ -0,0 +1,21 @@
+class FrameVariant(object):
+
+    def __init__(self, terms, frame_id):
+        assert(isinstance(terms, list))
+        assert(isinstance(frame_id, str))
+        self.__terms = terms
+        self.__frame_id = frame_id
+
+    @property
+    def FrameID(self):
+        return self.__frame_id
+
+    def get_value(self):
+        return " ".join(self.__terms)
+
+    def iter_terms(self):
+        for term in self.__terms:
+            yield term
+
+    def __len__(self):
+        return len(self.__terms)

arekit/common/frames/variants/collection.py

@@ -0,0 +1,60 @@
+from collections.abc import Iterable
+from arekit.common.frames.variants.base import FrameVariant
+
+
+class FrameVariantsCollection(object):
+
+    def __init__(self):
+        self.__variants = {}
+        self.__frames_list = []
+
+    # region private methods
+
+    @staticmethod
+    def __register_frame(frames_dict, frames_list, id):
+        assert(isinstance(id, str))
+        if id not in frames_dict:
+            frames_dict[id] = len(frames_list)
+            frames_list.append(id)
+        return frames_dict[id]
+
+    # endregion
+
+    # region public methods
+
+    def fill_from_iterable(self, variants_with_id, overwrite_existed_variant, raise_error_on_existed_variant):
+        assert(isinstance(variants_with_id, Iterable))
+        assert(isinstance(overwrite_existed_variant, bool))
+        assert(isinstance(raise_error_on_existed_variant, bool))
+        assert(len(self.__variants) == 0)
+        assert(len(self.__frames_list) == 0)
+
+        frames_dict = {}
+        for frame_id, variant in variants_with_id:
+            self.__register_frame(frames_dict, self.__frames_list, frame_id)
+
+            if variant in self.__variants:
+                if raise_error_on_existed_variant:
+                    raise Exception("Variant '{variant}' already registered".format(variant=variant))
+                if not overwrite_existed_variant:
+                    continue
+
+            self.__variants[variant] = FrameVariant(terms=variant.split(), frame_id=frame_id)
+
+    def get_frame_by_index(self, index):
+        return self.__frames_list[index]
+
+    def get_variant_by_value(self, value):
+        return self.__variants[value] if value in self.__variants else None
+
+    def has_variant(self, value):
+        return value in self.__variants
+
+    def iter_variants(self):
+        for value, variant in self.__variants.items():
+            yield value, variant
+
+    # endregion
+
+    def __len__(self):
+        return len(self.__variants)

arekit/common/labels/base.py

@@ -0,0 +1,19 @@
+class Label(object):
+
+    def __eq__(self, other):
+        assert(isinstance(other, Label))
+        return type(self) == type(other)
+
+    def __ne__(self, other):
+        assert(isinstance(other, Label))
+        return type(self) != type(other)
+
+    def __hash__(self):
+        return hash(self.to_class_str())
+
+    def to_class_str(self):
+        return self.__class__.__name__
+
+
+class NoLabel(Label):
+    pass

arekit/common/labels/provider/base.py

@@ -0,0 +1,7 @@
+class BasePairLabelProvider(object):
+
+    def __init__(self):
+        pass
+
+    def provide(self, source, target):
+        raise NotImplementedError()

arekit/common/labels/provider/constant.py

@@ -0,0 +1,14 @@
+from arekit.common.labels.provider.base import BasePairLabelProvider
+
+
+class ConstantLabelProvider(BasePairLabelProvider):
+    """ Providing a predefined label instance irrespective
+        from the source and target entity parameters.
+    """
+
+    def __init__(self, label_instance):
+        super(ConstantLabelProvider, self).__init__()
+        self.__label_instance = label_instance
+
+    def provide(self, source, target):
+        return self.__label_instance

arekit/common/labels/scaler/base.py

@@ -0,0 +1,85 @@
+from collections import OrderedDict
+
+from arekit.common.labels.base import NoLabel, Label
+
+
+class BaseLabelScaler(object):
+    """ NOTE:
+        Scaler -- set up conversion from int/uint to label and vice versa.
+    """
+
+    def __init__(self, uint_dict, int_dict):
+        assert(isinstance(uint_dict, OrderedDict))
+        assert(isinstance(int_dict, OrderedDict))
+        assert(len(uint_dict) == len(int_dict))
+
+        self.__uint_dict = uint_dict
+        self.__int_dict = int_dict
+
+        self.__ordered_labels = list(uint_dict.keys())
+        self.__no_label_instance = self.__find_no_label_instance(iter(uint_dict.keys()))
+
+    @property
+    def LabelsCount(self):
+        return len(self.__uint_dict)
+
+    def ordered_suppoted_labels(self):
+        return self.__ordered_labels
+
+    def get_no_label_instance(self):
+        if self.__no_label_instance is None:
+            raise Exception("NoLabel does no supported by this scaler")
+
+        return self.__no_label_instance
+
+    # region private methods
+
+    @staticmethod
+    def __find_no_label_instance(labels_it):
+        for label in labels_it:
+            if isinstance(label, NoLabel):
+                return label
+        return None
+
+    @staticmethod
+    def __ltoi(label, d):
+        assert(isinstance(label, Label))
+        assert(isinstance(d, OrderedDict))
+        return d[label]
+
+    @staticmethod
+    def __itol(value, d):
+        assert(isinstance(value, int))
+        assert(isinstance(d, OrderedDict))
+        for label, v in d.items():
+            if v == value:
+                return label
+
+    @staticmethod
+    def __has_value(value, d):
+        assert(isinstance(value, int))
+        assert(isinstance(d, OrderedDict))
+        for label, v in d.items():
+            if v == value:
+                return True
+        return False
+
+    # endregion
+
+    def classes_count(self):
+        return len(self.__uint_dict)
+
+    def label_to_uint(self, label):
+        return self.__ltoi(label, self.__uint_dict)
+
+    def label_to_int(self, label):
+        return self.__ltoi(label, self.__int_dict)
+
+    def uint_to_label(self, value):
+        return self.__itol(value, self.__uint_dict)
+
+    def int_to_label(self, value):
+        return self.__itol(value, self.__int_dict)
+
+    def support_int_value(self, value):
+        return self.__has_value(value, self.__int_dict)

arekit/common/labels/scaler/sentiment.py

@@ -0,0 +1,7 @@
+from arekit.common.labels.scaler.base import BaseLabelScaler
+
+
+class SentimentLabelScaler(BaseLabelScaler):
+
+    def invert_label(self, label):
+        raise NotImplementedError()

arekit/common/labels/scaler/single.py

@@ -0,0 +1,10 @@
+from collections import OrderedDict
+
+from arekit.common.labels.scaler.base import BaseLabelScaler
+
+
+class SingleLabelScaler(BaseLabelScaler):
+
+    def __init__(self, label, uint_label=0):
+        d = OrderedDict([(label, uint_label)])
+        super(SingleLabelScaler, self).__init__(uint_dict=d, int_dict=d)

arekit/common/labels/str_fmt.py

@@ -0,0 +1,55 @@
+from arekit.common.labels.base import Label
+
+
+# TODO. This should be moded into formatter.py
+class StringLabelsFormatter(object):
+    """ NOTE:
+        Set up convertion from string into label instance.
+    """
+
+    def __init__(self, stol):
+        """ stol: string to label dictionary
+                dictionary: string -> label_type
+        """
+        assert(isinstance(stol, dict))
+
+        for key, value in stol.items():
+            # Perfom parameters check.
+            assert(isinstance(key, str))
+            assert(issubclass(value, Label))
+
+        self._stol = stol
+        self.__supported_label_types = set(self._stol.values())
+
+    def __is_label_type_supported(self, label):
+        return label in self.__supported_label_types
+
+    def str_to_label(self, value):
+        assert(isinstance(value, str))
+
+        if not value in self._stol:
+            raise Exception("Label value `{}` is not supported.".format(value))
+
+        label_type = self._stol[value]
+        return label_type()
+
+    def label_to_str(self, label):
+        assert(isinstance(label, Label))
+
+        label_type = type(label)
+
+        if not self.__is_label_type_supported(label_type):
+            raise Exception("Label type {label} is not supported. Supported labels: [{values}]".format(
+                label=label_type, values=self.__supported_label_types))
+
+        for value, supported_label_type in self._stol.items():
+            if supported_label_type == label_type:
+                return value
+
+    def supports_label(self, label):
+        return type(label) in self.__supported_label_types
+
+    def supports_value(self, value):
+        assert(isinstance(value, str))
+        return value in self._stol
+

arekit/common/linkage/base.py

@@ -0,0 +1,44 @@
+from collections.abc import Iterable
+
+
+class LinkedDataWrapper(object):
+
+    def __init__(self, linked_data):
+        assert(isinstance(linked_data, Iterable))
+        self.__linked_data = list(linked_data)
+        self.__tag = None
+
+    @property
+    def RelatedDocID(self):
+        """ Linked data is limited to the particular document.
+        """
+        raise NotImplementedError()
+
+    @property
+    def First(self):
+        return self[0]
+
+    @property
+    def Tag(self):
+        return self.__tag
+
+    def set_tag(self, value):
+        self.__tag = value
+
+    def _get_data_label(self, item):
+        raise NotImplementedError()
+
+    def iter_labels(self):
+        for item in self.__linked_data:
+            yield self._get_data_label(item)
+
+    def __getitem__(self, item):
+        assert(isinstance(item, int))
+        return self.__linked_data[item]
+
+    def __iter__(self):
+        for data in self.__linked_data:
+            yield data
+
+    def __len__(self):
+        return len(self.__linked_data)

arekit/common/linkage/meta.py

@@ -0,0 +1,23 @@
+from arekit.common.linkage.base import LinkedDataWrapper
+
+
+class MetaEmptyLinkedDataWrapper(LinkedDataWrapper):
+    """ This is a placeholder data-wrapper utilized for passing system information
+        while iterating through the data pipelines.
+    """
+
+    def __init__(self, doc_id, meta_data=None):
+        """ meta_data:
+                optional parameter which serves any information need in further.
+        """
+        super(MetaEmptyLinkedDataWrapper, self).__init__([])
+        self.__doc_id = doc_id
+        self.__meta_data = meta_data
+
+    @property
+    def RelatedDocID(self):
+        return self.__doc_id
+
+    @property
+    def MetaData(self):
+        return self.__meta_data

arekit/common/linkage/opinions.py

@@ -0,0 +1,9 @@
+from arekit.common.linkage.base import LinkedDataWrapper
+from arekit.common.opinions.base import Opinion
+
+
+class OpinionsLinkage(LinkedDataWrapper):
+
+    def _get_data_label(self, item):
+        assert(isinstance(item, Opinion))
+        return item.Label

arekit/common/linkage/text_opinions.py

@@ -0,0 +1,22 @@
+from arekit.common.linkage.base import LinkedDataWrapper
+from arekit.common.text_opinions.base import TextOpinion
+
+
+class TextOpinionsLinkage(LinkedDataWrapper):
+
+    @property
+    def First(self):
+        first = super(TextOpinionsLinkage, self).First
+        assert(isinstance(first, TextOpinion))
+        return first
+
+    @property
+    def RelatedDocID(self):
+        return self.First.DocID
+
+    def get_linked_label(self):
+        return self.First.Label
+
+    def _get_data_label(self, item):
+        assert(isinstance(item, TextOpinion))
+        return item.Label