'''simple docstring'''


import unittest

from transformers import SqueezeBertConfig, is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch

					from transformers import (
					    SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
					    SqueezeBertForMaskedLM,
					    SqueezeBertForMultipleChoice,
					    SqueezeBertForQuestionAnswering,
					    SqueezeBertForSequenceClassification,
					    SqueezeBertForTokenClassification,
					    SqueezeBertModel,
					)






class 						A   (   UpperCAmelCase   ):





							def __init__(      self				:							Dict     ,		__a				:							str     ,		__a				:							Dict=1_3     ,		__a				:							Any=7     ,		__a				:							Tuple=True     ,		__a				:							List[str]=True     ,		__a				:							int=False     ,		__a				:							Optional[Any]=True     ,		__a				:							str=9_9     ,		__a				:							Optional[int]=3_2     ,		__a				:							int=5     ,		__a				:							str=4     ,		__a				:							int=6_4     ,		__a				:							Dict="gelu"     ,		__a				:							Dict=0.1     ,		__a				:							List[Any]=0.1     ,		__a				:							List[str]=5_1_2     ,		__a				:							int=1_6     ,		__a				:							Tuple=2     ,		__a				:							Optional[Any]=0.0_2     ,		__a				:							Tuple=3     ,		__a				:							List[Any]=4     ,		__a				:							Dict=None     ,		__a				:							Union[str, Any]=2     ,		__a				:							Dict=2     ,		__a				:							Dict=2     ,		__a				:							Optional[Any]=2     ,		__a				:							Dict=4     ,		__a				:							Optional[Any]=1     ,		)							->	str:
								__UpperCAmelCase							=			parent
								__UpperCAmelCase							=			batch_size
								__UpperCAmelCase							=			seq_length
								__UpperCAmelCase							=			is_training
								__UpperCAmelCase							=			use_input_mask
								__UpperCAmelCase							=			use_token_type_ids
								__UpperCAmelCase							=			use_labels
								__UpperCAmelCase							=			vocab_size
								__UpperCAmelCase							=			hidden_size
								__UpperCAmelCase							=			num_hidden_layers
								__UpperCAmelCase							=			num_attention_heads
								__UpperCAmelCase							=			intermediate_size
								__UpperCAmelCase							=			hidden_act
								__UpperCAmelCase							=			hidden_dropout_prob
								__UpperCAmelCase							=			attention_probs_dropout_prob
								__UpperCAmelCase							=			max_position_embeddings
								__UpperCAmelCase							=			type_vocab_size
								__UpperCAmelCase							=			type_sequence_label_size
								__UpperCAmelCase							=			initializer_range
								__UpperCAmelCase							=			num_labels
								__UpperCAmelCase							=			num_choices
								__UpperCAmelCase							=			scope
								__UpperCAmelCase							=			q_groups
								__UpperCAmelCase							=			k_groups
								__UpperCAmelCase							=			v_groups
								__UpperCAmelCase							=			post_attention_groups
								__UpperCAmelCase							=			intermediate_groups
								__UpperCAmelCase							=			output_groups





							def       snake_case__						(      self				:							Tuple	)							->	Optional[Any]:
								__UpperCAmelCase							=			ids_tensor([self.batch_size, self.seq_length]     ,		self.vocab_size	)

								__UpperCAmelCase							=			None
								if self.use_input_mask:
									__UpperCAmelCase							=			random_attention_mask([self.batch_size, self.seq_length]	)

								__UpperCAmelCase							=			None
								__UpperCAmelCase							=			None
								__UpperCAmelCase							=			None
								if self.use_labels:
									__UpperCAmelCase							=			ids_tensor([self.batch_size]     ,		self.type_sequence_label_size	)
									__UpperCAmelCase							=			ids_tensor([self.batch_size, self.seq_length]     ,		self.num_labels	)
									__UpperCAmelCase							=			ids_tensor([self.batch_size]     ,		self.num_choices	)

								__UpperCAmelCase							=			self.get_config()

								return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels





							def       snake_case__						(      self				:							Optional[Any]	)							->	int:
								return SqueezeBertConfig(
								    embedding_size=self.hidden_size     ,		vocab_size=self.vocab_size     ,		hidden_size=self.hidden_size     ,		num_hidden_layers=self.num_hidden_layers     ,		num_attention_heads=self.num_attention_heads     ,		intermediate_size=self.intermediate_size     ,		hidden_act=self.hidden_act     ,		attention_probs_dropout_prob=self.hidden_dropout_prob     ,		attention_dropout=self.attention_probs_dropout_prob     ,		max_position_embeddings=self.max_position_embeddings     ,		initializer_range=self.initializer_range     ,		q_groups=self.q_groups     ,		k_groups=self.k_groups     ,		v_groups=self.v_groups     ,		post_attention_groups=self.post_attention_groups     ,		intermediate_groups=self.intermediate_groups     ,		output_groups=self.output_groups     ,		)





							def       snake_case__						(      self				:							Dict     ,		__a				:							List[str]     ,		__a				:							Optional[Any]     ,		__a				:							Any     ,		__a				:							Union[str, Any]     ,		__a				:							Any     ,		__a				:							Optional[int]	)							->	Optional[Any]:
								__UpperCAmelCase							=			SqueezeBertModel(config=__a	)
								model.to(__a	)
								model.eval()
								__UpperCAmelCase							=			model(__a     ,		__a	)
								__UpperCAmelCase							=			model(__a	)
								self.parent.assertEqual(result.last_hidden_state.shape     ,		(self.batch_size, self.seq_length, self.hidden_size)	)





							def       snake_case__						(      self				:							List[Any]     ,		__a				:							Any     ,		__a				:							List[str]     ,		__a				:							List[Any]     ,		__a				:							Union[str, Any]     ,		__a				:							int     ,		__a				:							Union[str, Any]	)							->	str:
								__UpperCAmelCase							=			SqueezeBertForMaskedLM(config=__a	)
								model.to(__a	)
								model.eval()
								__UpperCAmelCase							=			model(__a     ,		attention_mask=__a     ,		labels=__a	)
								self.parent.assertEqual(result.logits.shape     ,		(self.batch_size, self.seq_length, self.vocab_size)	)





							def       snake_case__						(      self				:							str     ,		__a				:							List[str]     ,		__a				:							Optional[Any]     ,		__a				:							str     ,		__a				:							str     ,		__a				:							Optional[Any]     ,		__a				:							Union[str, Any]	)							->	Union[str, Any]:
								__UpperCAmelCase							=			SqueezeBertForQuestionAnswering(config=__a	)
								model.to(__a	)
								model.eval()
								__UpperCAmelCase							=			model(
								    __a     ,		attention_mask=__a     ,		start_positions=__a     ,		end_positions=__a	)
								self.parent.assertEqual(result.start_logits.shape     ,		(self.batch_size, self.seq_length)	)
								self.parent.assertEqual(result.end_logits.shape     ,		(self.batch_size, self.seq_length)	)





							def       snake_case__						(      self				:							int     ,		__a				:							List[Any]     ,		__a				:							Union[str, Any]     ,		__a				:							str     ,		__a				:							Union[str, Any]     ,		__a				:							Any     ,		__a				:							Any	)							->	List[Any]:
								__UpperCAmelCase							=			self.num_labels
								__UpperCAmelCase							=			SqueezeBertForSequenceClassification(__a	)
								model.to(__a	)
								model.eval()
								__UpperCAmelCase							=			model(__a     ,		attention_mask=__a     ,		labels=__a	)
								self.parent.assertEqual(result.logits.shape     ,		(self.batch_size, self.num_labels)	)





							def       snake_case__						(      self				:							Optional[Any]     ,		__a				:							Tuple     ,		__a				:							int     ,		__a				:							Any     ,		__a				:							Union[str, Any]     ,		__a				:							Union[str, Any]     ,		__a				:							Tuple	)							->	Union[str, Any]:
								__UpperCAmelCase							=			self.num_labels
								__UpperCAmelCase							=			SqueezeBertForTokenClassification(config=__a	)
								model.to(__a	)
								model.eval()

								__UpperCAmelCase							=			model(__a     ,		attention_mask=__a     ,		labels=__a	)
								self.parent.assertEqual(result.logits.shape     ,		(self.batch_size, self.seq_length, self.num_labels)	)





							def       snake_case__						(      self				:							Any     ,		__a				:							Union[str, Any]     ,		__a				:							List[Any]     ,		__a				:							Any     ,		__a				:							Any     ,		__a				:							Any     ,		__a				:							int	)							->	Tuple:
								__UpperCAmelCase							=			self.num_choices
								__UpperCAmelCase							=			SqueezeBertForMultipleChoice(config=__a	)
								model.to(__a	)
								model.eval()
								__UpperCAmelCase							=			input_ids.unsqueeze(1	).expand(-1     ,		self.num_choices     ,		-1	).contiguous()
								__UpperCAmelCase							=			input_mask.unsqueeze(1	).expand(-1     ,		self.num_choices     ,		-1	).contiguous()
								__UpperCAmelCase							=			model(
								    __a     ,		attention_mask=__a     ,		labels=__a     ,		)
								self.parent.assertEqual(result.logits.shape     ,		(self.batch_size, self.num_choices)	)






							def       snake_case__						(      self				:							Dict	)							->	List[str]:
								__UpperCAmelCase							=			self.prepare_config_and_inputs()
								((__UpperCAmelCase)				,			(__UpperCAmelCase)				,			(__UpperCAmelCase)				,			(__UpperCAmelCase)				,			(__UpperCAmelCase)				,			(__UpperCAmelCase))							=			config_and_inputs
								__UpperCAmelCase							=			{'''input_ids''': input_ids, '''attention_mask''': input_mask}
								return config, inputs_dict






@require_torch
class 						A   (   UpperCAmelCase       ,	UpperCAmelCase       ,	unittest.TestCase   ):
							a_        =      (
							    (
							        SqueezeBertModel,
							        SqueezeBertForMaskedLM,
							        SqueezeBertForMultipleChoice,
							        SqueezeBertForQuestionAnswering,
							        SqueezeBertForSequenceClassification,
							        SqueezeBertForTokenClassification,
							    )
							    if is_torch_available()
							    else None
							)
							a_        =      (
							    {
							        '''feature-extraction''': SqueezeBertModel,
							        '''fill-mask''': SqueezeBertForMaskedLM,
							        '''question-answering''': SqueezeBertForQuestionAnswering,
							        '''text-classification''': SqueezeBertForSequenceClassification,
							        '''token-classification''': SqueezeBertForTokenClassification,
							        '''zero-shot''': SqueezeBertForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)
							a_        =      False
							a_        =      True
							a_        =      False





							def       snake_case__						(      self				:							Union[str, Any]	)							->	Dict:
								__UpperCAmelCase							=			SqueezeBertModelTester(self	)
								__UpperCAmelCase							=			ConfigTester(self     ,		config_class=__a     ,		dim=3_7	)





							def       snake_case__						(      self				:							Union[str, Any]	)							->	List[str]:
								self.config_tester.run_common_tests()





							def       snake_case__						(      self				:							Any	)							->	Dict:
								__UpperCAmelCase							=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_squeezebert_model(*__a	)





							def       snake_case__						(      self				:							Union[str, Any]	)							->	int:
								__UpperCAmelCase							=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_squeezebert_for_masked_lm(*__a	)





							def       snake_case__						(      self				:							Optional[int]	)							->	Optional[int]:
								__UpperCAmelCase							=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_squeezebert_for_question_answering(*__a	)





							def       snake_case__						(      self				:							int	)							->	List[str]:
								__UpperCAmelCase							=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_squeezebert_for_sequence_classification(*__a	)





							def       snake_case__						(      self				:							Dict	)							->	Union[str, Any]:
								__UpperCAmelCase							=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_squeezebert_for_token_classification(*__a	)





							def       snake_case__						(      self				:							Optional[Any]	)							->	Optional[int]:
								__UpperCAmelCase							=			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_squeezebert_for_multiple_choice(*__a	)






							@slow
							def       snake_case__						(      self				:							Dict	)							->	Union[str, Any]:
								for model_name in SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__UpperCAmelCase							=			SqueezeBertModel.from_pretrained(__a	)
									self.assertIsNotNone(__a	)






@require_sentencepiece
@require_tokenizers
@require_torch
class 						A   (   unittest.TestCase   ):





							@slow
							def       snake_case__						(      self				:							Optional[Any]	)							->	Optional[Any]:
								__UpperCAmelCase							=			SqueezeBertForSequenceClassification.from_pretrained('''squeezebert/squeezebert-mnli'''	)

								__UpperCAmelCase							=			torch.tensor([[1, 2_9_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9, 1_3, 1_5_8_8, 2]]	)
								__UpperCAmelCase							=			model(__a	)[0]
								__UpperCAmelCase							=			torch.Size((1, 3)	)
								self.assertEqual(output.shape     ,		__a	)
								__UpperCAmelCase							=			torch.tensor([[0.6_4_0_1, -0.0_3_4_9, -0.6_0_4_1]]	)
								self.assertTrue(torch.allclose(__a     ,		__a     ,		atol=1e-4	)	)

'''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''']	)
