


'''simple docstring'''


import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import BlenderbotSmallConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor


if is_flax_available():
				import os

				# The slow tests are often failing with OOM error on GPU
				# This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed
				# but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html
				UpperCAmelCase_						:  Tuple				  =						'platform'

				import jax
				import jax.numpy as jnp

				from transformers.models.blenderbot_small.modeling_flax_blenderbot_small import (
				    FlaxBlenderbotSmallForConditionalGeneration,
				    FlaxBlenderbotSmallModel,
				    shift_tokens_right,
				)







def      snake_case_  (    SCREAMING_SNAKE_CASE__				, SCREAMING_SNAKE_CASE__				, SCREAMING_SNAKE_CASE__=None				, SCREAMING_SNAKE_CASE__=None				, SCREAMING_SNAKE_CASE__=None				, SCREAMING_SNAKE_CASE__=None				, SCREAMING_SNAKE_CASE__=None				, SCREAMING_SNAKE_CASE__=None				, ):







				"""simple docstring"""





				if attention_mask is None:
								_SCREAMING_SNAKE_CASE					:			Any							= np.where(input_ids != config.pad_token_id				, 1				, 0	)
				if decoder_attention_mask is None:
								_SCREAMING_SNAKE_CASE					:			List[Any]							= np.where(decoder_input_ids != config.pad_token_id				, 1				, 0	)
				if head_mask is None:
								_SCREAMING_SNAKE_CASE					:			List[str]							= np.ones((config.encoder_layers, config.encoder_attention_heads)	)
				if decoder_head_mask is None:
								_SCREAMING_SNAKE_CASE					:			Dict							= np.ones((config.decoder_layers, config.decoder_attention_heads)	)
				if cross_attn_head_mask is None:
								_SCREAMING_SNAKE_CASE					:			Optional[Any]							= np.ones((config.decoder_layers, config.decoder_attention_heads)	)
				return {
				    "input_ids": input_ids,
				    "decoder_input_ids": decoder_input_ids,
				    "attention_mask": attention_mask,
				    "decoder_attention_mask": attention_mask,
				}





class        lowercase__    :





							'''simple docstring'''


							def __init__(       self       ,   __snake_case       ,   __snake_case=13       ,   __snake_case=7       ,   __snake_case=True       ,   __snake_case=False       ,   __snake_case=99       ,   __snake_case=16       ,   __snake_case=2       ,   __snake_case=4       ,   __snake_case=4       ,   __snake_case="gelu"       ,   __snake_case=0.1       ,   __snake_case=0.1       ,   __snake_case=32       ,   __snake_case=2       ,   __snake_case=1       ,   __snake_case=0       ,   __snake_case=0.02       ,   ):
											_SCREAMING_SNAKE_CASE					:			str							= parent
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= batch_size
											_SCREAMING_SNAKE_CASE					:			Tuple							= seq_length
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= is_training
											_SCREAMING_SNAKE_CASE					:			Tuple							= use_labels
											_SCREAMING_SNAKE_CASE					:			Tuple							= vocab_size
											_SCREAMING_SNAKE_CASE					:			List[Any]							= hidden_size
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= num_hidden_layers
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= num_attention_heads
											_SCREAMING_SNAKE_CASE					:			List[str]							= intermediate_size
											_SCREAMING_SNAKE_CASE					:			List[str]							= hidden_act
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= hidden_dropout_prob
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= attention_probs_dropout_prob
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= max_position_embeddings
											_SCREAMING_SNAKE_CASE					:			int							= eos_token_id
											_SCREAMING_SNAKE_CASE					:			List[str]							= pad_token_id
											_SCREAMING_SNAKE_CASE					:			str							= bos_token_id
											_SCREAMING_SNAKE_CASE					:			int							= initializer_range






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= np.clip(ids_tensor([self.batch_size, self.seq_length - 1]       ,   self.vocab_size    )       ,   3       ,   self.vocab_size    )
											_SCREAMING_SNAKE_CASE					:			List[str]							= np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)       ,   dtype=np.intaa    ))       ,   -1    )

											_SCREAMING_SNAKE_CASE					:			int							= shift_tokens_right(_lowerCAmelCase       ,   1       ,   2    )

											_SCREAMING_SNAKE_CASE					:			List[Any]							= BlenderbotSmallConfig(
											    vocab_size=self.vocab_size       ,   d_model=self.hidden_size       ,   encoder_layers=self.num_hidden_layers       ,   decoder_layers=self.num_hidden_layers       ,   encoder_attention_heads=self.num_attention_heads       ,   decoder_attention_heads=self.num_attention_heads       ,   encoder_ffn_dim=self.intermediate_size       ,   decoder_ffn_dim=self.intermediate_size       ,   dropout=self.hidden_dropout_prob       ,   attention_dropout=self.attention_probs_dropout_prob       ,   max_position_embeddings=self.max_position_embeddings       ,   eos_token_id=self.eos_token_id       ,   bos_token_id=self.bos_token_id       ,   pad_token_id=self.pad_token_id       ,   initializer_range=self.initializer_range       ,   use_cache=_lowerCAmelCase       ,   )
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= prepare_blenderbot_inputs_dict(_lowerCAmelCase       ,   _lowerCAmelCase       ,   _lowerCAmelCase    )
											return config, inputs_dict






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			str							= self.prepare_config_and_inputs()
											return config, inputs_dict






							def UpperCAmelCase_      (       self       ,   __snake_case       ,   __snake_case       ,   __snake_case    ):
											_SCREAMING_SNAKE_CASE					:			int							= 20
											_SCREAMING_SNAKE_CASE					:			List[Any]							= model_class_name(_lowerCAmelCase    )

											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= model.encode(inputs_dict["""input_ids"""]    )

											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			Any							= (
											    inputs_dict["""decoder_input_ids"""],
											    inputs_dict["""decoder_attention_mask"""],
											)

											_SCREAMING_SNAKE_CASE					:			Tuple							= model.init_cache(decoder_input_ids.shape[0]       ,   _lowerCAmelCase       ,   _lowerCAmelCase    )
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= jnp.ones((decoder_input_ids.shape[0], max_decoder_length)       ,   dtype="""i4"""    )

											_SCREAMING_SNAKE_CASE					:			Tuple							= jnp.broadcast_to(
											    jnp.arange(decoder_input_ids.shape[-1] - 1    )[None, :]       ,   (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)       ,   )
											_SCREAMING_SNAKE_CASE					:			Any							= model.decode(
											    decoder_input_ids[:, :-1]       ,   _lowerCAmelCase       ,   decoder_attention_mask=_lowerCAmelCase       ,   past_key_values=_lowerCAmelCase       ,   decoder_position_ids=_lowerCAmelCase       ,   )

											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]       ,   dtype="""i4"""    )
											_SCREAMING_SNAKE_CASE					:			Tuple							= model.decode(
											    decoder_input_ids[:, -1:]       ,   _lowerCAmelCase       ,   decoder_attention_mask=_lowerCAmelCase       ,   past_key_values=outputs_cache.past_key_values       ,   decoder_position_ids=_lowerCAmelCase       ,   )

											_SCREAMING_SNAKE_CASE					:			List[Any]							= model.decode(_lowerCAmelCase       ,   _lowerCAmelCase    )

											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])    )    )
											self.parent.assertTrue(diff < 1e-3       ,   msg=f"""Max diff is {diff}"""    )






							def UpperCAmelCase_      (       self       ,   __snake_case       ,   __snake_case       ,   __snake_case    ):
											_SCREAMING_SNAKE_CASE					:			List[Any]							= 20
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= model_class_name(_lowerCAmelCase    )

											_SCREAMING_SNAKE_CASE					:			Optional[int]							= model.encode(inputs_dict["""input_ids"""]    )

											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			Dict							= (
											    inputs_dict["""decoder_input_ids"""],
											    inputs_dict["""decoder_attention_mask"""],
											)

											_SCREAMING_SNAKE_CASE					:			Dict							= jnp.concatenate(
											    [
											        decoder_attention_mask,
											        jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1])    ),
											    ]       ,   axis=-1       ,   )

											_SCREAMING_SNAKE_CASE					:			Tuple							= model.init_cache(decoder_input_ids.shape[0]       ,   _lowerCAmelCase       ,   _lowerCAmelCase    )
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= jnp.broadcast_to(
											    jnp.arange(decoder_input_ids.shape[-1] - 1    )[None, :]       ,   (decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)       ,   )

											_SCREAMING_SNAKE_CASE					:			str							= model.decode(
											    decoder_input_ids[:, :-1]       ,   _lowerCAmelCase       ,   decoder_attention_mask=_lowerCAmelCase       ,   past_key_values=_lowerCAmelCase       ,   decoder_position_ids=_lowerCAmelCase       ,   )
											_SCREAMING_SNAKE_CASE					:			List[str]							= jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]       ,   dtype="""i4"""    )
											_SCREAMING_SNAKE_CASE					:			List[str]							= model.decode(
											    decoder_input_ids[:, -1:]       ,   _lowerCAmelCase       ,   past_key_values=outputs_cache.past_key_values       ,   decoder_attention_mask=_lowerCAmelCase       ,   decoder_position_ids=_lowerCAmelCase       ,   )

											_SCREAMING_SNAKE_CASE					:			Any							= model.decode(_lowerCAmelCase       ,   _lowerCAmelCase       ,   decoder_attention_mask=_lowerCAmelCase    )

											_SCREAMING_SNAKE_CASE					:			Dict							= np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])    )    )
											self.parent.assertTrue(diff < 1e-3       ,   msg=f"""Max diff is {diff}"""    )





@require_flax
class        lowercase__    (		unittest.TestCase   ):





							'''simple docstring'''


							A_				: str       =    99






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= np.array(
											    [
											        [71, 82, 18, 33, 46, 91, 2],
											        [68, 34, 26, 58, 30, 82, 2],
											        [5, 97, 17, 39, 94, 40, 2],
											        [76, 83, 94, 25, 70, 78, 2],
											        [87, 59, 41, 35, 48, 66, 2],
											        [55, 13, 16, 58, 5, 2, 1],  # note padding
											        [64, 27, 31, 51, 12, 75, 2],
											        [52, 64, 86, 17, 83, 39, 2],
											        [48, 61, 9, 24, 71, 82, 2],
											        [26, 1, 60, 48, 22, 13, 2],
											        [21, 5, 62, 28, 14, 76, 2],
											        [45, 98, 37, 86, 59, 48, 2],
											        [70, 70, 50, 9, 28, 0, 2],
											    ]       ,   dtype=np.intaa       ,   )

											_SCREAMING_SNAKE_CASE					:			Optional[int]							= input_ids.shape[0]
											_SCREAMING_SNAKE_CASE					:			Dict							= BlenderbotSmallConfig(
											    vocab_size=self.vocab_size       ,   d_model=24       ,   encoder_layers=2       ,   decoder_layers=2       ,   encoder_attention_heads=2       ,   decoder_attention_heads=2       ,   encoder_ffn_dim=32       ,   decoder_ffn_dim=32       ,   max_position_embeddings=48       ,   eos_token_id=2       ,   pad_token_id=1       ,   bos_token_id=0       ,   )
											return config, input_ids, batch_size






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			Dict							= self._get_config_and_data()
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= FlaxBlenderbotSmallForConditionalGeneration(_lowerCAmelCase    )
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= lm_model(input_ids=_lowerCAmelCase    )
											_SCREAMING_SNAKE_CASE					:			Tuple							= (batch_size, input_ids.shape[1], config.vocab_size)
											self.assertEqual(outputs["""logits"""].shape       ,   _lowerCAmelCase    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			Tuple							= BlenderbotSmallConfig(
											    vocab_size=self.vocab_size       ,   d_model=14       ,   encoder_layers=2       ,   decoder_layers=2       ,   encoder_attention_heads=2       ,   decoder_attention_heads=2       ,   encoder_ffn_dim=8       ,   decoder_ffn_dim=8       ,   max_position_embeddings=48       ,   )
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= FlaxBlenderbotSmallForConditionalGeneration(_lowerCAmelCase    )
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]]       ,   dtype=np.intaa    )
											_SCREAMING_SNAKE_CASE					:			Tuple							= np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]]       ,   dtype=np.intaa    )
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= lm_model(input_ids=_lowerCAmelCase       ,   decoder_input_ids=_lowerCAmelCase    )
											_SCREAMING_SNAKE_CASE					:			Tuple							= (*summary.shape, config.vocab_size)
											self.assertEqual(outputs["""logits"""].shape       ,   _lowerCAmelCase    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			str							= np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]]       ,   dtype=np.intaa    )
											_SCREAMING_SNAKE_CASE					:			str							= shift_tokens_right(_lowerCAmelCase       ,   1       ,   2    )
											_SCREAMING_SNAKE_CASE					:			Any							= np.equal(_lowerCAmelCase       ,   1    ).astype(np.floataa    ).sum()
											_SCREAMING_SNAKE_CASE					:			int							= np.equal(_lowerCAmelCase       ,   1    ).astype(np.floataa    ).sum()
											self.assertEqual(shifted.shape       ,   input_ids.shape    )
											self.assertEqual(_lowerCAmelCase       ,   n_pad_before - 1    )
											self.assertTrue(np.equal(shifted[:, 0]       ,   2    ).all()    )





@require_flax
class        lowercase__    (		_snake_case	,	unittest.TestCase	,	_snake_case   ):





							'''simple docstring'''


							A_				: List[Any]       =    True
							A_				: List[str]       =    (
							    (
							        FlaxBlenderbotSmallModel,
							        FlaxBlenderbotSmallForConditionalGeneration,
							    )
							    if is_flax_available()
							    else ()
							)
							A_				: Optional[Any]       =    (FlaxBlenderbotSmallForConditionalGeneration,) if is_flax_available() else ()






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			List[str]							= FlaxBlenderbotSmallModelTester(self    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			List[str]							= self.model_tester.prepare_config_and_inputs()
											for model_class in self.all_model_classes:
															self.model_tester.check_use_cache_forward(_lowerCAmelCase       ,   _lowerCAmelCase       ,   _lowerCAmelCase    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			Tuple							= self.model_tester.prepare_config_and_inputs()
											for model_class in self.all_model_classes:
															self.model_tester.check_use_cache_forward_with_attn_mask(_lowerCAmelCase       ,   _lowerCAmelCase       ,   _lowerCAmelCase    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			Optional[int]							= self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
															with self.subTest(model_class.__name__    ):
																			_SCREAMING_SNAKE_CASE					:			Optional[int]							= self._prepare_for_class(_lowerCAmelCase       ,   _lowerCAmelCase    )
																			_SCREAMING_SNAKE_CASE					:			Optional[int]							= model_class(_lowerCAmelCase    )

																			@jax.jit
																			def encode_jitted(__snake_case       ,   __snake_case=None       ,   **__snake_case    ):
																							return model.encode(input_ids=_lowerCAmelCase       ,   attention_mask=_lowerCAmelCase    )

																			with self.subTest("""JIT Enabled"""    ):
																							_SCREAMING_SNAKE_CASE					:			Dict							= encode_jitted(**_lowerCAmelCase    ).to_tuple()

																			with self.subTest("""JIT Disabled"""    ):
																							with jax.disable_jit():
																											_SCREAMING_SNAKE_CASE					:			Any							= encode_jitted(**_lowerCAmelCase    ).to_tuple()

																			self.assertEqual(len(_lowerCAmelCase    )       ,   len(_lowerCAmelCase    )    )
																			for jitted_output, output in zip(_lowerCAmelCase       ,   _lowerCAmelCase    ):
																							self.assertEqual(jitted_output.shape       ,   output.shape    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			int							= self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
															with self.subTest(model_class.__name__    ):
																			_SCREAMING_SNAKE_CASE					:			Dict							= model_class(_lowerCAmelCase    )
																			_SCREAMING_SNAKE_CASE					:			int							= model.encode(inputs_dict["""input_ids"""]       ,   inputs_dict["""attention_mask"""]    )

																			_SCREAMING_SNAKE_CASE					:			int							= {
																			    """decoder_input_ids""": inputs_dict["""decoder_input_ids"""],
																			    """decoder_attention_mask""": inputs_dict["""decoder_attention_mask"""],
																			    """encoder_outputs""": encoder_outputs,
																			}

																			@jax.jit
																			def decode_jitted(__snake_case       ,   __snake_case       ,   __snake_case    ):
																							return model.decode(
																							    decoder_input_ids=_lowerCAmelCase       ,   decoder_attention_mask=_lowerCAmelCase       ,   encoder_outputs=_lowerCAmelCase       ,   )

																			with self.subTest("""JIT Enabled"""    ):
																							_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= decode_jitted(**_lowerCAmelCase    ).to_tuple()

																			with self.subTest("""JIT Disabled"""    ):
																							with jax.disable_jit():
																											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= decode_jitted(**_lowerCAmelCase    ).to_tuple()

																			self.assertEqual(len(_lowerCAmelCase    )       ,   len(_lowerCAmelCase    )    )
																			for jitted_output, output in zip(_lowerCAmelCase       ,   _lowerCAmelCase    ):
																							self.assertEqual(jitted_output.shape       ,   output.shape    )






							@slow
							def UpperCAmelCase_      (       self    ):
											for model_class_name in self.all_model_classes:
															_SCREAMING_SNAKE_CASE					:			List[Any]							= model_class_name.from_pretrained("""facebook/blenderbot_small-90M"""    )
															# FlaxBlenderbotForSequenceClassification expects eos token in input_ids
															_SCREAMING_SNAKE_CASE					:			Optional[int]							= np.ones((1, 1)    ) * model.config.eos_token_id
															_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= model(_lowerCAmelCase    )
															self.assertIsNotNone(_lowerCAmelCase    )











'''simple docstring'''


from ..utils import DummyObject, requires_backends

class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				int								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Union[str, Any]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Union[str, Any]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				int								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Any:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				List[Any]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Any:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[Any]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				List[Any]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[int]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[Any]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[str]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Dict								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				int:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[str]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				List[Any]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[str]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				str:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[str]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				int								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Any:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				str:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[Any]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Optional[int]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Tuple:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[Any]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Union[str, Any]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				int:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[str]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Optional[int]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[int]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[int]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Union[str, Any]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				str:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Union[str, Any]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				int:
     requires_backends(cls      ,  ["torch"]		)







def 						__a(*SCREAMING_SNAKE_CASE_	:       Optional[Any]		,							**SCREAMING_SNAKE_CASE_	:       int     ):



    '''simple docstring'''





    requires_backends(SCREAMING_SNAKE_CASE_		,							["torch"]     )


def 						__a(*SCREAMING_SNAKE_CASE_	:       str		,							**SCREAMING_SNAKE_CASE_	:       str     ):



    '''simple docstring'''





    requires_backends(SCREAMING_SNAKE_CASE_		,							["torch"]     )


def 						__a(*SCREAMING_SNAKE_CASE_	:       str		,							**SCREAMING_SNAKE_CASE_	:       List[Any]     ):



    '''simple docstring'''





    requires_backends(SCREAMING_SNAKE_CASE_		,							["torch"]     )


def 						__a(*SCREAMING_SNAKE_CASE_	:       Optional[Any]		,							**SCREAMING_SNAKE_CASE_	:       List[str]     ):



    '''simple docstring'''





    requires_backends(SCREAMING_SNAKE_CASE_		,							["torch"]     )


def 						__a(*SCREAMING_SNAKE_CASE_	:       List[Any]		,							**SCREAMING_SNAKE_CASE_	:       List[str]     ):



    '''simple docstring'''





    requires_backends(SCREAMING_SNAKE_CASE_		,							["torch"]     )


def 						__a(*SCREAMING_SNAKE_CASE_	:       Tuple		,							**SCREAMING_SNAKE_CASE_	:       str     ):



    '''simple docstring'''





    requires_backends(SCREAMING_SNAKE_CASE_		,							["torch"]     )


def 						__a(*SCREAMING_SNAKE_CASE_	:       int		,							**SCREAMING_SNAKE_CASE_	:       Dict     ):



    '''simple docstring'''





    requires_backends(SCREAMING_SNAKE_CASE_		,							["torch"]     )

class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Dict								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Dict:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Dict:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Union[str, Any]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				str:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Tuple:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[Any]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Optional[Any]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Tuple:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[Any]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				List[Any]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Tuple:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Union[str, Any]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				int:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				List[Any]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				int:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[int]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Any								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[int]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[int]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[int]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Optional[int]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Dict:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[str]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Tuple:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				List[str]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[Any]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[str]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Any:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Any								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				int:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				int:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Dict:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				List[str]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[int]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Any:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				List[str]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				int:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Optional[int]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				str:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Dict:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Union[str, Any]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Any:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				str:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Dict:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				List[Any]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Any:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Tuple:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Union[str, Any]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Optional[int]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				int:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				int:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[str]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				str								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				int:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[int]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[Any]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Tuple								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				str:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[str]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Union[str, Any]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				str:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Union[str, Any]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Tuple:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				List[str]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[int]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				str:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Any								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				str:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[str]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				int:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Union[str, Any]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[str]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Any:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Dict:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Union[str, Any]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				int:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Any:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				str:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				int								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Union[str, Any]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Tuple:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Tuple								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[Any]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Dict:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				int:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				str								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[Any]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[int]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[int]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Dict								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				str:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Any:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Tuple:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Any								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				int:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Tuple:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				List[str]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				int								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Union[str, Any]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Dict:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Dict								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Any:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[Any]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Dict:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				str								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[Any]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Tuple:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[Any]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				int								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Union[str, Any]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[str]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[Any]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				List[Any]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[Any]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				List[Any]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Dict:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				List[Any]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Union[str, Any]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				str:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Union[str, Any]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				List[str]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[int]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Union[str, Any]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Tuple								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[Any]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Dict:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Tuple:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Union[str, Any]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				str:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Any:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Union[str, Any]:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				str								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Optional[int]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Tuple:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				str:
     requires_backends(cls      ,  ["torch"]		)







class  lowerCAmelCase_		(		metaclass=__magic_name__		):
 __lowerCamelCase    :				Union[str, Any]								=       ["torch"]




 def __init__(						self      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Union[str, Any]:
     requires_backends(self      ,  ["torch"]		)




 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				str:
     requires_backends(cls      ,  ["torch"]		)





 @classmethod
 def 				_snake_case (						cls      ,  *_lowerCAmelCase      ,  **_lowerCAmelCase		)     ->				Dict:
     requires_backends(cls      ,  ["torch"]		)


