
'''simple docstring'''





import numpy as np

def   A			(							A_				:       Tuple     ,				A_				:       Dict     ,				A_				:       List[Any]							):
						snake_case							:  Any			=     n_draws * class_counts / class_counts.sum()
						# floored means we don't overshoot n_samples, but probably undershoot
						snake_case							:  int			=     np.floor(A_							)
						# we add samples according to how much "left over" probability
						# they had, until we arrive at n_samples
						snake_case							:  Tuple			=     int(n_draws - floored.sum()							)
						if need_to_add > 0:
												snake_case							:  int			=     continuous - floored
												snake_case							:  str			=     np.sort(np.unique(A_							)							)[::-1]
												# add according to remainder, but break ties
												# randomly to avoid biases
												for value in values:
																		((snake_case),       )							:  str			=     np.where(remainder == value							)
																		# if we need_to_add less than what's in inds
																		# we draw randomly from them.
																		# if we need to add more, we add them all and
																		# go to the next value
																		snake_case							:  Dict			=     min(len(A_							)     ,				A_							)
																		snake_case							:  Optional[Any]			=     rng.choice(A_     ,				size=A_     ,				replace=A_							)
																		floored[inds] += 1
																		need_to_add -= add_now
																		if need_to_add == 0:
																								break
						return floored.astype(np.intaa							)





def   A			(							A_				:       Union[str, Any]     ,				A_				:       str     ,				A_				:       Optional[Any]     ,				A_				:       List[Any]     ,				A_				:       Union[str, Any]=10							):
						snake_case,       snake_case							:  Tuple			=     np.unique(A_     ,				return_inverse=A_							)
						snake_case							:  str			=     classes.shape[0]
						snake_case							:  Optional[Any]			=     np.bincount(A_							)
						if np.min(A_							) < 2:
												raise ValueError('''Minimum class count error'''							)
						if n_train < n_classes:
												raise ValueError(
												    '''The train_size = %d should be greater or ''' '''equal to the number of classes = %d''' % (n_train, n_classes)							)
						if n_test < n_classes:
												raise ValueError(
												    '''The test_size = %d should be greater or ''' '''equal to the number of classes = %d''' % (n_test, n_classes)							)
						snake_case							:  List[Any]			=     np.split(np.argsort(A_     ,				kind='''mergesort'''							)     ,				np.cumsum(A_							)[:-1]							)
						for _ in range(A_							):
												snake_case							:  int			=     approximate_mode(A_     ,				A_     ,				A_							)
												snake_case							:  List[str]			=     class_counts - n_i
												snake_case							:  Dict			=     approximate_mode(A_     ,				A_     ,				A_							)

												snake_case							:  List[Any]			=     []
												snake_case							:  Union[str, Any]			=     []

												for i in range(A_							):
																		snake_case							:  Optional[int]			=     rng.permutation(class_counts[i]							)
																		snake_case							:  List[str]			=     class_indices[i].take(A_     ,				mode='''clip'''							)
																		train.extend(perm_indices_class_i[: n_i[i]]							)
																		test.extend(perm_indices_class_i[n_i[i] : n_i[i] + t_i[i]]							)
												snake_case							:  Any			=     rng.permutation(A_							)
												snake_case							:  str			=     rng.permutation(A_							)

												yield train, test



from ..utils import DummyObject, requires_backends
class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Dict            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Union[str, Any]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		str            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[Any]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[str]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Any            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Dict            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[Any]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		str            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Dict            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[Any]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Dict            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[str]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		int            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		int            =				["tokenizers"]





							def __init__(					self    :  Tuple	,					*_UpperCAmelCase    :  Tuple	,					**_UpperCAmelCase    :  Tuple							)		->						Tuple:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[str]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[str]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		str            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Dict            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Union[str, Any]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Union[str, Any]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		int            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Any            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[Any]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Any            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Union[str, Any]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[Any]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Any            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[str]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[Any]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Union[str, Any]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[Any]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		int            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Any            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Tuple            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		int            =				["tokenizers"]





							def __init__(					self    :  int	,					*_UpperCAmelCase    :  Any	,					**_UpperCAmelCase    :  Any							)		->						str:



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		List[Any]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[int]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Optional[Any]            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Any            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Any            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)






class       A__  (		metaclass=lowerCAmelCase__							):
							lowerCAmelCase__						:		Dict            =				["tokenizers"]





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



											"""simple docstring"""


											requires_backends(self	,					['tokenizers']							)





