






from ..utils import DummyObject, requires_backends






class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : List[Any]    =      ['''tokenizers''']


 def __init__(  self	:		Any							,		*UpperCAmelCase__	:		Tuple							,		**UpperCAmelCase__	:		Dict							)      -> Optional[int]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Dict    =      ['''tokenizers''']


 def __init__(  self	:		str							,		*UpperCAmelCase__	:		Optional[int]							,		**UpperCAmelCase__	:		List[str]							)      -> Dict:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Any    =      ['''tokenizers''']


 def __init__(  self	:		Any							,		*UpperCAmelCase__	:		Any							,		**UpperCAmelCase__	:		Union[str, Any]							)      -> int:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Optional[int]    =      ['''tokenizers''']


 def __init__(  self	:		Tuple							,		*UpperCAmelCase__	:		List[str]							,		**UpperCAmelCase__	:		Any							)      -> Optional[int]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : List[Any]    =      ['''tokenizers''']


 def __init__(  self	:		str							,		*UpperCAmelCase__	:		Optional[Any]							,		**UpperCAmelCase__	:		Optional[Any]							)      -> List[Any]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : List[str]    =      ['''tokenizers''']


 def __init__(  self	:		List[Any]							,		*UpperCAmelCase__	:		Dict							,		**UpperCAmelCase__	:		List[str]							)      -> Tuple:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : int    =      ['''tokenizers''']


 def __init__(  self	:		int							,		*UpperCAmelCase__	:		int							,		**UpperCAmelCase__	:		Dict							)      -> List[Any]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Dict    =      ['''tokenizers''']


 def __init__(  self	:		int							,		*UpperCAmelCase__	:		str							,		**UpperCAmelCase__	:		Optional[int]							)      -> Optional[Any]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Optional[Any]    =      ['''tokenizers''']


 def __init__(  self	:		Tuple							,		*UpperCAmelCase__	:		int							,		**UpperCAmelCase__	:		Any							)      -> Union[str, Any]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : int    =      ['''tokenizers''']


 def __init__(  self	:		Union[str, Any]							,		*UpperCAmelCase__	:		Any							,		**UpperCAmelCase__	:		Tuple							)      -> Tuple:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : List[str]    =      ['''tokenizers''']


 def __init__(  self	:		Optional[Any]							,		*UpperCAmelCase__	:		int							,		**UpperCAmelCase__	:		Dict							)      -> List[Any]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Union[str, Any]    =      ['''tokenizers''']


 def __init__(  self	:		List[Any]							,		*UpperCAmelCase__	:		Tuple							,		**UpperCAmelCase__	:		Optional[Any]							)      -> Optional[Any]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Tuple    =      ['''tokenizers''']


 def __init__(  self	:		List[str]							,		*UpperCAmelCase__	:		Union[str, Any]							,		**UpperCAmelCase__	:		List[str]							)      -> List[Any]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Optional[int]    =      ['''tokenizers''']


 def __init__(  self	:		Dict							,		*UpperCAmelCase__	:		Tuple							,		**UpperCAmelCase__	:		Dict							)      -> List[Any]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Optional[Any]    =      ['''tokenizers''']


 def __init__(  self	:		Union[str, Any]							,		*UpperCAmelCase__	:		List[Any]							,		**UpperCAmelCase__	:		int							)      -> Optional[Any]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Any    =      ['''tokenizers''']


 def __init__(  self	:		Dict							,		*UpperCAmelCase__	:		Optional[int]							,		**UpperCAmelCase__	:		Union[str, Any]							)      -> List[str]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : str    =      ['''tokenizers''']


 def __init__(  self	:		List[Any]							,		*UpperCAmelCase__	:		Tuple							,		**UpperCAmelCase__	:		Optional[int]							)      -> List[Any]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : str    =      ['''tokenizers''']


 def __init__(  self	:		int							,		*UpperCAmelCase__	:		int							,		**UpperCAmelCase__	:		Tuple							)      -> str:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Dict    =      ['''tokenizers''']


 def __init__(  self	:		Optional[Any]							,		*UpperCAmelCase__	:		Tuple							,		**UpperCAmelCase__	:		Dict							)      -> str:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : int    =      ['''tokenizers''']


 def __init__(  self	:		Optional[int]							,		*UpperCAmelCase__	:		int							,		**UpperCAmelCase__	:		Union[str, Any]							)      -> Tuple:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Union[str, Any]    =      ['''tokenizers''']


 def __init__(  self	:		Dict							,		*UpperCAmelCase__	:		Tuple							,		**UpperCAmelCase__	:		int							)      -> Optional[int]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Dict    =      ['''tokenizers''']


 def __init__(  self	:		Any							,		*UpperCAmelCase__	:		List[str]							,		**UpperCAmelCase__	:		Tuple							)      -> Optional[int]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : List[str]    =      ['''tokenizers''']


 def __init__(  self	:		Optional[Any]							,		*UpperCAmelCase__	:		Union[str, Any]							,		**UpperCAmelCase__	:		Any							)      -> Optional[Any]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Dict    =      ['''tokenizers''']


 def __init__(  self	:		Tuple							,		*UpperCAmelCase__	:		Tuple							,		**UpperCAmelCase__	:		Optional[Any]							)      -> int:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : List[Any]    =      ['''tokenizers''']


 def __init__(  self	:		List[Any]							,		*UpperCAmelCase__	:		Any							,		**UpperCAmelCase__	:		List[str]							)      -> int:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : List[Any]    =      ['''tokenizers''']


 def __init__(  self	:		Optional[int]							,		*UpperCAmelCase__	:		Optional[int]							,		**UpperCAmelCase__	:		Tuple							)      -> Any:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : str    =      ['''tokenizers''']


 def __init__(  self	:		Optional[int]							,		*UpperCAmelCase__	:		str							,		**UpperCAmelCase__	:		List[Any]							)      -> int:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Dict    =      ['''tokenizers''']


 def __init__(  self	:		Optional[Any]							,		*UpperCAmelCase__	:		List[Any]							,		**UpperCAmelCase__	:		int							)      -> Optional[Any]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : str    =      ['''tokenizers''']


 def __init__(  self	:		Tuple							,		*UpperCAmelCase__	:		int							,		**UpperCAmelCase__	:		str							)      -> Tuple:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Tuple    =      ['''tokenizers''']


 def __init__(  self	:		Any							,		*UpperCAmelCase__	:		Optional[int]							,		**UpperCAmelCase__	:		List[str]							)      -> int:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Optional[int]    =      ['''tokenizers''']


 def __init__(  self	:		List[Any]							,		*UpperCAmelCase__	:		List[str]							,		**UpperCAmelCase__	:		str							)      -> Any:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : List[Any]    =      ['''tokenizers''']


 def __init__(  self	:		str							,		*UpperCAmelCase__	:		str							,		**UpperCAmelCase__	:		Optional[Any]							)      -> Optional[Any]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : int    =      ['''tokenizers''']


 def __init__(  self	:		Tuple							,		*UpperCAmelCase__	:		Union[str, Any]							,		**UpperCAmelCase__	:		Optional[int]							)      -> Tuple:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : List[Any]    =      ['''tokenizers''']


 def __init__(  self	:		Union[str, Any]							,		*UpperCAmelCase__	:		Optional[Any]							,		**UpperCAmelCase__	:		List[str]							)      -> Tuple:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Optional[Any]    =      ['''tokenizers''']


 def __init__(  self	:		List[Any]							,		*UpperCAmelCase__	:		List[Any]							,		**UpperCAmelCase__	:		Any							)      -> Optional[Any]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Any    =      ['''tokenizers''']


 def __init__(  self	:		Tuple							,		*UpperCAmelCase__	:		Any							,		**UpperCAmelCase__	:		Any							)      -> Optional[int]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Optional[Any]    =      ['''tokenizers''']


 def __init__(  self	:		Dict							,		*UpperCAmelCase__	:		List[str]							,		**UpperCAmelCase__	:		Tuple							)      -> List[Any]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : List[Any]    =      ['''tokenizers''']


 def __init__(  self	:		Union[str, Any]							,		*UpperCAmelCase__	:		List[Any]							,		**UpperCAmelCase__	:		int							)      -> Optional[int]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : List[str]    =      ['''tokenizers''']


 def __init__(  self	:		Any							,		*UpperCAmelCase__	:		Optional[int]							,		**UpperCAmelCase__	:		List[Any]							)      -> Tuple:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : List[Any]    =      ['''tokenizers''']


 def __init__(  self	:		Tuple							,		*UpperCAmelCase__	:		Any							,		**UpperCAmelCase__	:		List[str]							)      -> List[Any]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Tuple    =      ['''tokenizers''']


 def __init__(  self	:		Tuple							,		*UpperCAmelCase__	:		Optional[int]							,		**UpperCAmelCase__	:		str							)      -> Union[str, Any]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : str    =      ['''tokenizers''']


 def __init__(  self	:		Optional[int]							,		*UpperCAmelCase__	:		Union[str, Any]							,		**UpperCAmelCase__	:		Optional[Any]							)      -> Any:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : int    =      ['''tokenizers''']


 def __init__(  self	:		List[str]							,		*UpperCAmelCase__	:		Optional[int]							,		**UpperCAmelCase__	:		str							)      -> Any:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Optional[int]    =      ['''tokenizers''']


 def __init__(  self	:		int							,		*UpperCAmelCase__	:		Union[str, Any]							,		**UpperCAmelCase__	:		Any							)      -> Any:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Union[str, Any]    =      ['''tokenizers''']


 def __init__(  self	:		Any							,		*UpperCAmelCase__	:		List[str]							,		**UpperCAmelCase__	:		Union[str, Any]							)      -> List[str]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Dict    =      ['''tokenizers''']


 def __init__(  self	:		Dict							,		*UpperCAmelCase__	:		int							,		**UpperCAmelCase__	:		int							)      -> str:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : List[str]    =      ['''tokenizers''']


 def __init__(  self	:		Union[str, Any]							,		*UpperCAmelCase__	:		List[Any]							,		**UpperCAmelCase__	:		Union[str, Any]							)      -> str:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : List[Any]    =      ['''tokenizers''']


 def __init__(  self	:		int							,		*UpperCAmelCase__	:		Tuple							,		**UpperCAmelCase__	:		Optional[int]							)      -> int:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : List[str]    =      ['''tokenizers''']


 def __init__(  self	:		int							,		*UpperCAmelCase__	:		Optional[int]							,		**UpperCAmelCase__	:		Dict							)      -> Dict:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Optional[Any]    =      ['''tokenizers''']


 def __init__(  self	:		str							,		*UpperCAmelCase__	:		Optional[Any]							,		**UpperCAmelCase__	:		Union[str, Any]							)      -> Dict:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Tuple    =      ['''tokenizers''']


 def __init__(  self	:		List[str]							,		*UpperCAmelCase__	:		List[Any]							,		**UpperCAmelCase__	:		Dict							)      -> List[str]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Dict    =      ['''tokenizers''']


 def __init__(  self	:		Union[str, Any]							,		*UpperCAmelCase__	:		Dict							,		**UpperCAmelCase__	:		List[str]							)      -> List[str]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : int    =      ['''tokenizers''']


 def __init__(  self	:		Tuple							,		*UpperCAmelCase__	:		Tuple							,		**UpperCAmelCase__	:		List[Any]							)      -> str:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : List[str]    =      ['''tokenizers''']


 def __init__(  self	:		Dict							,		*UpperCAmelCase__	:		Tuple							,		**UpperCAmelCase__	:		List[Any]							)      -> Optional[int]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Tuple    =      ['''tokenizers''']


 def __init__(  self	:		Union[str, Any]							,		*UpperCAmelCase__	:		List[Any]							,		**UpperCAmelCase__	:		int							)      -> Any:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Union[str, Any]    =      ['''tokenizers''']


 def __init__(  self	:		str							,		*UpperCAmelCase__	:		Union[str, Any]							,		**UpperCAmelCase__	:		Optional[int]							)      -> Union[str, Any]:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : List[str]    =      ['''tokenizers''']


 def __init__(  self	:		str							,		*UpperCAmelCase__	:		Tuple							,		**UpperCAmelCase__	:		Tuple							)      -> int:
   requires_backends(self							,		["""tokenizers"""]							)







class  UpperCamelCase    (			metaclass=snake_case_   ):
 UpperCamelCase      : Dict    =      ['''tokenizers''']


 def __init__(  self	:		Union[str, Any]							,		*UpperCAmelCase__	:		List[str]							,		**UpperCAmelCase__	:		List[str]							)      -> List[Any]:
   requires_backends(self							,		["""tokenizers"""]							)









"""simple docstring"""




# this script builds a small sample spm file tests/fixtures/test_sentencepiece_no_bos.model, with features needed by pegasus

# 1. pip install sentencepiece
#
# 2. wget https://raw.githubusercontent.com/google/sentencepiece/master/data/botchan.txt

# 3. build
import sentencepiece as spm

# pegasus:
# 1. no bos
# 2. eos_id is 1
# 3. unk_id is 2
# build a sample spm file accordingly
spm.SentencePieceTrainer.train(
    '--input=botchan.txt --model_prefix=test_sentencepiece_no_bos --bos_id=-1 --unk_id=2  --eos_id=1  --vocab_size=1000'
)

# 4. now update the fixture
# mv test_sentencepiece_no_bos.model ../../tests/fixtures/

