


'''simple docstring'''



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
__A	="src/transformers"


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

__A	=transformers.models.auto.configuration_auto.CONFIG_MAPPING

__A	={
    # 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     _UpperCamelCase      (		UpperCamelCase__ ,      UpperCamelCase__ ,      UpperCamelCase__ ,      UpperCamelCase__					):
			UpperCAmelCase__  :					Union[str, Any]        =     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__  :					List[str]        =     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}"''' ,      UpperCamelCase__ ,      )
									    is not None
									):
												UpperCAmelCase__  :					Optional[Any]        =     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__  :					int        =     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__  :					Dict        =     [
			    """bos_index""",
			    """eos_index""",
			    """pad_index""",
			    """unk_index""",
			    """mask_index""",
			    """image_size""",
			    """use_cache""",
			    """out_features""",
			    """out_indices""",
			]
			UpperCAmelCase__  :					List[Any]        =     ["""encoder_no_repeat_ngram_size"""]

			# Special cases to be allowed
			UpperCAmelCase__  :					Dict        =     True
			if not attribute_used:
						UpperCAmelCase__  :					Tuple        =     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__  :					Any        =     True
									elif attribute in ["tie_word_embeddings"] and default_value is False:
												UpperCAmelCase__  :					Union[str, Any]        =     True

									# Allow cases without checking the default value in the configuration class
									elif attribute in attributes_to_allow + attributes_used_in_generation:
												UpperCAmelCase__  :					str        =     True
									elif attribute.endswith("""_token_id"""					):
												UpperCAmelCase__  :					str        =     True

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

			return attribute_used or case_allowed







def     _UpperCamelCase      (		UpperCamelCase__					):
			UpperCAmelCase__  :					Tuple        =     dict(inspect.signature(config_class.__init__					).parameters					)
			UpperCAmelCase__  :					List[str]        =     [x for x in list(signature.keys()					) if x not in ["""self""", """kwargs"""]]
			UpperCAmelCase__  :					List[Any]        =     [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__  :					Dict        =     {}
			if len(config_class.attribute_map					) > 0:
						UpperCAmelCase__  :					Optional[int]        =     {v: k for k, v in config_class.attribute_map.items()}

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

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

			UpperCAmelCase__  :					str        =     []
			for config_param, default_value in zip(UpperCamelCase__ ,      UpperCamelCase__					):
						# `attributes` here is all the variant names for `config_param`
						UpperCAmelCase__  :					Union[str, 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(UpperCamelCase__ ,      UpperCamelCase__ ,      UpperCamelCase__ ,      UpperCamelCase__					):
									unused_attributes.append(attributes[0]					)

			return sorted(UpperCamelCase__					)







def     _UpperCamelCase      (		):
			UpperCAmelCase__  :					Dict        =     {}
			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__  :					Any        =     [
						    cls
						    for name, cls in inspect.getmembers(
						        inspect.getmodule(_config_class					) ,      lambda UpperCamelCase__					: inspect.isclass(UpperCamelCase__					)
						        and issubclass(UpperCamelCase__ ,      UpperCamelCase__					)
						        and inspect.getmodule(UpperCamelCase__					) == inspect.getmodule(_config_class					) ,      )
						]
						for config_class in config_classes_in_module:
									UpperCAmelCase__  :					int        =     check_config_attributes_being_used(UpperCamelCase__					)
									if len(UpperCamelCase__					) > 0:
												UpperCAmelCase__  :					str        =     unused_attributes

			if len(UpperCamelCase__					) > 0:
						UpperCAmelCase__  :					str        =     """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(UpperCamelCase__					)


if __name__ == "__main__":
		check_config_attributes()



'''simple docstring'''



import re

import jax.numpy as jnp
from flax.traverse_util import flatten_dict, unflatten_dict
from jax.random import PRNGKey

from ..utils import logging


__A	=logging.get_logger(__name__)







def     _UpperCamelCase      (		UpperCamelCase__					):
			UpperCAmelCase__  :					List[str]        =     R"""\w+[.]\d+"""
			UpperCAmelCase__  :					List[Any]        =     re.findall(UpperCamelCase__ ,      UpperCamelCase__					)
			for pat in pats:
						UpperCAmelCase__  :					str        =     key.replace(UpperCamelCase__ ,      """_""".join(pat.split("""."""					)					)					)
			return key







def     _UpperCamelCase      (		UpperCamelCase__ ,      UpperCamelCase__ ,      UpperCamelCase__					):
			UpperCAmelCase__  :					str        =     pt_tuple_key[:-1] + ("""scale""",)
			if (
			    any("""norm""" in str_ for str_ in pt_tuple_key					)
			    and (pt_tuple_key[-1] == "bias")
			    and (pt_tuple_key[:-1] + ("bias",) not in random_flax_state_dict)
			    and (pt_tuple_key[:-1] + ("scale",) in random_flax_state_dict)
			):
						UpperCAmelCase__  :					Union[str, Any]        =     pt_tuple_key[:-1] + ("""scale""",)
						return renamed_pt_tuple_key, pt_tensor
			elif pt_tuple_key[-1] in ["weight", "gamma"] and pt_tuple_key[:-1] + ("scale",) in random_flax_state_dict:
						UpperCAmelCase__  :					str        =     pt_tuple_key[:-1] + ("""scale""",)
						return renamed_pt_tuple_key, pt_tensor

			# embedding
			if pt_tuple_key[-1] == "weight" and pt_tuple_key[:-1] + ("embedding",) in random_flax_state_dict:
						UpperCAmelCase__  :					Union[str, Any]        =     pt_tuple_key[:-1] + ("""embedding""",)
						return renamed_pt_tuple_key, pt_tensor

			# conv layer
			UpperCAmelCase__  :					Any        =     pt_tuple_key[:-1] + ("""kernel""",)
			if pt_tuple_key[-1] == "weight" and pt_tensor.ndim == 4:
						UpperCAmelCase__  :					Any        =     pt_tensor.transpose(2 ,      3 ,      1 ,      0					)
						return renamed_pt_tuple_key, pt_tensor

			# linear layer
			UpperCAmelCase__  :					Optional[int]        =     pt_tuple_key[:-1] + ("""kernel""",)
			if pt_tuple_key[-1] == "weight":
						UpperCAmelCase__  :					Any        =     pt_tensor.T
						return renamed_pt_tuple_key, pt_tensor

			# old PyTorch layer norm weight
			UpperCAmelCase__  :					Optional[Any]        =     pt_tuple_key[:-1] + ("""weight""",)
			if pt_tuple_key[-1] == "gamma":
						return renamed_pt_tuple_key, pt_tensor

			# old PyTorch layer norm bias
			UpperCAmelCase__  :					Dict        =     pt_tuple_key[:-1] + ("""bias""",)
			if pt_tuple_key[-1] == "beta":
						return renamed_pt_tuple_key, pt_tensor

			return pt_tuple_key, pt_tensor







def     _UpperCamelCase      (		UpperCamelCase__ ,      UpperCamelCase__ ,      UpperCamelCase__=4_2					):
			# Step 1: Convert pytorch tensor to numpy
			UpperCAmelCase__  :					str        =     {k: v.numpy() for k, v in pt_state_dict.items()}

			# Step 2: Since the model is stateless, get random Flax params
			UpperCAmelCase__  :					str        =     flax_model.init_weights(PRNGKey(UpperCamelCase__					)					)

			UpperCAmelCase__  :					Union[str, Any]        =     flatten_dict(UpperCamelCase__					)
			UpperCAmelCase__  :					int        =     {}

			# Need to change some parameters name to match Flax names
			for pt_key, pt_tensor in pt_state_dict.items():
						UpperCAmelCase__  :					str        =     rename_key(UpperCamelCase__					)
						UpperCAmelCase__  :					Optional[Any]        =     tuple(renamed_pt_key.split("""."""					)					)

						# Correctly rename weight parameters
						UpperCAmelCase__   ,       UpperCAmelCase__  :					Tuple        =     rename_key_and_reshape_tensor(UpperCamelCase__ ,      UpperCamelCase__ ,      UpperCamelCase__					)

						if flax_key in random_flax_state_dict:
									if flax_tensor.shape != random_flax_state_dict[flax_key].shape:
												raise ValueError(
												    f'''PyTorch checkpoint seems to be incorrect. Weight {pt_key} was expected to be of shape '''
												    f'''{random_flax_state_dict[flax_key].shape}, but is {flax_tensor.shape}.'''					)

        # also add unexpected weight so that warning is thrown
						UpperCAmelCase__  :					str        =     jnp.asarray(UpperCamelCase__					)

			return unflatten_dict(UpperCamelCase__					)