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

arekit/contrib/utils/data/writers/sqlite_native.py

@@ -0,0 +1,114 @@
+import os
+import sqlite3
+from os.path import dirname
+
+from arekit.common.data import const
+from arekit.contrib.utils.data.storages.row_cache import RowCacheStorage
+from arekit.contrib.utils.data.writers.base import BaseWriter
+
+
+class SQliteWriter(BaseWriter):
+    """ TODO. This implementation is dedicated for the writing concepts of the data
+        serialization pipeline. However we add the SQLite3 service, it would be
+        right to refactor and utlize some core functionality from the core/service/sqlite.py
+    """
+
+    def __init__(self, table_name="contents", index_column_names=None, skip_existed=False, clear_table=True):
+        """ index_column_names: list or None
+                column names should be considered to build a unique index;
+                if None, the default 'const.ID' will be considered for row indexation.
+        """
+        assert (isinstance(index_column_names, list) or index_column_names is None)
+        self.__index_column_names = index_column_names if index_column_names is not None else [const.ID]
+        self.__table_name = table_name
+        self.__conn = None
+        self.__cur = None
+        self.__need_init_table = True
+        self.__origin_column_names = None
+        self.__skip_existed = skip_existed
+        self.__clear_table = clear_table
+
+    def extension(self):
+        return ".sqlite"
+
+    @staticmethod
+    def __iter_storage_column_names(storage):
+        """ Iter only those columns that existed in storage.
+        """
+        assert (isinstance(storage, RowCacheStorage))
+        for col_name, col_type in zip(storage.iter_column_names(), storage.iter_column_types()):
+            if col_name in storage.RowCache:
+                yield col_name, col_type
+
+    def __init_table(self, column_data):
+        # Compose column name with the related SQLITE type.
+        column_types = ",".join([" ".join([col_name, self.type_to_sqlite(col_type)])
+                                 for col_name, col_type in column_data])
+        # Create table if not exists.
+        self.__cur.execute(f"CREATE TABLE IF NOT EXISTS {self.__table_name}({column_types})")
+        # Table exists, however we may optionally remove the content from it.
+        if self.__clear_table:
+            self.__cur.execute(f"DELETE FROM {self.__table_name};")
+        # Create index.
+        index_name = f"i_{self.__table_name}_id"
+        self.__cur.execute(f"DROP INDEX IF EXISTS {index_name};")
+        self.__cur.execute("CREATE INDEX IF NOT EXISTS {index} ON {table}({columns})".format(
+            index=index_name,
+            table=self.__table_name,
+            columns=", ".join(self.__index_column_names)
+        ))
+        self.__origin_column_names = [col_name for col_name, _ in column_data]
+
+    @staticmethod
+    def type_to_sqlite(col_type):
+        """ This is a simple function that provides conversion from the
+            base numpy types to SQLITE.
+            NOTE: this method represent a quick implementation for supporting
+            types, however it is far away from the generalized implementation.
+        """
+        if isinstance(col_type, str):
+            if 'int' in col_type:
+                return 'INTEGER'
+
+        return "TEXT"
+
+    def open_target(self, target):
+        os.makedirs(dirname(target), exist_ok=True)
+        self.__conn = sqlite3.connect(target)
+        self.__cur = self.__conn.cursor()
+
+    def commit_line(self, storage):
+        assert (isinstance(storage, RowCacheStorage))
+
+        column_data = list(self.__iter_storage_column_names(storage))
+
+        if self.__need_init_table:
+            self.__init_table(column_data)
+            self.__need_init_table = False
+
+        # Check whether the related row is already exist in SQLITE database.
+        row_id = storage.RowCache[const.ID]
+        top_row = self.__cur.execute(f"SELECT EXISTS(SELECT 1 FROM {self.__table_name} WHERE id='{row_id}');")
+        is_exists = top_row.fetchone()[0]
+        if is_exists == 1 and self.__skip_existed:
+            return
+
+        line_data = [storage.RowCache[col_name] for col_name, _ in column_data]
+        parameters = ",".join(["?"] * len(line_data))
+
+        assert (len(self.__origin_column_names) == len(line_data))
+
+        self.__cur.execute(
+            f"INSERT OR REPLACE INTO {self.__table_name} VALUES ({parameters})",
+            tuple(line_data))
+
+        self.__conn.commit()
+
+    def close_target(self):
+        self.__cur = None
+        self.__origin_column_names = None
+        self.__need_init_table = True
+        self.__conn.close()
+
+    def write_all(self, storage, target):
+        pass

arekit/contrib/utils/io_utils/embedding.py

@@ -1,11 +1,9 @@
 from os.path import join
 
-from arekit.common.folding.base import BaseDataFolding
 from arekit.contrib.networks.embedding_io import BaseEmbeddingIO
 from arekit.contrib.utils.io_utils.utils import check_targets_existence
 from arekit.contrib.utils.np_utils.embedding import NpzEmbeddingHelper
 from arekit.contrib.utils.np_utils.vocab import VocabRepositoryUtils
-from arekit.contrib.utils.utils_folding import experiment_iter_index
 
 
 class NpEmbeddingIO(BaseEmbeddingIO):
@@ -17,37 +15,35 @@ class NpEmbeddingIO(BaseEmbeddingIO):
             - embedding vocabulary.
     """
 
-    TERM_EMBEDDING_FILENAME_TEMPLATE = 'term_embedding-{cv_index}'
-    VOCABULARY_FILENAME_TEMPLATE = "vocab-{cv_index}.txt"
-
-    def __init__(self, target_dir):
+    def __init__(self, target_dir, prefix_name="sample"):
         assert(isinstance(target_dir, str))
+
         self.__target_dir = target_dir
+        self.__term_emb_fn_template = "-".join([prefix_name, "term_embedding"])
+        self.__vocab_fn_template = "-".join([prefix_name, "term_embedding"])
 
     # region Embedding-related data
 
-    def save_vocab(self, data, data_folding):
-        assert(isinstance(data_folding, BaseDataFolding))
-        target = self.__get_default_vocab_filepath(data_folding)
+    def save_vocab(self, data):
+        target = self.__get_default_vocab_filepath()
         return VocabRepositoryUtils.save(data=data, target=target)
 
-    def load_vocab(self, data_folding):
-        source = self.___get_vocab_source(data_folding)
+    def load_vocab(self):
+        source = self.___get_vocab_source()
         return dict(VocabRepositoryUtils.load(source))
 
-    def save_embedding(self, data, data_folding):
-        assert(isinstance(data_folding, BaseDataFolding))
-        target = self.__get_default_embedding_filepath(data_folding)
+    def save_embedding(self, data):
+        target = self.__get_default_embedding_filepath()
         NpzEmbeddingHelper.save_embedding(data=data, target=target)
 
-    def load_embedding(self, data_folding):
-        source = self.__get_term_embedding_source(data_folding)
+    def load_embedding(self):
+        source = self.__get_term_embedding_source()
         return NpzEmbeddingHelper.load_embedding(source)
 
-    def check_targets_existed(self, data_folding):
+    def check_targets_existed(self):
         targets = [
-            self.__get_default_vocab_filepath(data_folding=data_folding),
-            self.__get_term_embedding_target(data_folding=data_folding)
+            self.__get_default_vocab_filepath(),
+            self.__get_term_embedding_target()
         ]
         return check_targets_existence(targets=targets)
 
@@ -55,26 +51,22 @@ class NpEmbeddingIO(BaseEmbeddingIO):
 
     # region embedding-related data
 
-    def ___get_vocab_source(self, data_folding):
+    def ___get_vocab_source(self):
         """ It is possible to load a predefined embedding from another experiment
             using the related filepath provided by model_io.
         """
-        return self.__get_default_vocab_filepath(data_folding)
+        return self.__get_default_vocab_filepath()
 
-    def __get_term_embedding_target(self, data_folding):
-        return self.__get_default_embedding_filepath(data_folding)
+    def __get_term_embedding_target(self):
+        return self.__get_default_embedding_filepath()
 
-    def __get_term_embedding_source(self, data_folding):
-        return self.__get_default_embedding_filepath(data_folding)
+    def __get_term_embedding_source(self):
+        return self.__get_default_embedding_filepath()
 
-    def __get_default_vocab_filepath(self, data_folding):
-        return join(self.__target_dir,
-                    self.VOCABULARY_FILENAME_TEMPLATE.format(
-                        cv_index=experiment_iter_index(data_folding)))
+    def __get_default_vocab_filepath(self):
+        return join(self.__target_dir, self.__vocab_fn_template)
 
-    def __get_default_embedding_filepath(self, data_folding):
-        return join(self.__target_dir,
-                    self.TERM_EMBEDDING_FILENAME_TEMPLATE.format(
-                        cv_index=experiment_iter_index(data_folding)) + '.npz')
+    def __get_default_embedding_filepath(self):
+        return join(self.__target_dir, self.__term_emb_fn_template)
 
     # endregion

arekit/contrib/utils/io_utils/utils.py

@@ -1,35 +1,14 @@
-import collections
+from collections.abc import Iterable
 import logging
-from os.path import join, exists
-
-from arekit.common.experiment.data_type import DataType
-from arekit.common.folding.base import BaseDataFolding
-from arekit.contrib.utils.utils_folding import experiment_iter_index
+from os.path import exists
 
 
 logger = logging.getLogger(__name__)
 logging.basicConfig(level=logging.INFO)
 
 
-def join_dir_with_subfolder_name(subfolder_name, dir):
-    """ Returns subfolder in in directory
-    """
-    assert(isinstance(subfolder_name, str))
-    assert(isinstance(dir, str))
-
-    target_dir = join(dir, "{}/".format(subfolder_name))
-    return target_dir
-
-
-def filename_template(data_type, data_folding):
-    assert(isinstance(data_type, DataType))
-    assert(isinstance(data_folding, BaseDataFolding))
-    return "{data_type}-{iter_index}".format(data_type=data_type.name.lower(),
-                                             iter_index=experiment_iter_index(data_folding))
-
-
 def check_targets_existence(targets):
-    assert (isinstance(targets, collections.Iterable))
+    assert (isinstance(targets, Iterable))
 
     result = True
     for filepath in targets:

arekit/contrib/utils/pipelines/items/sampling/base.py

@@ -2,17 +2,13 @@ from arekit.common.data.input.providers.rows.samples import BaseSampleRowProvide
 from arekit.common.data.storages.base import BaseRowsStorage
 from arekit.common.experiment.api.base_samples_io import BaseSamplesIO
 from arekit.common.experiment.data_type import DataType
-from arekit.common.folding.base import BaseDataFolding
-from arekit.common.pipeline.base import BasePipeline
-from arekit.common.pipeline.context import PipelineContext
 from arekit.common.pipeline.items.base import BasePipelineItem
 from arekit.contrib.utils.serializer import InputDataSerializationHelper
-from arekit.contrib.utils.utils_folding import folding_iter_states
 
 
 class BaseSerializerPipelineItem(BasePipelineItem):
 
-    def __init__(self, rows_provider, samples_io, save_labels_func, balance_func, storage):
+    def __init__(self, rows_provider, samples_io, save_labels_func, storage, **kwargs):
         """ sample_rows_formatter:
                 how we format input texts for a BERT model, for example:
                     - single text
@@ -24,18 +20,20 @@ class BaseSerializerPipelineItem(BasePipelineItem):
         assert(isinstance(rows_provider, BaseSampleRowProvider))
         assert(isinstance(samples_io, BaseSamplesIO))
         assert(callable(save_labels_func))
-        assert(callable(balance_func))
         assert(isinstance(storage, BaseRowsStorage))
+        super(BaseSerializerPipelineItem, self).__init__(**kwargs)
 
         self._rows_provider = rows_provider
-        self._balance_func = balance_func
         self._samples_io = samples_io
         self._save_labels_func = save_labels_func
         self._storage = storage
 
-    def _serialize_iteration(self, data_type, pipeline, data_folding):
-        assert (isinstance(data_type, DataType))
-        assert (isinstance(pipeline, BasePipeline))
+    def _serialize_iteration(self, data_type, pipeline, data_folding, doc_ids):
+        assert(isinstance(data_type, DataType))
+        assert(isinstance(pipeline, list))
+        assert(isinstance(data_folding, dict) or data_folding is None)
+        assert(isinstance(doc_ids, list) or doc_ids is None)
+        assert(doc_ids is not None or data_folding is not None)
 
         repos = {
             "sample": InputDataSerializationHelper.create_samples_repo(
@@ -46,27 +44,36 @@ class BaseSerializerPipelineItem(BasePipelineItem):
 
         writer_and_targets = {
             "sample": (self._samples_io.Writer,
-                       self._samples_io.create_target(
-                           data_type=data_type, data_folding=data_folding)),
+                       self._samples_io.create_target(data_type=data_type)),
         }
 
         for description, repo in repos.items():
+
+            if data_folding is None:
+                # Consider only the predefined doc_ids.
+                doc_ids_iter = doc_ids
+            else:
+                # Take particular data_type.
+                doc_ids_iter = data_folding[data_type]
+                # Consider only predefined doc_ids.
+                if doc_ids is not None:
+                    doc_ids_iter = set(doc_ids_iter).intersection(doc_ids)
+
             InputDataSerializationHelper.fill_and_write(
                 repo=repo,
                 pipeline=pipeline,
-                doc_ids_iter=data_folding.fold_doc_ids_set()[data_type],
-                do_balance=self._balance_func(data_type),
+                doc_ids_iter=doc_ids_iter,
                 desc="{desc} [{data_type}]".format(desc=description, data_type=data_type),
                 writer=writer_and_targets[description][0],
                 target=writer_and_targets[description][1])
 
-    def _handle_iteration(self, data_type_pipelines, data_folding):
+    def _handle_iteration(self, data_type_pipelines, data_folding, doc_ids):
         """ Performing data serialization for a particular iteration
         """
         assert(isinstance(data_type_pipelines, dict))
-        assert(isinstance(data_folding, BaseDataFolding))
         for data_type, pipeline in data_type_pipelines.items():
-            self._serialize_iteration(data_type=data_type, pipeline=pipeline, data_folding=data_folding)
+            self._serialize_iteration(data_type=data_type, pipeline=pipeline, data_folding=data_folding,
+                                      doc_ids=doc_ids)
 
     def apply_core(self, input_data, pipeline_ctx):
         """
@@ -76,14 +83,12 @@ class BaseSerializerPipelineItem(BasePipelineItem):
                     DataType.Test: BasePipeline
                 }
 
-                pipeline: doc_id -> parsed_news -> annot -> opinion linkages
+                data_type_pipelines: doc_id -> parsed_doc -> annot -> opinion linkages
                     for example, function: sentiment_attitude_extraction_default_pipeline
+                doc_ids: optional
+                    this parameter allows to limit amount of documents considered for sampling
         """
-        assert (isinstance(pipeline_ctx, PipelineContext))
-        assert ("data_type_pipelines" in pipeline_ctx)
-        assert ("data_folding" in pipeline_ctx)
-
-        data_folding = pipeline_ctx.provide("data_folding")
-        for _ in folding_iter_states(data_folding):
-            self._handle_iteration(data_type_pipelines=pipeline_ctx.provide("data_type_pipelines"),
-                                   data_folding=data_folding)
+        assert("data_type_pipelines" in pipeline_ctx)
+        self._handle_iteration(data_type_pipelines=pipeline_ctx.provide("data_type_pipelines"),
+                               doc_ids=pipeline_ctx.provide_or_none("doc_ids"),
+                               data_folding=pipeline_ctx.provide_or_none("data_folding"))

arekit/contrib/utils/pipelines/items/sampling/networks.py

@@ -1,4 +1,3 @@
-from arekit.common.folding.base import BaseDataFolding
 from arekit.contrib.networks.input.embedding.matrix import create_term_embedding_matrix
 from arekit.contrib.networks.input.embedding.offsets import TermsEmbeddingOffsets
 from arekit.contrib.networks.embedding import Embedding
@@ -9,8 +8,7 @@ from arekit.contrib.utils.pipelines.items.sampling.base import BaseSerializerPip
 
 class NetworksInputSerializerPipelineItem(BaseSerializerPipelineItem):
 
-    def __init__(self, save_labels_func, rows_provider, samples_io,
-                 emb_io, balance_func, storage, save_embedding=True):
+    def __init__(self, save_labels_func, rows_provider, samples_io, emb_io, storage, save_embedding=True, **kwargs):
         """ This pipeline item allows to perform a data preparation for neural network models.
 
             considering a list of the whole data_types with the related pipelines,
@@ -25,23 +23,22 @@ class NetworksInputSerializerPipelineItem(BaseSerializerPipelineItem):
             rows_provider=rows_provider,
             samples_io=samples_io,
             save_labels_func=save_labels_func,
-            balance_func=balance_func,
-            storage=storage)
+            storage=storage,
+            **kwargs)
 
         self.__emb_io = emb_io
         self.__save_embedding = save_embedding
 
-    def _handle_iteration(self, data_type_pipelines, data_folding):
+    def _handle_iteration(self, data_type_pipelines, data_folding, doc_ids):
         """ Performing data serialization for a particular iteration
         """
         assert(isinstance(data_type_pipelines, dict))
-        assert(isinstance(data_folding, BaseDataFolding))
 
         # Prepare for the present iteration.
         self._rows_provider.clear_embedding_pairs()
 
         super(NetworksInputSerializerPipelineItem, self)._handle_iteration(
-            data_type_pipelines=data_type_pipelines, data_folding=data_folding)
+            data_type_pipelines=data_type_pipelines, data_folding=data_folding, doc_ids=doc_ids)
 
         if not (self.__save_embedding and self._rows_provider.HasEmbeddingPairs):
             return
@@ -52,7 +49,7 @@ class NetworksInputSerializerPipelineItem(BaseSerializerPipelineItem):
         vocab = list(TermsEmbeddingOffsets.extract_vocab(words_embedding=term_embedding))
 
         # Save embedding matrix
-        self.__emb_io.save_embedding(data=embedding_matrix, data_folding=data_folding)
-        self.__emb_io.save_vocab(data=vocab, data_folding=data_folding)
+        self.__emb_io.save_embedding(data=embedding_matrix)
+        self.__emb_io.save_vocab(data=vocab)
 
         del embedding_matrix

arekit/contrib/utils/pipelines/items/text/entities_default.py

@@ -4,8 +4,8 @@ from arekit.common.pipeline.items.base import BasePipelineItem
 
 class TextEntitiesParser(BasePipelineItem):
 
-    def __init__(self):
-        super(TextEntitiesParser, self).__init__()
+    def __init__(self, **kwargs):
+        super(TextEntitiesParser, self).__init__(**kwargs)
 
     @staticmethod
     def __process_word(word):

arekit/contrib/utils/pipelines/items/text/frames.py

@@ -6,11 +6,10 @@ from arekit.common.pipeline.items.base import BasePipelineItem
 
 class FrameVariantsParser(BasePipelineItem):
 
-    def __init__(self, frame_variants):
+    def __init__(self, frame_variants, **kwargs):
         assert(isinstance(frame_variants, FrameVariantsCollection))
         assert(len(frame_variants) > 0)
-
-        super(FrameVariantsParser, self).__init__()
+        super(FrameVariantsParser, self).__init__(**kwargs)
 
         self.__frame_variants = frame_variants
         self.__max_variant_len = max([len(variant) for _, variant in frame_variants.iter_variants()])

arekit/contrib/utils/pipelines/items/text/frames_lemmatized.py

@@ -5,10 +5,10 @@ from arekit.contrib.utils.processing.languages.ru.mods import RussianLanguageMod
 
 class LemmasBasedFrameVariantsParser(FrameVariantsParser):
 
-    def __init__(self, frame_variants, stemmer, locale_mods=RussianLanguageMods, save_lemmas=False):
+    def __init__(self, frame_variants, stemmer, locale_mods=RussianLanguageMods, save_lemmas=False, **kwargs):
         assert(isinstance(stemmer, Stemmer))
         assert(isinstance(save_lemmas, bool))
-        super(LemmasBasedFrameVariantsParser, self).__init__(frame_variants=frame_variants)
+        super(LemmasBasedFrameVariantsParser, self).__init__(frame_variants=frame_variants, **kwargs)
 
         self.__frame_variants = frame_variants
         self.__stemmer = stemmer
@@ -24,7 +24,7 @@ class LemmasBasedFrameVariantsParser(FrameVariantsParser):
 
     def __provide_lemmatized_terms(self, terms):
         """
-        Compose a list of lemmatized versions of parsed_news
+        Compose a list of lemmatized versions of parsed_doc
         PS: Might be significantly slow, depending on stemmer were used.
         """
         assert(isinstance(terms, list))

arekit/contrib/utils/pipelines/items/text/frames_negation.py

@@ -7,8 +7,9 @@ from arekit.contrib.utils.processing.languages.ru.mods import RussianLanguageMod
 
 class FrameVariantsSentimentNegation(BasePipelineItem):
 
-    def __init__(self, locale_mods=RussianLanguageMods):
+    def __init__(self, locale_mods=RussianLanguageMods, **kwargs):
         assert(issubclass(locale_mods, BaseLanguageMods))
+        super(FrameVariantsSentimentNegation, self).__init__(**kwargs)
         self._locale_mods = locale_mods
 
     @staticmethod

arekit/contrib/utils/pipelines/items/text/tokenizer.py

@@ -1,7 +1,6 @@
 import logging
 
 from arekit.common.context.token import Token
-from arekit.common.pipeline.context import PipelineContext
 from arekit.common.pipeline.items.base import BasePipelineItem
 from arekit.common.utils import split_by_whitespaces
 from arekit.contrib.utils.processing.text.tokens import Tokens
@@ -14,14 +13,13 @@ class DefaultTextTokenizer(BasePipelineItem):
     """ Default parser implementation.
     """
 
-    def __init__(self, keep_tokens=True):
-        super(DefaultTextTokenizer, self).__init__()
+    def __init__(self, keep_tokens=True, **kwargs):
+        super(DefaultTextTokenizer, self).__init__(**kwargs)
         self.__keep_tokens = keep_tokens
 
     # region protected methods
 
     def apply_core(self, input_data, pipeline_ctx):
-        assert(isinstance(pipeline_ctx, PipelineContext))
         output_data = self.__process_parts(input_data)
         if not self.__keep_tokens:
             output_data = [word for word in output_data if not isinstance(word, Token)]
@@ -60,7 +58,7 @@ class DefaultTextTokenizer(BasePipelineItem):
     @staticmethod
     def __split_tokens(term):
         """
-        Splitting off tokens from parsed_news ending, i.e. for example:
+        Splitting off tokens from parsed_doc ending, i.e. for example:
             term: "сказать,-" -> "(term: "сказать", ["COMMA_TOKEN", "DASH_TOKEN"])
         return: (unicode or None, list)
             modified term and list of extracted tokens.

arekit/contrib/utils/pipelines/items/text/translator.py

@@ -0,0 +1,136 @@
+from arekit.common.data.input.providers.const import IDLE_MODE
+from arekit.common.pipeline.conts import PARENT_CTX
+from arekit.common.entities.base import Entity
+from arekit.common.pipeline.context import PipelineContext
+from arekit.common.pipeline.items.base import BasePipelineItem
+
+
+class MLTextTranslatorPipelineItem(BasePipelineItem):
+    """ Machine learning based translator pipeline item.
+    """
+
+    def __init__(self, batch_translate_model, do_translate_entity=True, **kwargs):
+        """ Model, which is based on translation of the text,
+            represented as a list of words.
+        """
+        super(MLTextTranslatorPipelineItem, self).__init__(**kwargs)
+        self.__do_translate_entity = do_translate_entity
+        self.__translate = batch_translate_model
+
+    def fast_most_accurate_approach(self, input_data, entity_placeholder_template="<entityTag={}/>"):
+        """ This approach assumes that the translation won't corrupt the original
+            meta-annotation for entities and objects mentioned in text.
+        """
+
+        def __optionally_register(prts):
+            if len(prts) > 0:
+                content.append(" ".join(prts))
+            parts_to_join.clear()
+
+        content = []
+        origin_entities = []
+        parts_to_join = []
+
+        for part in input_data:
+            if isinstance(part, str) and part.strip():
+                parts_to_join.append(part)
+            elif isinstance(part, Entity):
+                entity_index = len(origin_entities)
+                parts_to_join.append(entity_placeholder_template.format(entity_index))
+                # Register entities information for further restoration.
+                origin_entities.append(part)
+
+        # Register original text with masked named entities.
+        __optionally_register(parts_to_join)
+        # Register all named entities in order of their appearance in text.
+        content.extend([e.Value for e in origin_entities])
+
+        # Compose text parts.
+        translated_parts = self.__translate(content)
+
+        if len(translated_parts) == 0:
+            return None
+
+        # Take the original text.
+        text = translated_parts[0]
+        for entity_index in range(len(origin_entities)):
+            if entity_placeholder_template.format(entity_index) not in text:
+                return None
+
+        # Enumerate entities.
+        from_ind = 0
+        text_parts = []
+        for entity_index, translated_value in enumerate(translated_parts[1:]):
+            entity_placeholder_instance = entity_placeholder_template.format(entity_index)
+            # Cropping text part.
+            to_ind = text.index(entity_placeholder_instance)
+
+            if self.__do_translate_entity:
+                origin_entities[entity_index].set_display_value(translated_value.strip())
+
+            # Register entities.
+            text_parts.append(text[from_ind:to_ind])
+            text_parts.append(origin_entities[entity_index])
+            # Update from index.
+            from_ind = to_ind + len(entity_placeholder_instance)
+
+        # Consider the remaining part.
+        text_parts.append(text[from_ind:])
+        return text_parts
+
+    def default_pre_part_splitting_approach(self, input_data):
+        """ This is the original strategy, based on the manually cropped named entities
+            before the actual translation call.
+        """
+
+        def __optionally_register(prts):
+            if len(prts) > 0:
+                content.append(" ".join(prts))
+            parts_to_join.clear()
+
+        content = []
+        origin_entities = []
+        origin_entity_ind = []
+        parts_to_join = []
+
+        for _, part in enumerate(input_data):
+            if isinstance(part, str) and part.strip():
+                parts_to_join.append(part)
+            elif isinstance(part, Entity):
+                # Register first the prior parts were merged.
+                __optionally_register(parts_to_join)
+                # Register entities information for further restoration.
+                origin_entity_ind.append(len(content))
+                origin_entities.append(part)
+                content.append(part.Value)
+
+        __optionally_register(parts_to_join)
+
+        # Compose text parts.
+        translated_parts = self.__translate(content)
+
+        for entity_ind, entity_part_ind in enumerate(origin_entity_ind):
+            entity = origin_entities[entity_ind]
+            if self.__do_translate_entity:
+                entity.set_display_value(translated_parts[entity_part_ind].strip())
+            translated_parts[entity_part_ind] = entity
+
+        return translated_parts
+
+    def apply_core(self, input_data, pipeline_ctx):
+        assert(isinstance(pipeline_ctx, PipelineContext))
+        assert(isinstance(input_data, list))
+
+        # Check the pipeline state whether is an idle mode or not.
+        parent_ctx = pipeline_ctx.provide(PARENT_CTX)
+        idle_mode = parent_ctx.provide(IDLE_MODE)
+
+        # When pipeline utilized only for the assessing the expected amount
+        # of rows (common case of idle_mode), there is no need to perform
+        # translation.
+        if idle_mode:
+            return
+
+        fast_accurate = self.fast_most_accurate_approach(input_data)
+        return self.default_pre_part_splitting_approach(input_data) \
+            if fast_accurate is None else fast_accurate