




import inspect
import tempfile
import unittest

from huggingface_hub import hf_hub_download

from transformers import is_torch_available
from transformers.testing_utils import is_flaky, require_torch, slow, torch_device

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


__A						:							int							=  1e-4

if is_torch_available():
		import torch

		from transformers import AutoformerConfig, AutoformerForPrediction, AutoformerModel
		from transformers.models.autoformer.modeling_autoformer import AutoformerDecoder, AutoformerEncoder




@require_torch
class 			UpperCAmelCase_      :




							'''simple docstring'''



							def __init__(					self       :	Optional[int]       ,     a       :	List[str]       ,     a       :	Optional[int]=16       ,     a       :	int=13       ,     a       :	Optional[Any]=7       ,     a       :	Union[str, Any]=14       ,     a       :	Dict=10       ,     a       :	List[Any]=19       ,     a       :	List[str]=5       ,     a       :	Optional[Any]=4       ,     a       :	Dict=True       ,     a       :	Optional[int]=16       ,     a       :	str=2       ,     a       :	Dict=4       ,     a       :	Dict=4       ,     a       :	List[str]="gelu"       ,     a       :	int=0.1       ,     a       :	Optional[Any]=0.1       ,     a       :	Tuple=[1, 2, 3, 4, 5]       ,     a       :	Dict=25       ,     a       :	List[Any]=5       ,     )			->					Dict:
										SCREAMING_SNAKE_CASE           =					d_model
										SCREAMING_SNAKE_CASE           =					parent
										SCREAMING_SNAKE_CASE           =					batch_size
										SCREAMING_SNAKE_CASE           =					prediction_length
										SCREAMING_SNAKE_CASE           =					context_length
										SCREAMING_SNAKE_CASE           =					cardinality
										SCREAMING_SNAKE_CASE           =					num_time_features
										SCREAMING_SNAKE_CASE           =					lags_sequence
										SCREAMING_SNAKE_CASE           =					embedding_dimension
										SCREAMING_SNAKE_CASE           =					is_training
										SCREAMING_SNAKE_CASE           =					hidden_size
										SCREAMING_SNAKE_CASE           =					num_hidden_layers
										SCREAMING_SNAKE_CASE           =					num_attention_heads
										SCREAMING_SNAKE_CASE           =					intermediate_size
										SCREAMING_SNAKE_CASE           =					hidden_act
										SCREAMING_SNAKE_CASE           =					hidden_dropout_prob
										SCREAMING_SNAKE_CASE           =					attention_probs_dropout_prob

										SCREAMING_SNAKE_CASE           =					context_length
										SCREAMING_SNAKE_CASE           =					prediction_length + label_length
										SCREAMING_SNAKE_CASE           =					label_length

										SCREAMING_SNAKE_CASE           =					moving_average
										SCREAMING_SNAKE_CASE           =					autocorrelation_factor





							def    _UpperCAmelCase     (					self       :	Optional[int]			)			->					Dict:
										return AutoformerConfig(
										    d_model=self.d_model       ,     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       ,     prediction_length=self.prediction_length       ,     context_length=self.context_length       ,     label_length=self.label_length       ,     lags_sequence=self.lags_sequence       ,     num_time_features=self.num_time_features       ,     num_static_categorical_features=1       ,     cardinality=[self.cardinality]       ,     embedding_dimension=[self.embedding_dimension]       ,     moving_average=self.moving_average       ,     )





							def    _UpperCAmelCase     (					self       :	Optional[int]       ,     a       :	Optional[int]			)			->					Any:
										SCREAMING_SNAKE_CASE           =					config.context_length + max(config.lags_sequence			)

										SCREAMING_SNAKE_CASE           =					ids_tensor([self.batch_size, 1]       ,     config.cardinality[0]			)
										SCREAMING_SNAKE_CASE           =					floats_tensor([self.batch_size, _past_length, config.num_time_features]			)
										SCREAMING_SNAKE_CASE           =					floats_tensor([self.batch_size, _past_length]			)
										SCREAMING_SNAKE_CASE           =					floats_tensor([self.batch_size, _past_length]			) > 0.5

										# decoder inputs
										SCREAMING_SNAKE_CASE           =					floats_tensor([self.batch_size, config.prediction_length, config.num_time_features]			)
										SCREAMING_SNAKE_CASE           =					floats_tensor([self.batch_size, config.prediction_length]			)

										SCREAMING_SNAKE_CASE           =					{
										    """past_values""": past_values,
										    """static_categorical_features""": static_categorical_features,
										    """past_time_features""": past_time_features,
										    """past_observed_mask""": past_observed_mask,
										    """future_time_features""": future_time_features,
										    """future_values""": future_values,
										}
										return inputs_dict





							def    _UpperCAmelCase     (					self       :	Optional[int]			)			->					List[Any]:
										SCREAMING_SNAKE_CASE           =					self.get_config()
										SCREAMING_SNAKE_CASE           =					self.prepare_autoformer_inputs_dict(a			)
										return config, inputs_dict





							def    _UpperCAmelCase     (					self       :	str			)			->					Optional[int]:
										SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE           =					self.prepare_config_and_inputs()
										return config, inputs_dict







							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	Optional[Any]       ,     a       :	Any			)			->					Union[str, Any]:
										SCREAMING_SNAKE_CASE           =					AutoformerModel(config=a			).to(a			).eval()
										SCREAMING_SNAKE_CASE           =					model(**a			)

										SCREAMING_SNAKE_CASE           =					outputs.encoder_last_hidden_state
										SCREAMING_SNAKE_CASE           =					outputs.last_hidden_state

										with tempfile.TemporaryDirectory() as tmpdirname:
													SCREAMING_SNAKE_CASE           =					model.get_encoder()
													encoder.save_pretrained(a			)
													SCREAMING_SNAKE_CASE           =					AutoformerEncoder.from_pretrained(a			).to(a			)

										SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE           =					model.create_network_inputs(**a			)
										SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE           =					model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]			)

										SCREAMING_SNAKE_CASE           =					torch.cat(
										    (transformer_inputs[:, : config.context_length, ...], feature[:, : config.context_length, ...])       ,     dim=-1       ,     )
										SCREAMING_SNAKE_CASE           =					encoder(inputs_embeds=a			)[0]
										self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1E-3			)

										SCREAMING_SNAKE_CASE           =					(
										    torch.mean(transformer_inputs[:, : config.context_length, ...]       ,     dim=1			)
										    .unsqueeze(1			)
										    .repeat(1       ,     config.prediction_length       ,     1			)
										)
										SCREAMING_SNAKE_CASE           =					torch.zeros(
										    [transformer_inputs.shape[0], config.prediction_length, transformer_inputs.shape[2]]       ,     device=enc_input.device       ,     )

										SCREAMING_SNAKE_CASE           =					torch.cat(
										    (
										        torch.cat((seasonal_input[:, -config.label_length :, ...], zeros)       ,     dim=1			),
										        feature[:, config.context_length - config.label_length :, ...],
										    )       ,     dim=-1       ,     )
										SCREAMING_SNAKE_CASE           =					torch.cat(
										    (
										        torch.cat((trend_input[:, -config.label_length :, ...], mean)       ,     dim=1			),
										        feature[:, config.context_length - config.label_length :, ...],
										    )       ,     dim=-1       ,     )

										with tempfile.TemporaryDirectory() as tmpdirname:
													SCREAMING_SNAKE_CASE           =					model.get_decoder()
													decoder.save_pretrained(a			)
													SCREAMING_SNAKE_CASE           =					AutoformerDecoder.from_pretrained(a			).to(a			)

										SCREAMING_SNAKE_CASE           =					decoder(
										    trend=a       ,     inputs_embeds=a       ,     encoder_hidden_states=a       ,     )[0]

										self.parent.assertTrue((last_hidden_state_a - last_hidden_state).abs().max().item() < 1E-3			)





@require_torch
class 			UpperCAmelCase_      (   A		,      A		,      unittest.TestCase       ):




							'''simple docstring'''



							a__						  =     (AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
							a__						  =     (AutoformerForPrediction,) if is_torch_available() else ()
							a__						  =     {'''feature-extraction''': AutoformerModel} if is_torch_available() else {}
							a__						  =     False
							a__						  =     False
							a__						  =     False
							a__						  =     False
							a__						  =     False
							a__						  =     False





							def    _UpperCAmelCase     (					self       :	Any			)			->					Dict:
										SCREAMING_SNAKE_CASE           =					AutoformerModelTester(self			)
										SCREAMING_SNAKE_CASE           =					ConfigTester(self       ,     config_class=a       ,     has_text_modality=a			)





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





							def    _UpperCAmelCase     (					self       :	Optional[int]			)			->					Union[str, Any]:
										SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE           =					self.model_tester.prepare_config_and_inputs()
										for model_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE           =					model_class(a			)

													with tempfile.TemporaryDirectory() as tmpdirname:
																model.save_pretrained(a			)
																SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE           =					model_class.from_pretrained(a       ,     output_loading_info=a			)
													self.assertEqual(info["""missing_keys"""]       ,     []			)





							def    _UpperCAmelCase     (					self       :	Dict			)			->					Dict:
										SCREAMING_SNAKE_CASE           =					self.model_tester.prepare_config_and_inputs_for_common()
										self.model_tester.check_encoder_decoder_model_standalone(*a			)





							@unittest.skip(reason="""Model has no tokens embeddings"""			)
							def    _UpperCAmelCase     (					self       :	Tuple			)			->					List[str]:
										pass





							def    _UpperCAmelCase     (					self       :	Union[str, Any]			)			->					Tuple:
										SCREAMING_SNAKE_CASE           =					inspect.signature(getattr(a       ,     """forward"""			)			)
										# The main input is the name of the argument after `self`
										SCREAMING_SNAKE_CASE           =					list(model_signature.parameters.keys()			)[1]
										self.assertEqual(AutoformerModel.main_input_name       ,     a			)





							def    _UpperCAmelCase     (					self       :	int			)			->					List[str]:
										SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE           =					self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE           =					model_class(a			)
													SCREAMING_SNAKE_CASE           =					inspect.signature(model.forward			)
													# signature.parameters is an OrderedDict => so arg_names order is deterministic
													SCREAMING_SNAKE_CASE           =					[*signature.parameters.keys()]

													SCREAMING_SNAKE_CASE           =					[
													    """past_values""",
													    """past_time_features""",
													    """past_observed_mask""",
													    """static_categorical_features""",
													    """static_real_features""",
													    """future_values""",
													    """future_time_features""",
													]

													if model.__class__.__name__ in ["AutoformerForPrediction"]:
																expected_arg_names.append("""future_observed_mask"""			)

													expected_arg_names.extend(
													    [
													        """decoder_attention_mask""",
													        """head_mask""",
													        """decoder_head_mask""",
													        """cross_attn_head_mask""",
													        """encoder_outputs""",
													        """past_key_values""",
													        """output_hidden_states""",
													        """output_attentions""",
													        """use_cache""",
													        """return_dict""",
													    ]			)

													self.assertListEqual(arg_names[: len(a			)]       ,     a			)





							def    _UpperCAmelCase     (					self       :	Dict			)			->					Dict:
										SCREAMING_SNAKE_CASE     ,  SCREAMING_SNAKE_CASE           =					self.model_tester.prepare_config_and_inputs_for_common()
										SCREAMING_SNAKE_CASE           =					True

										SCREAMING_SNAKE_CASE           =					getattr(self.model_tester       ,     """seq_length"""       ,     a			)
										SCREAMING_SNAKE_CASE           =					getattr(self.model_tester       ,     """decoder_seq_length"""       ,     a			)
										SCREAMING_SNAKE_CASE           =					getattr(self.model_tester       ,     """encoder_seq_length"""       ,     a			)
										SCREAMING_SNAKE_CASE           =					getattr(self.model_tester       ,     """d_model"""       ,     a			)
										SCREAMING_SNAKE_CASE           =					getattr(self.model_tester       ,     """num_attention_heads"""       ,     a			)
										SCREAMING_SNAKE_CASE           =					d_model // num_attention_heads

										for model_class in self.all_model_classes:
													SCREAMING_SNAKE_CASE           =					True
													SCREAMING_SNAKE_CASE           =					False
													SCREAMING_SNAKE_CASE           =					True
													SCREAMING_SNAKE_CASE           =					model_class(a			)
													model.to(a			)
													model.eval()
													with torch.no_grad():
																SCREAMING_SNAKE_CASE           =					model(**self._prepare_for_class(a       ,     a			)			)
													SCREAMING_SNAKE_CASE           =					outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
													self.assertEqual(len(a			)       ,     self.model_tester.num_hidden_layers			)

													# check that output_attentions also work using config
													del inputs_dict["output_attentions"]
													SCREAMING_SNAKE_CASE           =					True
													SCREAMING_SNAKE_CASE           =					model_class(a			)
													model.to(a			)
													model.eval()
													with torch.no_grad():
																SCREAMING_SNAKE_CASE           =					model(**self._prepare_for_class(a       ,     a			)			)
													SCREAMING_SNAKE_CASE           =					outputs.encoder_attentions
													self.assertEqual(len(a			)       ,     self.model_tester.num_hidden_layers			)

													self.assertListEqual(
													    list(attentions[0].shape[-3:]			)       ,     [self.model_tester.num_attention_heads, encoder_seq_length, dim]       ,     )
													SCREAMING_SNAKE_CASE           =					len(a			)

													SCREAMING_SNAKE_CASE           =					7

													if "last_hidden_state" in outputs:
																correct_outlen += 1

													if "trend" in outputs:
																correct_outlen += 1

													if "past_key_values" in outputs:
																correct_outlen += 1  # past_key_values have been returned

													if "loss" in outputs:
																correct_outlen += 1

													if "params" in outputs:
																correct_outlen += 1

													self.assertEqual(a       ,     a			)

													# decoder attentions
													SCREAMING_SNAKE_CASE           =					outputs.decoder_attentions
													self.assertIsInstance(a       ,     (list, tuple)			)
													self.assertEqual(len(a			)       ,     self.model_tester.num_hidden_layers			)
													self.assertListEqual(
													    list(decoder_attentions[0].shape[-3:]			)       ,     [self.model_tester.num_attention_heads, decoder_seq_length, dim]       ,     )

													# cross attentions
													SCREAMING_SNAKE_CASE           =					outputs.cross_attentions
													self.assertIsInstance(a       ,     (list, tuple)			)
													self.assertEqual(len(a			)       ,     self.model_tester.num_hidden_layers			)
													self.assertListEqual(
													    list(cross_attentions[0].shape[-3:]			)       ,     [self.model_tester.num_attention_heads, decoder_seq_length, dim]       ,     )

										# Check attention is always last and order is fine
										SCREAMING_SNAKE_CASE           =					True
										SCREAMING_SNAKE_CASE           =					True
										SCREAMING_SNAKE_CASE           =					model_class(a			)
										model.to(a			)
										model.eval()
										with torch.no_grad():
													SCREAMING_SNAKE_CASE           =					model(**self._prepare_for_class(a       ,     a			)			)

										self.assertEqual(out_len + 2       ,     len(a			)			)

										SCREAMING_SNAKE_CASE           =					outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions

										self.assertEqual(len(a			)       ,     self.model_tester.num_hidden_layers			)
										self.assertListEqual(
										    list(self_attentions[0].shape[-3:]			)       ,     [self.model_tester.num_attention_heads, encoder_seq_length, dim]       ,     )







							@is_flaky()
							def    _UpperCAmelCase     (					self       :	Optional[int]			)			->					int:
										super().test_retain_grad_hidden_states_attentions()





def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE="train-batch.pt"   ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE           =					hf_hub_download(repo_id="""hf-internal-testing/tourism-monthly-batch"""					,	filename=SCREAMING_SNAKE_CASE					,	repo_type="""dataset"""   )
			SCREAMING_SNAKE_CASE           =					torch.load(SCREAMING_SNAKE_CASE					,	map_location=SCREAMING_SNAKE_CASE   )
			return batch




@require_torch
@slow
class 			UpperCAmelCase_      (   unittest.TestCase       ):




							'''simple docstring'''



							def    _UpperCAmelCase     (					self       :	Any			)			->					int:
										SCREAMING_SNAKE_CASE           =					AutoformerModel.from_pretrained("""huggingface/autoformer-tourism-monthly"""			).to(a			)
										SCREAMING_SNAKE_CASE           =					prepare_batch()

										with torch.no_grad():
													SCREAMING_SNAKE_CASE           =					model(
													    past_values=batch["""past_values"""]       ,     past_time_features=batch["""past_time_features"""]       ,     past_observed_mask=batch["""past_observed_mask"""]       ,     static_categorical_features=batch["""static_categorical_features"""]       ,     future_values=batch["""future_values"""]       ,     future_time_features=batch["""future_time_features"""]       ,     )[0]

										SCREAMING_SNAKE_CASE           =					torch.Size(
										    (64, model.config.prediction_length + model.config.label_length, model.config.feature_size)			)
										self.assertEqual(output.shape       ,     a			)

										SCREAMING_SNAKE_CASE           =					torch.tensor(
										    [[0.3593, -1.3398, 0.6330], [0.2279, 1.5396, -0.1792], [0.0450, 1.3225, -0.2335]]       ,     device=a			)
										self.assertTrue(torch.allclose(output[0, :3, :3]       ,     a       ,     atol=a			)			)





							def    _UpperCAmelCase     (					self       :	Union[str, Any]			)			->					Optional[Any]:
										SCREAMING_SNAKE_CASE           =					AutoformerForPrediction.from_pretrained("""huggingface/autoformer-tourism-monthly"""			).to(a			)
										SCREAMING_SNAKE_CASE           =					prepare_batch("""val-batch.pt"""			)
										with torch.no_grad():
													SCREAMING_SNAKE_CASE           =					model(
													    past_values=batch["""past_values"""]       ,     past_time_features=batch["""past_time_features"""]       ,     past_observed_mask=batch["""past_observed_mask"""]       ,     static_categorical_features=batch["""static_categorical_features"""]       ,     ).encoder_last_hidden_state
										SCREAMING_SNAKE_CASE           =					torch.Size((64, model.config.context_length, model.config.d_model)			)
										self.assertEqual(output.shape       ,     a			)

										SCREAMING_SNAKE_CASE           =					torch.tensor(
										    [[-0.0734, -0.9036, 0.8358], [4.7186, 2.4113, 1.9581], [1.7953, 2.3558, 1.2970]]       ,     device=a			)
										self.assertTrue(torch.allclose(output[0, :3, :3]       ,     a       ,     atol=a			)			)







							def    _UpperCAmelCase     (					self       :	List[str]			)			->					Any:
										SCREAMING_SNAKE_CASE           =					AutoformerForPrediction.from_pretrained("""huggingface/autoformer-tourism-monthly"""			).to(a			)
										SCREAMING_SNAKE_CASE           =					prepare_batch("""val-batch.pt"""			)
										with torch.no_grad():
													SCREAMING_SNAKE_CASE           =					model.generate(
													    static_categorical_features=batch["""static_categorical_features"""]       ,     past_time_features=batch["""past_time_features"""]       ,     past_values=batch["""past_values"""]       ,     future_time_features=batch["""future_time_features"""]       ,     past_observed_mask=batch["""past_observed_mask"""]       ,     )
										SCREAMING_SNAKE_CASE           =					torch.Size((64, model.config.num_parallel_samples, model.config.prediction_length)			)
										self.assertEqual(outputs.sequences.shape       ,     a			)

										SCREAMING_SNAKE_CASE           =					torch.tensor([3130.6763, 4056.5293, 7053.0786]       ,     device=a			)
										SCREAMING_SNAKE_CASE           =					outputs.sequences.mean(dim=1			)
										self.assertTrue(torch.allclose(mean_prediction[0, -3:]       ,     a       ,     rtol=1E-1			)			)












import os
import sys
import unittest


__A						:							Any							=  os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, """utils"""))

import check_dummies  # noqa: E402
from check_dummies import create_dummy_files, create_dummy_object, find_backend, read_init  # noqa: E402


# Align TRANSFORMERS_PATH in check_dummies with the current path
__A						:							List[Any]							=  os.path.join(git_repo_path, """src""", """diffusers""")




class 			UpperCAmelCase_      (   unittest.TestCase       ):




							'''simple docstring'''



							def    _UpperCAmelCase     (					self       :	Any			)			->					Optional[Any]:
										SCREAMING_SNAKE_CASE           =					find_backend("""    if not is_torch_available():"""			)
										self.assertEqual(a       ,     """torch"""			)

										# backend_with_underscore = find_backend("    if not is_tensorflow_text_available():")
										# self.assertEqual(backend_with_underscore, "tensorflow_text")

										SCREAMING_SNAKE_CASE           =					find_backend("""    if not (is_torch_available() and is_transformers_available()):"""			)
										self.assertEqual(a       ,     """torch_and_transformers"""			)

										# double_backend_with_underscore = find_backend(
										#    "    if not (is_sentencepiece_available() and is_tensorflow_text_available()):"
										# )
										# self.assertEqual(double_backend_with_underscore, "sentencepiece_and_tensorflow_text")

										SCREAMING_SNAKE_CASE           =					find_backend(
										    """    if not (is_torch_available() and is_transformers_available() and is_onnx_available()):"""			)
										self.assertEqual(a       ,     """torch_and_transformers_and_onnx"""			)





							def    _UpperCAmelCase     (					self       :	List[str]			)			->					int:
										SCREAMING_SNAKE_CASE           =					read_init()
										# We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects
										self.assertIn("""torch"""       ,     a			)
										self.assertIn("""torch_and_transformers"""       ,     a			)
										self.assertIn("""flax_and_transformers"""       ,     a			)
										self.assertIn("""torch_and_transformers_and_onnx"""       ,     a			)

										# Likewise, we can't assert on the exact content of a key
										self.assertIn("""UNet2DModel"""       ,     objects["""torch"""]			)
										self.assertIn("""FlaxUNet2DConditionModel"""       ,     objects["""flax"""]			)
										self.assertIn("""StableDiffusionPipeline"""       ,     objects["""torch_and_transformers"""]			)
										self.assertIn("""FlaxStableDiffusionPipeline"""       ,     objects["""flax_and_transformers"""]			)
										self.assertIn("""LMSDiscreteScheduler"""       ,     objects["""torch_and_scipy"""]			)
										self.assertIn("""OnnxStableDiffusionPipeline"""       ,     objects["""torch_and_transformers_and_onnx"""]			)





							def    _UpperCAmelCase     (					self       :	Any			)			->					int:
										SCREAMING_SNAKE_CASE           =					create_dummy_object("""CONSTANT"""       ,     """'torch'"""			)
										self.assertEqual(a       ,     """\nCONSTANT = None\n"""			)

										SCREAMING_SNAKE_CASE           =					create_dummy_object("""function"""       ,     """'torch'"""			)
										self.assertEqual(
										    a       ,     """\ndef function(*args, **kwargs):\n    requires_backends(function, 'torch')\n"""			)

										SCREAMING_SNAKE_CASE           =					"""
class FakeClass(metaclass=DummyObject):
    _backends = 'torch'

    def __init__(self, *args, **kwargs):
        requires_backends(self, 'torch')

    @classmethod
    def from_config(cls, *args, **kwargs):
        requires_backends(cls, 'torch')

    @classmethod
    def from_pretrained(cls, *args, **kwargs):
        requires_backends(cls, 'torch')
"""
										SCREAMING_SNAKE_CASE           =					create_dummy_object("""FakeClass"""       ,     """'torch'"""			)
										self.assertEqual(a       ,     a			)







							def    _UpperCAmelCase     (					self       :	Union[str, Any]			)			->					Union[str, Any]:
										SCREAMING_SNAKE_CASE           =					"""# This file is autogenerated by the command `make fix-copies`, do not edit.
from ..utils import DummyObject, requires_backends


CONSTANT = None


def function(*args, **kwargs):
    requires_backends(function, [\"torch\"])


class FakeClass(metaclass=DummyObject):
    _backends = [\"torch\"]

    def __init__(self, *args, **kwargs):
        requires_backends(self, [\"torch\"])

    @classmethod
    def from_config(cls, *args, **kwargs):
        requires_backends(cls, [\"torch\"])

    @classmethod
    def from_pretrained(cls, *args, **kwargs):
        requires_backends(cls, [\"torch\"])
"""
										SCREAMING_SNAKE_CASE           =					create_dummy_files({"""torch""": ["""CONSTANT""", """function""", """FakeClass"""]}			)
										self.assertEqual(dummy_files["""torch"""]       ,     a			)






