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

arekit/common/docs/parsed/providers/base.py

@@ -0,0 +1,68 @@
+from arekit.common.entities.base import Entity
+from arekit.common.docs.entity import DocumentEntity
+from arekit.common.docs.parsed.base import ParsedDocument
+
+
+class BaseParsedDocumentServiceProvider(object):
+
+    def __init__(self, entity_index_func=None):
+        """ Outside enity indexing function
+            entity_index_func: provides id for a given entity, i.e.
+                func(entity) -> int (id)
+        """
+        assert(callable(entity_index_func) or entity_index_func is None)
+        self._doc_entities = None
+        self.__entity_map = {}
+        self.__entity_index_func = entity_index_func
+
+    @property
+    def Name(self):
+        raise NotImplementedError()
+
+    def init_parsed_doc(self, parsed_doc):
+        assert(isinstance(parsed_doc, ParsedDocument))
+
+        def __iter_childs_and_root_node(entity):
+            """ Note: Entity has childs and we would like to iterate over childs
+                to conider them as well as keep the root Node.
+            """
+            # We first add childs.
+            for child_entity in entity.iter_childs():
+                yield child_entity, True
+
+            # Return Root node.
+            yield entity, False
+
+        self._doc_entities = []
+        self.__entity_map.clear()
+
+        current_id = 0
+        for _, entity in enumerate(parsed_doc.iter_entities()):
+
+            child_doc_entities = []
+            for tree_entity, is_child in __iter_childs_and_root_node(entity):
+
+                doc_entity = DocumentEntity(id_in_doc=current_id,
+                                            value=tree_entity.Value,
+                                            e_type=tree_entity.Type,
+                                            display_value=tree_entity.DisplayValue,
+                                            childs=None if is_child else child_doc_entities,
+                                            group_index=tree_entity.GroupIndex)
+                current_id += 1
+
+                if is_child:
+                    child_doc_entities.append(doc_entity)
+
+                self._doc_entities.append(doc_entity)
+
+                if self.__entity_index_func is not None:
+                    self.__entity_map[self.__entity_index_func(tree_entity)] = doc_entity
+
+    def get_document_entity(self, entity):
+        """ Maps entity to the related one with DocumentEntity type
+        """
+        assert(isinstance(entity, Entity))
+        return self.__entity_map[self.__entity_index_func(entity)]
+
+    def contains_entity(self, entity):
+        return self.__entity_index_func(entity) in self.__entity_map

arekit/common/{news → docs}/parsed/providers/base_pairs.py

@@ -1,8 +1,8 @@
 from arekit.common.labels.provider.base import BasePairLabelProvider
-from arekit.common.news.parsed.providers.base import BaseParsedNewsServiceProvider
+from arekit.common.docs.parsed.providers.base import BaseParsedDocumentServiceProvider
 
 
-class BasePairProvider(BaseParsedNewsServiceProvider):
+class BasePairProvider(BaseParsedDocumentServiceProvider):
 
     @property
     def Name(self):

arekit/common/{news → docs}/parsed/providers/entity_service.py

@@ -1,10 +1,10 @@
 from enum import Enum
 
 from arekit.common.entities.base import Entity
-from arekit.common.news.entity import DocumentEntity
-from arekit.common.news.parsed.base import ParsedNews
-from arekit.common.news.parsed.providers.base import BaseParsedNewsServiceProvider
-from arekit.common.news.parsed.term_position import TermPositionTypes, TermPosition
+from arekit.common.docs.entity import DocumentEntity
+from arekit.common.docs.parsed.base import ParsedDocument
+from arekit.common.docs.parsed.providers.base import BaseParsedDocumentServiceProvider
+from arekit.common.docs.parsed.term_position import TermPositionTypes, TermPosition
 from arekit.common.text_opinions.base import TextOpinion
 
 
@@ -30,18 +30,19 @@ class DistanceType(Enum):
             return TermPositionTypes.SentenceIndex
 
 
-class EntityServiceProvider(BaseParsedNewsServiceProvider):
+class EntityServiceProvider(BaseParsedDocumentServiceProvider):
     """ This class provides a helper functions for TextOpinions, which become a part of TextOpinionCollection.
         The latter is important because of the dependency from Owner.
         We utilize 'extract' prefix in methods to emphasize that these are methods of helper.
 
         Wrapper over:
-            parsed news, positions, text_opinions
+            parsed doc, positions, text_opinions
     """
 
     NAME = "entity-service-provider"
 
     def __init__(self, entity_index_func):
+        assert(callable(entity_index_func))
         super(EntityServiceProvider, self).__init__(entity_index_func=entity_index_func)
         # Initialize API.
         self.__iter_raw_terms_func = None
@@ -52,11 +53,11 @@ class EntityServiceProvider(BaseParsedNewsServiceProvider):
     def Name(self):
         return self.NAME
 
-    def init_parsed_news(self, parsed_news):
-        super(EntityServiceProvider, self).init_parsed_news(parsed_news)
-        assert(isinstance(parsed_news, ParsedNews))
-        self.__iter_raw_terms_func = lambda: parsed_news.iter_terms(filter_func=None, term_only=False)
-        self.__init_entity_positions()
+    def init_parsed_doc(self, parsed_doc):
+        super(EntityServiceProvider, self).init_parsed_doc(parsed_doc)
+        assert(isinstance(parsed_doc, ParsedDocument))
+        self.__iter_raw_terms_func = lambda: parsed_doc.iter_terms(filter_func=None, term_only=False)
+        self.__entity_positions = self.__calculate_entity_positions()
 
     # region public 'extract' methods
 
@@ -146,25 +147,29 @@ class EntityServiceProvider(BaseParsedNewsServiceProvider):
         assert(end_type == EntityEndType.Source or end_type == EntityEndType.Target)
         return text_opinion.SourceId if end_type == EntityEndType.Source else text_opinion.TargetId
 
-    def __init_entity_positions(self):
-        self.__entity_positions = self.__calculate_entity_positions()
-
     def __calculate_entity_positions(self):
         """ Note: here we consider the same order as in self._entities.
         """
-        positions = []
-        t_ind_in_doc = 0
+        t_ind_in_doc = -1
 
+        positions = {}
         for s_ind, t_ind_in_sent, term in self.__iter_raw_terms_func():
 
-            if isinstance(term, Entity):
-                position = TermPosition(term_ind_in_doc=t_ind_in_doc,
-                                        term_ind_in_sent=t_ind_in_sent,
-                                        s_ind=s_ind)
-                positions.append(position)
-
             t_ind_in_doc += 1
 
+            if not isinstance(term, Entity):
+                continue
+
+            # We consider that entities within a single tree has the same positions.
+            for tree_entity in list(term.iter_childs()) + [term]:
+
+                key = self.get_document_entity(tree_entity).IdInDocument
+                assert(key not in positions)
+
+                positions[key] = TermPosition(term_ind_in_doc=t_ind_in_doc,
+                                              term_ind_in_sent=t_ind_in_sent,
+                                              s_ind=s_ind)
+
         return positions
 
     # endregion

arekit/common/{news → docs}/parsed/providers/opinion_pairs.py

@@ -1,5 +1,5 @@
 from arekit.common.entities.base import Entity
-from arekit.common.news.parsed.providers.base_pairs import BasePairProvider
+from arekit.common.docs.parsed.providers.base_pairs import BasePairProvider
 from arekit.common.opinions.base import Opinion
 
 
@@ -17,4 +17,4 @@ class OpinionPairsProvider(BasePairProvider):
 
         return Opinion(source_value=source_entity.Value,
                        target_value=target_entity.Value,
-                       sentiment=label)
+                       label=label)

arekit/common/{news → docs}/parsed/providers/text_opinion_pairs.py

@@ -1,8 +1,8 @@
 import logging
 
 from arekit.common.entities.collection import EntityCollection
-from arekit.common.news.entity import DocumentEntity
-from arekit.common.news.parsed.providers.base_pairs import BasePairProvider
+from arekit.common.docs.entity import DocumentEntity
+from arekit.common.docs.parsed.providers.base_pairs import BasePairProvider
 from arekit.common.opinions.base import Opinion
 from arekit.common.text_opinions.base import TextOpinion
 from arekit.common.labels.provider.constant import ConstantLabelProvider
@@ -36,9 +36,9 @@ class TextOpinionPairsProvider(BasePairProvider):
                            label=label,
                            text_opinion_id=None)
 
-    def init_parsed_news(self, parsed_news):
-        super(TextOpinionPairsProvider, self).init_parsed_news(parsed_news)
-        self.__doc_id = parsed_news.RelatedDocID
+    def init_parsed_doc(self, parsed_doc):
+        super(TextOpinionPairsProvider, self).init_parsed_doc(parsed_doc)
+        self.__doc_id = parsed_doc.RelatedDocID
         self.__entities_collection = EntityCollection(
             entities=list(self._doc_entities),
             value_to_group_id_func=self.__value_to_group_id_func)
@@ -68,7 +68,7 @@ class TextOpinionPairsProvider(BasePairProvider):
             return
             yield
 
-        label_provider = ConstantLabelProvider(label_instance=opinion.Sentiment)
+        label_provider = ConstantLabelProvider(label_instance=opinion.Label)
 
         pairs_it = self._iter_from_entities(src_entity_doc_ids=list(map(lambda e: e.IdInDocument, source_entities)),
                                             tgt_entity_doc_ids=list(map(lambda e: e.IdInDocument, target_entities)),

arekit/common/docs/parsed/service.py

@@ -0,0 +1,31 @@
+from arekit.common.docs.parsed.base import ParsedDocument
+from arekit.common.docs.parsed.providers.base import BaseParsedDocumentServiceProvider
+
+
+class ParsedDocumentService(object):
+    """ Represents a collection of providers, combined with the parsed doc.
+    """
+
+    def __init__(self, parsed_doc, providers):
+        assert(isinstance(parsed_doc, ParsedDocument))
+        assert(isinstance(providers, list))
+        self.__parsed_doc = parsed_doc
+        self.__providers = {}
+
+        for provider in providers:
+            assert(isinstance(provider, BaseParsedDocumentServiceProvider))
+            assert(provider.Name not in self.__providers)
+
+            # Link provider with the related name.
+            self.__providers[provider.Name] = provider
+
+            # Post initialize with the related parsed doc.
+            provider.init_parsed_doc(self.__parsed_doc)
+
+
+    @property
+    def ParsedDocument(self):
+        return self.__parsed_doc
+
+    def get_provider(self, name):
+        return self.__providers[name]

arekit/common/docs/parser.py

@@ -0,0 +1,66 @@
+from tqdm import tqdm
+from arekit.common.docs.base import Document
+from arekit.common.docs.parsed.base import ParsedDocument
+from arekit.common.pipeline.base import BasePipelineLauncher
+from arekit.common.pipeline.batching import BatchingPipelineLauncher
+from arekit.common.pipeline.context import PipelineContext
+from arekit.common.pipeline.utils import BatchIterator
+from arekit.common.text.parsed import BaseParsedText
+
+
+class DocumentParsers(object):
+
+    @staticmethod
+    def parse(doc, pipeline_items, parent_ppl_ctx=None, src_key="input", show_progress=False):
+        """ This document parser is based on single text parts (sentences)
+            that passes sequentially through the pipeline of transformations.
+        """
+        assert(isinstance(doc, Document))
+        assert(isinstance(pipeline_items, list))
+        assert(isinstance(parent_ppl_ctx, PipelineContext) or parent_ppl_ctx is None)
+
+        parsed_sentences = []
+
+        data_it = range(doc.SentencesCount)
+        progress_it = tqdm(data_it, disable=not show_progress)
+
+        for sent_ind in progress_it:
+
+            # Composing the context from a single sentence.
+            ctx = PipelineContext({src_key: doc.get_sentence(sent_ind)}, parent_ctx=parent_ppl_ctx)
+
+            # Apply all the operations.
+            BasePipelineLauncher.run(pipeline=pipeline_items, pipeline_ctx=ctx, src_key=src_key)
+
+            # Collecting the result.
+            parsed_sentences.append(BaseParsedText(terms=ctx.provide("result")))
+
+        return ParsedDocument(doc_id=doc.ID, parsed_sentences=parsed_sentences)
+
+    @staticmethod
+    def parse_batch(doc, pipeline_items, batch_size, parent_ppl_ctx=None, src_key="input", show_progress=False):
+        """ This document parser is based on batch of sentences.
+        """
+        assert(isinstance(batch_size, int) and batch_size > 0)
+        assert(isinstance(doc, Document))
+        assert(isinstance(pipeline_items, list))
+        assert(isinstance(parent_ppl_ctx, PipelineContext) or parent_ppl_ctx is None)
+
+        parsed_sentences = []
+
+        data_it = BatchIterator(data_iter=iter(range(doc.SentencesCount)), batch_size=batch_size)
+        progress_it = tqdm(data_it, total=round(doc.SentencesCount / batch_size), disable=not show_progress)
+
+        for batch in progress_it:
+
+            # Composing the context from a single sentence.
+            ctx = PipelineContext({src_key: [doc.get_sentence(s_ind) for s_ind in batch]},
+                                  parent_ctx=parent_ppl_ctx)
+
+            # Apply all the operations.
+            BatchingPipelineLauncher.run(pipeline=pipeline_items, pipeline_ctx=ctx, src_key=src_key)
+
+            # Collecting the result.
+            parsed_sentences += [BaseParsedText(terms=result) for result in ctx.provide("result")]
+
+        return ParsedDocument(doc_id=doc.ID, parsed_sentences=parsed_sentences)

arekit/common/{news → docs}/sentence.py

@@ -1,5 +1,5 @@
 
-class BaseNewsSentence(object):
+class BaseDocumentSentence(object):
 
     def __init__(self, text):
         self.__text = text

arekit/common/entities/base.py

@@ -1,14 +1,16 @@
 class Entity(object):
 
-    def __init__(self, value, e_type, display_value=None, group_index=None):
+    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)
-        self.__value = value.lower()
+        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):
@@ -40,3 +42,10 @@ class Entity(object):
         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/experiment/api/base_samples_io.py

@@ -14,7 +14,7 @@ class BaseSamplesIO(object):
         """
         raise NotImplementedError()
 
-    def create_target(self, data_type, data_folding):
+    def create_target(self, data_type):
         """ Path for reaiding/viewing
         """
         raise NotImplementedError()

arekit/common/frames/variants/collection.py

@@ -1,4 +1,4 @@
-import collections
+from collections.abc import Iterable
 from arekit.common.frames.variants.base import FrameVariant
 
 
@@ -23,7 +23,7 @@ class FrameVariantsCollection(object):
     # region public methods
 
     def fill_from_iterable(self, variants_with_id, overwrite_existed_variant, raise_error_on_existed_variant):
-        assert(isinstance(variants_with_id, collections.Iterable))
+        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)

arekit/common/linkage/base.py

@@ -1,10 +1,10 @@
-import collections
+from collections.abc import Iterable
 
 
 class LinkedDataWrapper(object):
 
     def __init__(self, linked_data):
-        assert(isinstance(linked_data, collections.Iterable))
+        assert(isinstance(linked_data, Iterable))
         self.__linked_data = list(linked_data)
         self.__tag = None
 

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

@@ -6,4 +6,4 @@ class OpinionsLinkage(LinkedDataWrapper):
 
     def _get_data_label(self, item):
         assert(isinstance(item, Opinion))
-        return item.Sentiment
+        return item.Label

arekit/common/linkage/text_opinions.py

@@ -15,8 +15,8 @@ class TextOpinionsLinkage(LinkedDataWrapper):
         return self.First.DocID
 
     def get_linked_label(self):
-        return self.First.Sentiment
+        return self.First.Label
 
     def _get_data_label(self, item):
         assert(isinstance(item, TextOpinion))
-        return item.Sentiment
+        return item.Label

arekit/common/opinions/annot/algo/base.py

@@ -1,4 +1,4 @@
 class BaseOpinionAnnotationAlgorithm(object):
 
-    def iter_opinions(self, parsed_news, existed_opinions=None):
+    def iter_opinions(self, parsed_doc, existed_opinions=None):
         pass

arekit/common/opinions/annot/algo/pair_based.py

@@ -1,9 +1,9 @@
 from arekit.common.entities.types import OpinionEntityType
 from arekit.common.labels.provider.base import BasePairLabelProvider
-from arekit.common.news.entity import DocumentEntity
-from arekit.common.news.parsed.base import ParsedNews
-from arekit.common.news.parsed.providers.entity_service import EntityServiceProvider, DistanceType
-from arekit.common.news.parsed.providers.opinion_pairs import OpinionPairsProvider
+from arekit.common.docs.entity import DocumentEntity
+from arekit.common.docs.parsed.base import ParsedDocument
+from arekit.common.docs.parsed.providers.entity_service import EntityServiceProvider, DistanceType
+from arekit.common.docs.parsed.providers.opinion_pairs import OpinionPairsProvider
 from arekit.common.opinions.annot.algo.base import BaseOpinionAnnotationAlgorithm
 from arekit.common.opinions.base import Opinion
 
@@ -16,7 +16,8 @@ class PairBasedOpinionAnnotationAlgorithm(BaseOpinionAnnotationAlgorithm):
             [1] Extracting Sentiment Attitudes from Analytical Texts https://arxiv.org/pdf/1808.08932.pdf
     """
 
-    def __init__(self, dist_in_terms_bound, label_provider, dist_in_sents=0, is_entity_ignored_func=None):
+    def __init__(self, dist_in_terms_bound, label_provider, entity_index_func, dist_in_sents=0,
+                 is_entity_ignored_func=None):
         """
         dist_in_terms_bound: int
             max allowed distance in term (less than passed value)
@@ -25,6 +26,7 @@ class PairBasedOpinionAnnotationAlgorithm(BaseOpinionAnnotationAlgorithm):
         """
         assert(isinstance(dist_in_terms_bound, int) or dist_in_terms_bound is None)
         assert(isinstance(label_provider, BasePairLabelProvider))
+        assert(callable(entity_index_func))
         assert(isinstance(dist_in_sents, int))
         assert(callable(is_entity_ignored_func) or is_entity_ignored_func is None)
 
@@ -32,6 +34,7 @@ class PairBasedOpinionAnnotationAlgorithm(BaseOpinionAnnotationAlgorithm):
         self.__dist_in_terms_bound = dist_in_terms_bound
         self.__dist_in_sents = dist_in_sents
         self.__is_entity_ignored_func = is_entity_ignored_func
+        self.__entity_index_func = entity_index_func
 
     # region private methods
 
@@ -68,7 +71,7 @@ class PairBasedOpinionAnnotationAlgorithm(BaseOpinionAnnotationAlgorithm):
         if existed_opinions is not None:
             o = Opinion(source_value=e1.Value,
                         target_value=e2.Value,
-                        sentiment=self.__label_provider.provide(source=e1, target=e2))
+                        label=self.__label_provider.provide(source=e1, target=e2))
             if existed_opinions.has_synonymous_opinion(opinion=o):
                 return
 
@@ -76,8 +79,8 @@ class PairBasedOpinionAnnotationAlgorithm(BaseOpinionAnnotationAlgorithm):
 
     # endregion
 
-    def iter_opinions(self, parsed_news, existed_opinions=None):
-        assert(isinstance(parsed_news, ParsedNews))
+    def iter_opinions(self, parsed_doc, existed_opinions=None):
+        assert(isinstance(parsed_doc, ParsedDocument))
 
         def __filter_pair_func(e1, e2):
             key = self.__try_create_pair_key(entity_service=entity_service_provider,
@@ -87,11 +90,10 @@ class PairBasedOpinionAnnotationAlgorithm(BaseOpinionAnnotationAlgorithm):
             return key is not None
 
         # Initialize providers.
-        # TODO. Provide here service #245 issue.
-        opinions_provider = OpinionPairsProvider(entity_index_func=None)
-        entity_service_provider = EntityServiceProvider(entity_index_func=None)
-        opinions_provider.init_parsed_news(parsed_news)
-        entity_service_provider.init_parsed_news(parsed_news)
+        opinions_provider = OpinionPairsProvider(entity_index_func=self.__entity_index_func)
+        entity_service_provider = EntityServiceProvider(entity_index_func=self.__entity_index_func)
+        opinions_provider.init_parsed_doc(parsed_doc)
+        entity_service_provider.init_parsed_doc(parsed_doc)
 
         return opinions_provider.iter_from_all(label_provider=self.__label_provider,
                                                filter_func=__filter_pair_func)

arekit/common/opinions/annot/algo/predefined.py

@@ -1,4 +1,4 @@
-from arekit.common.news.parsed.base import ParsedNews
+from arekit.common.docs.parsed.base import ParsedDocument
 from arekit.common.opinions.annot.algo.base import BaseOpinionAnnotationAlgorithm
 
 
@@ -11,6 +11,6 @@ class PredefinedOpinionAnnotationAlgorithm(BaseOpinionAnnotationAlgorithm):
         assert(callable(get_opinions_by_doc_id_func))
         self.__get_opinions_by_doc_id_func = get_opinions_by_doc_id_func
 
-    def iter_opinions(self, parsed_news, existed_opinions=None):
-        assert(isinstance(parsed_news, ParsedNews))
-        return self.__get_opinions_by_doc_id_func(parsed_news.RelatedDocID)
+    def iter_opinions(self, parsed_doc, existed_opinions=None):
+        assert(isinstance(parsed_doc, ParsedDocument))
+        return self.__get_opinions_by_doc_id_func(parsed_doc.RelatedDocID)

arekit/common/opinions/annot/algo_based.py

@@ -1,6 +1,6 @@
 import logging
 
-from arekit.common.news.parsed.base import ParsedNews
+from arekit.common.docs.parsed.base import ParsedDocument
 from arekit.common.opinions.annot.algo.base import BaseOpinionAnnotationAlgorithm
 from arekit.common.opinions.annot.base import BaseOpinionAnnotator
 from arekit.common.opinions.collection import OpinionCollection
@@ -31,14 +31,14 @@ class AlgorithmBasedOpinionAnnotator(BaseOpinionAnnotator):
 
     # region private methods
 
-    def _annot_collection_core(self, parsed_news):
-        assert(isinstance(parsed_news, ParsedNews))
+    def _annot_collection_core(self, parsed_doc):
+        assert(isinstance(parsed_doc, ParsedDocument))
 
-        opinions = self.__get_existed_opinions_func(parsed_news.RelatedDocID)
+        opinions = self.__get_existed_opinions_func(parsed_doc.RelatedDocID)
         assert(isinstance(opinions, OpinionCollection) or opinions is None)
         
         annotated_opinions_it = self.__annot_algo.iter_opinions(
-            parsed_news=parsed_news, existed_opinions=opinions)
+            parsed_doc=parsed_doc, existed_opinions=opinions)
 
         collection = self.__create_empty_collection_func()
         assert(isinstance(collection, OpinionCollection))

arekit/common/opinions/annot/base.py

@@ -4,12 +4,12 @@ class BaseOpinionAnnotator(object):
     using OpinOps and DocOps API.
     """
 
-    def _annot_collection_core(self, parsed_news):
+    def _annot_collection_core(self, parsed_doc):
         raise NotImplementedError
 
     # region public methods
 
-    def annotate_collection(self, parsed_news):
-        return self._annot_collection_core(parsed_news=parsed_news)
+    def annotate_collection(self, parsed_doc):
+        return self._annot_collection_core(parsed_doc=parsed_doc)
 
     # endregion

arekit/common/opinions/base.py

@@ -7,13 +7,13 @@ class Opinion(object):
     """ Source opinion description
     """
 
-    def __init__(self, source_value, target_value, sentiment):
+    def __init__(self, source_value, target_value, label):
         assert(isinstance(source_value, str))
         assert(isinstance(target_value, str))
-        assert(isinstance(sentiment, Label))
-        self.__source_value = source_value.lower()
-        self.__target_value = target_value.lower()
-        self.__sentiment = sentiment
+        assert(isinstance(label, Label))
+        self.__source_value = source_value
+        self.__target_value = target_value
+        self.__label = label
         self.__tag = None
 
     # region properties
@@ -27,8 +27,8 @@ class Opinion(object):
         return self.__target_value
 
     @property
-    def Sentiment(self):
-        return self.__sentiment
+    def Label(self):
+        return self.__label
 
     @property
     def Tag(self):

arekit/common/opinions/collection.py

@@ -1,4 +1,4 @@
-import collections
+from collections.abc import Iterable
 
 from arekit.common import log_utils
 from arekit.common.labels.base import Label
@@ -23,7 +23,7 @@ class OpinionCollection(object):
         raise_exception_on_duplicates: bool
             denotes whether there is a need to fire exception for duplicates in opinions list.
         """
-        assert(isinstance(opinions, collections.Iterable) or isinstance(opinions, type(None)))
+        assert(isinstance(opinions, Iterable) or isinstance(opinions, type(None)))
         assert(isinstance(synonyms, SynonymsCollection))
         assert(isinstance(error_on_duplicates, bool))
         assert(isinstance(error_on_synonym_end_missed, bool))
@@ -76,7 +76,7 @@ class OpinionCollection(object):
         f_o = self.__by_synonyms[s_id]
         if label is None:
             return f_o
-        elif f_o.sentiment == label:
+        elif f_o.Label == label:
             return f_o
         else:
             return None