





'''simple docstring'''






import json
import os
import shutil
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoConfig, BertConfig, GPTaConfig
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / '''utils'''))

from test_module.custom_configuration import CustomConfig  # noqa E402


A__				:   Any      ={
    '''return_dict''': False,
    '''output_hidden_states''': True,
    '''output_attentions''': True,
    '''torchscript''': True,
    '''torch_dtype''': '''float16''',
    '''use_bfloat16''': True,
    '''tf_legacy_loss''': True,
    '''pruned_heads''': {'''a''': 1},
    '''tie_word_embeddings''': False,
    '''is_decoder''': True,
    '''cross_attention_hidden_size''': 1_28,
    '''add_cross_attention''': True,
    '''tie_encoder_decoder''': True,
    '''max_length''': 50,
    '''min_length''': 3,
    '''do_sample''': True,
    '''early_stopping''': True,
    '''num_beams''': 3,
    '''num_beam_groups''': 3,
    '''diversity_penalty''': 0.5,
    '''temperature''': 2.0,
    '''top_k''': 10,
    '''top_p''': 0.7,
    '''typical_p''': 0.2,
    '''repetition_penalty''': 0.8,
    '''length_penalty''': 0.8,
    '''no_repeat_ngram_size''': 5,
    '''encoder_no_repeat_ngram_size''': 5,
    '''bad_words_ids''': [1, 2, 3],
    '''num_return_sequences''': 3,
    '''chunk_size_feed_forward''': 5,
    '''output_scores''': True,
    '''return_dict_in_generate''': True,
    '''forced_bos_token_id''': 2,
    '''forced_eos_token_id''': 3,
    '''remove_invalid_values''': True,
    '''architectures''': ['''BertModel'''],
    '''finetuning_task''': '''translation''',
    '''id2label''': {0: '''label'''},
    '''label2id''': {'''label''': '''0'''},
    '''tokenizer_class''': '''BertTokenizerFast''',
    '''prefix''': '''prefix''',
    '''bos_token_id''': 6,
    '''pad_token_id''': 7,
    '''eos_token_id''': 8,
    '''sep_token_id''': 9,
    '''decoder_start_token_id''': 10,
    '''exponential_decay_length_penalty''': (5, 1.01),
    '''suppress_tokens''': [0, 1],
    '''begin_suppress_tokens''': 2,
    '''task_specific_params''': {'''translation''': '''some_params'''},
    '''problem_type''': '''regression''',
}




@is_staging_test
class  UpperCAmelCase     (			unittest.TestCase   ):




      @classmethod
      def 				lowercase__    (			cls			: Optional[Any]  )				->      Tuple:
            _lowerCAmelCase							     =							TOKEN
            HfFolder.save_token(__snake_case  )




      @classmethod
      def 				lowercase__    (			cls			: Optional[int]  )				->      List[str]:
            try:
                  delete_repo(token=cls._token			,			repo_id="""test-config"""  )
            except HTTPError:
                  pass

            try:
                  delete_repo(token=cls._token			,			repo_id="""valid_org/test-config-org"""  )
            except HTTPError:
                  pass

            try:
                  delete_repo(token=cls._token			,			repo_id="""test-dynamic-config"""  )
            except HTTPError:
                  pass




      def 				lowercase__    (			self			: int  )				->      Union[str, Any]:
            _lowerCAmelCase							     =							BertConfig(
                vocab_size=99			,			hidden_size=32			,			num_hidden_layers=5			,			num_attention_heads=4			,			intermediate_size=37  )
            config.push_to_hub("""test-config"""			,			use_auth_token=self._token  )

            _lowerCAmelCase							     =							BertConfig.from_pretrained(f"{USER}/test-config"  )
            for k, v in config.to_dict().items():
                  if k != "transformers_version":
                        self.assertEqual(__snake_case			,			getattr(__snake_case			,			__snake_case  )  )

        # Reset repo
            delete_repo(token=self._token			,			repo_id="""test-config"""  )

            # Push to hub via save_pretrained
            with tempfile.TemporaryDirectory() as tmp_dir:
                  config.save_pretrained(__snake_case			,			repo_id="""test-config"""			,			push_to_hub=__snake_case			,			use_auth_token=self._token  )

            _lowerCAmelCase							     =							BertConfig.from_pretrained(f"{USER}/test-config"  )
            for k, v in config.to_dict().items():
                  if k != "transformers_version":
                        self.assertEqual(__snake_case			,			getattr(__snake_case			,			__snake_case  )  )




      def 				lowercase__    (			self			: Union[str, Any]  )				->      List[Any]:
            _lowerCAmelCase							     =							BertConfig(
                vocab_size=99			,			hidden_size=32			,			num_hidden_layers=5			,			num_attention_heads=4			,			intermediate_size=37  )
            config.push_to_hub("""valid_org/test-config-org"""			,			use_auth_token=self._token  )

            _lowerCAmelCase							     =							BertConfig.from_pretrained("""valid_org/test-config-org"""  )
            for k, v in config.to_dict().items():
                  if k != "transformers_version":
                        self.assertEqual(__snake_case			,			getattr(__snake_case			,			__snake_case  )  )

        # Reset repo
            delete_repo(token=self._token			,			repo_id="""valid_org/test-config-org"""  )

            # Push to hub via save_pretrained
            with tempfile.TemporaryDirectory() as tmp_dir:
                  config.save_pretrained(
                      __snake_case			,			repo_id="""valid_org/test-config-org"""			,			push_to_hub=__snake_case			,			use_auth_token=self._token  )

            _lowerCAmelCase							     =							BertConfig.from_pretrained("""valid_org/test-config-org"""  )
            for k, v in config.to_dict().items():
                  if k != "transformers_version":
                        self.assertEqual(__snake_case			,			getattr(__snake_case			,			__snake_case  )  )




      def 				lowercase__    (			self			: Dict  )				->      Any:
            CustomConfig.register_for_auto_class()
            _lowerCAmelCase							     =							CustomConfig(attribute=42  )

            config.push_to_hub("""test-dynamic-config"""			,			use_auth_token=self._token  )

            # This has added the proper auto_map field to the config
            self.assertDictEqual(config.auto_map			,			{"""AutoConfig""": """custom_configuration.CustomConfig"""}  )

            _lowerCAmelCase							     =							AutoConfig.from_pretrained(f"{USER}/test-dynamic-config"			,			trust_remote_code=__snake_case  )
            # Can't make an isinstance check because the new_config is from the FakeConfig class of a dynamic module
            self.assertEqual(new_config.__class__.__name__			,			"""CustomConfig"""  )
            self.assertEqual(new_config.attribute			,			42  )




class  UpperCAmelCase     (			unittest.TestCase   ):




      def 				lowercase__    (			self			: List[Any]  )				->      Optional[Any]:
            _lowerCAmelCase							     =							GPTaConfig()

            # attempt to modify each of int/float/bool/str config records and verify they were updated
            _lowerCAmelCase							     =							c.n_embd + 1  # int
            _lowerCAmelCase							     =							c.resid_pdrop + 1.0  # float
            _lowerCAmelCase							     =							not c.scale_attn_weights  # bool
            _lowerCAmelCase							     =							c.summary_type + """foo"""  # str
            c.update_from_string(
                f"n_embd={n_embd},resid_pdrop={resid_pdrop},scale_attn_weights={scale_attn_weights},summary_type={summary_type}"  )
            self.assertEqual(__snake_case			,			c.n_embd			,			"""mismatch for key: n_embd"""  )
            self.assertEqual(__snake_case			,			c.resid_pdrop			,			"""mismatch for key: resid_pdrop"""  )
            self.assertEqual(__snake_case			,			c.scale_attn_weights			,			"""mismatch for key: scale_attn_weights"""  )
            self.assertEqual(__snake_case			,			c.summary_type			,			"""mismatch for key: summary_type"""  )




      def 				lowercase__    (			self			: Optional[Any]  )				->      Any:
            _lowerCAmelCase							     =							PretrainedConfig()
            _lowerCAmelCase							     =							[key for key in base_config.__dict__ if key not in config_common_kwargs]
            # If this part of the test fails, you have arguments to addin config_common_kwargs above.
            self.assertListEqual(
                __snake_case			,			["""is_encoder_decoder""", """_name_or_path""", """_commit_hash""", """transformers_version"""]  )
            _lowerCAmelCase							     =							[key for key, value in config_common_kwargs.items() if value == getattr(__snake_case			,			__snake_case  )]
            if len(__snake_case  ) > 0:
                  raise ValueError(
                      """The following keys are set with the default values in"""
                      """ `test_configuration_common.config_common_kwargs` pick another value for them:"""
                      f" {', '.join(__snake_case  )}."  )




      def 				lowercase__    (			self			: List[str]  )				->      List[Any]:
            with self.assertRaises(__snake_case  ):
                  # config is in subfolder, the following should not work without specifying the subfolder
                  _lowerCAmelCase							     =							BertConfig.from_pretrained("""hf-internal-testing/tiny-random-bert-subfolder"""  )

            _lowerCAmelCase							     =							BertConfig.from_pretrained("""hf-internal-testing/tiny-random-bert-subfolder"""			,			subfolder="""bert"""  )

            self.assertIsNotNone(__snake_case  )




      def 				lowercase__    (			self			: Optional[Any]  )				->      str:
            # A mock response for an HTTP head request to emulate server down
            _lowerCAmelCase							     =							mock.Mock()
            _lowerCAmelCase							     =							5_00
            _lowerCAmelCase							     =							{}
            _lowerCAmelCase							     =							HTTPError
            _lowerCAmelCase							     =							{}

            # Download this model to make sure it's in the cache.
            _lowerCAmelCase							     =							BertConfig.from_pretrained("""hf-internal-testing/tiny-random-bert"""  )

            # Under the mock environment we get a 500 error when trying to reach the model.
            with mock.patch("""requests.Session.request"""			,			return_value=__snake_case  ) as mock_head:
                  _lowerCAmelCase							     =							BertConfig.from_pretrained("""hf-internal-testing/tiny-random-bert"""  )
                  # This check we did call the fake head request
                  mock_head.assert_called()




      def 				lowercase__    (			self			: str  )				->      Union[str, Any]:
            # This test is for deprecated behavior and can be removed in v5
            _lowerCAmelCase							     =							BertConfig.from_pretrained(
                """https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json"""  )




      def 				lowercase__    (			self			: str  )				->      Union[str, Any]:
            _lowerCAmelCase							     =							AutoConfig.from_pretrained("""bert-base-cased"""  )
            _lowerCAmelCase							     =							["""config.4.0.0.json"""]

            with tempfile.TemporaryDirectory() as tmp_dir:
                  configuration.save_pretrained(__snake_case  )
                  _lowerCAmelCase							     =							2
                  json.dump(configuration.to_dict()			,			open(os.path.join(__snake_case			,			"""config.4.0.0.json"""  )			,			"""w"""  )  )

                  # This should pick the new configuration file as the version of Transformers is > 4.0.0
                  _lowerCAmelCase							     =							AutoConfig.from_pretrained(__snake_case  )
                  self.assertEqual(new_configuration.hidden_size			,			2  )

                  # Will need to be adjusted if we reach v42 and this test is still here.
                  # Should pick the old configuration file as the version of Transformers is < 4.42.0
                  _lowerCAmelCase							     =							["""config.42.0.0.json"""]
                  _lowerCAmelCase							     =							7_68
                  configuration.save_pretrained(__snake_case  )
                  shutil.move(os.path.join(__snake_case			,			"""config.4.0.0.json"""  )			,			os.path.join(__snake_case			,			"""config.42.0.0.json"""  )  )
                  _lowerCAmelCase							     =							AutoConfig.from_pretrained(__snake_case  )
                  self.assertEqual(new_configuration.hidden_size			,			7_68  )




      def 				lowercase__    (			self			: Optional[Any]  )				->      Optional[Any]:
            # This repo has two configuration files, one for v4.0.0 and above with a different hidden size.
            _lowerCAmelCase							     =							"""hf-internal-testing/test-two-configs"""

            import transformers as new_transformers

            _lowerCAmelCase							     =							"""v4.0.0"""
            _lowerCAmelCase     ,							_lowerCAmelCase							     =							new_transformers.models.auto.AutoConfig.from_pretrained(
                __snake_case			,			return_unused_kwargs=__snake_case  )
            self.assertEqual(new_configuration.hidden_size			,			2  )
            # This checks `_configuration_file` ia not kept in the kwargs by mistake.
            self.assertDictEqual(__snake_case			,			{}  )

            # Testing an older version by monkey-patching the version in the module it's used.
            import transformers as old_transformers

            _lowerCAmelCase							     =							"""v3.0.0"""
            _lowerCAmelCase							     =							old_transformers.models.auto.AutoConfig.from_pretrained(__snake_case  )
            self.assertEqual(old_configuration.hidden_size			,			7_68  )













"""simple docstring"""
from typing import TYPE_CHECKING

from ...file_utils import _LazyModule, is_tokenizers_available, is_torch_available, is_vision_available
from ...utils import OptionalDependencyNotAvailable


lowerCamelCase_								=		{"configuration_dpt": ["DPT_PRETRAINED_CONFIG_ARCHIVE_MAP", "DPTConfig"]}

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowerCamelCase_								=		["DPTFeatureExtractor"]
  lowerCamelCase_								=		["DPTImageProcessor"]

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowerCamelCase_								=		[
      "DPT_PRETRAINED_MODEL_ARCHIVE_LIST",
      "DPTForDepthEstimation",
      "DPTForSemanticSegmentation",
      "DPTModel",
      "DPTPreTrainedModel",
  ]


if TYPE_CHECKING:
  from .configuration_dpt import DPT_PRETRAINED_CONFIG_ARCHIVE_MAP, DPTConfig

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .feature_extraction_dpt import DPTFeatureExtractor
    from .image_processing_dpt import DPTImageProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_dpt import (
        DPT_PRETRAINED_MODEL_ARCHIVE_LIST,
        DPTForDepthEstimation,
        DPTForSemanticSegmentation,
        DPTModel,
        DPTPreTrainedModel,
    )


else:
  import sys

  lowerCamelCase_								=		_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)