






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


_UpperCAmelCase			:		Optional[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  lowerCAmelCase_       :




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

											lowerCAmelCase__      			=						context_length
											lowerCAmelCase__      			=						prediction_length + label_length
											lowerCAmelCase__      			=						label_length

											lowerCAmelCase__      			=						moving_average
											lowerCAmelCase__      			=						autocorrelation_factor




							def 						__snake_case					(   self     :   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 						__snake_case					(   self     :   Optional[int] ,							SCREAMING_SNAKE_CASE_     :   List[Any]	):
											lowerCAmelCase__      			=						config.context_length + max(config.lags_sequence	)

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

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

											lowerCAmelCase__      			=						{
											    '''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 						__snake_case					(   self     :   Any	):
											lowerCAmelCase__      			=						self.get_config()
											lowerCAmelCase__      			=						self.prepare_autoformer_inputs_dict(SCREAMING_SNAKE_CASE_	)
											return config, inputs_dict




							def 						__snake_case					(   self     :   int	):
											lowerCAmelCase__			,		lowerCAmelCase__      			=						self.prepare_config_and_inputs()
											return config, inputs_dict




							def 						__snake_case					(   self     :   Dict ,							SCREAMING_SNAKE_CASE_     :   Union[str, Any] ,							SCREAMING_SNAKE_CASE_     :   Dict	):
											lowerCAmelCase__      			=						AutoformerModel(config=SCREAMING_SNAKE_CASE_	).to(SCREAMING_SNAKE_CASE_	).eval()
											lowerCAmelCase__      			=						model(**SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						outputs.encoder_last_hidden_state
											lowerCAmelCase__      			=						outputs.last_hidden_state

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

											lowerCAmelCase__			,		lowerCAmelCase__			,		lowerCAmelCase__			,		lowerCAmelCase__			,		lowerCAmelCase__      			=						model.create_network_inputs(**SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__			,		lowerCAmelCase__      			=						model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]	)

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

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

											lowerCAmelCase__      			=						torch.cat(
											    (
											        torch.cat((seasonal_input[:, -config.label_length :, ...], zeros) ,							dim=1	),
											        feature[:, config.context_length - config.label_length :, ...],
											    ) ,							dim=-1 ,							)
											lowerCAmelCase__      			=						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:
															lowerCAmelCase__      			=						model.get_decoder()
															decoder.save_pretrained(SCREAMING_SNAKE_CASE_	)
															lowerCAmelCase__      			=						AutoformerDecoder.from_pretrained(SCREAMING_SNAKE_CASE_	).to(SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						decoder(
											    trend=SCREAMING_SNAKE_CASE_ ,							inputs_embeds=SCREAMING_SNAKE_CASE_ ,							encoder_hidden_states=SCREAMING_SNAKE_CASE_ ,							)[0]

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



@require_torch
class  lowerCAmelCase_       (				snake_case__     ,    snake_case__     ,    unittest.TestCase					):
							UpperCamelCase_		:Dict		      =    (AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
							UpperCamelCase_		:int		      =    (AutoformerForPrediction,) if is_torch_available() else ()
							UpperCamelCase_		:List[Any]		      =    {'feature-extraction': AutoformerModel} if is_torch_available() else {}
							UpperCamelCase_		:Optional[Any]		      =    False
							UpperCamelCase_		:Optional[Any]		      =    False
							UpperCamelCase_		:List[str]		      =    False
							UpperCamelCase_		:Tuple		      =    False
							UpperCamelCase_		:Optional[int]		      =    False
							UpperCamelCase_		:List[Any]		      =    False




							def 						__snake_case					(   self     :   Optional[int]	):
											lowerCAmelCase__      			=						AutoformerModelTester(self	)
											lowerCAmelCase__      			=						ConfigTester(self ,							config_class=SCREAMING_SNAKE_CASE_ ,							has_text_modality=SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   Any	):
											self.config_tester.run_common_tests()




							def 						__snake_case					(   self     :   Optional[int]	):
											lowerCAmelCase__			,		lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs()
											for model_class in self.all_model_classes:
															lowerCAmelCase__      			=						model_class(SCREAMING_SNAKE_CASE_	)

															with tempfile.TemporaryDirectory() as tmpdirname:
																			model.save_pretrained(SCREAMING_SNAKE_CASE_	)
																			lowerCAmelCase__			,		lowerCAmelCase__      			=						model_class.from_pretrained(SCREAMING_SNAKE_CASE_ ,							output_loading_info=SCREAMING_SNAKE_CASE_	)
															self.assertEqual(info['''missing_keys'''] ,							[]	)




							def 						__snake_case					(   self     :   Optional[Any]	):
											lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs_for_common()
											self.model_tester.check_encoder_decoder_model_standalone(*SCREAMING_SNAKE_CASE_	)




							@unittest.skip(reason='''Model has no tokens embeddings'''	)
							def 						__snake_case					(   self     :   str	):
											pass




							def 						__snake_case					(   self     :   Union[str, Any]	):
											lowerCAmelCase__      			=						inspect.signature(getattr(SCREAMING_SNAKE_CASE_ ,							'''forward'''	)	)
											# The main input is the name of the argument after `self`
											lowerCAmelCase__      			=						list(model_signature.parameters.keys()	)[1]
											self.assertEqual(AutoformerModel.main_input_name ,							SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   List[Any]	):
											lowerCAmelCase__			,		lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs_for_common()

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

															lowerCAmelCase__      			=						[
															    '''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(SCREAMING_SNAKE_CASE_	)] ,							SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   List[Any]	):
											lowerCAmelCase__			,		lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs_for_common()
											lowerCAmelCase__      			=						True

											lowerCAmelCase__      			=						getattr(self.model_tester ,							'''seq_length''' ,							SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						getattr(self.model_tester ,							'''decoder_seq_length''' ,							SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						getattr(self.model_tester ,							'''encoder_seq_length''' ,							SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						getattr(self.model_tester ,							'''d_model''' ,							SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						getattr(self.model_tester ,							'''num_attention_heads''' ,							SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						d_model // num_attention_heads

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

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

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

															lowerCAmelCase__      			=						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(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	)

															# decoder attentions
															lowerCAmelCase__      			=						outputs.decoder_attentions
															self.assertIsInstance(SCREAMING_SNAKE_CASE_ ,							(list, tuple)	)
															self.assertEqual(len(SCREAMING_SNAKE_CASE_	) ,							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
															lowerCAmelCase__      			=						outputs.cross_attentions
															self.assertIsInstance(SCREAMING_SNAKE_CASE_ ,							(list, tuple)	)
															self.assertEqual(len(SCREAMING_SNAKE_CASE_	) ,							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
											lowerCAmelCase__      			=						True
											lowerCAmelCase__      			=						True
											lowerCAmelCase__      			=						model_class(SCREAMING_SNAKE_CASE_	)
											model.to(SCREAMING_SNAKE_CASE_	)
											model.eval()
											with torch.no_grad():
															lowerCAmelCase__      			=						model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	)	)

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

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

											self.assertEqual(len(SCREAMING_SNAKE_CASE_	) ,							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 						__snake_case					(   self     :   Tuple	):
											super().test_retain_grad_hidden_states_attentions()





def 	lowerCAmelCase_		(lowercase__						:       str="train-batch.pt"       )		->    Tuple:


				'''simple docstring'''




				lowerCAmelCase__      			=						hf_hub_download(repo_id='''hf-internal-testing/tourism-monthly-batch'''     ,					filename=lowercase__     ,					repo_type='''dataset'''       )
				lowerCAmelCase__      			=						torch.load(lowercase__     ,					map_location=lowercase__       )
				return batch




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




							def 						__snake_case					(   self     :   Tuple	):
											lowerCAmelCase__      			=						AutoformerModel.from_pretrained('''huggingface/autoformer-tourism-monthly'''	).to(SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						prepare_batch()

											with torch.no_grad():
															lowerCAmelCase__      			=						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]

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

											lowerCAmelCase__      			=						torch.tensor(
											    [[0.3_593, -1.3_398, 0.6_330], [0.2_279, 1.5_396, -0.1_792], [0.0_450, 1.3_225, -0.2_335]] ,							device=SCREAMING_SNAKE_CASE_	)
											self.assertTrue(torch.allclose(output[0, :3, :3] ,							SCREAMING_SNAKE_CASE_ ,							atol=SCREAMING_SNAKE_CASE_	)	)




							def 						__snake_case					(   self     :   List[Any]	):
											lowerCAmelCase__      			=						AutoformerForPrediction.from_pretrained('''huggingface/autoformer-tourism-monthly'''	).to(SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						prepare_batch('''val-batch.pt'''	)
											with torch.no_grad():
															lowerCAmelCase__      			=						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
											lowerCAmelCase__      			=						torch.Size((64, model.config.context_length, model.config.d_model)	)
											self.assertEqual(output.shape ,							SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						torch.tensor(
											    [[-0.0_734, -0.9_036, 0.8_358], [4.7_186, 2.4_113, 1.9_581], [1.7_953, 2.3_558, 1.2_970]] ,							device=SCREAMING_SNAKE_CASE_	)
											self.assertTrue(torch.allclose(output[0, :3, :3] ,							SCREAMING_SNAKE_CASE_ ,							atol=SCREAMING_SNAKE_CASE_	)	)




							def 						__snake_case					(   self     :   Dict	):
											lowerCAmelCase__      			=						AutoformerForPrediction.from_pretrained('''huggingface/autoformer-tourism-monthly'''	).to(SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						prepare_batch('''val-batch.pt'''	)
											with torch.no_grad():
															lowerCAmelCase__      			=						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'''] ,							)
											lowerCAmelCase__      			=						torch.Size((64, model.config.num_parallel_samples, model.config.prediction_length)	)
											self.assertEqual(outputs.sequences.shape ,							SCREAMING_SNAKE_CASE_	)

											lowerCAmelCase__      			=						torch.tensor([3_130.6_763, 4_056.5_293, 7_053.0_786] ,							device=SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						outputs.sequences.mean(dim=1	)
											self.assertTrue(torch.allclose(mean_prediction[0, -3:] ,							SCREAMING_SNAKE_CASE_ ,							rtol=1e-1	)	)













import pytest

import datasets


# Import fixture modules as plugins
_UpperCAmelCase			:		Tuple   				=    ["tests.fixtures.files", "tests.fixtures.hub", "tests.fixtures.fsspec"]





def 	lowerCAmelCase_		(lowercase__						:       Optional[int]     ,					lowercase__						:       int       )		->    Any:


				'''simple docstring'''




				for item in items:
								if any(marker in item.keywords for marker in ['''integration''', '''unit''']       ):
												continue
								item.add_marker(pytest.mark.unit       )





def 	lowerCAmelCase_		(lowercase__						:       str       )		->    List[str]:


				'''simple docstring'''




				config.addinivalue_line('''markers'''     ,					'''torchaudio_latest: mark test to run with torchaudio>=0.12'''       )





@pytest.fixture(autouse=lowercase__       )
def 	lowerCAmelCase_		(lowercase__						:       int     ,					lowercase__						:       Dict       )		->    Optional[Any]:


				'''simple docstring'''




				lowerCAmelCase__      			=						tmp_path_factory.getbasetemp() / '''cache'''
				lowerCAmelCase__      			=						test_hf_cache_home / '''datasets'''
				lowerCAmelCase__      			=						test_hf_cache_home / '''metrics'''
				lowerCAmelCase__      			=						test_hf_cache_home / '''modules'''
				monkeypatch.setattr('''datasets.config.HF_DATASETS_CACHE'''     ,					str(lowercase__       )       )
				monkeypatch.setattr('''datasets.config.HF_METRICS_CACHE'''     ,					str(lowercase__       )       )
				monkeypatch.setattr('''datasets.config.HF_MODULES_CACHE'''     ,					str(lowercase__       )       )
				lowerCAmelCase__      			=						test_hf_datasets_cache / '''downloads'''
				monkeypatch.setattr('''datasets.config.DOWNLOADED_DATASETS_PATH'''     ,					str(lowercase__       )       )
				lowerCAmelCase__      			=						test_hf_datasets_cache / '''downloads''' / '''extracted'''
				monkeypatch.setattr('''datasets.config.EXTRACTED_DATASETS_PATH'''     ,					str(lowercase__       )       )





@pytest.fixture(autouse=lowercase__     ,					scope='''session'''       )
def 	lowerCAmelCase_		()		->    int:


				'''simple docstring'''




				datasets.disable_progress_bar()





@pytest.fixture(autouse=lowercase__       )
def 	lowerCAmelCase_		(lowercase__						:       Dict       )		->    List[str]:


				'''simple docstring'''




				monkeypatch.setattr('''datasets.config.HF_UPDATE_DOWNLOAD_COUNTS'''     ,					lowercase__       )





@pytest.fixture
def 	lowerCAmelCase_		(lowercase__						:       List[str]       )		->    List[Any]:


				'''simple docstring'''




				monkeypatch.setattr('''sqlalchemy.util.deprecations.SILENCE_UBER_WARNING'''     ,					lowercase__       )





