


from ..utils import DummyObject, requires_backends

class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		List[Any]								=   ["tokenizers"]


     def __init__(   self				:  Optional[Any]				,						*lowerCamelCase__				:  Any				,						**lowerCamelCase__				:  Optional[int]      )	->   str:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Union[str, Any]								=   ["tokenizers"]


     def __init__(   self				:  str				,						*lowerCamelCase__				:  Optional[int]				,						**lowerCamelCase__				:  Any      )	->   Optional[int]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Any								=   ["tokenizers"]


     def __init__(   self				:  int				,						*lowerCamelCase__				:  Union[str, Any]				,						**lowerCamelCase__				:  Tuple      )	->   Optional[int]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Dict								=   ["tokenizers"]


     def __init__(   self				:  Any				,						*lowerCamelCase__				:  List[Any]				,						**lowerCamelCase__				:  Any      )	->   Any:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		str								=   ["tokenizers"]


     def __init__(   self				:  Union[str, Any]				,						*lowerCamelCase__				:  List[str]				,						**lowerCamelCase__				:  Optional[Any]      )	->   Any:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Optional[int]								=   ["tokenizers"]


     def __init__(   self				:  List[str]				,						*lowerCamelCase__				:  Any				,						**lowerCamelCase__				:  Optional[int]      )	->   int:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		int								=   ["tokenizers"]


     def __init__(   self				:  str				,						*lowerCamelCase__				:  str				,						**lowerCamelCase__				:  Dict      )	->   str:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Any								=   ["tokenizers"]


     def __init__(   self				:  Optional[int]				,						*lowerCamelCase__				:  Any				,						**lowerCamelCase__				:  str      )	->   List[str]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Tuple								=   ["tokenizers"]


     def __init__(   self				:  List[Any]				,						*lowerCamelCase__				:  str				,						**lowerCamelCase__				:  Optional[int]      )	->   Tuple:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		int								=   ["tokenizers"]


     def __init__(   self				:  Optional[Any]				,						*lowerCamelCase__				:  Dict				,						**lowerCamelCase__				:  List[Any]      )	->   Dict:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Dict								=   ["tokenizers"]


     def __init__(   self				:  Tuple				,						*lowerCamelCase__				:  Optional[Any]				,						**lowerCamelCase__				:  Optional[int]      )	->   Dict:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Optional[int]								=   ["tokenizers"]


     def __init__(   self				:  Tuple				,						*lowerCamelCase__				:  Optional[Any]				,						**lowerCamelCase__				:  Dict      )	->   Union[str, Any]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Optional[int]								=   ["tokenizers"]


     def __init__(   self				:  Tuple				,						*lowerCamelCase__				:  str				,						**lowerCamelCase__				:  List[str]      )	->   List[Any]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Optional[int]								=   ["tokenizers"]


     def __init__(   self				:  Dict				,						*lowerCamelCase__				:  Optional[int]				,						**lowerCamelCase__				:  Tuple      )	->   str:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Union[str, Any]								=   ["tokenizers"]


     def __init__(   self				:  int				,						*lowerCamelCase__				:  Union[str, Any]				,						**lowerCamelCase__				:  Tuple      )	->   int:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		List[str]								=   ["tokenizers"]


     def __init__(   self				:  Dict				,						*lowerCamelCase__				:  Optional[Any]				,						**lowerCamelCase__				:  Tuple      )	->   int:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Optional[int]								=   ["tokenizers"]


     def __init__(   self				:  int				,						*lowerCamelCase__				:  Any				,						**lowerCamelCase__				:  Optional[int]      )	->   Dict:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		int								=   ["tokenizers"]


     def __init__(   self				:  List[str]				,						*lowerCamelCase__				:  Dict				,						**lowerCamelCase__				:  Optional[int]      )	->   str:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Optional[int]								=   ["tokenizers"]


     def __init__(   self				:  str				,						*lowerCamelCase__				:  Dict				,						**lowerCamelCase__				:  List[Any]      )	->   Optional[Any]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		str								=   ["tokenizers"]


     def __init__(   self				:  List[str]				,						*lowerCamelCase__				:  Dict				,						**lowerCamelCase__				:  Optional[int]      )	->   List[Any]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		List[str]								=   ["tokenizers"]


     def __init__(   self				:  Tuple				,						*lowerCamelCase__				:  List[str]				,						**lowerCamelCase__				:  Tuple      )	->   int:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		str								=   ["tokenizers"]


     def __init__(   self				:  str				,						*lowerCamelCase__				:  Optional[Any]				,						**lowerCamelCase__				:  Union[str, Any]      )	->   List[str]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Union[str, Any]								=   ["tokenizers"]


     def __init__(   self				:  Any				,						*lowerCamelCase__				:  Tuple				,						**lowerCamelCase__				:  str      )	->   Optional[int]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		str								=   ["tokenizers"]


     def __init__(   self				:  Tuple				,						*lowerCamelCase__				:  Union[str, Any]				,						**lowerCamelCase__				:  Union[str, Any]      )	->   Dict:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		str								=   ["tokenizers"]


     def __init__(   self				:  int				,						*lowerCamelCase__				:  Any				,						**lowerCamelCase__				:  Tuple      )	->   Union[str, Any]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Optional[int]								=   ["tokenizers"]


     def __init__(   self				:  Union[str, Any]				,						*lowerCamelCase__				:  Tuple				,						**lowerCamelCase__				:  Tuple      )	->   Optional[int]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Tuple								=   ["tokenizers"]


     def __init__(   self				:  List[str]				,						*lowerCamelCase__				:  Union[str, Any]				,						**lowerCamelCase__				:  Tuple      )	->   Dict:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		List[Any]								=   ["tokenizers"]


     def __init__(   self				:  List[str]				,						*lowerCamelCase__				:  Any				,						**lowerCamelCase__				:  int      )	->   Optional[int]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Dict								=   ["tokenizers"]


     def __init__(   self				:  Any				,						*lowerCamelCase__				:  str				,						**lowerCamelCase__				:  List[Any]      )	->   Optional[Any]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		str								=   ["tokenizers"]


     def __init__(   self				:  Union[str, Any]				,						*lowerCamelCase__				:  Any				,						**lowerCamelCase__				:  int      )	->   Tuple:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Tuple								=   ["tokenizers"]


     def __init__(   self				:  str				,						*lowerCamelCase__				:  Optional[Any]				,						**lowerCamelCase__				:  List[Any]      )	->   Union[str, Any]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Optional[int]								=   ["tokenizers"]


     def __init__(   self				:  Tuple				,						*lowerCamelCase__				:  List[Any]				,						**lowerCamelCase__				:  Optional[int]      )	->   int:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Optional[int]								=   ["tokenizers"]


     def __init__(   self				:  Tuple				,						*lowerCamelCase__				:  Tuple				,						**lowerCamelCase__				:  Dict      )	->   Optional[Any]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Optional[int]								=   ["tokenizers"]


     def __init__(   self				:  Optional[int]				,						*lowerCamelCase__				:  Tuple				,						**lowerCamelCase__				:  Optional[int]      )	->   str:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Tuple								=   ["tokenizers"]


     def __init__(   self				:  Tuple				,						*lowerCamelCase__				:  Optional[Any]				,						**lowerCamelCase__				:  Tuple      )	->   Dict:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		List[str]								=   ["tokenizers"]


     def __init__(   self				:  Optional[Any]				,						*lowerCamelCase__				:  Any				,						**lowerCamelCase__				:  Dict      )	->   Optional[int]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		int								=   ["tokenizers"]


     def __init__(   self				:  Optional[int]				,						*lowerCamelCase__				:  List[Any]				,						**lowerCamelCase__				:  Any      )	->   Optional[Any]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Optional[int]								=   ["tokenizers"]


     def __init__(   self				:  Optional[Any]				,						*lowerCamelCase__				:  str				,						**lowerCamelCase__				:  Tuple      )	->   List[Any]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Any								=   ["tokenizers"]


     def __init__(   self				:  Any				,						*lowerCamelCase__				:  Tuple				,						**lowerCamelCase__				:  Any      )	->   Optional[Any]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Union[str, Any]								=   ["tokenizers"]


     def __init__(   self				:  Union[str, Any]				,						*lowerCamelCase__				:  int				,						**lowerCamelCase__				:  str      )	->   Any:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		str								=   ["tokenizers"]


     def __init__(   self				:  Any				,						*lowerCamelCase__				:  str				,						**lowerCamelCase__				:  int      )	->   Optional[Any]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		int								=   ["tokenizers"]


     def __init__(   self				:  List[str]				,						*lowerCamelCase__				:  int				,						**lowerCamelCase__				:  Dict      )	->   Union[str, Any]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		int								=   ["tokenizers"]


     def __init__(   self				:  Dict				,						*lowerCamelCase__				:  str				,						**lowerCamelCase__				:  Optional[Any]      )	->   Optional[Any]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		str								=   ["tokenizers"]


     def __init__(   self				:  List[str]				,						*lowerCamelCase__				:  Optional[int]				,						**lowerCamelCase__				:  Any      )	->   Dict:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Any								=   ["tokenizers"]


     def __init__(   self				:  Tuple				,						*lowerCamelCase__				:  Union[str, Any]				,						**lowerCamelCase__				:  Dict      )	->   str:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		str								=   ["tokenizers"]


     def __init__(   self				:  Tuple				,						*lowerCamelCase__				:  Dict				,						**lowerCamelCase__				:  int      )	->   List[str]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Tuple								=   ["tokenizers"]


     def __init__(   self				:  List[str]				,						*lowerCamelCase__				:  Optional[Any]				,						**lowerCamelCase__				:  int      )	->   Tuple:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Union[str, Any]								=   ["tokenizers"]


     def __init__(   self				:  str				,						*lowerCamelCase__				:  Union[str, Any]				,						**lowerCamelCase__				:  Optional[int]      )	->   Optional[Any]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Optional[int]								=   ["tokenizers"]


     def __init__(   self				:  Any				,						*lowerCamelCase__				:  Optional[Any]				,						**lowerCamelCase__				:  Union[str, Any]      )	->   Optional[int]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Optional[Any]								=   ["tokenizers"]


     def __init__(   self				:  Any				,						*lowerCamelCase__				:  Any				,						**lowerCamelCase__				:  List[Any]      )	->   Tuple:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Optional[Any]								=   ["tokenizers"]


     def __init__(   self				:  List[str]				,						*lowerCamelCase__				:  List[str]				,						**lowerCamelCase__				:  str      )	->   Any:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Optional[int]								=   ["tokenizers"]


     def __init__(   self				:  Union[str, Any]				,						*lowerCamelCase__				:  List[Any]				,						**lowerCamelCase__				:  Tuple      )	->   str:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Dict								=   ["tokenizers"]


     def __init__(   self				:  Any				,						*lowerCamelCase__				:  Union[str, Any]				,						**lowerCamelCase__				:  int      )	->   str:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Optional[Any]								=   ["tokenizers"]


     def __init__(   self				:  str				,						*lowerCamelCase__				:  Union[str, Any]				,						**lowerCamelCase__				:  List[str]      )	->   Union[str, Any]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		List[str]								=   ["tokenizers"]


     def __init__(   self				:  Any				,						*lowerCamelCase__				:  List[str]				,						**lowerCamelCase__				:  Optional[int]      )	->   Dict:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		List[Any]								=   ["tokenizers"]


     def __init__(   self				:  Optional[Any]				,						*lowerCamelCase__				:  int				,						**lowerCamelCase__				:  int      )	->   Optional[Any]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		Optional[int]								=   ["tokenizers"]


     def __init__(   self				:  Union[str, Any]				,						*lowerCamelCase__				:  str				,						**lowerCamelCase__				:  Tuple      )	->   Tuple:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )



class    __magic_name__						(  metaclass=__lowerCAmelCase):
     A:		str								=   ["tokenizers"]


     def __init__(   self				:  Any				,						*lowerCamelCase__				:  Optional[Any]				,						**lowerCamelCase__				:  int      )	->   Optional[int]:





      '''simple docstring'''






      requires_backends(self				,						['''tokenizers''']      )






import unittest
import warnings
from dataclasses import dataclass

from transformers.convert_slow_tokenizer import SpmConverter
from transformers.testing_utils import get_tests_dir

@dataclass
class    __magic_name__						:
     A:		str



class    __magic_name__						(  unittest.TestCase):


     def   UpperCAmelCase__						(   self				:  Any      )	->   List[Any]:





      '''simple docstring'''






      UpperCamelCase__       :     Optional[Any] 							= get_tests_dir('''fixtures/test_sentencepiece.model'''      )
      UpperCamelCase__       :     Any 							= get_tests_dir('''fixtures/test_sentencepiece_with_bytefallback.model'''      )

      UpperCamelCase__       :     List[str] 							= FakeOriginalTokenizer(vocab_file=lowerCamelCase__      )

      with warnings.catch_warnings(record=lowerCamelCase__      ) as w:
       UpperCamelCase__       :     Optional[int] 							= SpmConverter(lowerCamelCase__      )
      self.assertEqual(len(lowerCamelCase__      )				,						0      )

      UpperCamelCase__       :     Tuple 							= FakeOriginalTokenizer(vocab_file=lowerCamelCase__      )

      with warnings.catch_warnings(record=lowerCamelCase__      ) as w:
       UpperCamelCase__       :     str 							= SpmConverter(lowerCamelCase__      )
      self.assertEqual(len(lowerCamelCase__      )				,						1      )

      self.assertIn(
          '''The sentencepiece tokenizer that you are converting to a fast tokenizer uses the byte fallback option'''
          ''' which is not implemented in the fast tokenizers.'''				,						str(w[0].message      )				,						)


