
'''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__   :		Any 		='src/transformers'


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

A__   :		Any 		=transformers.models.auto.configuration_auto.CONFIG_MAPPING

A__   :		Optional[int] 		={
    # 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_     (						__SCREAMING_SNAKE_CASE						:  List[str]			,     __SCREAMING_SNAKE_CASE						:  Tuple			,     __SCREAMING_SNAKE_CASE						:  Union[str, Any]			,     __SCREAMING_SNAKE_CASE						:  List[Any] )				->       int:





  """simple docstring"""

  __A		:     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
      ):
        __A		:     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}\""			,     __SCREAMING_SNAKE_CASE			,     )
          is not None
      ):
        __A		:     Dict												=		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:
          __A		:     List[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
  __A		:     List[Any]												=		[
      """bos_index""",
      """eos_index""",
      """pad_index""",
      """unk_index""",
      """mask_index""",
      """image_size""",
      """use_cache""",
      """out_features""",
      """out_indices""",
  ]
  __A		:     List[Any]												=		["""encoder_no_repeat_ngram_size"""]

  # Special cases to be allowed
  __A		:     Optional[int]												=		True
  if not attribute_used:
    __A		:     Any												=		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:
        __A		:     str												=		True
      elif attribute in ["tie_word_embeddings"] and default_value is False:
        __A		:     List[str]												=		True

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

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

  return attribute_used or case_allowed







def        A_     (						__SCREAMING_SNAKE_CASE						:  Optional[int] )				->       Optional[Any]:





  """simple docstring"""

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

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

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

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

  return sorted(__SCREAMING_SNAKE_CASE )







def        A_     (						)				->       str:





  """simple docstring"""

  __A		:     List[Any]												=		{}
  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.)
    __A		:     List[Any]												=		[
        cls
        for name, cls in inspect.getmembers(
            inspect.getmodule(_config_class )			,     lambda __SCREAMING_SNAKE_CASE : inspect.isclass(__SCREAMING_SNAKE_CASE )
            and issubclass(__SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE )
            and inspect.getmodule(__SCREAMING_SNAKE_CASE ) == inspect.getmodule(_config_class )			,     )
    ]
    for config_class in config_classes_in_module:
      __A		:     int												=		check_config_attributes_being_used(__SCREAMING_SNAKE_CASE )
      if len(__SCREAMING_SNAKE_CASE ) > 0:
        __A		:     List[Any]												=		unused_attributes

  if len(__SCREAMING_SNAKE_CASE ) > 0:
    __A		:     Optional[Any]												=		"""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(__SCREAMING_SNAKE_CASE )


if __name__ == "__main__":
     check_config_attributes()





'''simple docstring'''
def        A_     (						__SCREAMING_SNAKE_CASE						:  int			,     __SCREAMING_SNAKE_CASE						:  bool = False )				->       bool:





  """simple docstring"""

  if n == 2:
    return True
  if not n % 2 or n < 2:
    return False
  if n > 5 and n % 10 not in (1, 3, 7, 9):  # can quickly check last digit
    return False
  if n > 3_3170_4406_4679_8873_8596_1981 and not allow_probable:
    raise ValueError(
        """Warning: upper bound of deterministic test is exceeded. """
        """Pass allow_probable=True to allow probabilistic test. """
        """A return value of True indicates a probable prime.""" )
  # array bounds provided by analysis
  __A		:     Optional[int]												=		[
      2047,
      137_3653,
      2532_6001,
      32_1503_1751,
      2_1523_0289_8747,
      3_4747_4966_0383,
      341_5500_7172_8321,
      1,
      382_5123_0565_4641_3051,
      1,
      1,
      3186_6585_7834_0311_5116_7461,
      3_3170_4406_4679_8873_8596_1981,
  ]

  __A		:     Optional[int]												=		[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41]
  for idx, _p in enumerate(__SCREAMING_SNAKE_CASE			,     1 ):
    if n < _p:
      # then we have our last prime to check
      __A		:     Union[str, Any]												=		primes[:idx]
      break
  __A							,					__A		:     int												=		n - 1, 0
  # break up n -1 into a power of 2 (s) and
  # remaining odd component
  # essentially, solve for d * 2 ** s == n - 1
  while d % 2 == 0:
    d //= 2
    s += 1
  for prime in plist:
    __A		:     int												=		False
    for r in range(__SCREAMING_SNAKE_CASE ):
      __A		:     Optional[Any]												=		pow(__SCREAMING_SNAKE_CASE			,     d * 2**r			,     __SCREAMING_SNAKE_CASE )
      # see article for analysis explanation for m
      if (r == 0 and m == 1) or ((m + 1) % n == 0):
        __A		:     Optional[int]												=		True
        # this loop will not determine compositeness
        break
    if pr:
      continue
    # if pr is False, then the above loop never evaluated to true,
    # and the n MUST be composite
    return False
  return True







def        A_     (						)				->       None:





  """simple docstring"""

  assert not miller_rabin(561 )
  assert miller_rabin(563 )
  # 2047

  assert not miller_rabin(83_8201 )
  assert miller_rabin(83_8207 )
  # 1_373_653

  assert not miller_rabin(1731_6001 )
  assert miller_rabin(1731_6017 )
  # 25_326_001

  assert not miller_rabin(30_7838_6641 )
  assert miller_rabin(30_7838_6653 )
  # 3_215_031_751

  assert not miller_rabin(1_7130_4557_4801 )
  assert miller_rabin(1_7130_4557_4819 )
  # 2_152_302_898_747

  assert not miller_rabin(2_7797_9972_8307 )
  assert miller_rabin(2_7797_9972_8327 )
  # 3_474_749_660_383

  assert not miller_rabin(113_8500_2390_9441 )
  assert miller_rabin(113_8500_2390_9527 )
  # 341_550_071_728_321

  assert not miller_rabin(127_5041_0188_4880_4351 )
  assert miller_rabin(127_5041_0188_4880_4391 )
  # 3_825_123_056_546_413_051

  assert not miller_rabin(796_6646_4458_5077_8779_1867 )
  assert miller_rabin(796_6646_4458_5077_8779_1951 )
  # 318_665_857_834_031_151_167_461

  assert not miller_rabin(5528_4067_7446_6478_9766_0333 )
  assert miller_rabin(5528_4067_7446_6478_9766_0359 )
  # 3_317_044_064_679_887_385_961_981
  # upper limit for probabilistic test


if __name__ == "__main__":
     test_miller_rabin()



