arekit 0.24.0__py3-none-any.whl

arekit/contrib/utils/pipelines/sources/sentinerel/entity_filter.py

@@ -0,0 +1,62 @@
+from arekit.common.entities.base import Entity
+from arekit.common.entities.types import OpinionEntityType
+from arekit.contrib.utils.entities.filter import EntityFilter
+
+
+class EntityHelper(object):
+    """ Named Entities formatting in text.
+        Based on OntoNotes5 collection tags:
+        https://catalog.ldc.upenn.edu/LDC2013T19
+    """
+
+    AGE = "AGE"
+    AWARD = "AWARD"
+    CITY = "CITY"
+    COUNTRY = "COUNTRY"
+    CRIME = "CRIME"
+    DATE = "DATE"
+    DISEASE = "DISEASE"
+    DISTRICT = "DISTRICT"
+    EVENT = "EVENT"
+    FACILITY = "FACILITY"
+    FAMILY = "FAMILY"
+    IDEOLOGY = "IDEOLOGY"
+    LANGUAGE = "LANGUAGE"
+    LAW = "LAW"
+    LOCATION = "LOCATION"
+    MONEY = "MONEY"
+    NATIONALITY = "NATIONALITY"
+    NUMBER = "NUMBER"
+    ORDINAL = "ORDINAL"
+    ORGANIZATION = "ORGANIZATION"
+    PENALTY = "PENALTY"
+    PERCENT = "PERCENT"
+    PERSON = "PERSON"
+    PRODUCT = "PRODUCT"
+    PROFESSION = "PROFESSION"
+    RELIGION = "RELIGION"
+    STATE_OR_PROVINCE = "STATE_OR_PROVINCE"
+    TIME = "TIME"
+    WORK_OF_ART = "WORK_OF_ART"
+
+
+class SentiNerelEntityFilter(EntityFilter):
+    """ Filter, oriented on sentiment related extraction task
+        within SentiNEREL dataset.
+    """
+
+    def is_ignored(self, entity, e_type):
+        """ Subject and Object could be one of the following object types:
+                [PERSON, ORGANIZATION, COUNTRY, PROFESSION]
+        """
+        assert(isinstance(entity, Entity))
+        assert(isinstance(e_type, OpinionEntityType))
+
+        supported = [EntityHelper.PERSON, EntityHelper.ORGANIZATION, EntityHelper.COUNTRY, EntityHelper.PROFESSION]
+
+        if e_type == OpinionEntityType.Subject:
+            return entity.Type not in supported
+        if e_type == OpinionEntityType.Object:
+            return entity.Type not in supported
+        else:
+            return True

arekit/contrib/utils/pipelines/sources/sentinerel/extract_text_opinions.py

@@ -0,0 +1,180 @@
+from arekit.common.data.doc_provider import DocumentProvider
+from arekit.common.experiment.data_type import DataType
+from arekit.common.labels.base import NoLabel
+from arekit.common.labels.provider.constant import ConstantLabelProvider
+from arekit.common.opinions.annot.algo.pair_based import PairBasedOpinionAnnotationAlgorithm
+from arekit.common.opinions.collection import OpinionCollection
+from arekit.common.synonyms.base import SynonymsCollection
+from arekit.common.synonyms.grouping import SynonymsCollectionValuesGroupingProviders
+from arekit.contrib.source.sentinerel.io_utils import SentiNerelVersions, SentiNerelIOUtils
+from arekit.contrib.utils.pipelines.sources.sentinerel.doc_provider import SentiNERELDocProvider
+from arekit.contrib.utils.pipelines.sources.sentinerel.labels_fmt import SentiNERELSentimentLabelFormatter
+from arekit.contrib.utils.pipelines.text_opinion.annot.algo_based import AlgorithmBasedTextOpinionAnnotator
+from arekit.contrib.utils.pipelines.text_opinion.annot.predefined import PredefinedTextOpinionAnnotator
+from arekit.contrib.utils.pipelines.text_opinion.extraction import text_opinion_extraction_pipeline
+from arekit.contrib.utils.pipelines.text_opinion.filters.distance_based import DistanceLimitedTextOpinionFilter
+from arekit.contrib.utils.processing.lemmatization.mystem import MystemWrapper
+from arekit.contrib.utils.sources.sentinerel.text_opinion.prof_per_org_filter import \
+    ProfessionAsCharacteristicSentimentTextOpinionFilter
+from arekit.contrib.utils.synonyms.stemmer_based import StemmerBasedSynonymCollection
+
+
+def create_text_opinion_extraction_pipeline(sentinerel_version,
+                                            text_parser,
+                                            custom_text_opinion_filters=None,
+                                            label_formatter=SentiNERELSentimentLabelFormatter(),
+                                            no_label=NoLabel(),
+                                            terms_per_context=50,
+                                            doc_provider=None,
+                                            dist_in_sentences=0,
+                                            docs_limit=None):
+    """ This is a main pipeline which generates the samples for a SentiNEREL documents.
+        SentiNEREL is a collection that becomes a part of the:
+            1. Attitude extraction studies (AREkit focused studies):
+                https://github.com/nicolay-r/SentiNEREL-attitude-extraction
+            2. RuSentNE-2023 competitions under CODALAB platform (github page):
+                https://github.com/dialogue-evaluation/RuSentNE-evaluation
+
+        Parameters:
+            sentinerel_version: enum
+                Version of the SentiNEREL collection.
+            text_parser: Is the way of how do we process the text.
+            doc_provider: DocumentProvider or None
+                In case of None we consider the default initialization.
+            label_formatter:
+                Formatter for labels which allows to: limit set of labels, and perform its conversion from
+                string to actual python type.
+            terms_per_context: int
+                Amount of terms that we consider in between the Object and Subject.
+
+        Returns: dict, (data_folding) optional
+            pipelines per every type.
+    """
+    assert(isinstance(sentinerel_version, SentiNerelVersions))
+    assert(isinstance(doc_provider, DocumentProvider) or doc_provider is None)
+    assert(isinstance(custom_text_opinion_filters, list) or custom_text_opinion_filters is None)
+
+    data_folding = None
+
+    if doc_provider is None:
+        # Default Initialization.
+        filenames_by_ids, data_folding = SentiNerelIOUtils.read_dataset_split(version=sentinerel_version,
+                                                                              docs_limit=docs_limit)
+        doc_provider = SentiNERELDocProvider(filename_by_id=filenames_by_ids,
+                                             version=sentinerel_version)
+
+    train_neut_annot = create_nolabel_text_opinion_annotator(terms_per_context=terms_per_context,
+                                                             dist_in_sents=dist_in_sentences,
+                                                             no_label=no_label)
+    test_neut_annot = create_nolabel_text_opinion_annotator(terms_per_context=terms_per_context,
+                                                            dist_in_sents=dist_in_sentences,
+                                                            no_label=no_label)
+
+    text_opinion_filters = [
+        ProfessionAsCharacteristicSentimentTextOpinionFilter(),
+        DistanceLimitedTextOpinionFilter(terms_per_context)
+    ]
+
+    # Append with the custom filters afterwards.
+    if custom_text_opinion_filters is not None:
+        text_opinion_filters += custom_text_opinion_filters
+
+    predefined_annot = PredefinedTextOpinionAnnotator(doc_provider, label_formatter)
+
+    pipelines = {
+        DataType.Train: create_main_pipeline(text_parser=text_parser,
+                                             doc_provider=doc_provider,
+                                             annotators=[
+                                                  predefined_annot,
+                                                  train_neut_annot
+                                              ],
+                                             text_opinion_filters=text_opinion_filters),
+        DataType.Test: create_main_pipeline(text_parser=text_parser,
+                                            doc_provider=doc_provider,
+                                            annotators=[
+                                                test_neut_annot
+                                            ],
+                                            text_opinion_filters=text_opinion_filters),
+        DataType.Etalon: create_etalon_pipeline(text_parser=text_parser,
+                                                doc_provider=doc_provider,
+                                                predefined_annot=predefined_annot,
+                                                text_opinion_filters=text_opinion_filters),
+        DataType.Dev: create_etalon_with_no_label_pipeline(text_parser=text_parser,
+                                                           doc_provider=doc_provider,
+                                                           annotators=[
+                                                               predefined_annot,
+                                                               train_neut_annot
+                                                           ],
+                                                           text_opinion_filters=text_opinion_filters),
+    }
+
+    # In the case when we setup a default data-folding.
+    # There is a need to provide it, due to the needs in further.
+    if data_folding is not None:
+        return pipelines, data_folding
+
+    return pipelines
+
+
+def create_nolabel_text_opinion_annotator(terms_per_context, no_label, dist_in_sents=0, synonyms=None):
+    """ This is a core annotator, which provides all entity pairs.
+        Could be revealed from the document.
+
+        Parameters:
+            terms_per_context: int
+                Amount of terms that we consider in between the Object and Subject.
+            dist_in_sents: int
+                Distance in sentences in between the objects.
+    """
+    assert(isinstance(terms_per_context, int))
+    assert(isinstance(synonyms, SynonymsCollection) or synonyms is None)
+    assert(isinstance(dist_in_sents, int))
+
+    if synonyms is None:
+        synonyms = StemmerBasedSynonymCollection(stemmer=MystemWrapper(), is_read_only=False)
+
+    return AlgorithmBasedTextOpinionAnnotator(
+        value_to_group_id_func=lambda value:
+        SynonymsCollectionValuesGroupingProviders.provide_existed_or_register_missed_value(
+            synonyms=synonyms, value=value),
+        annot_algo=PairBasedOpinionAnnotationAlgorithm(
+            dist_in_sents=dist_in_sents,
+            dist_in_terms_bound=terms_per_context,
+            label_provider=ConstantLabelProvider(no_label),
+            entity_index_func=lambda brat_entity: brat_entity.ID),
+        create_empty_collection_func=lambda: OpinionCollection(
+            synonyms=synonyms,
+            error_on_duplicates=True,
+            error_on_synonym_end_missed=False))
+
+
+def create_main_pipeline(text_parser, doc_provider, annotators, text_opinion_filters):
+    """ Train pipeline is based on the predefined annotations and
+        automatic annotations of other pairs with a NoLabel.
+    """
+    return text_opinion_extraction_pipeline(
+        get_doc_by_id_func=doc_provider.by_id,
+        text_parser=text_parser,
+        annotators=annotators,
+        entity_index_func=lambda brat_entity: brat_entity.ID,
+        text_opinion_filters=text_opinion_filters)
+
+
+def create_etalon_pipeline(text_parser, doc_provider, predefined_annot, text_opinion_filters):
+    """ We adopt exact the same pipeline as for training data,
+        but we do not perform "NoLabel" annotation.
+        (we are interested only in sentiment attitudes).
+    """
+    return create_main_pipeline(text_parser=text_parser,
+                                doc_provider=doc_provider,
+                                annotators=[predefined_annot],
+                                text_opinion_filters=text_opinion_filters)
+
+
+def create_etalon_with_no_label_pipeline(annotators, text_parser, doc_provider, text_opinion_filters):
+    """ We adopt exact the same pipeline as for training data.
+    """
+    return create_main_pipeline(text_parser=text_parser,
+                                doc_provider=doc_provider,
+                                annotators=annotators,
+                                text_opinion_filters=text_opinion_filters)

arekit/contrib/utils/pipelines/sources/sentinerel/labels_fmt.py

@@ -0,0 +1,50 @@
+from arekit.common.labels.base import NoLabel
+from arekit.common.labels.str_fmt import StringLabelsFormatter
+from arekit.contrib.source.sentinerel import labels
+
+
+class SentiNERELAnyLabelFormatter(StringLabelsFormatter):
+
+    def __init__(self):
+
+        stol = {
+            "OPINION_BELONGS_TO": labels.OpinionBelongsTo,
+            "OPINION_RELATES_TO": labels.OpinionRelatesTo,
+            "NEG_EFFECT_FROM": labels.NegEffectFrom,
+            "POS_EFFECT_FROM": labels.PosEffectFrom,
+            "NEG_STATE_FROM": labels.NegStateFrom,
+            "POS_STATE_FROM": labels.PosStateFrom,
+            "NEGATIVE_TO": labels.NegativeTo,
+            "POSITIVE_TO": labels.PositiveTo,
+            "STATE_BELONGS_TO": labels.StateBelongsTo,
+            "POS_AUTHOR_FROM": labels.PosAuthorFrom,
+            "NEG_AUTHOR_FROM": labels.NegAuthorFrom,
+            "ALTERNATIVE_NAME": labels.AlternativeName,
+            "ORIGINS_FROM": labels.OriginsFrom
+        }
+
+        super(SentiNERELAnyLabelFormatter, self).__init__(stol=stol)
+
+
+class SentiNERELSentimentLabelFormatter(StringLabelsFormatter):
+
+    def __init__(self):
+        stol = {
+            "NEGATIVE_TO": labels.NegativeTo,
+            "POSITIVE_TO": labels.PositiveTo,
+        }
+
+        super(SentiNERELSentimentLabelFormatter, self).__init__(stol=stol)
+
+
+class SentiNERELPosNegNeuRelationsLabelFormatter(StringLabelsFormatter):
+
+    def __init__(self):
+
+        stol = {
+            "NEUTRAL": NoLabel,
+            "NEGATIVE_TO": labels.NegativeTo,
+            "POSITIVE_TO": labels.PositiveTo,
+        }
+
+        super(SentiNERELPosNegNeuRelationsLabelFormatter, self).__init__(stol=stol)

arekit/contrib/utils/pipelines/text_opinion/annot/algo_based.py

@@ -0,0 +1,34 @@
+from arekit.common.docs.parsed.providers.text_opinion_pairs import TextOpinionPairsProvider
+from arekit.common.docs.parsed.service import ParsedDocumentService
+from arekit.common.opinions.annot.algo_based import AlgorithmBasedOpinionAnnotator
+
+
+class AlgorithmBasedTextOpinionAnnotator(AlgorithmBasedOpinionAnnotator):
+    """ This class represent a wrap over TextOpinionAnnotator
+        and allows to perform a conversion into TextOpinions
+    """
+
+    def __init__(self, value_to_group_id_func, annot_algo, create_empty_collection_func,
+                 get_doc_existed_opinions_func=None):
+        """ get_doc_existed_opinions_func: func or None
+                function that provides existed opinions for a document;
+                if None, then we consider an absence of the existed document-level opinions.
+        """
+        assert(callable(value_to_group_id_func))
+        super(AlgorithmBasedTextOpinionAnnotator, self).__init__(
+            annot_algo=annot_algo,
+            create_empty_collection_func=create_empty_collection_func,
+            get_doc_existed_opinions_func=get_doc_existed_opinions_func)
+        self.__value_to_group_id_func = value_to_group_id_func
+
+    def __create_service(self, parsed_doc):
+        return ParsedDocumentService(parsed_doc=parsed_doc, providers=[
+            TextOpinionPairsProvider(self.__value_to_group_id_func)
+        ])
+
+    def annotate_collection(self, parsed_doc):
+        service = self.__create_service(parsed_doc)
+        topp = service.get_provider(TextOpinionPairsProvider.NAME)
+        for opinion in super(AlgorithmBasedTextOpinionAnnotator, self).annotate_collection(parsed_doc):
+            for text_opinion in topp.iter_from_opinion(opinion):
+                yield text_opinion

arekit/contrib/utils/pipelines/text_opinion/annot/predefined.py

@@ -0,0 +1,88 @@
+from arekit.common.data.doc_provider import DocumentProvider
+from arekit.common.labels.str_fmt import StringLabelsFormatter
+from arekit.common.docs.parsed.base import ParsedDocument
+from arekit.common.docs.parsed.providers.base import BaseParsedDocumentServiceProvider
+from arekit.common.docs.parsed.providers.entity_service import EntityServiceProvider
+from arekit.common.docs.parsed.service import ParsedDocumentService
+from arekit.common.opinions.annot.base import BaseOpinionAnnotator
+from arekit.contrib.source.brat.doc import BratDocument
+from arekit.contrib.source.brat.opinions.converter import BratRelationConverter
+
+
+class PredefinedTextOpinionAnnotator(BaseOpinionAnnotator):
+    """ Brat-based text-opinion annotator (converter).
+        It converts the pre-annotated Relations from BRAT-documents to TextOpinions
+    """
+
+    def __init__(self, doc_provider, label_formatter, keep_any_type=False, entity_index_func=None):
+        """
+            get_doc_func:
+                func(doc_id)
+
+            label_formatter: String Labels Formatter
+                required for conversion.
+
+            keep_any_type: bool
+                flag that defines whether there is a need to consider all the text opinions
+                or only one that supported by label formatter.
+
+            entity_index_func: is a way of how we provide an external entity ID
+                fund(entity) -> ID
+        """
+        assert(isinstance(doc_provider, DocumentProvider))
+        assert(isinstance(label_formatter, StringLabelsFormatter))
+        assert(callable(entity_index_func) or entity_index_func is None)
+        super(PredefinedTextOpinionAnnotator, self).__init__()
+
+        self.__doc_provider = doc_provider
+        self.__label_formatter = label_formatter
+        self.__keep_any_type = keep_any_type
+        self.__entity_index_func = (lambda brat_entity: brat_entity.ID) if \
+            entity_index_func is None else entity_index_func
+
+    @staticmethod
+    def __convert_entity_id(doc, origin_entity_id, esp):
+        assert(isinstance(doc, BratDocument))
+        assert(isinstance(origin_entity_id, int))
+        assert(isinstance(esp, BaseParsedDocumentServiceProvider))
+
+        if not doc.contains_entity(origin_entity_id):
+            # Due to the complexity of entities, some entities might be nested.
+            # Therefore the latter, some entities might be discarded.
+            return None
+
+        origin_entity = doc.get_entity_by_id(origin_entity_id)
+
+        if not esp.contains_entity(origin_entity):
+            return None
+
+        document_entity = esp.get_document_entity(origin_entity)
+        return document_entity.IdInDocument
+
+    def _annot_collection_core(self, parsed_doc):
+        assert(isinstance(parsed_doc, ParsedDocument))
+
+        pns = ParsedDocumentService(parsed_doc=parsed_doc, providers=[
+            EntityServiceProvider(self.__entity_index_func)
+        ])
+        esp = pns.get_provider(EntityServiceProvider.NAME)
+        doc = self.__doc_provider.by_id(parsed_doc.RelatedDocID)
+
+        for brat_relation in doc.Relations:
+
+            if self.__label_formatter.supports_value(brat_relation.Type) or self.__keep_any_type:
+
+                text_opinion = BratRelationConverter.to_text_opinion(
+                    brat_relation=brat_relation,
+                    doc_id=parsed_doc.RelatedDocID,
+                    label_formatter=self.__label_formatter)
+
+                internal_opinion = text_opinion.try_convert(
+                    other=text_opinion,
+                    convert_entity_id_func=lambda origin_id: PredefinedTextOpinionAnnotator.__convert_entity_id(
+                        doc=doc, origin_entity_id=origin_id, esp=esp))
+
+                if internal_opinion is None:
+                    continue
+
+                yield internal_opinion

arekit/contrib/utils/pipelines/text_opinion/extraction.py

@@ -0,0 +1,93 @@
+from arekit.common.linkage.meta import MetaEmptyLinkedDataWrapper
+from arekit.common.linkage.text_opinions import TextOpinionsLinkage
+from arekit.common.docs.parsed.base import ParsedDocument
+from arekit.common.docs.parsed.providers.entity_service import EntityServiceProvider
+from arekit.common.docs.parsed.service import ParsedDocumentService
+from arekit.common.docs.parser import DocumentParser
+from arekit.common.pipeline.base import BasePipeline
+from arekit.common.pipeline.items.flatten import FlattenIterPipelineItem
+from arekit.common.pipeline.items.map import MapPipelineItem
+from arekit.common.pipeline.items.map_nested import MapNestedPipelineItem
+from arekit.common.text.parser import BaseTextParser
+from arekit.common.text_opinions.base import TextOpinion
+from arekit.contrib.utils.pipelines.text_opinion.filters.base import TextOpinionFilter
+from arekit.contrib.utils.pipelines.text_opinion.filters.limitation import FrameworkLimitationsTextOpinionFilter
+
+
+def __iter_text_opinion_linkages(parsed_doc, annotators, entity_index_func,
+                                 text_opinion_filters, use_meta):
+    """ use_meta: bool
+            this is mainly for tqdm and other console parameters to stay up-to-date
+            with the state in the case we do not have that much output results
+            across multiple amount of documents.
+    """
+    assert(isinstance(annotators, list))
+    assert(isinstance(parsed_doc, ParsedDocument))
+    assert(isinstance(text_opinion_filters, list))
+    assert(isinstance(use_meta, bool))
+
+    def __to_id(text_opinion):
+        return "{}_{}".format(text_opinion.SourceId, text_opinion.TargetId)
+
+    service = ParsedDocumentService(parsed_doc=parsed_doc, providers=[EntityServiceProvider(entity_index_func)])
+    esp = service.get_provider(EntityServiceProvider.NAME)
+
+    predefined = set()
+
+    for annotator in annotators:
+        for text_opinion in annotator.annotate_collection(parsed_doc=parsed_doc):
+            assert(isinstance(text_opinion, TextOpinion))
+
+            passed = True
+            for f in text_opinion_filters:
+                assert(isinstance(f, TextOpinionFilter))
+                if not f.filter(text_opinion=text_opinion, parsed_doc=parsed_doc, entity_service_provider=esp):
+                    passed = False
+                    break
+
+            if not passed:
+                continue
+
+            if __to_id(text_opinion) in predefined:
+                # We reject those one which was already obtained
+                # from the predefined sentiment annotation.
+                continue
+
+            predefined.add(__to_id(text_opinion))
+
+            text_opinion_linkage = TextOpinionsLinkage([text_opinion])
+            text_opinion_linkage.set_tag(service)
+            yield text_opinion_linkage
+
+    # This is the case to consider the end of the document.
+    if use_meta:
+        yield MetaEmptyLinkedDataWrapper(doc_id=parsed_doc.RelatedDocID)
+
+
+def text_opinion_extraction_pipeline(text_parser, get_doc_by_id_func, annotators, entity_index_func,
+                                     text_opinion_filters=None, use_meta_between_docs=True):
+    assert(isinstance(text_parser, BaseTextParser))
+    assert(callable(get_doc_by_id_func))
+    assert(isinstance(annotators, list))
+    assert(isinstance(text_opinion_filters, list) or text_opinion_filters is None)
+    assert(isinstance(use_meta_between_docs, bool))
+
+    extra_filters = [] if text_opinion_filters is None else text_opinion_filters
+    actual_text_opinion_filters = [FrameworkLimitationsTextOpinionFilter()] + extra_filters
+
+    return BasePipeline([
+        # (doc_id) -> (doc)
+        MapPipelineItem(map_func=lambda doc_id: get_doc_by_id_func(doc_id)),
+
+        # (doc, ppl_ctx) -> (parsed_doc)
+        MapNestedPipelineItem(map_func=lambda doc, ppl_ctx: DocumentParser.parse(
+            doc=doc, text_parser=text_parser, parent_ppl_ctx=ppl_ctx)),
+
+        # (parsed_doc) -> (text_opinions)
+        MapPipelineItem(map_func=lambda parsed_doc: __iter_text_opinion_linkages(
+            annotators=annotators, parsed_doc=parsed_doc, entity_index_func=entity_index_func,
+            text_opinion_filters=actual_text_opinion_filters, use_meta=use_meta_between_docs)),
+
+        # linkages[] -> linkages
+        FlattenIterPipelineItem()
+    ])

arekit/contrib/utils/pipelines/text_opinion/filters/base.py

@@ -0,0 +1,4 @@
+class TextOpinionFilter(object):
+
+    def filter(self, text_opinion, parsed_doc, entity_service_provider):
+        raise NotImplementedError()

arekit/contrib/utils/pipelines/text_opinion/filters/distance_based.py

@@ -0,0 +1,16 @@
+from arekit.common.data.input.sample import InputSampleBase
+from arekit.contrib.utils.pipelines.text_opinion.filters.base import TextOpinionFilter
+
+
+class DistanceLimitedTextOpinionFilter(TextOpinionFilter):
+
+    def __init__(self, terms_per_context):
+        super(DistanceLimitedTextOpinionFilter, self).__init__()
+        self.__terms_per_context = terms_per_context
+
+    def filter(self, text_opinion, parsed_doc, entity_service_provider):
+
+        return InputSampleBase.check_ability_to_create_sample(
+            entity_service=entity_service_provider,
+            text_opinion=text_opinion,
+            window_size=self.__terms_per_context)

arekit/contrib/utils/pipelines/text_opinion/filters/entity_based.py

@@ -0,0 +1,29 @@
+from arekit.common.entities.types import OpinionEntityType
+from arekit.common.docs.parsed.base import ParsedDocument
+from arekit.common.text_opinions.base import TextOpinion
+
+from arekit.contrib.utils.entities.filter import EntityFilter
+from arekit.contrib.utils.pipelines.text_opinion.filters.base import TextOpinionFilter
+
+
+class EntityBasedTextOpinionFilter(TextOpinionFilter):
+
+    def __init__(self, entity_filter):
+        super(EntityBasedTextOpinionFilter, self).__init__()
+        assert(isinstance(entity_filter, EntityFilter) or entity_filter is None)
+        self.__entity_filter = entity_filter
+
+    def filter(self, text_opinion, parsed_doc, entity_service_provider):
+        assert(isinstance(text_opinion, TextOpinion))
+        assert(isinstance(parsed_doc, ParsedDocument))
+
+        if self.__entity_filter is not None:
+            e_source = entity_service_provider._doc_entities[text_opinion.SourceId]
+            if self.__entity_filter.is_ignored(e_source, OpinionEntityType.Subject):
+                return False
+
+            e_target = entity_service_provider._doc_entities[text_opinion.TargetId]
+            if self.__entity_filter.is_ignored(e_target, OpinionEntityType.Object):
+                return False
+
+        return True

arekit/contrib/utils/pipelines/text_opinion/filters/limitation.py

@@ -0,0 +1,26 @@
+from arekit.common.docs.parsed.base import ParsedDocument
+from arekit.common.docs.parsed.term_position import TermPositionTypes
+from arekit.common.text_opinions.base import TextOpinion
+from arekit.contrib.utils.pipelines.text_opinion.filters.base import TextOpinionFilter
+
+
+class FrameworkLimitationsTextOpinionFilter(TextOpinionFilter):
+    """ Note: this is an internal class, there is no need to
+        adopt this from the outside of the AREkit.
+        It is require to hide and provide known limitations.
+    """
+
+    def filter(self, text_opinion, parsed_doc, entity_service_provider):
+        assert(isinstance(text_opinion, TextOpinion))
+        assert(isinstance(parsed_doc, ParsedDocument))
+
+        s_ind = entity_service_provider.get_entity_position(
+            text_opinion.SourceId, position_type=TermPositionTypes.SentenceIndex)
+        t_ind = entity_service_provider.get_entity_position(
+            text_opinion.TargetId, position_type=TermPositionTypes.SentenceIndex)
+
+        if s_ind != t_ind:
+            # AREkit does not provide a support for multi-sentence opinions at present.
+            return False
+
+        return True

arekit/contrib/utils/processing/languages/mods.py

@@ -0,0 +1,12 @@
+class BaseLanguageMods(object):
+    """
+    Represents a class with static methods that provides text/word modifies.
+    """
+
+    @staticmethod
+    def replace_specific_word_chars(word):
+        pass
+
+    @staticmethod
+    def is_negation_word(word):
+        pass

arekit/contrib/utils/processing/languages/pos.py

@@ -0,0 +1,23 @@
+from enum import IntEnum
+
+
+class PartOfSpeechType(IntEnum):
+
+    NOUN = 1
+    ADV = 2
+    ADVPRO = 3
+    ANUM = 4
+    APRO = 5
+    COM = 6
+    CONJ = 7
+    INTJ = 8
+    NUM = 9
+    PART = 10
+    PR = 11
+    ADJ = 12
+    SPRO = 13
+    VERB = 14
+
+    Unknown = 15
+
+    Empty = 16