'''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


lowerCAmelCase_ : 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": 128,
    "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 							SCREAMING_SNAKE_CASE__						(						unittest.TestCase ):


   @classmethod
   def __UpperCAmelCase       (   cls				:	Any)      ->					Optional[Any]:
         lowercase_     =      TOKEN
         HfFolder.save_token(__A)


   @classmethod
   def __UpperCAmelCase       (   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 __UpperCAmelCase       (   self				:	Union[str, Any])      ->					str:
         lowercase_     =      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)

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

        # 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(__A   ,		repo_id="test-config"   ,		push_to_hub=__A   ,		use_auth_token=self._token)

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


   def __UpperCAmelCase       (   self				:	Any)      ->					Dict:
         lowercase_     =      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)

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

        # 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(
                   __A   ,		repo_id="valid_org/test-config-org"   ,		push_to_hub=__A   ,		use_auth_token=self._token)

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


   def __UpperCAmelCase       (   self				:	Union[str, Any])      ->					List[str]:
         CustomConfig.register_for_auto_class()
         lowercase_     =      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"})

         lowercase_     =      AutoConfig.from_pretrained(F'{USER}/test-dynamic-config'   ,		trust_remote_code=__A)
         # 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 							SCREAMING_SNAKE_CASE__						(						unittest.TestCase ):


   def __UpperCAmelCase       (   self				:	Optional[int])      ->					List[Any]:
         lowercase_     =      GPTaConfig()

         # attempt to modify each of int/float/bool/str config records and verify they were updated
         lowercase_     =      c.n_embd + 1  # int
         lowercase_     =      c.resid_pdrop + 1.0  # float
         lowercase_     =      not c.scale_attn_weights  # bool
         lowercase_     =      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(__A   ,		c.n_embd   ,		"mismatch for key: n_embd")
         self.assertEqual(__A   ,		c.resid_pdrop   ,		"mismatch for key: resid_pdrop")
         self.assertEqual(__A   ,		c.scale_attn_weights   ,		"mismatch for key: scale_attn_weights")
         self.assertEqual(__A   ,		c.summary_type   ,		"mismatch for key: summary_type")


   def __UpperCAmelCase       (   self				:	Tuple)      ->					List[str]:
         lowercase_     =      PretrainedConfig()
         lowercase_     =      [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(
             __A   ,		["is_encoder_decoder", "_name_or_path", "_commit_hash", "transformers_version"])
         lowercase_     =      [key for key, value in config_common_kwargs.items() if value == getattr(__A   ,		__A)]
         if len(__A) > 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(__A)}.')


   def __UpperCAmelCase       (   self				:	int)      ->					Optional[int]:
         with self.assertRaises(__A):
               # config is in subfolder, the following should not work without specifying the subfolder
               lowercase_     =      BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert-subfolder")

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

         self.assertIsNotNone(__A)


   def __UpperCAmelCase       (   self				:	Union[str, Any])      ->					List[str]:
         # A mock response for an HTTP head request to emulate server down
         lowercase_     =      mock.Mock()
         lowercase_     =      500
         lowercase_     =      {}
         lowercase_     =      HTTPError
         lowercase_     =      {}

         # Download this model to make sure it's in the cache.
         lowercase_     =      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=__A) as mock_head:
               lowercase_     =      BertConfig.from_pretrained("hf-internal-testing/tiny-random-bert")
               # This check we did call the fake head request
               mock_head.assert_called()


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


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

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

               # This should pick the new configuration file as the version of Transformers is > 4.0.0
               lowercase_     =      AutoConfig.from_pretrained(__A)
               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
               lowercase_     =      ["config.42.0.0.json"]
               lowercase_     =      768
               configuration.save_pretrained(__A)
               shutil.move(os.path.join(__A   ,		"config.4.0.0.json")   ,		os.path.join(__A   ,		"config.42.0.0.json"))
               lowercase_     =      AutoConfig.from_pretrained(__A)
               self.assertEqual(new_configuration.hidden_size   ,		768)


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

         import transformers as new_transformers

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

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

         lowercase_     =      "v3.0.0"
         lowercase_     =      old_transformers.models.auto.AutoConfig.from_pretrained(__A)
         self.assertEqual(old_configuration.hidden_size   ,		768)







'''simple docstring'''

from typing import List, Optional, Union

import numpy as np
import PIL.Image

from ...image_processing_utils import BaseImageProcessor, BatchFeature
from ...image_transforms import rescale, resize, to_channel_dimension_format
from ...image_utils import (
    ChannelDimension,
    PILImageResampling,
    get_image_size,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


lowerCAmelCase_ : Any						  =      logging.get_logger(__name__)





class 							lowercase						(						__lowerCamelCase ):
   lowerCamelCase_    					=['pixel_values']


   def __init__(   self				:	Optional[int]   ,		__lowerCAmelCase				:	bool = True   ,		__lowerCAmelCase				:	int = 32   ,		__lowerCAmelCase				:	List[str]=PILImageResampling.BILINEAR   ,		__lowerCAmelCase				:	bool = True   ,		**__lowerCAmelCase				:	Union[str, Any]   ,		)      ->					None:
         lowercase_     =      do_resize
         lowercase_     =      do_rescale
         lowercase_     =      size_divisor
         lowercase_     =      resample
         super().__init__(**__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	List[str]   ,		__lowerCAmelCase				:	np.ndarray   ,		__lowerCAmelCase				:	int   ,		__lowerCAmelCase				:	Optional[int]   ,		__lowerCAmelCase				:	Optional[ChannelDimension] = None   ,		**__lowerCAmelCase				:	Any)      ->					np.ndarray:
         lowercase_ ,							lowercase_     =      get_image_size(__lowerCAmelCase)
         # Rounds the height and width down to the closest multiple of size_divisor
         lowercase_     =      height // size_divisor * size_divisor
         lowercase_     =      width // size_divisor * size_divisor
         lowercase_     =      resize(__lowerCAmelCase   ,		(new_h, new_w)   ,		resample=__lowerCAmelCase   ,		data_format=__lowerCAmelCase   ,		**__lowerCAmelCase)
         return image


   def __UpperCAmelCase       (   self				:	str   ,		__lowerCAmelCase				:	np.ndarray   ,		__lowerCAmelCase				:	float   ,		__lowerCAmelCase				:	Optional[ChannelDimension] = None   ,		**__lowerCAmelCase				:	int)      ->					np.ndarray:
         return rescale(image=__lowerCAmelCase   ,		scale=__lowerCAmelCase   ,		data_format=__lowerCAmelCase   ,		**__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	Optional[Any]   ,		__lowerCAmelCase				:	Union["PIL.Image.Image", TensorType, List["PIL.Image.Image"], List[TensorType]]   ,		__lowerCAmelCase				:	Optional[bool] = None   ,		__lowerCAmelCase				:	Optional[int] = None   ,		__lowerCAmelCase				:	str=None   ,		__lowerCAmelCase				:	Optional[bool] = None   ,		__lowerCAmelCase				:	Optional[Union[TensorType, str]] = None   ,		__lowerCAmelCase				:	ChannelDimension = ChannelDimension.FIRST   ,		**__lowerCAmelCase				:	List[str]   ,		)      ->					BatchFeature:
         lowercase_     =      do_resize if do_resize is not None else self.do_resize
         lowercase_     =      do_rescale if do_rescale is not None else self.do_rescale
         lowercase_     =      size_divisor if size_divisor is not None else self.size_divisor
         lowercase_     =      resample if resample is not None else self.resample

         if do_resize and size_divisor is None:
               raise ValueError("size_divisor is required for resizing")

         lowercase_     =      make_list_of_images(__lowerCAmelCase)

         if not valid_images(__lowerCAmelCase):
               raise ValueError("Invalid image(s)")

         # All transformations expect numpy arrays.
         lowercase_     =      [to_numpy_array(__lowerCAmelCase) for img in images]

         if do_resize:
               lowercase_     =      [self.resize(__lowerCAmelCase   ,		size_divisor=__lowerCAmelCase   ,		resample=__lowerCAmelCase) for image in images]

         if do_rescale:
               lowercase_     =      [self.rescale(__lowerCAmelCase   ,		scale=1 / 255) for image in images]

         lowercase_     =      [to_channel_dimension_format(__lowerCAmelCase   ,		__lowerCAmelCase) for image in images]

         lowercase_     =      {"pixel_values": images}
         return BatchFeature(data=__lowerCAmelCase   ,		tensor_type=__lowerCAmelCase)






