


from importlib import import_module

from .logging import get_logger


_snake_case	:						Tuple         =							get_logger(__name__)

class 							a						:




							"""simple docstring"""


							def __init__(				self			:    str       ,      lowerCamelCase			:    str       ,      lowerCamelCase			:    Dict=None							)      ->       int:
														__snake_case						:     Dict									=  attrs or []
														if module is not None:
																					for key in module.__dict__:
																												if key in attrs or not key.startswith("__"							):
																																			setattr(self       ,      lowerCamelCase       ,      getattr(lowerCamelCase       ,      lowerCamelCase							)							)
														__snake_case						:     List[Any]									=  module._original_module if isinstance(lowerCamelCase       ,      _PatchedModuleObj							) else module

class 							a						:




							"""simple docstring"""


							__UpperCAmelCase       :				str	    =    []

							def __init__(				self			:    Dict       ,      lowerCamelCase			:    str       ,      lowerCamelCase			:    str       ,      lowerCamelCase			:    List[str]       ,      lowerCamelCase			:    Any=None							)      ->       Optional[Any]:
														__snake_case						:     str									=  obj
														__snake_case						:     str									=  target
														__snake_case						:     Dict									=  new
														__snake_case						:     Union[str, Any]									=  target.split("."							)[0]
														__snake_case						:     Any									=  {}
														__snake_case						:     str									=  attrs or []

							def __enter__(				self			:    Dict							)      ->       Optional[int]:
														*__snake_case					,     __snake_case						:     Union[str, Any]									=  self.target.split("."							)

														# Patch modules:
														# it's used to patch attributes of submodules like "os.path.join";
														# in this case we need to patch "os" and "os.path"

														for i in range(len(lowerCamelCase							)							):
																					try:
																												__snake_case						:     int									=  import_module(".".join(submodules[: i + 1]							)							)
																					except ModuleNotFoundError:
																												continue
																					# We iterate over all the globals in self.obj in case we find "os" or "os.path"
																					for attr in self.obj.__dir__():
																												__snake_case						:     Tuple									=  getattr(self.obj       ,      lowerCamelCase							)
																												# We don't check for the name of the global, but rather if its value *is* "os" or "os.path".
																												# This allows to patch renamed modules like "from os import path as ospath".
																												if obj_attr is submodule or (
																												    (isinstance(lowerCamelCase       ,      _PatchedModuleObj							) and obj_attr._original_module is submodule)
																												):
																																			__snake_case						:     Optional[Any]									=  obj_attr
																																			# patch at top level
																																			setattr(self.obj       ,      lowerCamelCase       ,      _PatchedModuleObj(lowerCamelCase       ,      attrs=self.attrs							)							)
																																			__snake_case						:     Union[str, Any]									=  getattr(self.obj       ,      lowerCamelCase							)
																																			# construct lower levels patches
																																			for key in submodules[i + 1 :]:
																																										setattr(lowerCamelCase       ,      lowerCamelCase       ,      _PatchedModuleObj(getattr(lowerCamelCase       ,      lowerCamelCase       ,      lowerCamelCase							)       ,      attrs=self.attrs							)							)
																																										__snake_case						:     Dict									=  getattr(lowerCamelCase       ,      lowerCamelCase							)
																																			# finally set the target attribute
																																			setattr(lowerCamelCase       ,      lowerCamelCase       ,      self.new							)

        # Patch attribute itself:
        # it's used for builtins like "open",
        # and also to patch "os.path.join" we may also need to patch "join"
        # itself if it was imported as "from os.path import join".

														if submodules:  # if it's an attribute of a submodule like "os.path.join"
																					try:
																												__snake_case						:     List[Any]									=  getattr(import_module(".".join(lowerCamelCase							)							)       ,      lowerCamelCase							)
																					except (AttributeError, ModuleNotFoundError):
																												return
																					# We iterate over all the globals in self.obj in case we find "os.path.join"
																					for attr in self.obj.__dir__():
																												# We don't check for the name of the global, but rather if its value *is* "os.path.join".
																												# This allows to patch renamed attributes like "from os.path import join as pjoin".
																												if getattr(self.obj       ,      lowerCamelCase							) is attr_value:
																																			__snake_case						:     Dict									=  getattr(self.obj       ,      lowerCamelCase							)
																																			setattr(self.obj       ,      lowerCamelCase       ,      self.new							)
														elif target_attr in globals()["__builtins__"]:  # if it'a s builtin like "open"
																					__snake_case						:     Tuple									=  globals()["__builtins__"][target_attr]
																					setattr(self.obj       ,      lowerCamelCase       ,      self.new							)
														else:
																					raise RuntimeError(F'Tried to patch attribute {target_attr} instead of a submodule.'							)

							def __exit__(				self			:    Optional[int]       ,      *lowerCamelCase			:    Optional[Any]							)      ->       Dict:
														for attr in list(self.original							):
																					setattr(self.obj       ,      lowerCamelCase       ,      self.original.pop(lowerCamelCase							)							)

							def        __snake_case   (				self			:    Any							)      ->       Optional[int]:
														self.__enter__()
														self._active_patches.append(self							)






							def        __snake_case   (				self			:    List[str]							)      ->       Tuple:
														try:
																					self._active_patches.remove(self							)
														except ValueError:
																					# If the patch hasn't been started this will fail
																					return None

														return self.__exit__()







import os
import re
import warnings
from shutil import copyfile
from typing import List, Optional, Tuple

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
      from .tokenization_ta import TaTokenizer
else:
      __magic_name__  :  Dict					=       None


__magic_name__  :  Optional[Any]					=       logging.get_logger(__name__)

__magic_name__  :  Optional[Any]					=       {"""vocab_file""": """spiece.model""", """tokenizer_file""": """tokenizer.json"""}

__magic_name__  :  Union[str, Any]					=       {
    """vocab_file""": {
        """t5-small""": """https://huggingface.co/t5-small/resolve/main/spiece.model""",
        """t5-base""": """https://huggingface.co/t5-base/resolve/main/spiece.model""",
        """t5-large""": """https://huggingface.co/t5-large/resolve/main/spiece.model""",
        """t5-3b""": """https://huggingface.co/t5-3b/resolve/main/spiece.model""",
        """t5-11b""": """https://huggingface.co/t5-11b/resolve/main/spiece.model""",
    },
    """tokenizer_file""": {
        """t5-small""": """https://huggingface.co/t5-small/resolve/main/tokenizer.json""",
        """t5-base""": """https://huggingface.co/t5-base/resolve/main/tokenizer.json""",
        """t5-large""": """https://huggingface.co/t5-large/resolve/main/tokenizer.json""",
        """t5-3b""": """https://huggingface.co/t5-3b/resolve/main/tokenizer.json""",
        """t5-11b""": """https://huggingface.co/t5-11b/resolve/main/tokenizer.json""",
    },
}


# TODO(PVP) - this should be removed in Transformers v5
__magic_name__  :  Tuple					=       {
    """t5-small""": 5_12,
    """t5-base""": 5_12,
    """t5-large""": 5_12,
    """t5-3b""": 5_12,
    """t5-11b""": 5_12,
}





class     SCREAMING_SNAKE_CASE__		(_a			):
     lowercase_ :      Dict				= VOCAB_FILES_NAMES
     lowercase_ :      Any				= PRETRAINED_VOCAB_FILES_MAP
     lowercase_ :      Tuple				= PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     lowercase_ :      Tuple				= ["input_ids", "attention_mask"]
     lowercase_ :      Any				= TaTokenizer

     lowercase_ :      List[int]				= []
     def __init__(						self	:		Tuple       ,						__lowerCamelCase	:		Tuple=None       ,						__lowerCamelCase	:		str=None       ,						__lowerCamelCase	:		Optional[int]="</s>"       ,						__lowerCamelCase	:		Optional[Any]="<unk>"       ,						__lowerCamelCase	:		int="<pad>"       ,						__lowerCamelCase	:		int=1_00       ,						__lowerCamelCase	:		List[str]=None       ,						**__lowerCamelCase	:		Tuple       ,						):



       """simple docstring"""
       # Add extra_ids to the special token list
       if extra_ids > 0 and additional_special_tokens is None:
         lowerCAmelCase__										=      [F"""<extra_id_{i}>""" for i in range(__lowerCamelCase						)]
       elif extra_ids > 0 and additional_special_tokens is not None:
         # Check that we have the right number of extra special tokens
         lowerCAmelCase__										=      len(set(filter(lambda __lowerCamelCase						: bool('''extra_id_''' in str(__lowerCamelCase						)						)       ,						__lowerCamelCase						)						)						)
         if extra_tokens != extra_ids:
           raise ValueError(
               F"""Both extra_ids ({extra_ids}) and additional_special_tokens ({additional_special_tokens}) are"""
               ''' provided to T5Tokenizer. In this case the additional_special_tokens must include the extra_ids'''
               ''' tokens'''						)

       super().__init__(
           __lowerCamelCase       ,						tokenizer_file=__lowerCamelCase       ,						eos_token=__lowerCamelCase       ,						unk_token=__lowerCamelCase       ,						pad_token=__lowerCamelCase       ,						extra_ids=__lowerCamelCase       ,						additional_special_tokens=__lowerCamelCase       ,						**__lowerCamelCase       ,						)

       lowerCAmelCase__										=      vocab_file
       lowerCAmelCase__										=      False if not self.vocab_file else True
       lowerCAmelCase__										=      extra_ids
     @staticmethod
     def        A__      (						__lowerCamelCase	:		Dict       ,						__lowerCamelCase	:		List[str]       ,						__lowerCamelCase	:		Any						):



       """simple docstring"""
       if pretrained_model_name_or_path in TaTokenizerFast.max_model_input_sizes:
         lowerCAmelCase__										=      TaTokenizerFast.max_model_input_sizes[pretrained_model_name_or_path]
         if init_max_model_length is not None and init_max_model_length != max_model_length:
           return init_max_model_length
         elif init_max_model_length is None:
           warnings.warn(
               '''This tokenizer was incorrectly instantiated with a model max length of'''
               F""" {deprecated_max_model_length} which will be corrected in Transformers v5.\nFor now, this"""
               ''' behavior is kept to avoid breaking backwards compatibility when padding/encoding with'''
               ''' `truncation is True`.\n- Be aware that you SHOULD NOT rely on'''
               F""" {pretrained_model_name_or_path} automatically truncating your input to"""
               F""" {deprecated_max_model_length} when padding/encoding.\n- If you want to encode/pad to sequences"""
               F""" longer than {deprecated_max_model_length} you can either instantiate this tokenizer with"""
               ''' `model_max_length` or pass `max_length` when encoding/padding.\n- To avoid this warning, please'''
               ''' instantiate this tokenizer with `model_max_length` set to your preferred value.'''       ,						__lowerCamelCase       ,						)

       return max_model_length
     def        A__      (						self	:		int       ,						__lowerCamelCase	:		str       ,						__lowerCamelCase	:		Optional[str] = None						):



       """simple docstring"""
       if not self.can_save_slow_tokenizer:
         raise ValueError(
             '''Your fast tokenizer does not have the necessary information to save the vocabulary for a slow '''
             '''tokenizer.'''						)

       if not os.path.isdir(__lowerCamelCase						):
         logger.error(F"""Vocabulary path ({save_directory}) should be a directory"""						)
         return
       lowerCAmelCase__										=      os.path.join(
           __lowerCamelCase       ,						(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']						)

       if os.path.abspath(self.vocab_file						) != os.path.abspath(__lowerCamelCase						):
         copyfile(self.vocab_file       ,						__lowerCamelCase						)
         logger.info(F"""Copy vocab file to {out_vocab_file}"""						)

       return (out_vocab_file,)
     def        A__      (						self	:		Optional[Any]       ,						__lowerCamelCase	:		List[int]       ,						__lowerCamelCase	:		Optional[List[int]] = None						):



       """simple docstring"""
       lowerCAmelCase__										=      token_ids_a + [self.eos_token_id]
       if token_ids_a is None:
         return self.prefix_tokens + token_ids_a
       else:
         lowerCAmelCase__										=      token_ids_a + [self.eos_token_id]
         return self.prefix_tokens + token_ids_a + token_ids_a
     def        A__      (						self	:		int       ,						__lowerCamelCase	:		List[int]       ,						__lowerCamelCase	:		Optional[List[int]] = None						):



       """simple docstring"""
       lowerCAmelCase__										=      [self.eos_token_id]

       if token_ids_a is None:
         return len(token_ids_a + eos						) * [0]
       return len(token_ids_a + eos + token_ids_a + eos						) * [0]
     def        A__      (						self	:		int						):



       """simple docstring"""
       return list(
           set(filter(lambda __lowerCamelCase						: bool(re.search(r'''<extra_id_\d+>'''       ,						__lowerCamelCase						)						) is not None       ,						self.additional_special_tokens						)						)						)



     def        A__      (						self	:		Dict						):



       """simple docstring"""
       return [self.convert_tokens_to_ids(__lowerCamelCase						) for token in self.get_sentinel_tokens()]

