




'''simple docstring'''


import os
import sys
import warnings
from dataclasses import dataclass, field
from io import BytesIO
from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union

import numpy as np
import pyarrow as pa

from .. import config
from ..download.streaming_download_manager import xopen
from ..table import array_cast
from ..utils.file_utils import is_local_path
from ..utils.py_utils import first_non_null_value, no_op_if_value_is_null, string_to_dict


if TYPE_CHECKING:
				import PIL.Image

				from .features import FeatureType


_snake_case				:				Optional[List[str]]       							=		None
_snake_case				:				Union[str, Any]       							=		'<' if sys.byteorder == 'little' else '>'
# Origin: https://github.com/python-pillow/Pillow/blob/698951e19e19972aeed56df686868f1329981c12/src/PIL/Image.py#L3126 minus "|i1" which values are not preserved correctly when saving and loading an image
_snake_case				:				Optional[int]       							=		[
    np.dtype('|b1'),
    np.dtype('|u1'),
    np.dtype('<u2'),
    np.dtype('>u2'),
    np.dtype('<i2'),
    np.dtype('>i2'),
    np.dtype('<u4'),
    np.dtype('>u4'),
    np.dtype('<i4'),
    np.dtype('>i4'),
    np.dtype('<f4'),
    np.dtype('>f4'),
    np.dtype('<f8'),
    np.dtype('>f8'),
]

@dataclass
class       A   :
							lowercase_          =    True
							lowercase_          =    None
							# Automatically constructed
							lowercase_          =    "PIL.Image.Image"
							lowercase_          =    pa.struct({'bytes': pa.binary(), 'path': pa.string()}   )
							lowercase_          =    field(default='Image'					,init=_a					,repr=_a   )







							def __call__(  self	:  int )      ->							int:


														"""simple docstring"""


														return self.pa_type







							def        __lowerCAmelCase      (  self	:  str							,      lowerCAmelCase_	:  Union[str, bytes, dict, np.ndarray, "PIL.Image.Image"] )      ->							dict:


														"""simple docstring"""


														if config.PIL_AVAILABLE:
																					import PIL.Image
														else:
																					raise ImportError('''To support encoding images, please install \'Pillow\'.''' )

														if isinstance(lowerCAmelCase_							,      lowerCAmelCase_ ):
																					_a     					=    np.array(lowerCAmelCase_ )

														if isinstance(lowerCAmelCase_							,      lowerCAmelCase_ ):
																					return {"path": value, "bytes": None}
														elif isinstance(lowerCAmelCase_							,      lowerCAmelCase_ ):
																					return {"path": None, "bytes": value}
														elif isinstance(lowerCAmelCase_							,      np.ndarray ):
																					# convert the image array to PNG/TIFF bytes
																					return encode_np_array(lowerCAmelCase_ )
														elif isinstance(lowerCAmelCase_							,      PIL.Image.Image ):
																					# convert the PIL image to bytes (default format is PNG/TIFF)
																					return encode_pil_image(lowerCAmelCase_ )
														elif value.get('''path''' ) is not None and os.path.isfile(value['''path'''] ):
																					# we set "bytes": None to not duplicate the data if they're already available locally
																					return {"bytes": None, "path": value.get('''path''' )}
														elif value.get('''bytes''' ) is not None or value.get('''path''' ) is not None:
																					# store the image bytes, and path is used to infer the image format using the file extension
																					return {"bytes": value.get('''bytes''' ), "path": value.get('''path''' )}
														else:
																					raise ValueError(
																					    F'An image sample should have one of \'path\' or \'bytes\' but they are missing or None in {value}.' )







							def        __lowerCAmelCase      (  self	:  Tuple							,      lowerCAmelCase_	:  dict							,      lowerCAmelCase_	:  Tuple=None )      ->							"PIL.Image.Image":


														"""simple docstring"""


														if not self.decode:
																					raise RuntimeError('''Decoding is disabled for this feature. Please use Image(decode=True) instead.''' )

														if config.PIL_AVAILABLE:
																					import PIL.Image
														else:
																					raise ImportError('''To support decoding images, please install \'Pillow\'.''' )

														if token_per_repo_id is None:
																					_a     					=    {}

														_a					,							_a     					=    value['''path'''], value['''bytes''']
														if bytes_ is None:
																					if path is None:
																												raise ValueError(F'An image should have one of \'path\' or \'bytes\' but both are None in {value}.' )
																					else:
																												if is_local_path(lowerCAmelCase_ ):
																																			_a     					=    PIL.Image.open(lowerCAmelCase_ )
																												else:
																																			_a     					=    path.split('''::''' )[-1]
																																			try:
																																										_a     					=    string_to_dict(lowerCAmelCase_							,      config.HUB_DATASETS_URL )['''repo_id''']
																																										_a     					=    token_per_repo_id.get(lowerCAmelCase_ )
																																			except ValueError:
																																										_a     					=    None
																																			with xopen(lowerCAmelCase_							,      '''rb'''							,      use_auth_token=lowerCAmelCase_ ) as f:
																																										_a     					=    BytesIO(f.read() )
																																			_a     					=    PIL.Image.open(bytes_ )
														else:
																					_a     					=    PIL.Image.open(BytesIO(bytes_ ) )
														image.load()  # to avoid "Too many open files" errors
														return image







							def        __lowerCAmelCase      (  self	:  Union[str, Any] )      ->							Union["FeatureType", Dict[str, "FeatureType"]]:


														"""simple docstring"""


														from .features import Value

														return (
														    self
														    if self.decode
														    else {
														        "bytes": Value('''binary''' ),
														        "path": Value('''string''' ),
														    }
														)







							def        __lowerCAmelCase      (  self	:  Any							,      lowerCAmelCase_	:  Union[pa.StringArray, pa.StructArray, pa.ListArray] )      ->							pa.StructArray:


														"""simple docstring"""


														if pa.types.is_string(storage.type ):
																					_a     					=    pa.array([None] * len(lowerCAmelCase_ )							,      type=pa.binary() )
																					_a     					=    pa.StructArray.from_arrays([bytes_array, storage]							,      ['''bytes''', '''path''']							,      mask=storage.is_null() )
														elif pa.types.is_binary(storage.type ):
																					_a     					=    pa.array([None] * len(lowerCAmelCase_ )							,      type=pa.string() )
																					_a     					=    pa.StructArray.from_arrays([storage, path_array]							,      ['''bytes''', '''path''']							,      mask=storage.is_null() )
														elif pa.types.is_struct(storage.type ):
																					if storage.type.get_field_index('''bytes''' ) >= 0:
																												_a     					=    storage.field('''bytes''' )
																					else:
																												_a     					=    pa.array([None] * len(lowerCAmelCase_ )							,      type=pa.binary() )
																					if storage.type.get_field_index('''path''' ) >= 0:
																												_a     					=    storage.field('''path''' )
																					else:
																												_a     					=    pa.array([None] * len(lowerCAmelCase_ )							,      type=pa.string() )
																					_a     					=    pa.StructArray.from_arrays([bytes_array, path_array]							,      ['''bytes''', '''path''']							,      mask=storage.is_null() )
														elif pa.types.is_list(storage.type ):
																					_a     					=    pa.array(
																					    [encode_np_array(np.array(lowerCAmelCase_ ) )['''bytes'''] if arr is not None else None for arr in storage.to_pylist()]							,      type=pa.binary()							,      )
																					_a     					=    pa.array([None] * len(lowerCAmelCase_ )							,      type=pa.string() )
																					_a     					=    pa.StructArray.from_arrays(
																					    [bytes_array, path_array]							,      ['''bytes''', '''path''']							,      mask=bytes_array.is_null() )
														return array_cast(lowerCAmelCase_							,      self.pa_type )







							def        __lowerCAmelCase      (  self	:  str							,      lowerCAmelCase_	:  pa.StructArray )      ->							pa.StructArray:


														"""simple docstring"""


														@no_op_if_value_is_null
														def path_to_bytes(lowerCAmelCase_	:  Optional[Any] ):
																					with xopen(lowerCAmelCase_							,      '''rb''' ) as f:
																												_a     					=    f.read()
																					return bytes_

														_a     					=    pa.array(
														    [
														        (path_to_bytes(x['''path'''] ) if x['''bytes'''] is None else x['''bytes''']) if x is not None else None
														        for x in storage.to_pylist()
														    ]							,      type=pa.binary()							,      )
														_a     					=    pa.array(
														    [os.path.basename(lowerCAmelCase_ ) if path is not None else None for path in storage.field('''path''' ).to_pylist()]							,      type=pa.string()							,      )
														_a     					=    pa.StructArray.from_arrays([bytes_array, path_array]							,      ['''bytes''', '''path''']							,      mask=bytes_array.is_null() )
														return array_cast(lowerCAmelCase_							,      self.pa_type )



def 		snake_case_   ():





							'''simple docstring'''


							if config.PIL_AVAILABLE:
														import PIL.Image
							else:
														raise ImportError('''To support encoding images, please install \'Pillow\'.'''				)

							global _IMAGE_COMPRESSION_FORMATS
							if _IMAGE_COMPRESSION_FORMATS is None:
														PIL.Image.init()
														_a     					=    list(set(PIL.Image.OPEN.keys()				) & set(PIL.Image.SAVE.keys()				)				)
							return _IMAGE_COMPRESSION_FORMATS
def 		snake_case_   (UpperCamelCase	:  "PIL.Image.Image"				):





							'''simple docstring'''


							_a     					=    BytesIO()
							if image.format in list_image_compression_formats():
														_a     					=    image.format
							else:
														_a     					=    '''PNG''' if image.mode in ['''1''', '''L''', '''LA''', '''RGB''', '''RGBA'''] else '''TIFF'''
							image.save(UpperCamelCase			,						format=UpperCamelCase				)
							return buffer.getvalue()
def 		snake_case_   (UpperCamelCase	:  "PIL.Image.Image"				):





							'''simple docstring'''


							if hasattr(UpperCamelCase			,						'''filename'''				) and image.filename != "":
														return {"path": image.filename, "bytes": None}
							else:
														return {"path": None, "bytes": image_to_bytes(UpperCamelCase				)}
def 		snake_case_   (UpperCamelCase	:  np.ndarray				):





							'''simple docstring'''


							if config.PIL_AVAILABLE:
														import PIL.Image
							else:
														raise ImportError('''To support encoding images, please install \'Pillow\'.'''				)

							_a     					=    array.dtype
							_a     					=    dtype.byteorder if dtype.byteorder != '''=''' else _NATIVE_BYTEORDER
							_a     					=    dtype.kind
							_a     					=    dtype.itemsize

							_a     					=    None

							# Multi-channel array case (only np.dtype("|u1") is allowed)
							if array.shape[2:]:
														_a     					=    np.dtype('''|u1'''				)
														if dtype_kind not in ["u", "i"]:
																					raise TypeError(
																					    f'Unsupported array dtype {dtype} for image encoding. Only {dest_dtype} is supported for multi-channel arrays.'				)
														if dtype is not dest_dtype:
																					warnings.warn(f'Downcasting array dtype {dtype} to {dest_dtype} to be compatible with \'Pillow\''				)
    # Exact match
							elif dtype in _VALID_IMAGE_ARRAY_DTPYES:
														_a     					=    dtype
							else:  # Downcast the type within the kind (np.can_cast(from_type, to_type, casting="same_kind") doesn't behave as expected, so do it manually)
														while dtype_itemsize >= 1:
																					_a     					=    dtype_byteorder + dtype_kind + str(UpperCamelCase				)
																					_a     					=    np.dtype(UpperCamelCase				)
																					if dest_dtype in _VALID_IMAGE_ARRAY_DTPYES:
																												warnings.warn(f'Downcasting array dtype {dtype} to {dest_dtype} to be compatible with \'Pillow\''				)
																												break
																					else:
																												dtype_itemsize //= 2

							if dest_dtype is None:
														raise TypeError(
														    f'Cannot convert dtype {dtype} to a valid image dtype. Valid image dtypes: {_VALID_IMAGE_ARRAY_DTPYES}'				)
							_a     					=    PIL.Image.fromarray(array.astype(UpperCamelCase				)				)
							return {"path": None, "bytes": image_to_bytes(UpperCamelCase				)}

def 		snake_case_   (UpperCamelCase	:  Union[List[str], List[dict], List[np.ndarray], List["PIL.Image.Image"]]				):





							'''simple docstring'''


							if config.PIL_AVAILABLE:
														import PIL.Image
							else:
														raise ImportError('''To support encoding images, please install \'Pillow\'.'''				)

							if objs:
														_a					,							_a     					=    first_non_null_value(UpperCamelCase				)
														if isinstance(UpperCamelCase			,						UpperCamelCase				):
																					return [{"path": obj, "bytes": None} if obj is not None else None for obj in objs]
														if isinstance(UpperCamelCase			,						np.ndarray				):
																					_a     					=    no_op_if_value_is_null(UpperCamelCase				)
																					return [obj_to_image_dict_func(UpperCamelCase				) for obj in objs]
														elif isinstance(UpperCamelCase			,						PIL.Image.Image				):
																					_a     					=    no_op_if_value_is_null(UpperCamelCase				)
																					return [obj_to_image_dict_func(UpperCamelCase				) for obj in objs]
														else:
																					return objs
							else:
														return objs







'''simple docstring'''


import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_bert import BertTokenizer


_snake_case				:				Any       							=		logging.get_logger(__name__)

_snake_case				:				Any       							=		{'vocab_file': 'vocab.txt', 'tokenizer_file': 'tokenizer.json'}

_snake_case				:				List[str]       							=		{
    'vocab_file': {
        'bert-base-uncased': 'https://huggingface.co/bert-base-uncased/resolve/main/vocab.txt',
        'bert-large-uncased': 'https://huggingface.co/bert-large-uncased/resolve/main/vocab.txt',
        'bert-base-cased': 'https://huggingface.co/bert-base-cased/resolve/main/vocab.txt',
        'bert-large-cased': 'https://huggingface.co/bert-large-cased/resolve/main/vocab.txt',
        'bert-base-multilingual-uncased': (
            'https://huggingface.co/bert-base-multilingual-uncased/resolve/main/vocab.txt'
        ),
        'bert-base-multilingual-cased': 'https://huggingface.co/bert-base-multilingual-cased/resolve/main/vocab.txt',
        'bert-base-chinese': 'https://huggingface.co/bert-base-chinese/resolve/main/vocab.txt',
        'bert-base-german-cased': 'https://huggingface.co/bert-base-german-cased/resolve/main/vocab.txt',
        'bert-large-uncased-whole-word-masking': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/vocab.txt'
        ),
        'bert-large-cased-whole-word-masking': (
            'https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/vocab.txt'
        ),
        'bert-large-uncased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt'
        ),
        'bert-large-cased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt'
        ),
        'bert-base-cased-finetuned-mrpc': (
            'https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/vocab.txt'
        ),
        'bert-base-german-dbmdz-cased': 'https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/vocab.txt',
        'bert-base-german-dbmdz-uncased': (
            'https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/vocab.txt'
        ),
        'TurkuNLP/bert-base-finnish-cased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/vocab.txt'
        ),
        'TurkuNLP/bert-base-finnish-uncased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/vocab.txt'
        ),
        'wietsedv/bert-base-dutch-cased': (
            'https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/vocab.txt'
        ),
    },
    'tokenizer_file': {
        'bert-base-uncased': 'https://huggingface.co/bert-base-uncased/resolve/main/tokenizer.json',
        'bert-large-uncased': 'https://huggingface.co/bert-large-uncased/resolve/main/tokenizer.json',
        'bert-base-cased': 'https://huggingface.co/bert-base-cased/resolve/main/tokenizer.json',
        'bert-large-cased': 'https://huggingface.co/bert-large-cased/resolve/main/tokenizer.json',
        'bert-base-multilingual-uncased': (
            'https://huggingface.co/bert-base-multilingual-uncased/resolve/main/tokenizer.json'
        ),
        'bert-base-multilingual-cased': (
            'https://huggingface.co/bert-base-multilingual-cased/resolve/main/tokenizer.json'
        ),
        'bert-base-chinese': 'https://huggingface.co/bert-base-chinese/resolve/main/tokenizer.json',
        'bert-base-german-cased': 'https://huggingface.co/bert-base-german-cased/resolve/main/tokenizer.json',
        'bert-large-uncased-whole-word-masking': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/tokenizer.json'
        ),
        'bert-large-cased-whole-word-masking': (
            'https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/tokenizer.json'
        ),
        'bert-large-uncased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json'
        ),
        'bert-large-cased-whole-word-masking-finetuned-squad': (
            'https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json'
        ),
        'bert-base-cased-finetuned-mrpc': (
            'https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/tokenizer.json'
        ),
        'bert-base-german-dbmdz-cased': (
            'https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/tokenizer.json'
        ),
        'bert-base-german-dbmdz-uncased': (
            'https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/tokenizer.json'
        ),
        'TurkuNLP/bert-base-finnish-cased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/tokenizer.json'
        ),
        'TurkuNLP/bert-base-finnish-uncased-v1': (
            'https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/tokenizer.json'
        ),
        'wietsedv/bert-base-dutch-cased': (
            'https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/tokenizer.json'
        ),
    },
}

_snake_case				:				int       							=		{
    'bert-base-uncased': 512,
    'bert-large-uncased': 512,
    'bert-base-cased': 512,
    'bert-large-cased': 512,
    'bert-base-multilingual-uncased': 512,
    'bert-base-multilingual-cased': 512,
    'bert-base-chinese': 512,
    'bert-base-german-cased': 512,
    'bert-large-uncased-whole-word-masking': 512,
    'bert-large-cased-whole-word-masking': 512,
    'bert-large-uncased-whole-word-masking-finetuned-squad': 512,
    'bert-large-cased-whole-word-masking-finetuned-squad': 512,
    'bert-base-cased-finetuned-mrpc': 512,
    'bert-base-german-dbmdz-cased': 512,
    'bert-base-german-dbmdz-uncased': 512,
    'TurkuNLP/bert-base-finnish-cased-v1': 512,
    'TurkuNLP/bert-base-finnish-uncased-v1': 512,
    'wietsedv/bert-base-dutch-cased': 512,
}

_snake_case				:				int       							=		{
    'bert-base-uncased': {'do_lower_case': True},
    'bert-large-uncased': {'do_lower_case': True},
    'bert-base-cased': {'do_lower_case': False},
    'bert-large-cased': {'do_lower_case': False},
    'bert-base-multilingual-uncased': {'do_lower_case': True},
    'bert-base-multilingual-cased': {'do_lower_case': False},
    'bert-base-chinese': {'do_lower_case': False},
    'bert-base-german-cased': {'do_lower_case': False},
    'bert-large-uncased-whole-word-masking': {'do_lower_case': True},
    'bert-large-cased-whole-word-masking': {'do_lower_case': False},
    'bert-large-uncased-whole-word-masking-finetuned-squad': {'do_lower_case': True},
    'bert-large-cased-whole-word-masking-finetuned-squad': {'do_lower_case': False},
    'bert-base-cased-finetuned-mrpc': {'do_lower_case': False},
    'bert-base-german-dbmdz-cased': {'do_lower_case': False},
    'bert-base-german-dbmdz-uncased': {'do_lower_case': True},
    'TurkuNLP/bert-base-finnish-cased-v1': {'do_lower_case': False},
    'TurkuNLP/bert-base-finnish-uncased-v1': {'do_lower_case': True},
    'wietsedv/bert-base-dutch-cased': {'do_lower_case': False},
}

class       A   (		_a   ):
							lowercase_          =    VOCAB_FILES_NAMES
							lowercase_          =    PRETRAINED_VOCAB_FILES_MAP
							lowercase_          =    PRETRAINED_INIT_CONFIGURATION
							lowercase_          =    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							lowercase_          =    BertTokenizer







							def __init__(  self	:  str							,      lowerCAmelCase_	:  Union[str, Any]=None							,      lowerCAmelCase_	:  str=None							,      lowerCAmelCase_	:  List[Any]=True							,      lowerCAmelCase_	:  Any="[UNK]"							,      lowerCAmelCase_	:  Union[str, Any]="[SEP]"							,      lowerCAmelCase_	:  Tuple="[PAD]"							,      lowerCAmelCase_	:  Tuple="[CLS]"							,      lowerCAmelCase_	:  Optional[int]="[MASK]"							,      lowerCAmelCase_	:  Dict=True							,      lowerCAmelCase_	:  Union[str, Any]=None							,      **lowerCAmelCase_	:  Union[str, Any]							,      )      ->							Union[str, Any]:


														"""simple docstring"""


														super().__init__(
														    lowerCAmelCase_							,      tokenizer_file=lowerCAmelCase_							,      do_lower_case=lowerCAmelCase_							,      unk_token=lowerCAmelCase_							,      sep_token=lowerCAmelCase_							,      pad_token=lowerCAmelCase_							,      cls_token=lowerCAmelCase_							,      mask_token=lowerCAmelCase_							,      tokenize_chinese_chars=lowerCAmelCase_							,      strip_accents=lowerCAmelCase_							,      **lowerCAmelCase_							,      )

														_a     					=    json.loads(self.backend_tokenizer.normalizer.__getstate__() )
														if (
														    normalizer_state.get('''lowercase'''							,      lowerCAmelCase_ ) != do_lower_case
														    or normalizer_state.get('''strip_accents'''							,      lowerCAmelCase_ ) != strip_accents
														    or normalizer_state.get('''handle_chinese_chars'''							,      lowerCAmelCase_ ) != tokenize_chinese_chars
														):
																					_a     					=    getattr(lowerCAmelCase_							,      normalizer_state.pop('''type''' ) )
																					_a     					=    do_lower_case
																					_a     					=    strip_accents
																					_a     					=    tokenize_chinese_chars
																					_a     					=    normalizer_class(**lowerCAmelCase_ )

														_a     					=    do_lower_case







							def        __lowerCAmelCase      (  self	:  str							,      lowerCAmelCase_	:  Dict							,      lowerCAmelCase_	:  int=None )      ->							List[str]:


														"""simple docstring"""


														_a     					=    [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        __lowerCAmelCase      (  self	:  Any							,      lowerCAmelCase_	:  List[int]							,      lowerCAmelCase_	:  Optional[List[int]] = None )      ->							List[int]:


														"""simple docstring"""


														_a     					=    [self.sep_token_id]
														_a     					=    [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        __lowerCAmelCase      (  self	:  List[Any]							,      lowerCAmelCase_	:  str							,      lowerCAmelCase_	:  Optional[str] = None )      ->							Tuple[str]:


														"""simple docstring"""


														_a     					=    self._tokenizer.model.save(lowerCAmelCase_							,      name=lowerCAmelCase_ )
														return tuple(lowerCAmelCase_ )

