






'''simple docstring'''




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


__lowerCamelCase   :					str   							=					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    A_	:
							"""simple docstring"""




							def __init__(		self			:List[str]       ,							lowerCAmelCase__			:List[Any]       ,							lowerCAmelCase__			:Optional[int]=16       ,							lowerCAmelCase__			:Tuple=13       ,							lowerCAmelCase__			:int=7       ,							lowerCAmelCase__			:Dict=14       ,							lowerCAmelCase__			:int=10       ,							lowerCAmelCase__			:str=19       ,							lowerCAmelCase__			:Optional[Any]=5       ,							lowerCAmelCase__			:int=4       ,							lowerCAmelCase__			:List[Any]=True       ,							lowerCAmelCase__			:Any=16       ,							lowerCAmelCase__			:Optional[int]=2       ,							lowerCAmelCase__			:str=4       ,							lowerCAmelCase__			:Union[str, Any]=4       ,							lowerCAmelCase__			:int="gelu"       ,							lowerCAmelCase__			:Dict=0.1       ,							lowerCAmelCase__			:int=0.1       ,							lowerCAmelCase__			:Optional[int]=[1, 2, 3, 4, 5]       ,							lowerCAmelCase__			:Dict=25       ,							lowerCAmelCase__			:Any=5       ,							)				->  Tuple:


										'''simple docstring'''




										snake_case_				:					Optional[Any]   =       d_model
										snake_case_				:					Any   =       parent
										snake_case_				:					Tuple   =       batch_size
										snake_case_				:					Tuple   =       prediction_length
										snake_case_				:					List[str]   =       context_length
										snake_case_				:					List[str]   =       cardinality
										snake_case_				:					Optional[Any]   =       num_time_features
										snake_case_				:					Dict   =       lags_sequence
										snake_case_				:					Union[str, Any]   =       embedding_dimension
										snake_case_				:					List[str]   =       is_training
										snake_case_				:					int   =       hidden_size
										snake_case_				:					int   =       num_hidden_layers
										snake_case_				:					Dict   =       num_attention_heads
										snake_case_				:					Optional[Any]   =       intermediate_size
										snake_case_				:					List[str]   =       hidden_act
										snake_case_				:					int   =       hidden_dropout_prob
										snake_case_				:					str   =       attention_probs_dropout_prob

										snake_case_				:					Optional[int]   =       context_length
										snake_case_				:					Dict   =       prediction_length + label_length
										snake_case_				:					Dict   =       label_length

										snake_case_				:					Union[str, Any]   =       moving_average
										snake_case_				:					int   =       autocorrelation_factor

							def 							_A	(		self			:Union[str, Any]				)				->  str:


										'''simple docstring'''




										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 							_A	(		self			:Optional[int]       ,							lowerCAmelCase__			:Union[str, Any]				)				->  List[Any]:


										'''simple docstring'''




										snake_case_				:					Union[str, Any]   =       config.context_length + max(config.lags_sequence				)

										snake_case_				:					Union[str, Any]   =       ids_tensor([self.batch_size, 1]       ,							config.cardinality[0]				)
										snake_case_				:					Union[str, Any]   =       floats_tensor([self.batch_size, _past_length, config.num_time_features]				)
										snake_case_				:					Any   =       floats_tensor([self.batch_size, _past_length]				)
										snake_case_				:					List[str]   =       floats_tensor([self.batch_size, _past_length]				) > 0.5

										# decoder inputs
										snake_case_				:					Tuple   =       floats_tensor([self.batch_size, config.prediction_length, config.num_time_features]				)
										snake_case_				:					Optional[Any]   =       floats_tensor([self.batch_size, config.prediction_length]				)

										snake_case_				:					Optional[Any]   =       {
										    "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 							_A	(		self			:Optional[int]				)				->  Dict:


										'''simple docstring'''




										snake_case_				:					Optional[int]   =       self.get_config()
										snake_case_				:					Any   =       self.prepare_autoformer_inputs_dict(lowerCAmelCase__				)
										return config, inputs_dict

							def 							_A	(		self			:Union[str, Any]				)				->  Optional[Any]:


										'''simple docstring'''




										snake_case_,	snake_case_				:					Optional[int]   =       self.prepare_config_and_inputs()
										return config, inputs_dict






							def 							_A	(		self			:Optional[int]       ,							lowerCAmelCase__			:Union[str, Any]       ,							lowerCAmelCase__			:Optional[Any]				)				->  Union[str, Any]:


										'''simple docstring'''




										snake_case_				:					int   =       AutoformerModel(config=lowerCAmelCase__				).to(lowerCAmelCase__				).eval()
										snake_case_				:					Union[str, Any]   =       model(**lowerCAmelCase__				)

										snake_case_				:					Dict   =       outputs.encoder_last_hidden_state
										snake_case_				:					Optional[Any]   =       outputs.last_hidden_state

										with tempfile.TemporaryDirectory() as tmpdirname:
													snake_case_				:					str   =       model.get_encoder()
													encoder.save_pretrained(lowerCAmelCase__				)
													snake_case_				:					List[str]   =       AutoformerEncoder.from_pretrained(lowerCAmelCase__				).to(lowerCAmelCase__				)

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

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

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

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

										snake_case_				:					Union[str, Any]   =       decoder(
										    trend=lowerCAmelCase__       ,							inputs_embeds=lowerCAmelCase__       ,							encoder_hidden_states=lowerCAmelCase__       ,							)[0]

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







@require_torch
class    A_	(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 							_A	(		self			:int				)				->  List[Any]:


										'''simple docstring'''




										snake_case_				:					Optional[int]   =       AutoformerModelTester(self				)
										snake_case_				:					Optional[Any]   =       ConfigTester(self       ,							config_class=lowerCAmelCase__       ,							has_text_modality=lowerCAmelCase__				)

							def 							_A	(		self			:Tuple				)				->  Dict:


										'''simple docstring'''




										self.config_tester.run_common_tests()

							def 							_A	(		self			:Optional[int]				)				->  Union[str, Any]:


										'''simple docstring'''




										snake_case_,	snake_case_				:					List[Any]   =       self.model_tester.prepare_config_and_inputs()
										for model_class in self.all_model_classes:
													snake_case_				:					Any   =       model_class(lowerCAmelCase__				)

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

							def 							_A	(		self			:Optional[int]				)				->  str:


										'''simple docstring'''




										snake_case_				:					Dict   =       self.model_tester.prepare_config_and_inputs_for_common()
										self.model_tester.check_encoder_decoder_model_standalone(*lowerCAmelCase__				)

							@unittest.skip(reason="Model has no tokens embeddings"				)
							def 							_A	(		self			:Optional[int]				)				->  Optional[Any]:


										'''simple docstring'''




										pass

							def 							_A	(		self			:Dict				)				->  Union[str, Any]:


										'''simple docstring'''




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

							def 							_A	(		self			:Union[str, Any]				)				->  Dict:


										'''simple docstring'''




										snake_case_,	snake_case_				:					str   =       self.model_tester.prepare_config_and_inputs_for_common()

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

													snake_case_				:					Optional[int]   =       [
													    "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(lowerCAmelCase__				)]       ,							lowerCAmelCase__				)

							def 							_A	(		self			:Dict				)				->  Union[str, Any]:


										'''simple docstring'''




										snake_case_,	snake_case_				:					Dict   =       self.model_tester.prepare_config_and_inputs_for_common()
										snake_case_				:					List[str]   =       True

										snake_case_				:					Dict   =       getattr(self.model_tester       ,							"seq_length"       ,							lowerCAmelCase__				)
										snake_case_				:					str   =       getattr(self.model_tester       ,							"decoder_seq_length"       ,							lowerCAmelCase__				)
										snake_case_				:					int   =       getattr(self.model_tester       ,							"encoder_seq_length"       ,							lowerCAmelCase__				)
										snake_case_				:					Tuple   =       getattr(self.model_tester       ,							"d_model"       ,							lowerCAmelCase__				)
										snake_case_				:					int   =       getattr(self.model_tester       ,							"num_attention_heads"       ,							lowerCAmelCase__				)
										snake_case_				:					Optional[int]   =       d_model // num_attention_heads

										for model_class in self.all_model_classes:
													snake_case_				:					int   =       True
													snake_case_				:					Dict   =       False
													snake_case_				:					Optional[Any]   =       True
													snake_case_				:					Optional[Any]   =       model_class(lowerCAmelCase__				)
													model.to(lowerCAmelCase__				)
													model.eval()
													with torch.no_grad():
																snake_case_				:					List[str]   =       model(**self._prepare_for_class(lowerCAmelCase__       ,							lowerCAmelCase__				)				)
													snake_case_				:					Optional[int]   =       outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
													self.assertEqual(len(lowerCAmelCase__				)       ,							self.model_tester.num_hidden_layers				)

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

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

													snake_case_				:					Dict   =       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(lowerCAmelCase__       ,							lowerCAmelCase__				)

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

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

										snake_case_				:					Optional[Any]   =       outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions

										self.assertEqual(len(lowerCAmelCase__				)       ,							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 							_A	(		self			:List[Any]				)				->  List[str]:


										'''simple docstring'''




										super().test_retain_grad_hidden_states_attentions()

def 	__UpperCAmelCase       ( __magic_name__="train-batch.pt"						)->    int:



			"""simple docstring"""



			snake_case_				:					Any   =       hf_hub_download(repo_id="hf-internal-testing/tourism-monthly-batch"     ,filename=__magic_name__     ,repo_type="dataset"						)
			snake_case_				:					str   =       torch.load(__magic_name__     ,map_location=__magic_name__						)
			return batch







@require_torch
@slow
class    A_	(unittest.TestCase							):
							"""simple docstring"""




							def 							_A	(		self			:Dict				)				->  Tuple:


										'''simple docstring'''




										snake_case_				:					Union[str, Any]   =       AutoformerModel.from_pretrained("huggingface/autoformer-tourism-monthly"				).to(lowerCAmelCase__				)
										snake_case_				:					int   =       prepare_batch()

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

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

										snake_case_				:					Any   =       torch.tensor(
										    [[0.3_5_9_3, -1.3_3_9_8, 0.6_3_3_0], [0.2_2_7_9, 1.5_3_9_6, -0.1_7_9_2], [0.0_4_5_0, 1.3_2_2_5, -0.2_3_3_5]]       ,							device=lowerCAmelCase__				)
										self.assertTrue(torch.allclose(output[0, :3, :3]       ,							lowerCAmelCase__       ,							atol=lowerCAmelCase__				)				)

							def 							_A	(		self			:Union[str, Any]				)				->  str:


										'''simple docstring'''




										snake_case_				:					str   =       AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly"				).to(lowerCAmelCase__				)
										snake_case_				:					Tuple   =       prepare_batch("val-batch.pt"				)
										with torch.no_grad():
													snake_case_				:					Any   =       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
										snake_case_				:					Optional[int]   =       torch.Size((64, model.config.context_length, model.config.d_model)				)
										self.assertEqual(output.shape       ,							lowerCAmelCase__				)

										snake_case_				:					List[Any]   =       torch.tensor(
										    [[-0.0_7_3_4, -0.9_0_3_6, 0.8_3_5_8], [4.7_1_8_6, 2.4_1_1_3, 1.9_5_8_1], [1.7_9_5_3, 2.3_5_5_8, 1.2_9_7_0]]       ,							device=lowerCAmelCase__				)
										self.assertTrue(torch.allclose(output[0, :3, :3]       ,							lowerCAmelCase__       ,							atol=lowerCAmelCase__				)				)






							def 							_A	(		self			:List[str]				)				->  List[Any]:


										'''simple docstring'''




										snake_case_				:					str   =       AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly"				).to(lowerCAmelCase__				)
										snake_case_				:					int   =       prepare_batch("val-batch.pt"				)
										with torch.no_grad():
													snake_case_				:					Union[str, Any]   =       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"]       ,							)
										snake_case_				:					Tuple   =       torch.Size((64, model.config.num_parallel_samples, model.config.prediction_length)				)
										self.assertEqual(outputs.sequences.shape       ,							lowerCAmelCase__				)

										snake_case_				:					str   =       torch.tensor([3_1_3_0.6_7_6_3, 4_0_5_6.5_2_9_3, 7_0_5_3.0_7_8_6]       ,							device=lowerCAmelCase__				)
										snake_case_				:					Union[str, Any]   =       outputs.sequences.mean(dim=1				)
										self.assertTrue(torch.allclose(mean_prediction[0, -3:]       ,							lowerCAmelCase__       ,							rtol=1E-1				)				)












'''simple docstring'''




import inspect
import re

from transformers.utils import direct_transformers_import


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_config_docstrings.py
__lowerCamelCase   :					Any   							=					'''src/transformers'''


# This is to make sure the transformers module imported is the one in the repo.
__lowerCamelCase   :					List[str]   							=					direct_transformers_import(PATH_TO_TRANSFORMERS)

__lowerCamelCase   :					Optional[Any]   							=					transformers.models.auto.configuration_auto.CONFIG_MAPPING

# Regex pattern used to find the checkpoint mentioned in the docstring of `config_class`.
# For example, `[bert-base-uncased](https://huggingface.co/bert-base-uncased)`
__lowerCamelCase   :					Union[str, Any]   							=					re.compile(R'''\[(.+?)\]\((https://huggingface\.co/.+?)\)''')


__lowerCamelCase   :					Any   							=					{
    '''DecisionTransformerConfig''',
    '''EncoderDecoderConfig''',
    '''MusicgenConfig''',
    '''RagConfig''',
    '''SpeechEncoderDecoderConfig''',
    '''TimmBackboneConfig''',
    '''VisionEncoderDecoderConfig''',
    '''VisionTextDualEncoderConfig''',
    '''LlamaConfig''',
}

def 	__UpperCAmelCase       ( __magic_name__						)->    List[Any]:



			"""simple docstring"""



			snake_case_				:					Tuple   =       None

			# source code of `config_class`
			snake_case_				:					List[Any]   =       inspect.getsource(__magic_name__						)
			snake_case_				:					List[str]   =       _re_checkpoint.findall(__magic_name__						)

			# Each `checkpoint` is a tuple of a checkpoint name and a checkpoint link.
			# For example, `('bert-base-uncased', 'https://huggingface.co/bert-base-uncased')`
			for ckpt_name, ckpt_link in checkpoints:
						# allow the link to end with `/`
						if ckpt_link.endswith("/"						):
									snake_case_				:					Optional[Any]   =       ckpt_link[:-1]

						# verify the checkpoint name corresponds to the checkpoint link
						snake_case_				:					str   =       F'''https://huggingface.co/{ckpt_name}'''
						if ckpt_link == ckpt_link_from_name:
									snake_case_				:					Dict   =       ckpt_name
									break

			return checkpoint

def 	__UpperCAmelCase       ( )->    Dict:



			"""simple docstring"""



			snake_case_				:					Optional[int]   =       []

			for config_class in list(CONFIG_MAPPING.values()						):
						# Skip deprecated models
						if "models.deprecated" in config_class.__module__:
									continue
						snake_case_				:					str   =       get_checkpoint_from_config_class(__magic_name__						)

						snake_case_				:					Union[str, Any]   =       config_class.__name__
						if checkpoint is None and name not in CONFIG_CLASSES_TO_IGNORE_FOR_DOCSTRING_CHECKPOINT_CHECK:
									configs_without_checkpoint.append(__magic_name__						)

			if len(__magic_name__						) > 0:
						snake_case_				:					Tuple   =       "\n".join(sorted(__magic_name__						)						)
						raise ValueError(F'''The following configurations don\'t contain any valid checkpoint:\n{message}'''						)


if __name__ == "__main__":
		check_config_docstrings_have_checkpoints()




