


'''simple docstring'''


import json
import os
import unittest

from transformers.models.biogpt.tokenization_biogpt import VOCAB_FILES_NAMES, BioGptTokenizer
from transformers.testing_utils import slow

from ...test_tokenization_common import TokenizerTesterMixin






class 						A   (   UpperCAmelCase       ,	unittest.TestCase   ):
							a_        =      BioGptTokenizer
							a_        =      False





							def       snake_case__						(      self				:							Any	)							->	str:
								super().setUp()

								# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
								__UpperCAmelCase							=			[
								    '''l''',
								    '''o''',
								    '''w''',
								    '''e''',
								    '''r''',
								    '''s''',
								    '''t''',
								    '''i''',
								    '''d''',
								    '''n''',
								    '''w</w>''',
								    '''r</w>''',
								    '''t</w>''',
								    '''lo''',
								    '''low''',
								    '''er</w>''',
								    '''low</w>''',
								    '''lowest</w>''',
								    '''newer</w>''',
								    '''wider</w>''',
								    '''<unk>''',
								]
								__UpperCAmelCase							=			dict(zip(__a     ,		range(len(__a	)	)	)	)
								__UpperCAmelCase							=			['''l o 123''', '''lo w 1456''', '''e r</w> 1789''', '''''']

								__UpperCAmelCase							=			os.path.join(self.tmpdirname     ,		VOCAB_FILES_NAMES['''vocab_file''']	)
								__UpperCAmelCase							=			os.path.join(self.tmpdirname     ,		VOCAB_FILES_NAMES['''merges_file''']	)
								with open(self.vocab_file     ,		'''w'''	) as fp:
									fp.write(json.dumps(__a	)	)
								with open(self.merges_file     ,		'''w'''	) as fp:
									fp.write('''\n'''.join(__a	)	)





							def       snake_case__						(      self				:							Dict     ,		__a				:							Any	)							->	List[Any]:
								__UpperCAmelCase							=			'''lower newer'''
								__UpperCAmelCase							=			'''lower newer'''
								return input_text, output_text





							def       snake_case__						(      self				:							Any	)							->	Tuple:
								__UpperCAmelCase							=			BioGptTokenizer(self.vocab_file     ,		self.merges_file	)

								__UpperCAmelCase							=			'''lower'''
								__UpperCAmelCase							=			['''low''', '''er</w>''']
								__UpperCAmelCase							=			tokenizer.tokenize(__a	)
								self.assertListEqual(__a     ,		__a	)

								__UpperCAmelCase							=			tokens + ['''<unk>''']
								__UpperCAmelCase							=			[1_4, 1_5, 2_0]
								self.assertListEqual(tokenizer.convert_tokens_to_ids(__a	)     ,		__a	)






							@slow
							def       snake_case__						(      self				:							List[Any]	)							->	List[str]:
								__UpperCAmelCase							=			BioGptTokenizer.from_pretrained('''microsoft/biogpt'''	)

								__UpperCAmelCase							=			tokenizer.encode('''sequence builders'''     ,		add_special_tokens=__a	)
								__UpperCAmelCase							=			tokenizer.encode('''multi-sequence build'''     ,		add_special_tokens=__a	)

								__UpperCAmelCase							=			tokenizer.build_inputs_with_special_tokens(__a	)
								__UpperCAmelCase							=			tokenizer.build_inputs_with_special_tokens(__a     ,		__a	)

								self.assertTrue(encoded_sentence == [2] + text	)
								self.assertTrue(encoded_pair == [2] + text + [2] + text_a	)

'''simple docstring'''


from ..utils import DummyObject, requires_backends






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[int]     ,		*__a				:							List[str]     ,		**__a				:							Union[str, Any]	)							->	Union[str, Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							List[str]     ,		**__a				:							int	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							int     ,		**__a				:							List[Any]	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							int     ,		*__a				:							Optional[Any]     ,		**__a				:							Tuple	)							->	Dict:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							Tuple     ,		**__a				:							Optional[Any]	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							str     ,		**__a				:							Tuple	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							List[str]     ,		**__a				:							int	)							->	Optional[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							List[str]     ,		**__a				:							Optional[int]	)							->	List[Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							str     ,		**__a				:							Any	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							List[str]     ,		*__a				:							Dict     ,		**__a				:							List[str]	)							->	List[str]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							Any     ,		**__a				:							List[Any]	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							List[str]     ,		**__a				:							Union[str, Any]	)							->	List[str]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							str     ,		*__a				:							Optional[int]     ,		**__a				:							Optional[int]	)							->	Any:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							Dict     ,		**__a				:							List[Any]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							List[str]     ,		**__a				:							List[str]	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Dict     ,		*__a				:							Optional[Any]     ,		**__a				:							int	)							->	Union[str, Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							int     ,		*__a				:							Optional[int]     ,		**__a				:							Dict	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Tuple     ,		**__a				:							Any	)							->	List[str]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[Any]     ,		*__a				:							Optional[Any]     ,		**__a				:							int	)							->	List[str]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Tuple     ,		**__a				:							Optional[int]	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							str     ,		**__a				:							List[Any]	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Dict     ,		*__a				:							List[Any]     ,		**__a				:							int	)							->	List[str]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							int     ,		**__a				:							str	)							->	List[Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							List[Any]     ,		**__a				:							Any	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Tuple     ,		*__a				:							str     ,		**__a				:							Tuple	)							->	Dict:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							List[str]     ,		**__a				:							Optional[Any]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							Optional[int]     ,		**__a				:							Union[str, Any]	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							Union[str, Any]     ,		**__a				:							List[str]	)							->	str:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							Dict     ,		**__a				:							Union[str, Any]	)							->	List[Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							Union[str, Any]     ,		**__a				:							Any	)							->	List[str]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							str     ,		*__a				:							int     ,		**__a				:							int	)							->	List[str]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Optional[int]     ,		**__a				:							int	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							Tuple     ,		**__a				:							str	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)





def       lowerCAmelCase					(		*UpperCamelCase__				:   int    ,					**UpperCamelCase__				:   Optional[int]       ):


	"""simple docstring"""
	requires_backends(UpperCamelCase__    ,					['''torch''']       )





def       lowerCAmelCase					(		*UpperCamelCase__				:   Optional[int]    ,					**UpperCamelCase__				:   List[Any]       ):


	"""simple docstring"""
	requires_backends(UpperCamelCase__    ,					['''torch''']       )





def       lowerCAmelCase					(		*UpperCamelCase__				:   Any    ,					**UpperCamelCase__				:   List[str]       ):


	"""simple docstring"""
	requires_backends(UpperCamelCase__    ,					['''torch''']       )





def       lowerCAmelCase					(		*UpperCamelCase__				:   str    ,					**UpperCamelCase__				:   str       ):


	"""simple docstring"""
	requires_backends(UpperCamelCase__    ,					['''torch''']       )





def       lowerCAmelCase					(		*UpperCamelCase__				:   Dict    ,					**UpperCamelCase__				:   Dict       ):


	"""simple docstring"""
	requires_backends(UpperCamelCase__    ,					['''torch''']       )





def       lowerCAmelCase					(		*UpperCamelCase__				:   Tuple    ,					**UpperCamelCase__				:   int       ):


	"""simple docstring"""
	requires_backends(UpperCamelCase__    ,					['''torch''']       )





def       lowerCAmelCase					(		*UpperCamelCase__				:   Union[str, Any]    ,					**UpperCamelCase__				:   Tuple       ):


	"""simple docstring"""
	requires_backends(UpperCamelCase__    ,					['''torch''']       )






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Union[str, Any]     ,		*__a				:							str     ,		**__a				:							List[Any]	)							->	Any:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							int     ,		**__a				:							int	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							Dict     ,		**__a				:							List[str]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[Any]     ,		*__a				:							str     ,		**__a				:							List[str]	)							->	Optional[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							Dict     ,		**__a				:							Tuple	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							List[Any]     ,		**__a				:							List[str]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[Any]     ,		*__a				:							List[Any]     ,		**__a				:							List[Any]	)							->	int:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							Tuple     ,		**__a				:							int	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							Any     ,		**__a				:							int	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							Optional[Any]     ,		**__a				:							Tuple	)							->	List[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							str     ,		**__a				:							int	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Dict     ,		**__a				:							Any	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							str     ,		**__a				:							str	)							->	List[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Union[str, Any]     ,		**__a				:							str	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							int     ,		**__a				:							Tuple	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[int]     ,		*__a				:							Tuple     ,		**__a				:							str	)							->	Union[str, Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							Any     ,		**__a				:							Dict	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							str     ,		**__a				:							List[str]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							int     ,		**__a				:							int	)							->	Union[str, Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							int     ,		*__a				:							str     ,		**__a				:							List[Any]	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							int     ,		**__a				:							List[str]	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							int     ,		*__a				:							Union[str, Any]     ,		**__a				:							Optional[Any]	)							->	Any:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							List[Any]     ,		**__a				:							str	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							int     ,		*__a				:							Optional[Any]     ,		**__a				:							Any	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							List[str]     ,		*__a				:							List[str]     ,		**__a				:							Dict	)							->	Optional[int]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							Union[str, Any]     ,		**__a				:							Optional[int]	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							int     ,		**__a				:							Dict	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							List[str]     ,		*__a				:							List[str]     ,		**__a				:							Union[str, Any]	)							->	str:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							int     ,		**__a				:							Dict	)							->	List[Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							Tuple     ,		**__a				:							List[str]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							str     ,		**__a				:							Any	)							->	int:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							Dict     ,		**__a				:							Optional[Any]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							str     ,		**__a				:							Union[str, Any]	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							Optional[Any]     ,		**__a				:							List[str]	)							->	str:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							Union[str, Any]     ,		**__a				:							Any	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							Union[str, Any]     ,		**__a				:							List[Any]	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Tuple     ,		*__a				:							Optional[int]     ,		**__a				:							List[Any]	)							->	Any:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							List[str]     ,		**__a				:							Dict	)							->	List[str]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							Optional[Any]     ,		**__a				:							List[Any]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[int]     ,		*__a				:							Any     ,		**__a				:							str	)							->	List[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							Optional[Any]     ,		**__a				:							int	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							int     ,		**__a				:							Optional[Any]	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							str     ,		*__a				:							List[str]     ,		**__a				:							Dict	)							->	List[str]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							Any     ,		**__a				:							Union[str, Any]	)							->	Optional[int]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							Dict     ,		**__a				:							Union[str, Any]	)							->	List[str]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							Tuple     ,		**__a				:							Optional[int]	)							->	str:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							List[Any]     ,		**__a				:							List[str]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Union[str, Any]     ,		**__a				:							Union[str, Any]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Dict     ,		*__a				:							List[Any]     ,		**__a				:							int	)							->	int:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Optional[Any]     ,		**__a				:							str	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							Tuple     ,		**__a				:							int	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[Any]     ,		*__a				:							Optional[int]     ,		**__a				:							Tuple	)							->	Optional[int]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							int     ,		*__a				:							Union[str, Any]     ,		**__a				:							List[Any]	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							int     ,		*__a				:							List[Any]     ,		**__a				:							List[str]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							List[Any]     ,		*__a				:							Optional[int]     ,		**__a				:							int	)							->	Dict:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Union[str, Any]     ,		**__a				:							List[Any]	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							int     ,		**__a				:							Any	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							str     ,		*__a				:							Any     ,		**__a				:							int	)							->	Tuple:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							List[Any]     ,		**__a				:							Union[str, Any]	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							List[Any]     ,		**__a				:							Dict	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							List[Any]     ,		*__a				:							int     ,		**__a				:							Optional[int]	)							->	List[str]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							List[Any]     ,		**__a				:							Any	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							Tuple     ,		**__a				:							List[Any]	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Dict     ,		*__a				:							Dict     ,		**__a				:							Optional[int]	)							->	Dict:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							Any     ,		**__a				:							Dict	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							Any     ,		**__a				:							Any	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Union[str, Any]     ,		*__a				:							Tuple     ,		**__a				:							Optional[int]	)							->	Optional[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							Optional[Any]     ,		**__a				:							Optional[Any]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							List[Any]     ,		**__a				:							Dict	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Dict     ,		*__a				:							Union[str, Any]     ,		**__a				:							Optional[int]	)							->	Dict:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							Any     ,		**__a				:							Optional[int]	)							->	Optional[int]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							Union[str, Any]     ,		**__a				:							List[str]	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[Any]     ,		*__a				:							Optional[int]     ,		**__a				:							List[Any]	)							->	str:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Any     ,		*__a				:							Dict     ,		**__a				:							int	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Optional[int]     ,		**__a				:							Union[str, Any]	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[int]     ,		*__a				:							Union[str, Any]     ,		**__a				:							int	)							->	Optional[int]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							Optional[Any]     ,		**__a				:							int	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							List[Any]     ,		**__a				:							Optional[int]	)							->	Optional[int]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[int]     ,		*__a				:							Optional[Any]     ,		**__a				:							Optional[int]	)							->	Tuple:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[int]     ,		*__a				:							Optional[int]     ,		**__a				:							List[Any]	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							int     ,		*__a				:							List[str]     ,		**__a				:							Union[str, Any]	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							str     ,		*__a				:							Tuple     ,		**__a				:							Tuple	)							->	str:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							List[str]     ,		**__a				:							Tuple	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							Dict     ,		**__a				:							Tuple	)							->	Tuple:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[Any]     ,		*__a				:							Union[str, Any]     ,		**__a				:							Optional[int]	)							->	List[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							List[str]     ,		**__a				:							int	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							int     ,		*__a				:							Tuple     ,		**__a				:							Optional[Any]	)							->	Optional[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[int]     ,		*__a				:							Union[str, Any]     ,		**__a				:							Union[str, Any]	)							->	Optional[int]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							Any     ,		**__a				:							List[str]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							int     ,		**__a				:							int	)							->	List[Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Dict     ,		*__a				:							Any     ,		**__a				:							List[Any]	)							->	Union[str, Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							int     ,		**__a				:							str	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							Dict     ,		**__a				:							Optional[Any]	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Union[str, Any]     ,		*__a				:							List[str]     ,		**__a				:							int	)							->	Union[str, Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							List[Any]     ,		**__a				:							Any	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							str     ,		**__a				:							Optional[Any]	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Optional[int]     ,		*__a				:							List[Any]     ,		**__a				:							List[str]	)							->	Optional[int]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							Optional[Any]     ,		**__a				:							str	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							List[Any]     ,		**__a				:							Union[str, Any]	)							->	Optional[int]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Union[str, Any]     ,		*__a				:							List[Any]     ,		**__a				:							Optional[Any]	)							->	int:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Union[str, Any]     ,		*__a				:							List[Any]     ,		**__a				:							Any	)							->	int:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Optional[Any]     ,		*__a				:							List[str]     ,		**__a				:							Any	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Any     ,		*__a				:							List[str]     ,		**__a				:							Dict	)							->	List[str]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							Dict     ,		**__a				:							Optional[Any]	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							str     ,		**__a				:							Any	)							->	Dict:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							List[str]     ,		*__a				:							Union[str, Any]     ,		**__a				:							Optional[int]	)							->	List[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							Dict     ,		**__a				:							Tuple	)							->	Optional[int]:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							str     ,		*__a				:							Any     ,		**__a				:							Any	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							int     ,		*__a				:							Any     ,		**__a				:							Optional[Any]	)							->	int:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							Dict     ,		*__a				:							int     ,		**__a				:							List[Any]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[str]     ,		*__a				:							Dict     ,		**__a				:							Tuple	)							->	Union[str, Any]:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Tuple     ,		*__a				:							int     ,		**__a				:							Optional[Any]	)							->	List[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							Union[str, Any]     ,		**__a				:							Union[str, Any]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							Tuple     ,		*__a				:							Any     ,		**__a				:							Optional[int]	)							->	str:
								requires_backends(cls     ,		['''torch''']	)






class 						A   (   metaclass=UpperCAmelCase   ):
							a_        =      ['''torch''']





							def __init__(      self				:							Dict     ,		*__a				:							List[str]     ,		**__a				:							List[Any]	)							->	Optional[Any]:
								requires_backends(self     ,		['''torch''']	)





							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							int     ,		**__a				:							Any	)							->	Any:
								requires_backends(cls     ,		['''torch''']	)






							@classmethod
							def       snake_case__						(      cls				:							List[Any]     ,		*__a				:							List[str]     ,		**__a				:							List[str]	)							->	List[Any]:
								requires_backends(cls     ,		['''torch''']	)
