


import numpy as np

from transformers import BatchFeature
from transformers.testing_utils import require_tf, require_torch

from .test_feature_extraction_common import FeatureExtractionSavingTestMixin


class 		_SCREAMING_SNAKE_CASE     (						A     ):
     # to overwrite at feature extractactor specific tests
     __SCREAMING_SNAKE_CASE     					=    None
     __SCREAMING_SNAKE_CASE     					=    None


     @property
     def        __snake_case(  self    ):
       return self.feat_extract_tester.prepare_feat_extract_dict()


     def        __snake_case(  self    ):
       _UpperCAmelCase		:							Optional[Any]							=     self.feature_extraction_class(**self.feat_extract_dict    )
       self.assertTrue(hasattr(A_							,					"""feature_size"""    )    )
       self.assertTrue(hasattr(A_							,					"""sampling_rate"""    )    )
       self.assertTrue(hasattr(A_							,					"""padding_value"""    )    )


     def        __snake_case(  self    ):
       _UpperCAmelCase		:							List[str]							=     self.feat_extract_tester.prepare_inputs_for_common()
       _UpperCAmelCase		:							int							=     self.feature_extraction_class(**self.feat_extract_dict    )
       _UpperCAmelCase		:							List[str]							=     feat_extract.model_input_names[0]

       _UpperCAmelCase		:							Dict							=     BatchFeature({input_name: speech_inputs}    )

       self.assertTrue(all(len(A_    ) == len(A_    ) for x, y in zip(A_							,					processed_features[input_name]    )    )    )

       _UpperCAmelCase		:							List[str]							=     self.feat_extract_tester.prepare_inputs_for_common(equal_length=A_    )
       _UpperCAmelCase		:							str							=     BatchFeature({input_name: speech_inputs}							,					tensor_type="""np"""    )

       _UpperCAmelCase		:							Tuple							=     processed_features[input_name]

       if len(batch_features_input.shape    ) < 3:
         _UpperCAmelCase		:							Optional[Any]							=     batch_features_input[:, :, None]

       self.assertTrue(
           batch_features_input.shape
           == (self.feat_extract_tester.batch_size, len(speech_inputs[0]    ), self.feat_extract_tester.feature_size)    )


     @require_torch
     def        __snake_case(  self    ):
       _UpperCAmelCase		:							Any							=     self.feat_extract_tester.prepare_inputs_for_common(equal_length=A_    )
       _UpperCAmelCase		:							Optional[Any]							=     self.feature_extraction_class(**self.feat_extract_dict    )
       _UpperCAmelCase		:							Optional[int]							=     feat_extract.model_input_names[0]

       _UpperCAmelCase		:							str							=     BatchFeature({input_name: speech_inputs}							,					tensor_type="""pt"""    )

       _UpperCAmelCase		:							Tuple							=     processed_features[input_name]

       if len(batch_features_input.shape    ) < 3:
         _UpperCAmelCase		:							Optional[Any]							=     batch_features_input[:, :, None]

       self.assertTrue(
           batch_features_input.shape
           == (self.feat_extract_tester.batch_size, len(speech_inputs[0]    ), self.feat_extract_tester.feature_size)    )


     @require_tf
     def        __snake_case(  self    ):
       _UpperCAmelCase		:							int							=     self.feat_extract_tester.prepare_inputs_for_common(equal_length=A_    )
       _UpperCAmelCase		:							str							=     self.feature_extraction_class(**self.feat_extract_dict    )
       _UpperCAmelCase		:							List[Any]							=     feat_extract.model_input_names[0]

       _UpperCAmelCase		:							Union[str, Any]							=     BatchFeature({input_name: speech_inputs}							,					tensor_type="""tf"""    )

       _UpperCAmelCase		:							Tuple							=     processed_features[input_name]

       if len(batch_features_input.shape    ) < 3:
         _UpperCAmelCase		:							List[str]							=     batch_features_input[:, :, None]

       self.assertTrue(
           batch_features_input.shape
           == (self.feat_extract_tester.batch_size, len(speech_inputs[0]    ), self.feat_extract_tester.feature_size)    )


     def        __snake_case(  self							,					A_=False    ):
       def _inputs_have_equal_length(A_    ):
         _UpperCAmelCase		:							str							=     len(input[0]    )
         for input_slice in input[1:]:
           if len(A_    ) != length:
             return False
         return True

       def _inputs_are_equal(A_							,					A_    ):
         if len(A_    ) != len(A_    ):
           return False

         for input_slice_a, input_slice_a in zip(A_							,					A_    ):
           if not np.allclose(np.asarray(A_    )							,					np.asarray(A_    )							,					atol=1e-3    ):
             return False
         return True

       _UpperCAmelCase		:							List[Any]							=     self.feature_extraction_class(**self.feat_extract_dict    )
       _UpperCAmelCase		:							List[Any]							=     self.feat_extract_tester.prepare_inputs_for_common(numpify=A_    )
       _UpperCAmelCase		:							str							=     feat_extract.model_input_names[0]

       _UpperCAmelCase		:							str							=     BatchFeature({input_name: speech_inputs}    )

       _UpperCAmelCase		:							Optional[Any]							=     self.feat_extract_tester.seq_length_diff
       _UpperCAmelCase		:							str							=     self.feat_extract_tester.max_seq_length + pad_diff
       _UpperCAmelCase		:							Union[str, Any]							=     self.feat_extract_tester.min_seq_length
       _UpperCAmelCase		:							str							=     self.feat_extract_tester.batch_size
       _UpperCAmelCase		:							List[Any]							=     self.feat_extract_tester.feature_size

       # test padding for List[int] + numpy
       _UpperCAmelCase		:							Union[str, Any]							=     feat_extract.pad(A_							,					padding=A_    )
       _UpperCAmelCase		:							List[Any]							=     input_a[input_name]

       _UpperCAmelCase		:							List[Any]							=     feat_extract.pad(A_							,					padding="""longest"""    )
       _UpperCAmelCase		:							List[str]							=     input_a[input_name]

       _UpperCAmelCase		:							Optional[Any]							=     feat_extract.pad(A_							,					padding="""max_length"""							,					max_length=len(speech_inputs[-1]    )    )
       _UpperCAmelCase		:							Optional[Any]							=     input_a[input_name]

       _UpperCAmelCase		:							Optional[Any]							=     feat_extract.pad(A_							,					padding="""longest"""							,					return_tensors="""np"""    )
       _UpperCAmelCase		:							str							=     input_a[input_name]

       # max_length parameter has to be provided when setting `padding="max_length"`
       with self.assertRaises(A_    ):
         feat_extract.pad(A_							,					padding="""max_length"""    )[input_name]

       _UpperCAmelCase		:							List[str]							=     feat_extract.pad(
           A_							,					padding="""max_length"""							,					max_length=A_							,					return_tensors="""np"""    )
       _UpperCAmelCase		:							Optional[Any]							=     input_a[input_name]

       self.assertFalse(_inputs_have_equal_length(A_    )    )
       self.assertTrue(_inputs_have_equal_length(A_    )    )
       self.assertTrue(_inputs_have_equal_length(A_    )    )
       self.assertTrue(_inputs_are_equal(A_							,					A_    )    )
       self.assertTrue(len(input_a[0]    ) == pad_min_length    )
       self.assertTrue(len(input_a[1]    ) == pad_min_length + pad_diff    )
       self.assertTrue(input_a.shape[:2] == (batch_size, len(input_a[0]    ))    )
       self.assertTrue(input_a.shape[:2] == (batch_size, pad_max_length)    )

       if feature_size > 1:
         self.assertTrue(input_a.shape[2] == input_a.shape[2] == feature_size    )

       # test padding for `pad_to_multiple_of` for List[int] + numpy
       _UpperCAmelCase		:							str							=     feat_extract.pad(A_							,					pad_to_multiple_of=10    )
       _UpperCAmelCase		:							Dict							=     input_a[input_name]

       _UpperCAmelCase		:							Dict							=     feat_extract.pad(A_							,					padding="""longest"""							,					pad_to_multiple_of=10    )
       _UpperCAmelCase		:							Optional[int]							=     input_a[input_name]

       _UpperCAmelCase		:							Optional[int]							=     feat_extract.pad(
           A_							,					padding="""max_length"""							,					pad_to_multiple_of=10							,					max_length=A_    )
       _UpperCAmelCase		:							List[Any]							=     input_a[input_name]

       _UpperCAmelCase		:							str							=     feat_extract.pad(
           A_							,					padding="""max_length"""							,					pad_to_multiple_of=10							,					max_length=A_							,					return_tensors="""np"""							,					)
       _UpperCAmelCase		:							List[str]							=     input_a[input_name]

       self.assertTrue(all(len(A_    ) % 10 == 0 for x in input_a    )    )
       self.assertTrue(_inputs_are_equal(A_							,					A_    )    )

       _UpperCAmelCase		:							int							=     pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
       self.assertTrue(all(len(A_    ) == expected_mult_pad_length for x in input_a    )    )
       self.assertEqual(input_a.shape[:2]							,					(batch_size, expected_mult_pad_length)    )

       if feature_size > 1:
         self.assertTrue(input_a.shape[2] == feature_size    )

       # Check padding value is correct
       _UpperCAmelCase		:							List[str]							=     (np.ones(self.feat_extract_tester.feature_size    ) * feat_extract.padding_value).sum()
       self.assertTrue(
           abs(np.asarray(input_a[0]    )[pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)    )
           < 1e-3    )
       self.assertTrue(
           abs(
               np.asarray(input_a[1]    )[pad_min_length + pad_diff :].sum()
               - padding_vector_sum * (pad_max_length - pad_min_length - pad_diff)    )
           < 1e-3    )
       self.assertTrue(
           abs(
               np.asarray(input_a[2]    )[pad_min_length + 2 * pad_diff :].sum()
               - padding_vector_sum * (pad_max_length - pad_min_length - 2 * pad_diff)    )
           < 1e-3    )
       self.assertTrue(
           abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)    ) < 1e-3    )
       self.assertTrue(
           abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (expected_mult_pad_length - pad_min_length)    )
           < 1e-3    )


     def        __snake_case(  self							,					A_=False    ):
       def _inputs_have_equal_length(A_    ):
         _UpperCAmelCase		:							Optional[int]							=     len(input[0]    )
         for input_slice in input[1:]:
           if len(A_    ) != length:
             return False
         return True

       def _inputs_are_equal(A_							,					A_    ):
         if len(A_    ) != len(A_    ):
           return False

         for input_slice_a, input_slice_a in zip(A_							,					A_    ):
           if not np.allclose(np.asarray(A_    )							,					np.asarray(A_    )							,					atol=1e-3    ):
             return False
         return True

       _UpperCAmelCase		:							Any							=     self.feature_extraction_class(**self.feat_extract_dict    )
       _UpperCAmelCase		:							List[str]							=     self.feat_extract_tester.prepare_inputs_for_common(numpify=A_    )
       _UpperCAmelCase		:							Tuple							=     feat_extract.model_input_names[0]

       _UpperCAmelCase		:							Optional[int]							=     BatchFeature({input_name: speech_inputs}    )

       # truncate to smallest
       _UpperCAmelCase		:							Union[str, Any]							=     feat_extract.pad(
           A_							,					padding="""max_length"""							,					max_length=len(speech_inputs[0]    )							,					truncation=A_    )
       _UpperCAmelCase		:							Tuple							=     input_a[input_name]

       _UpperCAmelCase		:							str							=     feat_extract.pad(A_							,					padding="""max_length"""							,					max_length=len(speech_inputs[0]    )    )
       _UpperCAmelCase		:							Dict							=     input_a[input_name]

       self.assertTrue(_inputs_have_equal_length(A_    )    )
       self.assertFalse(_inputs_have_equal_length(A_    )    )

       # truncate to smallest with np
       _UpperCAmelCase		:							str							=     feat_extract.pad(
           A_							,					padding="""max_length"""							,					max_length=len(speech_inputs[0]    )							,					return_tensors="""np"""							,					truncation=A_							,					)
       _UpperCAmelCase		:							Optional[int]							=     input_a[input_name]

       _UpperCAmelCase		:							Tuple							=     feat_extract.pad(
           A_							,					padding="""max_length"""							,					max_length=len(speech_inputs[0]    )							,					return_tensors="""np"""    )
       _UpperCAmelCase		:							Any							=     input_a[input_name]

       self.assertTrue(_inputs_have_equal_length(A_    )    )
       self.assertTrue(input_a.shape[1] == len(speech_inputs[0]    )    )

       # since truncation forces padding to be smaller than longest input
       # function can't return `np.ndarray`, but has to return list
       self.assertFalse(_inputs_have_equal_length(A_    )    )

       # truncate to middle
       _UpperCAmelCase		:							Optional[Any]							=     feat_extract.pad(
           A_							,					padding="""max_length"""							,					max_length=len(speech_inputs[1]    )							,					truncation=A_							,					return_tensors="""np"""							,					)
       _UpperCAmelCase		:							Optional[Any]							=     input_a[input_name]

       _UpperCAmelCase		:							Optional[int]							=     feat_extract.pad(
           A_							,					padding="""max_length"""							,					max_length=len(speech_inputs[1]    )							,					truncation=A_    )
       _UpperCAmelCase		:							Optional[Any]							=     input_a[input_name]

       _UpperCAmelCase		:							List[Any]							=     feat_extract.pad(
           A_							,					padding="""max_length"""							,					max_length=len(speech_inputs[1]    )							,					return_tensors="""np"""    )
       _UpperCAmelCase		:							str							=     input_a[input_name]

       self.assertTrue(input_a.shape[1] == len(speech_inputs[1]    )    )
       self.assertTrue(_inputs_have_equal_length(A_    )    )
       self.assertTrue(_inputs_have_equal_length(A_    )    )
       self.assertTrue(_inputs_are_equal(A_							,					A_    )    )

       # since truncation forces padding to be smaller than longest input
       # function can't return `np.ndarray`, but has to return list
       self.assertFalse(_inputs_have_equal_length(A_    )    )
       self.assertTrue(len(input_a[-1]    ) == len(speech_inputs[-1]    )    )

       # padding has to be max_length when setting `truncation=True`
       with self.assertRaises(A_    ):
         feat_extract.pad(A_							,					truncation=A_    )[input_name]

       # padding has to be max_length when setting `truncation=True`
       with self.assertRaises(A_    ):
         feat_extract.pad(A_							,					padding="""longest"""							,					truncation=A_    )[input_name]

       # padding has to be max_length when setting `truncation=True`
       with self.assertRaises(A_    ):
         feat_extract.pad(A_							,					padding="""longest"""							,					truncation=A_    )[input_name]

       # max_length parameter has to be provided when setting `truncation=True` and padding="max_length"
       with self.assertRaises(A_    ):
         feat_extract.pad(A_							,					padding="""max_length"""							,					truncation=A_    )[input_name]

       # test truncation for `pad_to_multiple_of` for List[int] + numpy
       _UpperCAmelCase		:							Union[str, Any]							=     12
       _UpperCAmelCase		:							Optional[int]							=     feat_extract.pad(
           A_							,					padding="""max_length"""							,					max_length=len(speech_inputs[0]    )							,					pad_to_multiple_of=A_							,					truncation=A_							,					)
       _UpperCAmelCase		:							Any							=     input_a[input_name]

       _UpperCAmelCase		:							List[Any]							=     feat_extract.pad(
           A_							,					padding="""max_length"""							,					max_length=len(speech_inputs[0]    )							,					pad_to_multiple_of=A_							,					)
       _UpperCAmelCase		:							Any							=     input_a[input_name]

       # retrieve expected_length as multiple of pad_to_multiple_of
       _UpperCAmelCase		:							Dict							=     len(speech_inputs[0]    )
       if expected_length % pad_to_multiple_of != 0:
         _UpperCAmelCase		:							Optional[int]							=     ((len(speech_inputs[0]    ) // pad_to_multiple_of) + 1) * pad_to_multiple_of

       self.assertTrue(len(input_a[0]    ) == expected_length    )
       self.assertTrue(_inputs_have_equal_length(A_    )    )
       self.assertFalse(_inputs_have_equal_length(A_    )    )


     def        __snake_case(  self    ):
       self._check_padding(numpify=A_    )


     def        __snake_case(  self    ):
       self._check_padding(numpify=A_    )


     def        __snake_case(  self    ):
       self._check_truncation(numpify=A_    )


     def        __snake_case(  self    ):
       self._check_truncation(numpify=A_    )


     @require_torch
     def        __snake_case(  self    ):
       _UpperCAmelCase		:							int							=     self.feature_extraction_class(**self.feat_extract_dict    )
       _UpperCAmelCase		:							Union[str, Any]							=     self.feat_extract_tester.prepare_inputs_for_common()
       _UpperCAmelCase		:							List[str]							=     feat_extract.model_input_names[0]

       _UpperCAmelCase		:							Optional[Any]							=     BatchFeature({input_name: speech_inputs}    )

       _UpperCAmelCase		:							List[str]							=     feat_extract.pad(A_							,					padding="""longest"""							,					return_tensors="""np"""    )[input_name]
       _UpperCAmelCase		:							Any							=     feat_extract.pad(A_							,					padding="""longest"""							,					return_tensors="""pt"""    )[input_name]

       self.assertTrue(abs(input_np.astype(np.floataa    ).sum() - input_pt.numpy().astype(np.floataa    ).sum()    ) < 1e-2    )


     @require_tf
     def        __snake_case(  self    ):
       _UpperCAmelCase		:							str							=     self.feature_extraction_class(**self.feat_extract_dict    )
       _UpperCAmelCase		:							List[str]							=     self.feat_extract_tester.prepare_inputs_for_common()
       _UpperCAmelCase		:							Any							=     feat_extract.model_input_names[0]

       _UpperCAmelCase		:							str							=     BatchFeature({input_name: speech_inputs}    )

       _UpperCAmelCase		:							int							=     feat_extract.pad(A_							,					padding="""longest"""							,					return_tensors="""np"""    )[input_name]
       _UpperCAmelCase		:							Optional[Any]							=     feat_extract.pad(A_							,					padding="""longest"""							,					return_tensors="""tf"""    )[input_name]

       self.assertTrue(abs(input_np.astype(np.floataa    ).sum() - input_tf.numpy().astype(np.floataa    ).sum()    ) < 1e-2    )


     def        __snake_case(  self    ):
       _UpperCAmelCase		:							str							=     self.feat_extract_dict
       _UpperCAmelCase		:							Dict							=     True
       _UpperCAmelCase		:							Optional[int]							=     self.feature_extraction_class(**A_    )
       _UpperCAmelCase		:							Dict							=     self.feat_extract_tester.prepare_inputs_for_common()
       _UpperCAmelCase		:							Union[str, Any]							=     [len(A_    ) for x in speech_inputs]
       _UpperCAmelCase		:							int							=     feat_extract.model_input_names[0]

       _UpperCAmelCase		:							Optional[int]							=     BatchFeature({input_name: speech_inputs}    )

       _UpperCAmelCase		:							Union[str, Any]							=     feat_extract.pad(A_							,					padding="""longest"""							,					return_tensors="""np"""    )
       self.assertIn("""attention_mask"""							,					A_    )
       self.assertListEqual(list(processed.attention_mask.shape    )							,					list(processed[input_name].shape[:2]    )    )
       self.assertListEqual(processed.attention_mask.sum(-1    ).tolist()							,					A_    )




     def        __snake_case(  self    ):
       _UpperCAmelCase		:							Optional[int]							=     self.feat_extract_dict
       _UpperCAmelCase		:							str							=     True
       _UpperCAmelCase		:							int							=     self.feature_extraction_class(**A_    )
       _UpperCAmelCase		:							str							=     self.feat_extract_tester.prepare_inputs_for_common()
       _UpperCAmelCase		:							Union[str, Any]							=     [len(A_    ) for x in speech_inputs]
       _UpperCAmelCase		:							Dict							=     feat_extract.model_input_names[0]

       _UpperCAmelCase		:							Optional[int]							=     BatchFeature({input_name: speech_inputs}    )
       _UpperCAmelCase		:							Any							=     min(A_    )

       _UpperCAmelCase		:							int							=     feat_extract.pad(
           A_							,					padding="""max_length"""							,					max_length=A_							,					truncation=A_							,					return_tensors="""np"""    )
       self.assertIn("""attention_mask"""							,					A_    )
       self.assertListEqual(
           list(processed_pad.attention_mask.shape    )							,					[processed_pad[input_name].shape[0], max_length]    )
       self.assertListEqual(
           processed_pad.attention_mask[:, :max_length].sum(-1    ).tolist()							,					[max_length for x in speech_inputs]    )









import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ....tokenization_utils_fast import PreTrainedTokenizerFast
from ....utils import logging
from .tokenization_retribert import RetriBertTokenizer


SCREAMING_SNAKE_CASE__					:     List[str]       =     logging.get_logger(__name__)

SCREAMING_SNAKE_CASE__					:     Optional[int]       =     {'vocab_file': 'vocab.txt', 'tokenizer_file': 'tokenizer.json'}

SCREAMING_SNAKE_CASE__					:     List[Any]       =     {
    'vocab_file': {
        'yjernite/retribert-base-uncased': (
            'https://huggingface.co/yjernite/retribert-base-uncased/resolve/main/vocab.txt'
        ),
    },
    'tokenizer_file': {
        'yjernite/retribert-base-uncased': (
            'https://huggingface.co/yjernite/retribert-base-uncased/resolve/main/tokenizer.json'
        ),
    },
}

SCREAMING_SNAKE_CASE__					:     Tuple       =     {
    'yjernite/retribert-base-uncased': 512,
}


SCREAMING_SNAKE_CASE__					:     Optional[Any]       =     {
    'yjernite/retribert-base-uncased': {'do_lower_case': True},
}


class 		_SCREAMING_SNAKE_CASE     (						A     ):
     __SCREAMING_SNAKE_CASE     					=    VOCAB_FILES_NAMES
     __SCREAMING_SNAKE_CASE     					=    PRETRAINED_VOCAB_FILES_MAP
     __SCREAMING_SNAKE_CASE     					=    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     __SCREAMING_SNAKE_CASE     					=    PRETRAINED_INIT_CONFIGURATION
     __SCREAMING_SNAKE_CASE     					=    RetriBertTokenizer
     __SCREAMING_SNAKE_CASE     					=    ['''input_ids''', '''attention_mask''']


     def __init__(  self							,					A_=None							,					A_=None							,					A_=True							,					A_="[UNK]"							,					A_="[SEP]"							,					A_="[PAD]"							,					A_="[CLS]"							,					A_="[MASK]"							,					A_=True							,					A_=None							,					**A_							,					):
       super().__init__(
           A_							,					tokenizer_file=A_							,					do_lower_case=A_							,					unk_token=A_							,					sep_token=A_							,					pad_token=A_							,					cls_token=A_							,					mask_token=A_							,					tokenize_chinese_chars=A_							,					strip_accents=A_							,					**A_							,					)

       _UpperCAmelCase		:							List[str]							=     json.loads(self.backend_tokenizer.normalizer.__getstate__()    )
       if (
           normalizer_state.get("""lowercase"""							,					A_    ) != do_lower_case
           or normalizer_state.get("""strip_accents"""							,					A_    ) != strip_accents
           or normalizer_state.get("""handle_chinese_chars"""							,					A_    ) != tokenize_chinese_chars
       ):
         _UpperCAmelCase		:							str							=     getattr(A_							,					normalizer_state.pop("""type"""    )    )
         _UpperCAmelCase		:							Optional[int]							=     do_lower_case
         _UpperCAmelCase		:							List[Any]							=     strip_accents
         _UpperCAmelCase		:							List[str]							=     tokenize_chinese_chars
         _UpperCAmelCase		:							Dict							=     normalizer_class(**A_    )

       _UpperCAmelCase		:							Dict							=     do_lower_case


     def        __snake_case(  self							,					A_							,					A_=None    ):
       _UpperCAmelCase		:							Tuple							=     [self.cls_token_id] + token_ids_a + [self.sep_token_id]

       if token_ids_a:
         output += token_ids_a + [self.sep_token_id]

       return output


     def        __snake_case(  self							,					A_							,					A_ = None    ):
       _UpperCAmelCase		:							List[Any]							=     [self.sep_token_id]
       _UpperCAmelCase		:							Tuple							=     [self.cls_token_id]
       if token_ids_a is None:
         return len(cls + token_ids_a + sep    ) * [0]
       return len(cls + token_ids_a + sep    ) * [0] + len(token_ids_a + sep    ) * [1]




     def        __snake_case(  self							,					A_							,					A_ = None    ):
       _UpperCAmelCase		:							Dict							=     self._tokenizer.model.save(A_							,					name=A_    )
       return tuple(A_    )





