


import inspect
import os
import re

from transformers.configuration_utils import PretrainedConfig
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       		=    """src/transformers"""


# This is to make sure the transformers module imported is the one in the repo.
lowerCAmelCase       		=    direct_transformers_import(PATH_TO_TRANSFORMERS)

lowerCAmelCase       		=    transformers.models.auto.configuration_auto.CONFIG_MAPPING

lowerCAmelCase       		=    {
    # used to compute the property `self.chunk_length`
    """EncodecConfig""": ["""overlap"""],
    # used as `self.bert_model = BertModel(config, ...)`
    """DPRConfig""": True,
    # not used in modeling files, but it's an important information
    """FSMTConfig""": ["""langs"""],
    # used internally in the configuration class file
    """GPTNeoConfig""": ["""attention_types"""],
    # used internally in the configuration class file
    """EsmConfig""": ["""is_folding_model"""],
    # used during training (despite we don't have training script for these models yet)
    """Mask2FormerConfig""": ["""ignore_value"""],
    # `ignore_value` used during training (despite we don't have training script for these models yet)
    # `norm` used in conversion script (despite not using in the modeling file)
    """OneFormerConfig""": ["""ignore_value""", """norm"""],
    # used during preprocessing and collation, see `collating_graphormer.py`
    """GraphormerConfig""": ["""spatial_pos_max"""],
    # used internally in the configuration class file
    """T5Config""": ["""feed_forward_proj"""],
    # used internally in the configuration class file
    # `tokenizer_class` get default value `T5Tokenizer` intentionally
    """MT5Config""": ["""feed_forward_proj""", """tokenizer_class"""],
    """UMT5Config""": ["""feed_forward_proj""", """tokenizer_class"""],
    # used internally in the configuration class file
    """LongT5Config""": ["""feed_forward_proj"""],
    # used internally in the configuration class file
    """SwitchTransformersConfig""": ["""feed_forward_proj"""],
    # having default values other than `1e-5` - we can't fix them without breaking
    """BioGptConfig""": ["""layer_norm_eps"""],
    # having default values other than `1e-5` - we can't fix them without breaking
    """GLPNConfig""": ["""layer_norm_eps"""],
    # having default values other than `1e-5` - we can't fix them without breaking
    """SegformerConfig""": ["""layer_norm_eps"""],
    # having default values other than `1e-5` - we can't fix them without breaking
    """CvtConfig""": ["""layer_norm_eps"""],
    # having default values other than `1e-5` - we can't fix them without breaking
    """PerceiverConfig""": ["""layer_norm_eps"""],
    # used internally to calculate the feature size
    """InformerConfig""": ["""num_static_real_features""", """num_time_features"""],
    # used internally to calculate the feature size
    """TimeSeriesTransformerConfig""": ["""num_static_real_features""", """num_time_features"""],
    # used internally to calculate the feature size
    """AutoformerConfig""": ["""num_static_real_features""", """num_time_features"""],
    # used internally to calculate `mlp_dim`
    """SamVisionConfig""": ["""mlp_ratio"""],
    # For (head) training, but so far not implemented
    """ClapAudioConfig""": ["""num_classes"""],
    # Not used, but providing useful information to users
    """SpeechT5HifiGanConfig""": ["""sampling_rate"""],
}


# TODO (ydshieh): Check the failing cases, try to fix them or move some cases to the above block once we are sure
SPECIAL_CASES_TO_ALLOW.update(
    {
        """CLIPSegConfig""": True,
        """DeformableDetrConfig""": True,
        """DetaConfig""": True,
        """DinatConfig""": True,
        """DonutSwinConfig""": True,
        """EfficientFormerConfig""": True,
        """FSMTConfig""": True,
        """JukeboxConfig""": True,
        """LayoutLMv2Config""": True,
        """MaskFormerSwinConfig""": True,
        """MT5Config""": True,
        """NatConfig""": True,
        """OneFormerConfig""": True,
        """PerceiverConfig""": True,
        """RagConfig""": True,
        """SpeechT5Config""": True,
        """SwinConfig""": True,
        """Swin2SRConfig""": True,
        """Swinv2Config""": True,
        """SwitchTransformersConfig""": True,
        """TableTransformerConfig""": True,
        """TapasConfig""": True,
        """TransfoXLConfig""": True,
        """UniSpeechConfig""": True,
        """UniSpeechSatConfig""": True,
        """WavLMConfig""": True,
        """WhisperConfig""": True,
        # TODO: @Arthur (for `alignment_head` and `alignment_layer`)
        """JukeboxPriorConfig""": True,
        # TODO: @Younes (for `is_decoder`)
        """Pix2StructTextConfig""": True,
    }
)




def     __SCREAMING_SNAKE_CASE							(       lowercase_      ,       lowercase_      ,       lowercase_      ,       lowercase_      )		->     Optional[Any]:




						'''simple docstring'''







						__UpperCAmelCase			:							str	    =	False
						for attribute in attributes:
												for modeling_source in source_strings:
																		# check if we can find `config.xxx`, `getattr(config, "xxx", ...)` or `getattr(self.config, "xxx", ...)`
																		if (
																		    f"config.{attribute}" in modeling_source
																		    or f"getattr(config, \"{attribute}\"" in modeling_source
																		    or f"getattr(self.config, \"{attribute}\"" in modeling_source
																		):
																								__UpperCAmelCase			:							Dict	    =	True
																		# Deal with multi-line cases
																		elif (
																		    re.search(
																		        rf"getattr[ \t\v\n\r\f]*\([ \t\v\n\r\f]*(self\.)?config,[ \t\v\n\r\f]*\"{attribute}\""      ,       lowercase_      ,       )
																		    is not None
																		):
																								__UpperCAmelCase			:							Tuple	    =	True
																		# `SequenceSummary` is called with `SequenceSummary(config)`
																		elif attribute in [
																		    "summary_type",
																		    "summary_use_proj",
																		    "summary_activation",
																		    "summary_last_dropout",
																		    "summary_proj_to_labels",
																		    "summary_first_dropout",
																		]:
																								if "SequenceSummary" in modeling_source:
																														__UpperCAmelCase			:							Any	    =	True
																		if attribute_used:
																								break
												if attribute_used:
																		break

    # common and important attributes, even if they do not always appear in the modeling files
						__UpperCAmelCase			:							str	    =	[
						    '''bos_index''',
						    '''eos_index''',
						    '''pad_index''',
						    '''unk_index''',
						    '''mask_index''',
						    '''image_size''',
						    '''use_cache''',
						    '''out_features''',
						    '''out_indices''',
						]
						__UpperCAmelCase			:							str	    =	['''encoder_no_repeat_ngram_size''']

						# Special cases to be allowed
						__UpperCAmelCase			:							List[Any]	    =	True
						if not attribute_used:
												__UpperCAmelCase			:							List[str]	    =	False
												for attribute in attributes:
																		# Allow if the default value in the configuration class is different from the one in `PretrainedConfig`
																		if attribute in ["is_encoder_decoder"] and default_value is True:
																								__UpperCAmelCase			:							int	    =	True
																		elif attribute in ["tie_word_embeddings"] and default_value is False:
																								__UpperCAmelCase			:							List[Any]	    =	True

																		# Allow cases without checking the default value in the configuration class
																		elif attribute in attributes_to_allow + attributes_used_in_generation:
																								__UpperCAmelCase			:							Tuple	    =	True
																		elif attribute.endswith('''_token_id'''      ):
																								__UpperCAmelCase			:							int	    =	True

																		# configuration class specific cases
																		if not case_allowed:
																								__UpperCAmelCase			:							List[Any]	    =	SPECIAL_CASES_TO_ALLOW.get(config_class.__name__      ,       []      )
																								__UpperCAmelCase			:							str	    =	allowed_cases is True or attribute in allowed_cases

						return attribute_used or case_allowed




def     __SCREAMING_SNAKE_CASE							(       lowercase_      )		->     List[Any]:




						'''simple docstring'''







						__UpperCAmelCase			:							Tuple	    =	dict(inspect.signature(config_class.__init__      ).parameters      )
						__UpperCAmelCase			:							Union[str, Any]	    =	[x for x in list(signature.keys()      ) if x not in ['''self''', '''kwargs''']]
						__UpperCAmelCase			:							str	    =	[signature[param].default for param in parameter_names]

						# If `attribute_map` exists, an attribute can have different names to be used in the modeling files, and as long
						# as one variant is used, the test should pass
						__UpperCAmelCase			:							Union[str, Any]	    =	{}
						if len(config_class.attribute_map      ) > 0:
												__UpperCAmelCase			:							List[Any]	    =	{v: k for k, v in config_class.attribute_map.items()}

						# Get the path to modeling source files
						__UpperCAmelCase			:							List[Any]	    =	inspect.getsourcefile(lowercase_      )
						__UpperCAmelCase			:							Optional[Any]	    =	os.path.dirname(lowercase_      )
						# Let's check against all frameworks: as long as one framework uses an attribute, we are good.
						__UpperCAmelCase			:							Optional[int]	    =	[os.path.join(lowercase_      ,       lowercase_      ) for fn in os.listdir(lowercase_      ) if fn.startswith('''modeling_'''      )]

						# Get the source code strings
						__UpperCAmelCase			:							str	    =	[]
						for path in modeling_paths:
												if os.path.isfile(lowercase_      ):
																		with open(lowercase_      ) as fp:
																								modeling_sources.append(fp.read()      )

						__UpperCAmelCase			:							Optional[Any]	    =	[]
						for config_param, default_value in zip(lowercase_      ,       lowercase_      ):
												# `attributes` here is all the variant names for `config_param`
												__UpperCAmelCase			:							Optional[Any]	    =	[config_param]
												# some configuration classes have non-empty `attribute_map`, and both names could be used in the
												# corresponding modeling files. As long as one of them appears, it is fine.
												if config_param in reversed_attribute_map:
																		attributes.append(reversed_attribute_map[config_param]      )

												if not check_attribute_being_used(lowercase_      ,       lowercase_      ,       lowercase_      ,       lowercase_      ):
																		unused_attributes.append(attributes[0]      )

						return sorted(lowercase_      )




def     __SCREAMING_SNAKE_CASE							(       )		->     Tuple:




						'''simple docstring'''







						__UpperCAmelCase			:							Tuple	    =	{}
						for _config_class in list(CONFIG_MAPPING.values()      ):
												# Skip deprecated models
												if "models.deprecated" in _config_class.__module__:
																		continue
												# Some config classes are not in `CONFIG_MAPPING` (e.g. `CLIPVisionConfig`, `Blip2VisionConfig`, etc.)
												__UpperCAmelCase			:							List[Any]	    =	[
												    cls
												    for name, cls in inspect.getmembers(
												        inspect.getmodule(_config_class      )      ,       lambda lowercase_      : inspect.isclass(lowercase_      )
												        and issubclass(lowercase_      ,       lowercase_      )
												        and inspect.getmodule(lowercase_      ) == inspect.getmodule(_config_class      )      ,       )
												]
												for config_class in config_classes_in_module:
																		__UpperCAmelCase			:							int	    =	check_config_attributes_being_used(lowercase_      )
																		if len(lowercase_      ) > 0:
																								__UpperCAmelCase			:							Optional[int]	    =	unused_attributes

						if len(lowercase_      ) > 0:
												__UpperCAmelCase			:							Tuple	    =	'''The following configuration classes contain unused attributes in the corresponding modeling files:\n'''
												for name, attributes in configs_with_unused_attributes.items():
																		error += f"{name}: {attributes}\n"

												raise ValueError(lowercase_      )


if __name__ == "__main__":
				check_config_attributes()





def     __SCREAMING_SNAKE_CASE							(       )		->     Optional[int]:




						'''simple docstring'''







						__UpperCAmelCase			:							str	    =	[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

						__UpperCAmelCase			:							Union[str, Any]	    =	6
						__UpperCAmelCase			:							Optional[Any]	    =	1
						__UpperCAmelCase			:							Tuple	    =	1901

						__UpperCAmelCase			:							Any	    =	0

						while year < 2001:
												day += 7

												if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
																		if day > days_per_month[month - 1] and month != 2:
																								month += 1
																								__UpperCAmelCase			:							Optional[int]	    =	day - days_per_month[month - 2]
																		elif day > 29 and month == 2:
																								month += 1
																								__UpperCAmelCase			:							Optional[Any]	    =	day - 29
												else:
																		if day > days_per_month[month - 1]:
																								month += 1
																								__UpperCAmelCase			:							Optional[Any]	    =	day - days_per_month[month - 2]

												if month > 12:
																		year += 1
																		__UpperCAmelCase			:							int	    =	1

												if year < 2001 and day == 1:
																		sundays += 1
						return sundays


if __name__ == "__main__":
				print(solution())

