arekit 0.24.0__py3-none-any.whl

arekit/contrib/source/nerelbio/labels.py

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

arekit/contrib/source/nerelbio/reader.py

@@ -0,0 +1,8 @@
+from arekit.contrib.source.nerel.reader import NerelDocReader
+from arekit.contrib.source.nerelbio.io_utils import NerelBioIOUtils
+
+
+class NerelBioDocReader(NerelDocReader):
+
+    def __init__(self, version):
+        super(NerelBioDocReader, self).__init__(version=version, io_utils=NerelBioIOUtils())

arekit/contrib/source/nerelbio/versions.py

@@ -0,0 +1,8 @@
+import enum
+
+
+class NerelBioVersions(enum.Enum):
+    V1 = "v1_0"
+
+
+DEFAULT_VERSION = NerelBioVersions.V1

arekit/contrib/source/ruattitudes/collection.py

@@ -0,0 +1,36 @@
+from arekit.contrib.source.ruattitudes.io_utils import RuAttitudesVersions, RuAttitudesIOUtils
+from arekit.contrib.source.ruattitudes.reader import RuAttitudesFormatReader
+
+
+class RuAttitudesCollection(object):
+
+    @staticmethod
+    def __get_reading_handler(input_file, read_inds_only, get_doc_inds_func):
+        assert(isinstance(read_inds_only, bool))
+
+        if read_inds_only:
+            return RuAttitudesFormatReader.iter_docs_inds(input_file=input_file,
+                                                          get_doc_index_func=get_doc_inds_func)
+        else:
+            return RuAttitudesFormatReader.iter_docs(input_file=input_file,
+                                                     get_doc_index_func=get_doc_inds_func)
+
+    @staticmethod
+    def iter_docs(version, get_doc_index_func, return_inds_only):
+        """
+        RuAttitudes collection reader from zip archive
+        """
+        assert(isinstance(version, RuAttitudesVersions))
+        assert(callable(get_doc_index_func))
+        assert(isinstance(return_inds_only, bool))
+
+        it = RuAttitudesIOUtils.iter_from_zip(
+            inner_path=RuAttitudesIOUtils.get_collection_filepath(),
+            process_func=lambda input_filepath: RuAttitudesCollection.__get_reading_handler(
+                input_file=input_filepath,
+                read_inds_only=return_inds_only,
+                get_doc_inds_func=get_doc_index_func),
+            version=version)
+
+        for doc in it:
+            yield doc

arekit/contrib/source/ruattitudes/doc.py

@@ -0,0 +1,51 @@
+from arekit.contrib.source.ruattitudes.sentence import RuAttitudesSentence
+
+
+class RuAttitudesDocument(object):
+
+    def __init__(self, sentences, doc_index):
+        assert(len(sentences) > 0)
+
+        self.__sentences = sentences
+        self.__objects_before_sentence = self.__cache_objects_declared_before()
+        self.__doc_index = doc_index
+
+        self.__set_owners()
+
+    # region properties
+
+    @property
+    def ID(self):
+        return self.__doc_index
+
+    @property
+    def Title(self):
+        return self.__sentences[0]
+
+    # endregion
+
+    # region private methods
+
+    def __set_owners(self):
+        for sentence in self.__sentences:
+            assert(isinstance(sentence, RuAttitudesSentence))
+            sentence.set_owner(self)
+
+    def __cache_objects_declared_before(self):
+        d = {}
+        before = 0
+        for s in self.__sentences:
+            assert(isinstance(s, RuAttitudesSentence))
+            d[s.SentenceIndex] = before
+            before += s.ObjectsCount
+
+        return d
+
+    # endregion
+
+    def get_objects_declared_before(self, sentence_index):
+        return self.__objects_before_sentence[sentence_index]
+
+    def iter_sentences(self):
+        for sentence in self.__sentences:
+            yield sentence

arekit/contrib/source/ruattitudes/doc_brat.py

@@ -0,0 +1,44 @@
+from arekit.contrib.source.brat.doc import BratDocument
+from arekit.contrib.source.brat.sentence import BratSentence
+from arekit.contrib.source.ruattitudes.doc import RuAttitudesDocument
+from arekit.contrib.source.ruattitudes.opinions.base import SentenceOpinion
+from arekit.contrib.source.ruattitudes.opinions.converter import RuAttitudesSentenceOpinionConverter
+from arekit.contrib.source.ruattitudes.sentence import RuAttitudesSentence
+from arekit.common.utils import split_by_whitespaces
+
+
+class RuAttitudesDocumentsConverter(object):
+    """ Performs conversion to a brat-based representation.
+        The latter allows then allows to adopt pipelines for TextOpnion extraction.
+    """
+
+    @staticmethod
+    def to_brat_doc(doc):
+        assert(isinstance(doc, RuAttitudesDocument))
+        text_opinions = RuAttitudesDocumentsConverter.__iter_text_opinions(doc=doc)
+        brat_sentences = RuAttitudesDocumentsConverter.__to_brat_sentences(doc.iter_sentences())
+        return BratDocument(doc_id=doc.ID,
+                            sentences=brat_sentences,
+                            text_relations=list(text_opinions))
+
+    @staticmethod
+    def __to_brat_sentences(sentences_iter):
+        sentences = []
+        for s in sentences_iter:
+            assert(isinstance(s, RuAttitudesSentence))
+            assert(s.Owner is not None)
+            brat_entities = [obj.to_entity(s.get_doc_level_text_object_id) for obj in s.iter_objects()]
+            brat_sentence = BratSentence(text=split_by_whitespaces(s.Text), index_begin=0, entities=brat_entities)
+            sentences.append(brat_sentence)
+        return sentences
+
+    @staticmethod
+    def __iter_text_opinions(doc):
+        assert(isinstance(doc, RuAttitudesDocument))
+        for sentence in doc.iter_sentences():
+            assert(isinstance(sentence, RuAttitudesSentence))
+            for sentence_opinion in sentence.iter_sentence_opins():
+                assert(isinstance(sentence_opinion, SentenceOpinion))
+                yield RuAttitudesSentenceOpinionConverter.to_brat_relation(
+                    sentence_opinion=sentence_opinion,
+                    end_to_doc_id_func=sentence.get_doc_level_text_object_id)

arekit/contrib/source/ruattitudes/entity/parser.py

@@ -0,0 +1,7 @@
+from arekit.contrib.source.brat.entities.parser import BratTextEntitiesParser
+
+
+class RuAttitudesTextEntitiesParser(BratTextEntitiesParser):
+
+    def __init__(self):
+        super(RuAttitudesTextEntitiesParser, self).__init__(partitioning="terms")

arekit/contrib/source/ruattitudes/io_utils.py

@@ -0,0 +1,56 @@
+from os import path
+
+from enum import Enum
+
+from arekit.contrib.source.zip_utils import ZipArchiveUtils
+
+
+class RuAttitudesVersions(Enum):
+    Debug = "dbg"
+    V10 = "v1_0"
+    V11 = "v1_1"
+    V20Base = 'v2_0_base'
+    V20Large = 'v2_0_large'
+    V20BaseNeut = 'v2_0_base_neut'
+    V20LargeNeut = 'v2_0_large_neut'
+
+
+class RuAttitudesVersionsService:
+
+    @staticmethod
+    def __iter_type_and_names():
+        for version_type in RuAttitudesVersions:
+            yield version_type, version_type.value
+
+    @staticmethod
+    def find_by_name(name):
+        for version_type, related_name in RuAttitudesVersionsService.__iter_type_and_names():
+            if name == related_name:
+                return version_type
+        raise Exception("Version `{}` does not supported".format(name))
+
+    @staticmethod
+    def iter_supported_names():
+        for _, name in RuAttitudesVersionsService.__iter_type_and_names():
+            yield name
+
+
+class RuAttitudesIOUtils(ZipArchiveUtils):
+
+    # region internal methods
+
+    @staticmethod
+    def get_archive_filepath(version):
+        assert(isinstance(version, str))
+        return path.join(RuAttitudesIOUtils.get_data_root(),
+                         "ruattitudes-{version}.zip".format(version=version))
+
+    @staticmethod
+    def get_collection_filepath():
+        return "collection.txt"
+
+    @classmethod
+    def get_synonyms_innerpath(cls):
+        return "synonyms.txt"
+
+    # endregion

arekit/contrib/source/ruattitudes/labels_fmt.py

@@ -0,0 +1,12 @@
+from arekit.common.labels.scaler.base import BaseLabelScaler
+from arekit.common.labels.str_fmt import StringLabelsFormatter
+
+
+class RuAttitudesLabelFormatter(StringLabelsFormatter):
+
+    def __init__(self, label_scaler):
+        assert(isinstance(label_scaler, BaseLabelScaler))
+        stol = {}
+        for int_label in [-1, 0, 1]:
+            stol[str(int_label)] = type(label_scaler.int_to_label(int_label))
+        super(RuAttitudesLabelFormatter, self).__init__(stol=stol)

arekit/contrib/source/ruattitudes/opinions/base.py

@@ -0,0 +1,28 @@
+class SentenceOpinion(object):
+    """ Provides an opinion within a sentence.
+        Specific for RuAttitudes collection, as the latter provides
+        connections within a sentence.
+    """
+
+    def __init__(self, source_id, target_id, label_int, tag):
+        assert(isinstance(label_int, int))
+        self.__label_int = label_int
+        self.__source_id = source_id
+        self.__target_id = target_id
+        self.__tag = tag
+
+    @property
+    def SourceID(self):
+        return self.__source_id
+
+    @property
+    def TargetID(self):
+        return self.__target_id
+
+    @property
+    def Label(self):
+        return self.__label_int
+
+    @property
+    def Tag(self):
+        return self.__tag

arekit/contrib/source/ruattitudes/opinions/converter.py

@@ -0,0 +1,37 @@
+from arekit.common.labels.scaler.base import BaseLabelScaler
+from arekit.common.opinions.base import Opinion
+from arekit.contrib.source.brat.relation import BratRelation
+from arekit.contrib.source.ruattitudes.opinions.base import SentenceOpinion
+
+
+class RuAttitudesSentenceOpinionConverter:
+
+    @staticmethod
+    def to_brat_relation(sentence_opinion, end_to_doc_id_func):
+        """ Converts opinion into brat-related relation.
+            NOTE: for rel_type we just call str() over int-based value.
+        """
+        assert(isinstance(sentence_opinion, SentenceOpinion))
+        return BratRelation(id_in_doc="0",
+                            source_id=end_to_doc_id_func(sentence_opinion.SourceID),
+                            target_id=end_to_doc_id_func(sentence_opinion.TargetID),
+                            rel_type=str(sentence_opinion.Label))
+
+    @staticmethod
+    def to_opinion(sentence_opinion, source_value, target_value, label_scaler):
+        """
+        Converts onto document, non referenced opinion
+        (non bounded to the text).
+        """
+        assert(isinstance(sentence_opinion, SentenceOpinion))
+        assert(isinstance(label_scaler, BaseLabelScaler))
+
+        opinion = Opinion(source_value=source_value,
+                          target_value=target_value,
+                          label=label_scaler.int_to_label(sentence_opinion.Label))
+
+        # Using this tag allows to perform a revert operation,
+        # i.e. to find opinion_ref by opinion.
+        opinion.set_tag(sentence_opinion.Tag)
+
+        return opinion