arekit 0.23.1__py3-none-any.whl → 0.25.0__py3-none-any.whl

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

@@ -1,79 +0,0 @@
-from arekit.common.labels.str_fmt import StringLabelsFormatter
-from arekit.contrib.source.nerelbio import labels
-
-
-class NerelBioAnyLabelFormatter(StringLabelsFormatter):
-
-    def __init__(self):
-
-        stol = {
-            "ABBREVIATION": labels.ABBREVIATION,
-            "ALTERNATIVE_NAME": labels.ALTERNATIVE_NAME,
-            "KNOWS": labels.KNOWS,
-            "AGE_IS": labels.AGE_IS,
-            "AGE_DIED_AT": labels.AGE_DIED_AT,
-            "AWARDED_WITH": labels.AWARDED_WITH,
-            "PLACE_OF_BIRTH": labels.PLACE_OF_BIRTH,
-            "DATE_DEFUNCT_IN": labels.DATE_DEFUNCT_IN,
-            "DATE_FOUNDED_IN": labels.DATE_FOUNDED_IN,
-            "DATE_OF_BIRTH": labels.DATE_OF_BIRTH,
-            "DATE_OF_CREATION": labels.DATE_OF_CREATION,
-            "DATE_OF_DEATH": labels.DATE_OF_DEATH,
-            "POINT_IN_TIME": labels.POINT_IN_TIME,
-            "PLACE_OF_DEATH": labels.PLACE_OF_DEATH,
-            "FOUNDED_BY": labels.FOUNDED_BY,
-            "HEADQUARTERED_IN": labels.HEADQUARTERED_IN,
-            "IDEOLOGY_OF": labels.IDEOLOGY_OF,
-            "SPOUSE": labels.SPOUSE,
-            "MEMBER_OF": labels.MEMBER_OF,
-            "ORGANIZES": labels.ORGANIZES,
-            "OWNER_OF": labels.OWNER_OF,
-            "PARENT_OF": labels.PARENT_OF,
-            "PARTICIPANT_IN": labels.PARTICIPANT_IN,
-            "PLACE_RESIDES_IN": labels.PLACE_RESIDES_IN,
-            "PRICE_OF": labels.PRICE_OF,
-            "PRODUCES": labels.PRODUCES,
-            "RELATIVE": labels.RELATIVE,
-            "RELIGION_OF": labels.RELIGION_OF,
-            "SCHOOLS_ATTENDED": labels.SCHOOLS_ATTENDED,
-            "SIBLING": labels.SIBLING,
-            "SUBEVENT_OF": labels.SUBEVENT_OF,
-            "SUBORDINATE_OF": labels.SUBORDINATE_OF,
-            "TAKES_PLACE_IN": labels.TAKES_PLACE_IN,
-            "WORKPLACE": labels.WORKPLACE,
-            "WORKS_AS": labels.WORKS_AS,
-            "CONVICTED_OF": labels.CONVICTED_OF,
-            "PENALIZED_AS": labels.PENALIZED_AS,
-            "START_TIME": labels.START_TIME,
-            "END_TIME": labels.END_TIME,
-            "EXPENDITURE": labels.EXPENDITURE,
-            "AGENT": labels.AGENT,
-            "INANIMATE_INVOLVED": labels.INANIMATE_INVOLVED,
-            "INCOME": labels.INCOME,
-            "SUBCLASS_OF": labels.SUBCLASS_OF,
-            "PART_OF": labels.PART_OF,
-            "LOCATED_IN": labels.LOCATED_IN,
-            "TREATED_USING": labels.TREATED_USING,
-            "ORIGINS_FROM": labels.ORIGINS_FROM,
-            "TO_DETECT_OR_STUDY": labels.TO_DETECT_OR_STUDY,
-            "AFFECTS": labels.AFFECTS,
-            "HAS_CAUSE": labels.HAS_CAUSE,
-            "APPLIED_TO": labels.APPLIED_TO,
-            "USED_IN": labels.USED_IN,
-            "ASSOCIATED_WITH": labels.ASSOCIATED_WITH,
-            "HAS_ADMINISTRATION_ROUTE": labels.HAS_ADMINISTRATION_ROUTE,
-            "HAS_STRENGTH": labels.HAS_STRENGTH,
-            "DURATION_OF": labels.DURATION_OF,
-            "VALUE_IS": labels.VALUE_IS,
-            "PHYSIOLOGY_OF": labels.PHYSIOLOGY_OF,
-            "PROCEDURE_PERFORMED": labels.PROCEDURE_PERFORMED,
-            "MENTAL_PROCESS_OF": labels.MENTAL_PROCESS_OF,
-            "MEDICAL_CONDITION": labels.MEDICAL_CONDITION,
-            "DOSE_IS": labels.DOSE_IS,
-            "FINDING_OF": labels.FINDING_OF,
-            "CAUSE_OF_DEATH": labels.CAUSE_OF_DEATH,
-            "CONSUME": labels.CONSUME,
-        }
-
-        super(NerelBioAnyLabelFormatter, self).__init__(stol=stol)
-

arekit/contrib/utils/pipelines/sources/ruattitudes/doc_ops.py

@@ -1,56 +0,0 @@
-from arekit.common.utils import progress_bar_iter
-from arekit.contrib.source.ruattitudes.collection import RuAttitudesCollection
-from arekit.contrib.source.ruattitudes.io_utils import RuAttitudesVersions
-from arekit.contrib.source.ruattitudes.news import RuAttitudesNews
-from arekit.contrib.source.ruattitudes.news_brat import RuAttitudesNewsConverter
-from arekit.contrib.utils.data.doc_ops.dict_based import DictionaryBasedDocumentOperations
-
-
-class RuAttitudesDocumentOperations(DictionaryBasedDocumentOperations):
-
-    def __init__(self, version, keep_doc_ids_only, doc_id_func, limit):
-        d = self.read_ruattitudes_to_brat_in_memory(version=version,
-                                                    keep_doc_ids_only=keep_doc_ids_only,
-                                                    doc_id_func=doc_id_func,
-                                                    limit=limit)
-        super(RuAttitudesDocumentOperations, self).__init__(d)
-
-    @staticmethod
-    def read_ruattitudes_to_brat_in_memory(version, keep_doc_ids_only, doc_id_func, limit=None):
-        """ Performs reading of RuAttitude formatted documents and
-            selection according to 'doc_ids_set' parameter.
-        """
-        assert (isinstance(version, RuAttitudesVersions))
-        assert (isinstance(keep_doc_ids_only, bool))
-        assert (callable(doc_id_func))
-
-        it = RuAttitudesCollection.iter_news(version=version,
-                                             get_news_index_func=doc_id_func,
-                                             return_inds_only=keep_doc_ids_only)
-
-        it_formatted_and_logged = progress_bar_iter(
-            iterable=RuAttitudesDocumentOperations.__iter_id_with_news(
-                docs_it=it, keep_doc_ids_only=keep_doc_ids_only),
-            desc="Loading RuAttitudes Collection [{}]".format("doc ids only" if keep_doc_ids_only else "fully"),
-            unit='docs')
-
-        d = {}
-        docs_read = 0
-        for doc_id, news in it_formatted_and_logged:
-            assert(isinstance(news, RuAttitudesNews) or news is None)
-            d[doc_id] = RuAttitudesNewsConverter.to_brat_news(news) if news is not None else None
-            docs_read += 1
-            if limit is not None and docs_read >= limit:
-                break
-
-        return d
-
-    @staticmethod
-    def __iter_id_with_news(docs_it, keep_doc_ids_only):
-        if keep_doc_ids_only:
-            for doc_id in docs_it:
-                yield doc_id, None
-        else:
-            for news in docs_it:
-                assert (isinstance(news, RuAttitudesNews))
-                yield news.ID, news

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

@@ -1,19 +0,0 @@
-from arekit.common.entities.types import OpinionEntityType
-from arekit.contrib.utils.entities.filter import EntityFilter
-
-
-class RuAttitudesEntityFilter(EntityFilter):
-    """ Among all the entities proposed by the OntonotesV5,
-     we consider only a short list related to sentiment attutde extraction task.
-    """
-
-    supported = ["GPE", "PERSON", "LOCAL", "GEO", "ORG"]
-
-    def is_ignored(self, entity, e_type):
-
-        if e_type == OpinionEntityType.Subject:
-            return entity.Type not in RuAttitudesEntityFilter.supported
-        if e_type == OpinionEntityType.Object:
-            return entity.Type not in RuAttitudesEntityFilter.supported
-        else:
-            return True

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

@@ -1,58 +0,0 @@
-from arekit.common.labels.scaler.base import BaseLabelScaler
-from arekit.contrib.source.ruattitudes.io_utils import RuAttitudesVersions
-from arekit.contrib.source.ruattitudes.labels_fmt import RuAttitudesLabelFormatter
-from arekit.contrib.utils.pipelines.sources.ruattitudes.doc_ops import RuAttitudesDocumentOperations
-from arekit.contrib.utils.pipelines.sources.ruattitudes.entity_filter import RuAttitudesEntityFilter
-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.pipelines.text_opinion.filters.entity_based import EntityBasedTextOpinionFilter
-
-
-def create_text_opinion_extraction_pipeline(text_parser,
-                                            label_scaler,
-                                            version=RuAttitudesVersions.V20Large,
-                                            terms_per_context=50,
-                                            entity_filter=RuAttitudesEntityFilter(),
-                                            limit=None):
-    """ Processing pipeline for RuAttitudes.
-        This pipeline is based on the in-memory RuAttitudes storage.
-
-        Original collection paper:  www.aclweb.org/anthology/r19-1118/
-        Github repository:          https://github.com/nicolay-r/RuAttitudes
-
-        version: enum
-            Version of the RuAttitudes collection.
-            NOTE: we consider to support a variations of the 2.0 versions.
-        label_scaler:
-            Scaler that allows to perform conversion from integer labels (RuAttitudes) to
-            the actual `Label` instances, required in further for text_opinions instances.
-        terms_per_context: int
-            Amount of terms that we consider in between the Object and Subject.
-        entity_filter:
-            Entity filter
-        limit: int or None
-            Limit of documents to consider.
-    """
-    assert(isinstance(label_scaler, BaseLabelScaler))
-    assert(isinstance(version, RuAttitudesVersions))
-    assert(version in [RuAttitudesVersions.V20Large, RuAttitudesVersions.V20Base,
-                       RuAttitudesVersions.V20BaseNeut, RuAttitudesVersions.V20LargeNeut])
-
-    doc_ops = RuAttitudesDocumentOperations(version=version,
-                                            keep_doc_ids_only=False,
-                                            doc_id_func=lambda doc_id: doc_id,
-                                            limit=limit)
-
-    pipeline = text_opinion_extraction_pipeline(
-        annotators=[
-            PredefinedTextOpinionAnnotator(doc_ops=doc_ops, label_formatter=RuAttitudesLabelFormatter(label_scaler))
-        ],
-        text_opinion_filters=[
-            EntityBasedTextOpinionFilter(entity_filter=entity_filter),
-            DistanceLimitedTextOpinionFilter(terms_per_context)
-        ],
-        get_doc_by_id_func=doc_ops.by_id,
-        text_parser=text_parser)
-
-    return pipeline

arekit/contrib/utils/pipelines/sources/rusentrel/doc_ops.py

@@ -1,21 +0,0 @@
-from arekit.common.experiment.api.ops_doc import DocumentOperations
-from arekit.common.synonyms.base import SynonymsCollection
-from arekit.contrib.source.rusentrel.io_utils import RuSentRelVersions
-from arekit.contrib.source.rusentrel.news_reader import RuSentRelNewsReader
-
-
-class RuSentrelDocumentOperations(DocumentOperations):
-    """ Limitations: Supported only train/test collections format
-    """
-
-    def __init__(self, version, synonyms):
-        assert(isinstance(version, RuSentRelVersions))
-        assert(isinstance(synonyms, SynonymsCollection))
-        super(RuSentrelDocumentOperations, self).__init__()
-        self.__version = version
-        self.__synonyms = synonyms
-
-    def by_id(self, doc_id):
-        assert (isinstance(doc_id, int))
-        return RuSentRelNewsReader.read_document(doc_id=doc_id, synonyms=self.__synonyms, version=self.__version)
-

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

@@ -1,100 +0,0 @@
-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.annot.algo.predefined import PredefinedOpinionAnnotationAlgorithm
-from arekit.common.opinions.collection import OpinionCollection
-from arekit.common.synonyms.grouping import SynonymsCollectionValuesGroupingProviders
-from arekit.contrib.source.rusentrel.labels_fmt import RuSentRelLabelsFormatter
-from arekit.contrib.source.rusentrel.opinions.collection import RuSentRelOpinions
-from arekit.contrib.source.rusentrel.synonyms import RuSentRelSynonymsCollectionHelper
-from arekit.contrib.utils.pipelines.sources.rusentrel.doc_ops import RuSentrelDocumentOperations
-from arekit.contrib.utils.pipelines.text_opinion.annot.algo_based import AlgorithmBasedTextOpinionAnnotator
-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.pipelines.text_opinion.filters.entity_based import EntityBasedTextOpinionFilter
-from arekit.contrib.utils.processing.lemmatization.mystem import MystemWrapper
-from arekit.contrib.utils.synonyms.stemmer_based import StemmerBasedSynonymCollection
-
-
-def create_text_opinion_extraction_pipeline(rusentrel_version,
-                                            text_parser,
-                                            labels_fmt,
-                                            entity_filter=None,
-                                            no_label=NoLabel(),
-                                            terms_per_context=50,
-                                            dist_in_sentences=0):
-    """ Processing pipeline for RuSentRel, which combines:
-            - predefined document-level annotation (sentiment labels)
-            - automatic annotation of opinions between mentioned named entities (no-label)
-
-        Original collection paper: arxiv.org/abs/1808.08932
-
-        version: enum
-            Version of the RuSentRel collection.
-        terms_per_context: int
-            Amount of terms that we consider in between the Object and Subject.
-        dist_in_sentences: int
-            considering amount of sentences that could be in between Object and Subject.
-    """
-    assert(isinstance(labels_fmt, RuSentRelLabelsFormatter))
-
-    synonyms = StemmerBasedSynonymCollection(
-        iter_group_values_lists=RuSentRelSynonymsCollectionHelper.iter_groups(rusentrel_version),
-        stemmer=MystemWrapper(),
-        is_read_only=False)
-
-    doc_ops = RuSentrelDocumentOperations(version=rusentrel_version, synonyms=synonyms)
-
-    pipeline = text_opinion_extraction_pipeline(
-        annotators=[
-            predefined_annotator(synonyms=synonyms, labels_fmt=labels_fmt),
-            nolabel_annotator(synonyms=synonyms, terms_per_context=terms_per_context,
-                              dist_in_sentences=dist_in_sentences, no_label=no_label)
-        ],
-        text_opinion_filters=[
-            EntityBasedTextOpinionFilter(entity_filter=entity_filter),
-            DistanceLimitedTextOpinionFilter(terms_per_context)
-        ],
-        get_doc_by_id_func=doc_ops.by_id,
-        text_parser=text_parser)
-
-    return pipeline
-
-
-def nolabel_annotator(synonyms, terms_per_context, dist_in_sentences=0, no_label=NoLabel()):
-    """ This is a default annotator, utilized to annotate `neutral`-like attitudes.
-        Neutral means that we adopt no-label parameter, and this label might be customized
-        to the one required in your studies.
-    """
-    return AlgorithmBasedTextOpinionAnnotator(
-        annot_algo=PairBasedOpinionAnnotationAlgorithm(dist_in_sents=dist_in_sentences,
-                                                       dist_in_terms_bound=terms_per_context,
-                                                       label_provider=ConstantLabelProvider(no_label)),
-        create_empty_collection_func=lambda: OpinionCollection(
-            synonyms=synonyms, error_on_duplicates=True, error_on_synonym_end_missed=False),
-        value_to_group_id_func=lambda value:
-        SynonymsCollectionValuesGroupingProviders.provide_existed_value(synonyms=synonyms, value=value))
-
-
-def predefined_annotator(synonyms, labels_fmt):
-    """ This is a annotator-converter of the predefined Document-Level opinions onto text-level one
-    """
-    return AlgorithmBasedTextOpinionAnnotator(
-        annot_algo=PredefinedOpinionAnnotationAlgorithm(
-            lambda doc_id: __get_document_opinions(doc_id=doc_id, synonyms=synonyms, labels_fmt=labels_fmt)),
-        create_empty_collection_func=lambda: OpinionCollection(
-            synonyms=synonyms, error_on_duplicates=True, error_on_synonym_end_missed=False),
-        value_to_group_id_func=lambda value:
-        SynonymsCollectionValuesGroupingProviders.provide_existed_value(synonyms=synonyms, value=value))
-
-
-def __get_document_opinions(doc_id, synonyms, labels_fmt):
-    """ RuSentRel provides a pre-defined list of Document-Level Opinions.
-        Within this function we create the related OpinionCollection by a given doc_id.
-    """
-    return OpinionCollection(
-        opinions=RuSentRelOpinions.iter_from_doc(
-            doc_id=doc_id, labels_fmt=labels_fmt),
-        synonyms=synonyms,
-        error_on_synonym_end_missed=True,
-        error_on_duplicates=True)

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

@@ -1,29 +0,0 @@
-from arekit.common.experiment.api.ops_doc import DocumentOperations
-from arekit.contrib.source.sentinerel.io_utils import SentiNerelVersions
-from arekit.contrib.source.sentinerel.reader import SentiNerelDocReader
-
-
-class SentiNERELDocOperation(DocumentOperations):
-    """ Document reader for the collection of the RuSentNE competition 2023.
-        For more details please follow the following repository:
-        github: https://github.com/dialogue-evaluation/RuSentNE-evaluation
-    """
-
-    def __init__(self, filename_by_id, version):
-        """ filename_ids: dict
-                Dictionary of {id: filename}, where
-                    - id: int
-                    - filename: str
-            version: SentiNerelVersions
-                Specify the appropriate version of teh SentiNEREL collection.
-        """
-        assert(isinstance(filename_by_id, dict))
-        assert(isinstance(version, SentiNerelVersions))
-        super(SentiNERELDocOperation, self).__init__()
-        self.__filename_by_id = filename_by_id
-        self.__version = version
-
-    def by_id(self, doc_id):
-        return SentiNerelDocReader.read_document(doc_id=doc_id,
-                                                 version=self.__version,
-                                                 filename=self.__filename_by_id[doc_id])

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

@@ -1,62 +0,0 @@
-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

@@ -1,175 +0,0 @@
-from arekit.common.experiment.api.ops_doc import DocumentOperations
-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_ops import SentiNERELDocOperation
-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.pipelines.text_opinion.filters.entity_based import EntityBasedTextOpinionFilter
-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,
-                                            label_formatter=SentiNERELSentimentLabelFormatter(),
-                                            no_label=NoLabel(),
-                                            terms_per_context=50,
-                                            doc_ops=None,
-                                            dist_in_sentences=0,
-                                            docs_limit=None,
-                                            entity_filter=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_ops: DocumentOperations 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_ops, DocumentOperations) or doc_ops is None)
-
-    data_folding = None
-
-    if doc_ops is None:
-        # Default Initialization.
-        filenames_by_ids, data_folding = SentiNerelIOUtils.read_dataset_split(version=sentinerel_version,
-                                                                              docs_limit=docs_limit)
-        doc_ops = SentiNERELDocOperation(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 = [
-        EntityBasedTextOpinionFilter(entity_filter=entity_filter),
-        ProfessionAsCharacteristicSentimentTextOpinionFilter(),
-        DistanceLimitedTextOpinionFilter(terms_per_context)
-    ]
-
-    predefined_annot = PredefinedTextOpinionAnnotator(doc_ops, label_formatter)
-
-    pipelines = {
-        DataType.Train: create_main_pipeline(text_parser=text_parser,
-                                             doc_ops=doc_ops,
-                                             annotators=[
-                                                 predefined_annot,
-                                                 train_neut_annot
-                                             ],
-                                             text_opinion_filters=text_opinion_filters),
-        DataType.Test: create_main_pipeline(text_parser=text_parser,
-                                            doc_ops=doc_ops,
-                                            annotators=[
-                                                test_neut_annot
-                                            ],
-                                            text_opinion_filters=text_opinion_filters),
-        DataType.Etalon: create_etalon_pipeline(text_parser=text_parser,
-                                                doc_ops=doc_ops,
-                                                predefined_annot=predefined_annot,
-                                                text_opinion_filters=text_opinion_filters),
-        DataType.Dev: create_etalon_with_no_label_pipeline(text_parser=text_parser,
-                                                           doc_ops=doc_ops,
-                                                           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)),
-        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_ops, 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_ops.by_id,
-        text_parser=text_parser,
-        annotators=annotators,
-        text_opinion_filters=text_opinion_filters)
-
-
-def create_etalon_pipeline(text_parser, doc_ops, 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_ops=doc_ops,
-                                annotators=[predefined_annot],
-                                text_opinion_filters=text_opinion_filters)
-
-
-def create_etalon_with_no_label_pipeline(annotators, text_parser, doc_ops, text_opinion_filters):
-    """ We adopt exact the same pipeline as for training data.
-    """
-    return create_main_pipeline(text_parser=text_parser,
-                                doc_ops=doc_ops,
-                                annotators=annotators,
-                                text_opinion_filters=text_opinion_filters)

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

@@ -1,50 +0,0 @@
-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)