arekit 0.24.0__py3-none-any.whl

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

@@ -0,0 +1,99 @@
+from arekit.common.data.input.providers.rows.samples import BaseSampleRowProvider
+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.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
+
+
+class BaseSerializerPipelineItem(BasePipelineItem):
+
+    def __init__(self, rows_provider, samples_io, save_labels_func, storage):
+        """ sample_rows_formatter:
+                how we format input texts for a BERT model, for example:
+                    - single text
+                    - two sequences, separated by [SEP] token
+
+            save_labels_func: function
+                data_type -> bool
+        """
+        assert(isinstance(rows_provider, BaseSampleRowProvider))
+        assert(isinstance(samples_io, BaseSamplesIO))
+        assert(callable(save_labels_func))
+        assert(isinstance(storage, BaseRowsStorage))
+
+        self._rows_provider = rows_provider
+        self._samples_io = samples_io
+        self._save_labels_func = save_labels_func
+        self._storage = storage
+
+    def _serialize_iteration(self, data_type, pipeline, data_folding, doc_ids):
+        assert(isinstance(data_type, DataType))
+        assert(isinstance(pipeline, BasePipeline))
+        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(
+                keep_labels=self._save_labels_func(data_type),
+                rows_provider=self._rows_provider,
+                storage=self._storage),
+        }
+
+        writer_and_targets = {
+            "sample": (self._samples_io.Writer,
+                       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=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, doc_ids):
+        """ Performing data serialization for a particular iteration
+        """
+        assert(isinstance(data_type_pipelines, dict))
+        for data_type, pipeline in data_type_pipelines.items():
+            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):
+        """
+            data_type_pipelines: dict of, for example:
+                {
+                    DataType.Train: BasePipeline,
+                    DataType.Test: BasePipeline
+                }
+
+                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(input_data, PipelineContext))
+        assert("data_type_pipelines" in input_data)
+
+        data_folding = input_data.provide_or_none("data_folding")
+
+        self._handle_iteration(data_type_pipelines=input_data.provide("data_type_pipelines"),
+                               doc_ids=input_data.provide_or_none("doc_ids"),
+                               data_folding=data_folding)

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

@@ -0,0 +1,54 @@
+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
+from arekit.contrib.networks.input.providers.sample import NetworkSampleRowProvider
+from arekit.contrib.utils.io_utils.embedding import NpEmbeddingIO
+from arekit.contrib.utils.pipelines.items.sampling.base import BaseSerializerPipelineItem
+
+
+class NetworksInputSerializerPipelineItem(BaseSerializerPipelineItem):
+
+    def __init__(self, save_labels_func, rows_provider, samples_io, emb_io, storage, save_embedding=True):
+        """ 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,
+            which are supported and required in a handler. It is necessary to know
+            data_types in advance as it allows to create a complete vocabulary of input terms,
+            with the related embeddings.
+        """
+        assert(isinstance(emb_io, NpEmbeddingIO))
+        assert(isinstance(rows_provider, NetworkSampleRowProvider))
+        assert(isinstance(save_embedding, bool))
+        super(NetworksInputSerializerPipelineItem, self).__init__(
+            rows_provider=rows_provider,
+            samples_io=samples_io,
+            save_labels_func=save_labels_func,
+            storage=storage)
+
+        self.__emb_io = emb_io
+        self.__save_embedding = save_embedding
+
+    def _handle_iteration(self, data_type_pipelines, data_folding, doc_ids):
+        """ Performing data serialization for a particular iteration
+        """
+        assert(isinstance(data_type_pipelines, dict))
+
+        # 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, doc_ids=doc_ids)
+
+        if not (self.__save_embedding and self._rows_provider.HasEmbeddingPairs):
+            return
+
+        # Save embedding information additionally.
+        term_embedding = Embedding.from_word_embedding_pairs_iter(self._rows_provider.iter_term_embedding_pairs())
+        embedding_matrix = create_term_embedding_matrix(term_embedding=term_embedding)
+        vocab = list(TermsEmbeddingOffsets.extract_vocab(words_embedding=term_embedding))
+
+        # Save embedding matrix
+        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

@@ -0,0 +1,23 @@
+from arekit.common.entities.base import Entity
+from arekit.common.pipeline.items.base import BasePipelineItem
+
+
+class TextEntitiesParser(BasePipelineItem):
+
+    def __init__(self):
+        super(TextEntitiesParser, self).__init__()
+
+    @staticmethod
+    def __process_word(word):
+        assert(isinstance(word, str))
+
+        # If this is a special word which is related to the [entity] mention.
+        if word[0] == "[" and word[-1] == "]":
+            entity = Entity(value=word[1:-1], e_type=None)
+            return entity
+
+        return word
+
+    def apply_core(self, input_data, pipeline_ctx):
+        assert(isinstance(input_data, list))
+        return [self.__process_word(w) for w in input_data]

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

@@ -0,0 +1,86 @@
+from arekit.common.frames.text_variant import TextFrameVariant
+from arekit.common.frames.variants.collection import FrameVariantsCollection
+from arekit.common.pipeline.context import PipelineContext
+from arekit.common.pipeline.items.base import BasePipelineItem
+
+
+class FrameVariantsParser(BasePipelineItem):
+
+    def __init__(self, frame_variants):
+        assert(isinstance(frame_variants, FrameVariantsCollection))
+        assert(len(frame_variants) > 0)
+
+        super(FrameVariantsParser, self).__init__()
+
+        self.__frame_variants = frame_variants
+        self.__max_variant_len = max([len(variant) for _, variant in frame_variants.iter_variants()])
+
+    # region private methods
+
+    @staticmethod
+    def __check_all_terms_within(terms, start_index, last_index):
+        for term_ind in range(start_index, last_index + 1):
+            if not isinstance(terms[term_ind], str):
+                return False
+        return True
+
+    def __try_compose_frame_variant(self, lemmas, start_ind, last_ind):
+
+        if last_ind >= len(lemmas):
+            return None
+
+        is_all_words_within = self.__check_all_terms_within(
+            terms=lemmas,
+            start_index=start_ind,
+            last_index=last_ind)
+
+        if not is_all_words_within:
+            return None
+
+        ctx_value = " ".join(lemmas[start_ind:last_ind + 1])
+
+        if not self.__frame_variants.has_variant(ctx_value):
+            return None
+
+        return ctx_value
+
+    def _iter_processed(self, terms, origin):
+        assert(len(terms) == len(origin))
+
+        start_ind = 0
+        last_ind = 0
+        while start_ind < len(terms):
+
+            found = False
+
+            for ctx_size in reversed(list(range(1, self.__max_variant_len))):
+
+                last_ind = start_ind + ctx_size - 1
+
+                ctx_value = self.__try_compose_frame_variant(
+                    start_ind=start_ind,
+                    last_ind=last_ind,
+                    lemmas=terms)
+
+                if ctx_value is None:
+                    continue
+
+                variant = self.__frame_variants.get_variant_by_value(ctx_value)
+
+                yield TextFrameVariant(variant)
+
+                found = True
+
+                break
+
+            if not found:
+                yield origin[start_ind]
+
+            start_ind = last_ind + 1
+
+    # endregion
+
+    def apply_core(self, input_data, pipeline_ctx):
+        assert(isinstance(pipeline_ctx, PipelineContext))
+        processed_it = self._iter_processed(terms=input_data, origin=input_data)
+        return list(processed_it)

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

@@ -0,0 +1,36 @@
+from arekit.common.text.stemmer import Stemmer
+from arekit.contrib.utils.pipelines.items.text.frames import FrameVariantsParser
+from arekit.contrib.utils.processing.languages.ru.mods import RussianLanguageMods
+
+
+class LemmasBasedFrameVariantsParser(FrameVariantsParser):
+
+    def __init__(self, frame_variants, stemmer, locale_mods=RussianLanguageMods, save_lemmas=False):
+        assert(isinstance(stemmer, Stemmer))
+        assert(isinstance(save_lemmas, bool))
+        super(LemmasBasedFrameVariantsParser, self).__init__(frame_variants=frame_variants)
+
+        self.__frame_variants = frame_variants
+        self.__stemmer = stemmer
+        self.__save_lemmas = save_lemmas
+        self.__max_variant_len = max([len(variant) for _, variant in frame_variants.iter_variants()])
+        self.__locale_mods = locale_mods
+
+    def __lemmatize_term(self, term):
+        # we first split onto words for lemmatization and then join all of them.
+        lemma = "".join(self.__stemmer.lemmatize_to_list(term))
+        # then we replace certain chars according to the locale restrictions.
+        return self.__locale_mods.replace_specific_word_chars(lemma)
+
+    def __provide_lemmatized_terms(self, terms):
+        """
+        Compose a list of lemmatized versions of parsed_doc
+        PS: Might be significantly slow, depending on stemmer were used.
+        """
+        assert(isinstance(terms, list))
+        return [self.__lemmatize_term(term) if isinstance(term, str) else term for term in terms]
+
+    def apply_core(self, input_data, pipeline_ctx):
+        lemmas = self.__provide_lemmatized_terms(input_data)
+        processed_it = self._iter_processed(terms=lemmas, origin=lemmas if self.__save_lemmas else input_data)
+        return list(processed_it)

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

@@ -0,0 +1,32 @@
+from arekit.common.frames.text_variant import TextFrameVariant
+from arekit.common.pipeline.context import PipelineContext
+from arekit.common.pipeline.items.base import BasePipelineItem
+from arekit.contrib.utils.processing.languages.mods import BaseLanguageMods
+from arekit.contrib.utils.processing.languages.ru.mods import RussianLanguageMods
+
+
+class FrameVariantsSentimentNegation(BasePipelineItem):
+
+    def __init__(self, locale_mods=RussianLanguageMods):
+        assert(issubclass(locale_mods, BaseLanguageMods))
+        self._locale_mods = locale_mods
+
+    @staticmethod
+    def __get_preposition(terms, index):
+        return terms[index-1] if index > 0 else None
+
+    def apply_core(self, input_data, pipeline_ctx):
+        assert(isinstance(input_data, list))
+        assert(isinstance(pipeline_ctx, PipelineContext))
+
+        for curr_ind, term in enumerate(input_data):
+
+            if not isinstance(term, TextFrameVariant):
+                continue
+
+            prep_term = self.__get_preposition(terms=input_data, index=curr_ind)
+            is_negated = self._locale_mods.is_negation_word(prep_term) if prep_term is not None else False
+
+            term.set_is_negated(is_negated)
+
+        return input_data

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

@@ -0,0 +1,10 @@
+from arekit.common.pipeline.context import PipelineContext
+from arekit.common.pipeline.items.base import BasePipelineItem
+from arekit.common.utils import split_by_whitespaces
+
+
+class TermsSplitterParser(BasePipelineItem):
+
+    def apply_core(self, input_data, pipeline_ctx):
+        assert(isinstance(pipeline_ctx, PipelineContext))
+        return split_by_whitespaces(input_data)

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

@@ -0,0 +1,107 @@
+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
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+
+class DefaultTextTokenizer(BasePipelineItem):
+    """ Default parser implementation.
+    """
+
+    def __init__(self, keep_tokens=True):
+        super(DefaultTextTokenizer, self).__init__()
+        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)]
+        return output_data
+
+    # endregion
+
+    # region private static methods
+
+    def __process_parts(self, parts):
+        assert(isinstance(parts, list))
+
+        parsed = []
+        for part in parts:
+
+            if part is None:
+                continue
+
+            # Keep non str words as it is and try to parse str-based words.
+            processed = [part] if not isinstance(part, str) else \
+                self.__iter_processed_part(part=part)
+
+            parsed.extend(processed)
+
+        return parsed
+
+    def __iter_processed_part(self, part):
+        for word in split_by_whitespaces(part):
+            for term in self.__process_word(word):
+                yield term
+
+    def __process_word(self, word):
+        assert(isinstance(word, str))
+        return self.__split_tokens(word)
+
+    @staticmethod
+    def __split_tokens(term):
+        """
+        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.
+        """
+
+        url = Tokens.try_create_url(term)
+        if url is not None:
+            return [url]
+
+        l = 0
+        words_and_tokens = []
+        while l < len(term):
+
+            # Token.
+            token = Tokens.try_create(term[l])
+            if token is not None:
+                if token.get_token_value() != Tokens.NEW_LINE:
+                    words_and_tokens.append(token)
+                l += 1
+
+            # Number.
+            elif str.isdigit(term[l]):
+                k = l + 1
+                while k < len(term) and str.isdigit(term[k]):
+                    k += 1
+                token = Tokens.try_create_number(term[l:k])
+                assert(token is not None)
+                words_and_tokens.append(token)
+                l = k
+
+            # Term.
+            else:
+                k = l + 1
+                while k < len(term):
+                    token = Tokens.try_create(term[k])
+                    if token is not None and token.get_token_value() != Tokens.DASH:
+                        break
+                    k += 1
+                words_and_tokens.append(term[l:k])
+                l = k
+
+        return words_and_tokens
+
+    # endregion

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

@@ -0,0 +1,135 @@
+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):
+        """ Model, which is based on translation of the text,
+            represented as a list of words.
+        """
+        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

arekit/contrib/utils/pipelines/opinion_collections.py

@@ -0,0 +1,85 @@
+from collections.abc import Iterable
+
+from arekit.common.labels.scaler.base import BaseLabelScaler
+from arekit.common.linkage.base import LinkedDataWrapper
+from arekit.common.model.labeling.modes import LabelCalculationMode
+from arekit.common.model.labeling.single import SingleLabelsHelper
+from arekit.common.opinions.base import Opinion
+from arekit.common.opinions.collection import OpinionCollection
+from arekit.common.pipeline.items.iter import FilterPipelineItem
+from arekit.common.pipeline.items.map import MapPipelineItem
+
+
+def __create_labeled_opinion(item, label):
+    assert(isinstance(item, Opinion))
+    return Opinion(source_value=item.SourceValue,
+                   target_value=item.TargetValue,
+                   label=label)
+
+
+def __linkages_to_opinions(linkages_iter, labels_helper, label_calc_mode):
+    assert(isinstance(linkages_iter, Iterable))
+
+    for linkage in linkages_iter:
+        assert(isinstance(linkage, LinkedDataWrapper))
+
+        agg_label = labels_helper.aggregate_labels(
+            labels_list=list(linkage.iter_labels()),
+            label_calc_mode=label_calc_mode)
+
+        yield __create_labeled_opinion(linkage.First, agg_label)
+
+
+def __fill_opinion_collection(opinions_iter, collection, supported_labels):
+    assert(isinstance(opinions_iter, Iterable))
+    assert(isinstance(collection, OpinionCollection))
+    assert(isinstance(supported_labels, set) or supported_labels is None)
+
+    for opinion in opinions_iter:
+        assert(isinstance(opinion, Opinion))
+
+        if supported_labels is not None:
+            if opinion.Label not in supported_labels:
+                continue
+
+        if collection.has_synonymous_opinion(opinion):
+            continue
+
+        collection.add_opinion(opinion)
+
+    return collection
+
+# endregion
+
+
+def text_opinion_linkages_to_opinion_collections_pipeline_part(
+        doc_ids_set, labels_scaler, iter_opinion_linkages_func,
+        create_opinion_collection_func, label_calc_mode):
+    """ Opinion collection generation pipeline.
+    """
+    assert(isinstance(labels_scaler, BaseLabelScaler))
+    assert(isinstance(label_calc_mode, LabelCalculationMode))
+    assert(callable(iter_opinion_linkages_func))
+    assert(callable(create_opinion_collection_func))
+
+    return [
+        # Filter doc-ids.
+        FilterPipelineItem(filter_func=lambda doc_id: doc_id in doc_ids_set),
+
+        # Iterate opinion linkages.
+        MapPipelineItem(lambda doc_id: (doc_id, iter_opinion_linkages_func(doc_id))),
+
+        # Convert linkages to opinions.
+        MapPipelineItem(lambda data:
+                        (data[0], __linkages_to_opinions(linkages_iter=data[1],
+                                                         labels_helper=SingleLabelsHelper(labels_scaler),
+                                                         label_calc_mode=label_calc_mode))),
+
+        # Filling opinion collection.
+        MapPipelineItem(lambda data:
+                        (data[0],
+                         __fill_opinion_collection(
+                             opinions_iter=data[1],
+                             collection=create_opinion_collection_func(),
+                             supported_labels=None))),
+    ]