





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	:					List[str]			  =					"""src/transformers"""


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

__lowerCamelCase	:					Dict			  =					transformers.models.auto.configuration_auto.CONFIG_MAPPING

__lowerCamelCase	:					List[str]			  =					{
    # 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 		A_    (					_lowerCAmelCase							,       _lowerCAmelCase							,       _lowerCAmelCase							,       _lowerCAmelCase					)						->			str:
 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     : Union[str, Any]	     =       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}\""""							,       _lowerCAmelCase							,       )
       is not None
   ):
    UpperCamelCase     : List[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     : Optional[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     : Any	     =       [
     "bos_index",
     "eos_index",
     "pad_index",
     "unk_index",
     "mask_index",
     "image_size",
     "use_cache",
     "out_features",
     "out_indices",
 ]
 UpperCamelCase     : Union[str, Any]	     =       ["encoder_no_repeat_ngram_size"]

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

   # Allow cases without checking the default value in the configuration class
   elif attribute in attributes_to_allow + attributes_used_in_generation:
    UpperCamelCase     : Optional[int]	     =       True
   elif attribute.endswith("_token_id"					):
    UpperCamelCase     : Tuple	     =       True

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

 return attribute_used or case_allowed



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

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

 # Get the source code strings
 UpperCamelCase     : List[Any]	     =       []
 for path in modeling_paths:
  if os.path.isfile(_lowerCAmelCase					):
   with open(_lowerCAmelCase					) as fp:
    modeling_sources.append(fp.read()					)

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

 return sorted(_lowerCAmelCase					)



def 		A_    (					)						->			Optional[Any]:
 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     : Union[str, Any]	     =       [
      cls
      for name, cls in inspect.getmembers(
          inspect.getmodule(_config_class					)							,       lambda _lowerCAmelCase					: inspect.isclass(_lowerCAmelCase					)
          and issubclass(_lowerCAmelCase							,       _lowerCAmelCase					)
          and inspect.getmodule(_lowerCAmelCase					) == inspect.getmodule(_config_class					)							,       )
  ]
  for config_class in config_classes_in_module:
   UpperCamelCase     : Optional[int]	     =       check_config_attributes_being_used(_lowerCAmelCase					)
   if len(_lowerCAmelCase					) > 0:
    UpperCamelCase     : Tuple	     =       unused_attributes

 if len(_lowerCAmelCase					) > 0:
  UpperCamelCase     : Dict	     =       "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(_lowerCAmelCase					)


if __name__ == "__main__":
    check_config_attributes()







from typing import Callable, Dict, Optional, Tuple

import torch
from torch import nn
from torch.distributions import (
    AffineTransform,
    Distribution,
    Independent,
    NegativeBinomial,
    Normal,
    StudentT,
    TransformedDistribution,
)



class  A__       (	__snake_case      ):





      def __init__(			self	,							A_	,							A_=None	,							A_=None	,							A_=0       ):
       '''simple docstring'''




       UpperCamelCase     : Union[str, Any]	     =       1.0 if scale is None else scale
       UpperCamelCase     : Optional[int]	     =       0.0 if loc is None else loc

       super().__init__(A_	,							[AffineTransform(loc=self.loc	,							scale=self.scale	,							event_dim=A_       )]       )





      @property
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       return self.base_dist.mean * self.scale + self.loc





      @property
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       return self.base_dist.variance * self.scale**2





      @property
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       return self.variance.sqrt()



class  A__       (	nn.Module      ):





      def __init__(			self	,							A_	,							A_	,							A_	,							**A_       ):
       '''simple docstring'''




       super().__init__(**A_       )
       UpperCamelCase     : Union[str, Any]	     =       args_dim
       UpperCamelCase     : str	     =       nn.ModuleList([nn.Linear(A_	,							A_       ) for dim in args_dim.values()]       )
       UpperCamelCase     : Union[str, Any]	     =       domain_map





      def 	__UpperCamelCase(			self	,							A_       ):
       '''simple docstring'''




       UpperCamelCase     : List[Any]	     =       [proj(A_       ) for proj in self.proj]

       return self.domain_map(*A_       )



class  A__       (	nn.Module      ):





      def __init__(			self	,							A_       ):
       '''simple docstring'''




       super().__init__()
       UpperCamelCase     : str	     =       function





      def 	__UpperCamelCase(			self	,							A_	,							*A_       ):
       '''simple docstring'''




       return self.function(A_	,							*A_       )



class  A__       :
      _UpperCAmelCase     :type
      _UpperCAmelCase     :int
      _UpperCAmelCase     :Dict[str, int]





      def __init__(			self	,							A_ = 1       ):
       '''simple docstring'''




       UpperCamelCase     : Tuple	     =       dim
       UpperCamelCase     : Union[str, Any]	     =       {k: dim * self.args_dim[k] for k in self.args_dim}





      def 	__UpperCamelCase(			self	,							A_       ):
       '''simple docstring'''




       if self.dim == 1:
        return self.distribution_class(*A_       )
       else:
        return Independent(self.distribution_class(*A_       )	,							1       )





      def 	__UpperCamelCase(			self	,							A_	,							A_ = None	,							A_ = None	,							):
       '''simple docstring'''




       UpperCamelCase     : str	     =       self._base_distribution(A_       )
       if loc is None and scale is None:
        return distr
       else:
        return AffineTransformed(A_	,							loc=A_	,							scale=A_	,							event_dim=self.event_dim       )





      @property
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       return () if self.dim == 1 else (self.dim,)





      @property
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       return len(self.event_shape       )





      @property
      def 	__UpperCamelCase(			self       ):
       '''simple docstring'''




       return 0.0





      def 	__UpperCamelCase(			self	,							A_       ):
       '''simple docstring'''




       return ParameterProjection(
           in_features=A_	,							args_dim=self.args_dim	,							domain_map=LambdaLayer(self.domain_map       )	,							)





      def 	__UpperCamelCase(			self	,							*A_       ):
       '''simple docstring'''




       raise NotImplementedError()





      @staticmethod
      def 	__UpperCamelCase(			A_       ):
       '''simple docstring'''




       return (x + torch.sqrt(torch.square(A_       ) + 4.0       )) / 2.0



class  A__       (	__snake_case      ):
      _UpperCAmelCase     :Dict[str, int]						   =       {"df": 1, "loc": 1, "scale": 1}
      _UpperCAmelCase     :type						   =       StudentT





      @classmethod
      def 	__UpperCamelCase(			cls	,							A_	,							A_	,							A_       ):
       '''simple docstring'''




       UpperCamelCase     : Optional[Any]	     =       cls.squareplus(A_       ).clamp_min(torch.finfo(scale.dtype       ).eps       )
       UpperCamelCase     : int	     =       2.0 + cls.squareplus(A_       )
       return df.squeeze(-1       ), loc.squeeze(-1       ), scale.squeeze(-1       )



class  A__       (	__snake_case      ):
      _UpperCAmelCase     :Dict[str, int]						   =       {"loc": 1, "scale": 1}
      _UpperCAmelCase     :type						   =       Normal





      @classmethod
      def 	__UpperCamelCase(			cls	,							A_	,							A_       ):
       '''simple docstring'''




       UpperCamelCase     : Dict	     =       cls.squareplus(A_       ).clamp_min(torch.finfo(scale.dtype       ).eps       )
       return loc.squeeze(-1       ), scale.squeeze(-1       )



class  A__       (	__snake_case      ):
      _UpperCAmelCase     :Dict[str, int]						   =       {"total_count": 1, "logits": 1}
      _UpperCAmelCase     :type						   =       NegativeBinomial





      @classmethod
      def 	__UpperCamelCase(			cls	,							A_	,							A_       ):
       '''simple docstring'''




       UpperCamelCase     : List[str]	     =       cls.squareplus(A_       )
       return total_count.squeeze(-1       ), logits.squeeze(-1       )





      def 	__UpperCamelCase(			self	,							A_       ):
       '''simple docstring'''




       UpperCamelCase     ,   UpperCamelCase     : Optional[int]	     =       distr_args
       if self.dim == 1:
        return self.distribution_class(total_count=A_	,							logits=A_       )
       else:
        return Independent(self.distribution_class(total_count=A_	,							logits=A_       )	,							1       )





      def 	__UpperCamelCase(			self	,							A_	,							A_ = None	,							A_ = None       ):
       '''simple docstring'''




       UpperCamelCase     ,   UpperCamelCase     : Any	     =       distr_args

       if scale is not None:
        # See scaling property of Gamma.
        logits += scale.log()

       return self._base_distribution((total_count, logits)       )
