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

arekit/common/pipeline/base.py

@@ -2,24 +2,20 @@ from arekit.common.pipeline.context import PipelineContext
 from arekit.common.pipeline.items.base import BasePipelineItem
 
 
-class BasePipeline(object):
+class BasePipelineLauncher:
 
-    def __init__(self, pipeline):
+    @staticmethod
+    def run(pipeline, pipeline_ctx, src_key=None, has_input=True):
         assert(isinstance(pipeline, list))
-        self.__pipeline = pipeline
+        assert(isinstance(pipeline_ctx, PipelineContext))
+        assert(isinstance(src_key, str) or src_key is None)
 
-    def run(self, input_data, params_dict=None, parent_ctx=None):
-        assert(isinstance(params_dict, dict) or params_dict is None)
-
-        pipeline_ctx = PipelineContext(d=params_dict if params_dict is not None else dict(),
-                                       parent_ctx=parent_ctx)
-
-        for item in filter(lambda itm: itm is not None, self.__pipeline):
+        for ind, item in enumerate(filter(lambda itm: itm is not None, pipeline)):
             assert(isinstance(item, BasePipelineItem))
-            input_data = item.apply(input_data=input_data, pipeline_ctx=pipeline_ctx)
-
-        return input_data
+            do_force_key = src_key is not None and ind == 0
+            input_data = item.get_source(pipeline_ctx, force_key=src_key if do_force_key else None) \
+                if has_input or ind > 0 else None
+            item_result = item.apply(input_data=input_data, pipeline_ctx=pipeline_ctx)
+            pipeline_ctx.update(param=item.ResultKey, value=item_result, is_new_key=False)
 
-    def append(self, item):
-        assert(isinstance(item, BasePipelineItem))
-        self.__pipeline.append(item)
+        return pipeline_ctx

arekit/common/pipeline/batching.py

@@ -0,0 +1,28 @@
+from arekit.common.pipeline.context import PipelineContext
+from arekit.common.pipeline.items.base import BasePipelineItem
+
+
+class BatchingPipelineLauncher:
+
+    @staticmethod
+    def run(pipeline, pipeline_ctx, src_key=None):
+        assert(isinstance(pipeline, list))
+        assert(isinstance(pipeline_ctx, PipelineContext))
+        assert(isinstance(src_key, str) or src_key is None)
+
+        for ind, item in enumerate(filter(lambda itm: itm is not None, pipeline)):
+            assert (isinstance(item, BasePipelineItem))
+
+            # Handle the content of the batch or batch itself.
+            content = item.get_source(pipeline_ctx, call_func=False, force_key=src_key if ind == 0 else None)
+            handled_batch = [item._src_func(i) if item._src_func is not None else i for i in content]
+
+            if item.SupportBatching:
+                batch_result = list(item.apply(input_data=handled_batch, pipeline_ctx=pipeline_ctx))
+            else:
+                batch_result = [item.apply(input_data=input_data, pipeline_ctx=pipeline_ctx)
+                                for input_data in handled_batch]
+
+            pipeline_ctx.update(param=item.ResultKey, value=batch_result, is_new_key=False)
+
+        return pipeline_ctx

arekit/common/pipeline/context.py

@@ -13,6 +13,8 @@ class PipelineContext(object):
         self._d[PARENT_CTX] = parent_ctx
 
     def __provide(self, param):
+        if param not in self._d:
+            raise Exception(f"Key `{param}` is not in dictionary.\n{self._d}")
         return self._d[param]
 
     # region public
@@ -23,7 +25,9 @@ class PipelineContext(object):
     def provide_or_none(self, param):
         return self.__provide(param) if param in self._d else None
 
-    def update(self, param, value):
+    def update(self, param, value, is_new_key=False):
+        if is_new_key and param in self._d:
+            raise Exception(f"Key `{param}` is already presented in pipeline context dictionary.")
         self._d[param] = value
 
     # endregion

arekit/common/pipeline/items/base.py

@@ -1,9 +1,46 @@
+from arekit.common.pipeline.context import PipelineContext
+
+
 class BasePipelineItem(object):
     """ Single pipeline item that might be instatiated and embedded into pipeline.
     """
 
+    def __init__(self, src_key="result", result_key="result", src_func=None):
+        assert(isinstance(src_key, str) or src_key is None)
+        assert(callable(src_func) or src_func is None)
+        self.__src_key = src_key
+        self._src_func = src_func
+        self.__result_key = result_key
+
+    @property
+    def ResultKey(self):
+        return self.__result_key
+
+    @property
+    def SupportBatching(self):
+        """ By default pipeline item is not designed for batching.
+        """
+        return False
+
+    def get_source(self, src_ctx, call_func=True, force_key=None):
+        """ Extract input element for processing.
+        """
+        assert(isinstance(src_ctx, PipelineContext))
+
+        # If there is no information about key, then we consider absence of the source.
+        if self.__src_key is None:
+            return None
+
+        # Extracting actual source.
+        src_data = src_ctx.provide(self.__src_key if force_key is None else force_key)
+        if self._src_func is not None and call_func:
+            src_data = self._src_func(src_data)
+
+        return src_data
+
     def apply_core(self, input_data, pipeline_ctx):
-        raise NotImplementedError()
+        """By default we do nothing."""
+        pass
 
     def apply(self, input_data, pipeline_ctx=None):
         """ Performs input processing an update it for a further pipeline items.

arekit/common/pipeline/items/flatten.py

@@ -5,10 +5,14 @@ class FlattenIterPipelineItem(BasePipelineItem):
     """ Considered to flat iterations of items that represent iterations.
     """
 
+    def __init__(self, **kwargs):
+        super(FlattenIterPipelineItem, self).__init__(**kwargs)
+        pass
+
     def __flat_iter(self, iter_data):
         for iter_item in iter_data:
             for item in iter_item:
                 yield item
 
     def apply_core(self, input_data, pipeline_ctx):
-        return self.__flat_iter(input_data)
+        return self.__flat_iter(input_data)

arekit/common/pipeline/items/handle.py

@@ -3,8 +3,9 @@ from arekit.common.pipeline.items.base import BasePipelineItem
 
 class HandleIterPipelineItem(BasePipelineItem):
 
-    def __init__(self, handle_func=None):
+    def __init__(self, handle_func=None, **kwargs):
         assert(callable(handle_func))
+        super(HandleIterPipelineItem, self).__init__(**kwargs)
         self.__handle_func = handle_func
 
     def __updated_data(self, items_iter):

arekit/common/pipeline/items/iter.py

@@ -3,8 +3,9 @@ from arekit.common.pipeline.items.base import BasePipelineItem
 
 class FilterPipelineItem(BasePipelineItem):
 
-    def __init__(self, filter_func=None):
+    def __init__(self, filter_func=None, **kwargs):
         assert(callable(filter_func))
+        super(FilterPipelineItem, self).__init__(**kwargs)
         self.__filter_func = filter_func
 
     def apply_core(self, input_data, pipeline_ctx):

arekit/common/pipeline/items/map.py

@@ -3,8 +3,9 @@ from arekit.common.pipeline.items.base import BasePipelineItem
 
 class MapPipelineItem(BasePipelineItem):
 
-    def __init__(self, map_func=None):
+    def __init__(self, map_func=None, **kwargs):
         assert(callable(map_func))
+        super(MapPipelineItem, self).__init__(**kwargs)
         self._map_func = map_func
 
     def apply_core(self, input_data, pipeline_ctx):

arekit/common/pipeline/items/map_nested.py

@@ -9,5 +9,9 @@ class MapNestedPipelineItem(MapPipelineItem):
         suppose to be mapped with the passed pipeline context.
     """
 
+    def __init__(self, **kwargs):
+        super(MapNestedPipelineItem, self).__init__(**kwargs)
+        pass
+
     def apply_core(self, input_data, pipeline_ctx):
         return map(lambda item: self._map_func(item, pipeline_ctx), input_data)

arekit/common/pipeline/utils.py

@@ -0,0 +1,32 @@
+class BatchIterator:
+
+    def __init__(self, data_iter, batch_size, end_value=None):
+        assert(isinstance(batch_size, int) and batch_size > 0)
+        assert(callable(end_value) or end_value is None)
+        self.__data_iter = data_iter
+        self.__index = 0
+        self.__batch_size = batch_size
+        self.__end_value = end_value
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        buffer = []
+        while True:
+            try:
+                data = next(self.__data_iter)
+            except StopIteration:
+                break
+            buffer.append(data)
+            if len(buffer) == self.__batch_size:
+                break
+
+        if len(buffer) > 0:
+            self.__index += 1
+            return buffer
+
+        if self.__end_value is None:
+            raise StopIteration
+        else:
+            return self.__end_value()

arekit/common/service/sqlite.py

@@ -0,0 +1,36 @@
+import sqlite3
+
+
+class SQLiteProvider(object):
+
+    @staticmethod
+    def write(data_it, target, data2col_func, table_name, columns, sqlite3_column_types,
+              id_column_name="id", id_column_type="TEXT"):
+        assert(callable(data2col_func))
+        assert(isinstance(columns, list))
+        assert(isinstance(sqlite3_column_types, list))
+        assert(len(columns) == len(sqlite3_column_types))
+
+        with sqlite3.connect(target) as con:
+            cur = con.cursor()
+
+            # Provide the ID column.
+            columns = [id_column_name] + columns
+            sqlite3_column_types = [id_column_type] + sqlite3_column_types
+
+            # Compose the whole columns list.
+            content = ", ".join([" ".join(item) for item in zip(columns, sqlite3_column_types)])
+            cur.execute(f"CREATE TABLE IF NOT EXISTS {table_name}({content})")
+            cur.execute(f"CREATE INDEX IF NOT EXISTS i_id ON {table_name}({id_column_name})")
+
+            for uid, data in data_it:
+                r = cur.execute(f"SELECT EXISTS(SELECT 1 FROM {table_name} WHERE {id_column_name}='{uid}');")
+                ans = r.fetchone()[0]
+                if ans == 1:
+                    continue
+
+                params = ", ".join(tuple(['?'] * (len(columns))))
+                cur.execute(f"INSERT INTO {table_name} VALUES ({params})", [str(uid)] + data2col_func(data))
+                con.commit()
+
+            cur.close()

arekit/common/synonyms/base.py

@@ -1,4 +1,4 @@
-import collections
+from collections.abc import Iterable
 
 from arekit.common import log_utils
 
@@ -12,7 +12,7 @@ class SynonymsCollection(object):
             debug: bool
                 utilized for logging the salient information during usage.
         """
-        assert(isinstance(iter_group_values_lists, collections.Iterable) or iter_group_values_lists is None)
+        assert(isinstance(iter_group_values_lists, Iterable) or iter_group_values_lists is None)
         assert(isinstance(is_read_only, bool))
         assert(isinstance(debug, bool))
 

arekit/common/text/{partitioning/str.py → partitioning.py}

@@ -1,28 +1,34 @@
-import collections
+from collections.abc import Iterable
 
 from arekit.common.bound import Bound
-from arekit.common.text.partitioning.base import BasePartitioning
 
 
-class StringPartitioning(BasePartitioning):
+class Partitioning(object):
     """ NOTE: considering that provided parts
         has no intersections between each other
     """
 
+    list_reg_types = {
+        "str": lambda p, item: p.append(item),
+        "list": lambda p, item: p.extend(item)
+    }
+
+    def __init__(self, text_fmt):
+        assert(isinstance(text_fmt, str) and text_fmt in self.list_reg_types)
+        self.__reg_part = self.list_reg_types[text_fmt]
+
     def provide(self, text, parts_it):
-        assert(isinstance(text, str))
-        assert(isinstance(parts_it, collections.Iterable))
+        assert(isinstance(parts_it, Iterable))
 
-        start = 0
         parts = []
+        start = 0
+
         for value, bound in parts_it:
             assert(isinstance(bound, Bound))
             assert(bound.Position >= start)
 
             # Release everything till the current value position.
-            part = text[start:bound.Position]
-
-            parts.append(part)
+            self.__reg_part(p=parts, item=text[start:bound.Position])
 
             # Release the entity value.
             parts.extend([value])
@@ -30,7 +36,6 @@ class StringPartitioning(BasePartitioning):
             start = bound.Position + bound.Length
 
         # Release everything after the last entity.
-        last_part = text[start:len(text)]
-        parts.extend([last_part])
+        self.__reg_part(p=parts, item=text[start:len(text)])
 
         return parts

arekit/common/text_opinions/base.py

@@ -3,7 +3,7 @@ from arekit.common.labels.base import Label
 
 class TextOpinion(object):
     """
-    Represents a relation which were found in news article
+    Represents a relation which were found in doc article
     and composed between two named entities
         (it was found especially by Opinion with predefined label)
         allows to modify label using set_label
@@ -31,28 +31,28 @@ class TextOpinion(object):
         return cls.__try_create_copy_core(other=other, keep_text_opinion_id=keep_text_opinion_id)
 
     @staticmethod
-    def try_convert(other, convert_func):
+    def try_convert(other, convert_entity_id_func):
         """ Creates a copy of `other` opinion with different id of opinion participants.
-            Use cases: required for BaseParsedNewsServiceProvider, when we decided to bring the outside
+            Use cases: required for BaseParsedDocumentServiceProvider, when we decided to bring the outside
             opinion into one which is based on DocumentEntities.
         """
         assert(isinstance(other, TextOpinion))
-        assert(callable(convert_func))
+        assert(callable(convert_entity_id_func))
         return TextOpinion.__try_create_copy_core(other=other,
-                                                  convert_id_func=convert_func,
+                                                  convert_entity_id_func=convert_entity_id_func,
                                                   keep_text_opinion_id=False)
 
     @staticmethod
-    def __try_create_copy_core(other, convert_id_func=lambda part_id: part_id, keep_text_opinion_id=True):
+    def __try_create_copy_core(other, convert_entity_id_func=lambda part_id: part_id, keep_text_opinion_id=True):
         """ Tries to compose a copy by considering an optional id conversion,
             and identification keeping.
             convert_id:
                 func(id) -> id
         """
-        assert(callable(convert_id_func))
+        assert(callable(convert_entity_id_func))
 
-        source_id = convert_id_func(other.SourceId)
-        target_id = convert_id_func(other.TargetId)
+        source_id = convert_entity_id_func(other.SourceId)
+        target_id = convert_entity_id_func(other.TargetId)
 
         if source_id is None or target_id is None:
             return None
@@ -61,7 +61,7 @@ class TextOpinion(object):
                            text_opinion_id=other.__text_opinion_id if keep_text_opinion_id else None,
                            source_id=source_id,
                            target_id=target_id,
-                           label=other.Sentiment)
+                           label=other.Label)
 
     def __set_label_core(self, label):
         assert(isinstance(label, Label))
@@ -72,7 +72,7 @@ class TextOpinion(object):
     # region properties
 
     @property
-    def Sentiment(self):
+    def Label(self):
         return self.__modifiable_label
 
     @property

arekit/common/utils.py

@@ -1,6 +1,5 @@
 import sys
 import os
-import requests
 from tqdm import tqdm
 
 
@@ -35,7 +34,38 @@ def progress_bar(iterable, total, desc="", unit="it"):
         return progress_bar_iter(iterable=iterable, desc=desc, unit=unit)
 
 
-def progress_bar_defined(iterable, total, desc="", unit="it"):
+def progress_bar_conditional(iterable, condition_func, total, postfix_func=None, desc="", unit="it"):
+    """ This progress-bar updates only on the
+        specific conditions during the iteration process.
+    """
+    assert(callable(condition_func))
+    assert(callable(postfix_func) or postfix_func is None)
+
+    # We consider artificial function that always iters 0.
+    def __iter_infinite_placeholder():
+        while True:
+            yield 0
+
+    pbar_it = progress_bar(iterable=__iter_infinite_placeholder(),
+                           desc=desc, unit=unit, total=total)
+    element = iter(pbar_it)
+
+    # Initialize with 0.
+    next(element)
+
+    for item in iterable:
+
+        # Optionally Update progress bar with the next state.
+        if condition_func(item):
+            next(element)
+            yield item
+
+        # Optionally provide meta-information.
+        if postfix_func is not None:
+            pbar_it.set_postfix(postfix_func(item))
+
+
+def progress_bar_defined(iterable, total, miniters=200, desc="", unit="it"):
     return tqdm(iterable=iterable,
                 total=total,
                 desc=desc,
@@ -43,7 +73,7 @@ def progress_bar_defined(iterable, total, desc="", unit="it"):
                 position=0,
                 leave=True,
                 unit=unit,
-                miniters=total / 200)
+                miniters=total / miniters if total is not None else total)
 
 
 def progress_bar_iter(iterable, desc="", unit='it'):
@@ -53,46 +83,3 @@ def progress_bar_iter(iterable, desc="", unit='it'):
                 leave=True,
                 ncols=120,
                 unit=unit)
-
-
-def get_default_download_dir():
-    """ Refered to NLTK toolkit approach
-        https://github.com/nltk/nltk/blob/8e771679cee1b4a9540633cc3ea17f4421ffd6c0/nltk/downloader.py#L1051
-    """
-
-    # On Windows, use %APPDATA%
-    if sys.platform == "win32" and "APPDATA" in os.environ:
-        homedir = os.environ["APPDATA"]
-
-    # Otherwise, install in the user's home directory.
-    else:
-        homedir = os.path.expanduser("~/")
-        if homedir == "~/":
-            raise ValueError("Could not find a default download directory")
-
-    return os.path.join(homedir, ".arekit")
-
-
-def download(dest_file_path, source_url):
-    """ Refered to https://github.com/nicolay-r/ner-bilstm-crf-tensorflow/blob/master/ner/utils.py
-        Simple http file downloader
-    """
-    print(('Downloading from {src} to {dest}'.format(src=source_url, dest=dest_file_path)))
-
-    sys.stdout.flush()
-    datapath = os.path.dirname(dest_file_path)
-
-    if not os.path.exists(datapath):
-        os.makedirs(datapath, mode=0o755)
-
-    dest_file_path = os.path.abspath(dest_file_path)
-
-    r = requests.get(source_url, stream=True)
-    total_length = int(r.headers.get('content-length', 0))
-
-    with open(dest_file_path, 'wb') as f:
-        pbar = tqdm(total=total_length, unit='B', unit_scale=True)
-        for chunk in r.iter_content(chunk_size=32 * 1024):
-            if chunk:  # filter out keep-alive new chunks
-                pbar.update(len(chunk))
-                f.write(chunk)

arekit/contrib/networks/embedding.py

@@ -1,4 +1,4 @@
-import collections
+from collections.abc import Iterable
 import numpy as np
 
 
@@ -31,7 +31,7 @@ class Embedding(object):
 
     @classmethod
     def from_word_embedding_pairs_iter(cls, word_embedding_pairs):
-        assert(isinstance(word_embedding_pairs, collections.Iterable))
+        assert(isinstance(word_embedding_pairs, Iterable))
 
         matrix = []
         words = []
@@ -51,7 +51,7 @@ class Embedding(object):
 
     @classmethod
     def from_list_with_embedding_func(cls, words_iter, embedding_func):
-        assert(isinstance(words_iter, collections.Iterable))
+        assert(isinstance(words_iter, Iterable))
         assert(callable(embedding_func))
 
         matrix = []

arekit/contrib/networks/embedding_io.py

@@ -2,17 +2,17 @@ class BaseEmbeddingIO(object):
     """ API for loading and saving embedding and vocabulary related data.
     """
 
-    def save_vocab(self, data, data_folding):
+    def save_vocab(self, data):
         raise NotImplementedError()
 
-    def load_vocab(self, data_folding):
+    def load_vocab(self,):
         raise NotImplementedError()
 
-    def save_embedding(self, data, data_folding):
+    def save_embedding(self, data):
         raise NotImplementedError()
 
-    def load_embedding(self, data_folding):
+    def load_embedding(self):
         raise NotImplementedError()
 
-    def check_targets_existed(self, data_folding):
+    def check_targets_existed(self):
         raise NotImplementedError()

arekit/contrib/networks/input/const.py

@@ -4,5 +4,3 @@ FrameConnotations = "frame_connots_uint"
 SynonymObject = "syn_objs"
 SynonymSubject = "syn_subjs"
 PosTags = "pos_tags"
-
-ArgsSep = ','

arekit/contrib/networks/input/providers/sample.py

@@ -5,10 +5,11 @@ from arekit.common.data.input.providers.rows.samples import BaseSampleRowProvide
 from arekit.common.entities.base import Entity
 from arekit.common.frames.text_variant import TextFrameVariant
 from arekit.common.labels.scaler.sentiment import SentimentLabelScaler
-from arekit.common.news.parsed.base import ParsedNews
+from arekit.common.docs.parsed.base import ParsedDocument
 from arekit.contrib.networks.input.formatters.pos_mapper import PosTermsMapper
 from arekit.contrib.networks.input import const
 from arekit.contrib.networks.input.providers.term_connotation import extract_uint_frame_variant_connotation
+from arekit.contrib.networks.input.rows_parser import create_nn_val_writer_fmt
 
 
 class NetworkSampleRowProvider(BaseSampleRowProvider):
@@ -36,6 +37,7 @@ class NetworkSampleRowProvider(BaseSampleRowProvider):
         self.__frame_role_label_scaler = frame_role_label_scaler
         self.__pos_terms_mapper = pos_terms_mapper
         self.__term_embedding_pairs = term_embedding_pairs
+        self.__nn_val_fmt = create_nn_val_writer_fmt(fmt_type="writer")
 
     @property
     def HasEmbeddingPairs(self):
@@ -57,21 +59,21 @@ class NetworkSampleRowProvider(BaseSampleRowProvider):
         self.__term_embedding_pairs.clear()
 
     def _fill_row_core(self, row, text_opinion_linkage, index_in_linked, etalon_label,
-                       parsed_news, sentence_ind, s_ind, t_ind):
-        assert(isinstance(parsed_news, ParsedNews))
+                       parsed_doc, sentence_ind, s_ind, t_ind):
+        assert(isinstance(parsed_doc, ParsedDocument))
 
         super(NetworkSampleRowProvider, self)._fill_row_core(
             row=row,
             text_opinion_linkage=text_opinion_linkage,
             index_in_linked=index_in_linked,
             etalon_label=etalon_label,
-            parsed_news=parsed_news,
+            parsed_doc=parsed_doc,
             sentence_ind=sentence_ind,
             s_ind=s_ind, t_ind=t_ind)
 
         # Extracting list of terms, utilized in further.
         terms_iter, actual_s_ind, actual_t_ind = self._provide_sentence_terms(
-            parsed_news=parsed_news, sentence_ind=sentence_ind, s_ind=s_ind, t_ind=t_ind)
+            parsed_doc=parsed_doc, sentence_ind=sentence_ind, s_ind=s_ind, t_ind=t_ind)
         terms = list(terms_iter)
 
         # Compose frame indices.
@@ -85,30 +87,18 @@ class NetworkSampleRowProvider(BaseSampleRowProvider):
                     three_label_scaler=self.__frame_role_label_scaler),
                 [terms[frame_ind] for frame_ind in uint_frame_inds]))
 
-        # Synonyms for source.
-        uint_syn_s_inds = self.__create_synonyms_set(terms=terms, term_ind=actual_s_ind)
+        vm = {
+            const.FrameVariantIndices: uint_frame_inds,
+            const.FrameConnotations: uint_frame_connotations,
+            const.SynonymSubject: self.__create_synonyms_set(terms=terms, term_ind=actual_s_ind),
+            const.SynonymObject: self.__create_synonyms_set(terms=terms, term_ind=actual_t_ind),
+            const.PosTags: None if self.__pos_terms_mapper is None else [int(pos_tag) for pos_tag in self.__pos_terms_mapper.iter_mapped(terms)]
+        }
 
-        # Synonyms for target.
-        uint_syn_t_inds = self.__create_synonyms_set(terms=terms, term_ind=actual_t_ind)
-
-        # Part of speech tags
-        pos_int_tags = None if self.__pos_terms_mapper is None \
-            else [int(pos_tag) for pos_tag in self.__pos_terms_mapper.iter_mapped(terms)]
-
-        # Saving.
-        row[const.FrameVariantIndices] = self.__to_arg(uint_frame_inds)
-        row[const.FrameConnotations] = self.__to_arg(uint_frame_connotations)
-        row[const.SynonymSubject] = self.__to_arg(uint_syn_s_inds)
-        row[const.SynonymObject] = self.__to_arg(uint_syn_t_inds)
-        if pos_int_tags is not None:
-            row[const.PosTags] = self.__to_arg(pos_int_tags)
+        self._apply_row_data(row=row, vm=vm, val_fmt=self.__nn_val_fmt)
 
     # region private methods
 
-    @staticmethod
-    def __is_entity(t):
-        return isinstance(t, Entity)
-
     def __create_synonyms_set(self, terms, term_ind):
         entity = terms[term_ind]
         assert(isinstance(entity, Entity))
@@ -136,8 +126,4 @@ class NetworkSampleRowProvider(BaseSampleRowProvider):
             return False
         return term.GroupIndex == group_ind
 
-    @staticmethod
-    def __to_arg(inds_iter):
-        return const.ArgsSep.join([str(i) for i in inds_iter])
-
     # endregion