
"""simple docstring"""


import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMInverseScheduler,
    DDIMScheduler,
    DPMSolverMultistepInverseScheduler,
    DPMSolverMultistepScheduler,
    StableDiffusionDiffEditPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_image, slow
from diffusers.utils.testing_utils import enable_full_determinism, floats_tensor, require_torch_gpu, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()



class 	__a	(   _lowerCAmelCase     ,  _lowerCAmelCase     ,  unittest.TestCase						):
       UpperCamelCase_		:       Tuple				=      StableDiffusionDiffEditPipeline
       UpperCamelCase_		:       str				=      TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {'''height''', '''width''', '''image'''} | {'''image_latents'''}
       UpperCamelCase_		:       Optional[Any]				=      TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS - {'''image'''} | {'''image_latents'''}
       UpperCamelCase_		:       str				=      frozenset(
           []						)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
       UpperCamelCase_		:       Union[str, Any]				=      frozenset([]						)






       def 						_SCREAMING_SNAKE_CASE							(	self			:				str      )->	Any:







              """simple docstring"""
              torch.manual_seed(0      )
              UpperCamelCase       			=		UNetaDConditionModel(
                  block_out_channels=(32, 64)							,   layers_per_block=2							,   sample_size=32							,   in_channels=4							,   out_channels=4							,   down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")							,   up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")							,   cross_attention_dim=32							,   attention_head_dim=(2, 4)							,   use_linear_projection=UpperCAmelCase_							,   )
              UpperCamelCase       			=		DDIMScheduler(
                  beta_start=0.00085							,   beta_end=0.012							,   beta_schedule="scaled_linear"							,   clip_sample=UpperCAmelCase_							,   set_alpha_to_one=UpperCAmelCase_							,   )
              UpperCamelCase       			=		DDIMInverseScheduler(
                  beta_start=0.00085							,   beta_end=0.012							,   beta_schedule="scaled_linear"							,   clip_sample=UpperCAmelCase_							,   set_alpha_to_zero=UpperCAmelCase_							,   )
              torch.manual_seed(0      )
              UpperCamelCase       			=		AutoencoderKL(
                  block_out_channels=[32, 64]							,   in_channels=3							,   out_channels=3							,   down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]							,   up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]							,   latent_channels=4							,   sample_size=128							,   )
              torch.manual_seed(0      )
              UpperCamelCase       			=		CLIPTextConfig(
                  bos_token_id=0							,   eos_token_id=2							,   hidden_size=32							,   intermediate_size=37							,   layer_norm_eps=1e-05							,   num_attention_heads=4							,   num_hidden_layers=5							,   pad_token_id=1							,   vocab_size=1_000							,   hidden_act="gelu"							,   projection_dim=512							,   )
              UpperCamelCase       			=		CLIPTextModel(UpperCAmelCase_      )
              UpperCamelCase       			=		CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"      )

              UpperCamelCase       			=		{
                  "unet": unet,
                  "scheduler": scheduler,
                  "inverse_scheduler": inverse_scheduler,
                  "vae": vae,
                  "text_encoder": text_encoder,
                  "tokenizer": tokenizer,
                  "safety_checker": None,
                  "feature_extractor": None,
              }

              return components






       def 						_SCREAMING_SNAKE_CASE							(	self			:				str							,   UpperCAmelCase_			:				Dict							,   UpperCAmelCase_			:				Dict=0      )->	Union[str, Any]:







              """simple docstring"""
              UpperCamelCase       			=		floats_tensor((1, 16, 16)							,   rng=random.Random(UpperCAmelCase_      )      ).to(UpperCAmelCase_      )
              UpperCamelCase       			=		floats_tensor((1, 2, 4, 16, 16)							,   rng=random.Random(UpperCAmelCase_      )      ).to(UpperCAmelCase_      )
              if str(UpperCAmelCase_      ).startswith("mps"      ):
                     UpperCamelCase       			=		torch.manual_seed(UpperCAmelCase_      )
              else:
                     UpperCamelCase       			=		torch.Generator(device=UpperCAmelCase_      ).manual_seed(UpperCAmelCase_      )
              UpperCamelCase       			=		{
                  "prompt": "a dog and a newt",
                  "mask_image": mask,
                  "image_latents": latents,
                  "generator": generator,
                  "num_inference_steps": 2,
                  "inpaint_strength": 1.0,
                  "guidance_scale": 6.0,
                  "output_type": "numpy",
              }

              return inputs






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Tuple							,   UpperCAmelCase_			:				Optional[int]							,   UpperCAmelCase_			:				Tuple=0      )->	Union[str, Any]:







              """simple docstring"""
              UpperCamelCase       			=		floats_tensor((1, 3, 32, 32)							,   rng=random.Random(UpperCAmelCase_      )      ).to(UpperCAmelCase_      )
              UpperCamelCase       			=		image.cpu().permute(0							,   2							,   3							,   1      )[0]
              UpperCamelCase       			=		Image.fromarray(np.uinta(UpperCAmelCase_      )      ).convert("RGB"      )
              if str(UpperCAmelCase_      ).startswith("mps"      ):
                     UpperCamelCase       			=		torch.manual_seed(UpperCAmelCase_      )
              else:
                     UpperCamelCase       			=		torch.Generator(device=UpperCAmelCase_      ).manual_seed(UpperCAmelCase_      )
              UpperCamelCase       			=		{
                  "image": image,
                  "source_prompt": "a cat and a frog",
                  "target_prompt": "a dog and a newt",
                  "generator": generator,
                  "num_inference_steps": 2,
                  "num_maps_per_mask": 2,
                  "mask_encode_strength": 1.0,
                  "guidance_scale": 6.0,
                  "output_type": "numpy",
              }

              return inputs






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Tuple							,   UpperCAmelCase_			:				Tuple							,   UpperCAmelCase_			:				Optional[Any]=0      )->	List[str]:







              """simple docstring"""
              UpperCamelCase       			=		floats_tensor((1, 3, 32, 32)							,   rng=random.Random(UpperCAmelCase_      )      ).to(UpperCAmelCase_      )
              UpperCamelCase       			=		image.cpu().permute(0							,   2							,   3							,   1      )[0]
              UpperCamelCase       			=		Image.fromarray(np.uinta(UpperCAmelCase_      )      ).convert("RGB"      )
              if str(UpperCAmelCase_      ).startswith("mps"      ):
                     UpperCamelCase       			=		torch.manual_seed(UpperCAmelCase_      )
              else:
                     UpperCamelCase       			=		torch.Generator(device=UpperCAmelCase_      ).manual_seed(UpperCAmelCase_      )
              UpperCamelCase       			=		{
                  "image": image,
                  "prompt": "a cat and a frog",
                  "generator": generator,
                  "num_inference_steps": 2,
                  "inpaint_strength": 1.0,
                  "guidance_scale": 6.0,
                  "decode_latents": True,
                  "output_type": "numpy",
              }
              return inputs






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Any      )->	Optional[int]:







              """simple docstring"""
              if not hasattr(self.pipeline_class							,   "_optional_components"      ):
                     return

              UpperCamelCase       			=		self.get_dummy_components()
              UpperCamelCase       			=		self.pipeline_class(**UpperCAmelCase_      )
              pipe.to(UpperCAmelCase_      )
              pipe.set_progress_bar_config(disable=UpperCAmelCase_      )

              # set all optional components to None and update pipeline config accordingly
              for optional_component in pipe._optional_components:
                     setattr(UpperCAmelCase_							,   UpperCAmelCase_							,   UpperCAmelCase_      )
              pipe.register_modules(**{optional_component: None for optional_component in pipe._optional_components}      )

              UpperCamelCase       			=		self.get_dummy_inputs(UpperCAmelCase_      )
              UpperCamelCase       			=		pipe(**UpperCAmelCase_      )[0]

              with tempfile.TemporaryDirectory() as tmpdir:
                     pipe.save_pretrained(UpperCAmelCase_      )
                     UpperCamelCase       			=		self.pipeline_class.from_pretrained(UpperCAmelCase_      )
                     pipe_loaded.to(UpperCAmelCase_      )
                     pipe_loaded.set_progress_bar_config(disable=UpperCAmelCase_      )

              for optional_component in pipe._optional_components:
                     self.assertTrue(
                         getattr(UpperCAmelCase_							,   UpperCAmelCase_      ) is None							,   f"`{optional_component}` did not stay set to None after loading."							,   )

              UpperCamelCase       			=		self.get_dummy_inputs(UpperCAmelCase_      )
              UpperCamelCase       			=		pipe_loaded(**UpperCAmelCase_      )[0]

              UpperCamelCase       			=		np.abs(output - output_loaded      ).max()
              self.assertLess(UpperCAmelCase_							,   1e-4      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				str      )->	str:







              """simple docstring"""
              UpperCamelCase       			=		"cpu"

              UpperCamelCase       			=		self.get_dummy_components()
              UpperCamelCase       			=		self.pipeline_class(**UpperCAmelCase_      )
              pipe.to(UpperCAmelCase_      )
              pipe.set_progress_bar_config(disable=UpperCAmelCase_      )

              UpperCamelCase       			=		self.get_dummy_mask_inputs(UpperCAmelCase_      )
              UpperCamelCase       			=		pipe.generate_mask(**UpperCAmelCase_      )
              UpperCamelCase       			=		mask[0, -3:, -3:]

              self.assertEqual(mask.shape							,   (1, 16, 16)      )
              UpperCamelCase       			=		np.array([0] * 9      )
              UpperCamelCase       			=		np.abs(mask_slice.flatten() - expected_slice      ).max()
              self.assertLessEqual(UpperCAmelCase_							,   1e-3      )
              self.assertEqual(mask[0, -3, -4]							,   0      )






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







              """simple docstring"""
              UpperCamelCase       			=		"cpu"

              UpperCamelCase       			=		self.get_dummy_components()
              UpperCamelCase       			=		self.pipeline_class(**UpperCAmelCase_      )
              pipe.to(UpperCAmelCase_      )
              pipe.set_progress_bar_config(disable=UpperCAmelCase_      )

              UpperCamelCase       			=		self.get_dummy_inversion_inputs(UpperCAmelCase_      )
              UpperCamelCase       			=		pipe.invert(**UpperCAmelCase_      ).images
              UpperCamelCase       			=		image[0, -1, -3:, -3:]

              self.assertEqual(image.shape							,   (2, 32, 32, 3)      )
              UpperCamelCase       			=		np.array(
                  [0.5150, 0.5134, 0.5043, 0.5376, 0.4694, 0.51050, 0.5015, 0.4407, 0.4799]							,   )
              UpperCamelCase       			=		np.abs(image_slice.flatten() - expected_slice      ).max()
              self.assertLessEqual(UpperCAmelCase_							,   1e-3      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Tuple      )->	int:







              """simple docstring"""
              super().test_inference_batch_single_identical(expected_max_diff=5e-3      )






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Any      )->	Tuple:







              """simple docstring"""
              UpperCamelCase       			=		"cpu"

              UpperCamelCase       			=		self.get_dummy_components()

              UpperCamelCase       			=		{"beta_start": 0.00085, "beta_end": 0.012, "beta_schedule": "scaled_linear"}
              UpperCamelCase       			=		DPMSolverMultistepScheduler(**UpperCAmelCase_      )
              UpperCamelCase       			=		DPMSolverMultistepInverseScheduler(**UpperCAmelCase_      )

              UpperCamelCase       			=		self.pipeline_class(**UpperCAmelCase_      )
              pipe.to(UpperCAmelCase_      )
              pipe.set_progress_bar_config(disable=UpperCAmelCase_      )

              UpperCamelCase       			=		self.get_dummy_inversion_inputs(UpperCAmelCase_      )
              UpperCamelCase       			=		pipe.invert(**UpperCAmelCase_      ).images
              UpperCamelCase       			=		image[0, -1, -3:, -3:]

              self.assertEqual(image.shape							,   (2, 32, 32, 3)      )
              UpperCamelCase       			=		np.array(
                  [0.5150, 0.5134, 0.5043, 0.5376, 0.4694, 0.51050, 0.5015, 0.4407, 0.4799]							,   )
              UpperCamelCase       			=		np.abs(image_slice.flatten() - expected_slice      ).max()
              self.assertLessEqual(UpperCAmelCase_							,   1e-3      )





@require_torch_gpu
@slow
class 	__a	(   unittest.TestCase						):






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







              """simple docstring"""
              super().tearDown()
              gc.collect()
              torch.cuda.empty_cache()






       @classmethod
       def 						_SCREAMING_SNAKE_CASE							(	cls			:				List[str]      )->	Dict:







              """simple docstring"""
              UpperCamelCase       			=		load_image(
                  "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/diffedit/fruit.png"      )

              UpperCamelCase       			=		raw_image.convert("RGB"      ).resize((768, 768)      )

              UpperCamelCase       			=		raw_image






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







              """simple docstring"""
              UpperCamelCase       			=		torch.manual_seed(0      )

              UpperCamelCase       			=		StableDiffusionDiffEditPipeline.from_pretrained(
                  "stabilityai/stable-diffusion-2-1"							,   safety_checker=UpperCAmelCase_							,   torch_dtype=torch.floataa      )
              UpperCamelCase       			=		DDIMScheduler.from_config(pipe.scheduler.config      )
              UpperCamelCase       			=		DDIMInverseScheduler.from_config(pipe.scheduler.config      )
              pipe.enable_model_cpu_offload()
              pipe.set_progress_bar_config(disable=UpperCAmelCase_      )

              UpperCamelCase       			=		"a bowl of fruit"
              UpperCamelCase       			=		"a bowl of pears"

              UpperCamelCase       			=		pipe.generate_mask(
                  image=self.raw_image							,   source_prompt=UpperCAmelCase_							,   target_prompt=UpperCAmelCase_							,   generator=UpperCAmelCase_							,   )

              UpperCamelCase       			=		pipe.invert(
                  prompt=UpperCAmelCase_							,   image=self.raw_image							,   inpaint_strength=0.7							,   generator=UpperCAmelCase_      ).latents

              UpperCamelCase       			=		pipe(
                  prompt=UpperCAmelCase_							,   mask_image=UpperCAmelCase_							,   image_latents=UpperCAmelCase_							,   generator=UpperCAmelCase_							,   negative_prompt=UpperCAmelCase_							,   inpaint_strength=0.7							,   output_type="numpy"							,   ).images[0]

              UpperCamelCase       			=		(
                  np.array(
                      load_image(
                          "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
                          "/diffedit/pears.png"      ).resize((768, 768)      )      )
                  / 255
              )
              assert np.abs((expected_image - image).max()      ) < 5e-1






       def 						_SCREAMING_SNAKE_CASE							(	self			:				Optional[Any]      )->	str:







              """simple docstring"""
              UpperCamelCase       			=		torch.manual_seed(0      )

              UpperCamelCase       			=		StableDiffusionDiffEditPipeline.from_pretrained(
                  "stabilityai/stable-diffusion-2-1"							,   safety_checker=UpperCAmelCase_							,   torch_dtype=torch.floataa      )
              UpperCamelCase       			=		DPMSolverMultistepScheduler.from_config(pipe.scheduler.config      )
              UpperCamelCase       			=		DPMSolverMultistepInverseScheduler.from_config(pipe.scheduler.config      )
              pipe.enable_model_cpu_offload()
              pipe.set_progress_bar_config(disable=UpperCAmelCase_      )

              UpperCamelCase       			=		"a bowl of fruit"
              UpperCamelCase       			=		"a bowl of pears"

              UpperCamelCase       			=		pipe.generate_mask(
                  image=self.raw_image							,   source_prompt=UpperCAmelCase_							,   target_prompt=UpperCAmelCase_							,   generator=UpperCAmelCase_							,   )

              UpperCamelCase       			=		pipe.invert(
                  prompt=UpperCAmelCase_							,   image=self.raw_image							,   inpaint_strength=0.7							,   generator=UpperCAmelCase_							,   num_inference_steps=25							,   ).latents

              UpperCamelCase       			=		pipe(
                  prompt=UpperCAmelCase_							,   mask_image=UpperCAmelCase_							,   image_latents=UpperCAmelCase_							,   generator=UpperCAmelCase_							,   negative_prompt=UpperCAmelCase_							,   inpaint_strength=0.7							,   num_inference_steps=25							,   output_type="numpy"							,   ).images[0]

              UpperCamelCase       			=		(
                  np.array(
                      load_image(
                          "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
                          "/diffedit/pears.png"      ).resize((768, 768)      )      )
                  / 255
              )
              assert np.abs((expected_image - image).max()      ) < 5e-1







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


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

SCREAMING_SNAKE_CASE			  =  transformers.models.auto.configuration_auto.CONFIG_MAPPING

SCREAMING_SNAKE_CASE			  =  {
    # 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 						lowerCamelCase__      (				UpperCAmelCase_		,   UpperCAmelCase_		,   UpperCAmelCase_		,   UpperCAmelCase_					)->				Optional[Any]:







       """simple docstring"""
       UpperCamelCase       			=		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       			=		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       			=		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       			=		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       			=		[
           "bos_index",
           "eos_index",
           "pad_index",
           "unk_index",
           "mask_index",
           "image_size",
           "use_cache",
           "out_features",
           "out_indices",
       ]
       UpperCamelCase       			=		["encoder_no_repeat_ngram_size"]

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

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

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

       return attribute_used or case_allowed



def 						lowerCamelCase__      (				UpperCAmelCase_					)->				Optional[Any]:







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

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

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

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







       """simple docstring"""
       UpperCamelCase       			=		{}
       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       			=		[
                  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       			=		check_config_attributes_being_used(UpperCAmelCase_					)
                     if len(UpperCAmelCase_					) > 0:
                            UpperCamelCase       			=		unused_attributes

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





