



'''simple docstring'''





import copy
import tempfile
import unittest

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

from transformers import AutoConfig, GenerationConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test


class 				snake_case (unittest.TestCase   ):



       @parameterized.expand([(None,), ("foo.json",)]      )
       def 							_a      (				self     ,UpperCAmelCase_      )  ->							Optional[Any]:
           lowercase__		       =						GenerationConfig(
               do_sample=UpperCAmelCase_     ,temperature=0.7     ,length_penalty=1.0     ,bad_words_ids=[[1, 2, 3], [4, 5]]     ,)
           with tempfile.TemporaryDirectory() as tmp_dir:
               config.save_pretrained(UpperCAmelCase_     ,config_name=UpperCAmelCase_      )
               lowercase__		       =						GenerationConfig.from_pretrained(UpperCAmelCase_     ,config_name=UpperCAmelCase_      )

           # Checks parameters that were specified
           self.assertEqual(loaded_config.do_sample     ,UpperCAmelCase_      )
           self.assertEqual(loaded_config.temperature     ,0.7      )
           self.assertEqual(loaded_config.length_penalty     ,1.0      )
           self.assertEqual(loaded_config.bad_words_ids     ,[[1, 2, 3], [4, 5]]      )

           # Checks parameters that were not specified (defaults)
           self.assertEqual(loaded_config.top_k     ,50      )
           self.assertEqual(loaded_config.max_length     ,20      )
           self.assertEqual(loaded_config.max_time     ,UpperCAmelCase_      )



       def 							_a      (				self      )  ->							List[str]:
           lowercase__		       =						AutoConfig.from_pretrained("gpt2"      )
           lowercase__		       =						GenerationConfig.from_model_config(UpperCAmelCase_      )
           lowercase__		       =						GenerationConfig()

           # The generation config has loaded a few non-default parameters from the model config
           self.assertNotEqual(UpperCAmelCase_     ,UpperCAmelCase_      )

           # One of those parameters is eos_token_id -- check if it matches
           self.assertNotEqual(generation_config_from_model.eos_token_id     ,default_generation_config.eos_token_id      )
           self.assertEqual(generation_config_from_model.eos_token_id     ,model_config.eos_token_id      )



       def 							_a      (				self      )  ->							Union[str, Any]:
           lowercase__		       =						GenerationConfig()
           lowercase__		       =						{
               "max_new_tokens": 1_024,
               "foo": "bar",
           }
           lowercase__		       =						copy.deepcopy(UpperCAmelCase_      )
           lowercase__		       =						generation_config.update(**UpperCAmelCase_      )

           # update_kwargs was not modified (no side effects)
           self.assertEqual(UpperCAmelCase_     ,UpperCAmelCase_      )

           # update_kwargs was used to update the config on valid attributes
           self.assertEqual(generation_config.max_new_tokens     ,1_024      )

           # `.update()` returns a dictionary of unused kwargs
           self.assertEqual(UpperCAmelCase_     ,{"foo": "bar"}      )



       def 							_a      (				self      )  ->							Optional[int]:
           lowercase__		       =						GenerationConfig()
           lowercase__		       =						"bar"

           with tempfile.TemporaryDirectory("test-generation-config"      ) as tmp_dir:
               generation_config.save_pretrained(UpperCAmelCase_      )

               lowercase__		       =						GenerationConfig.from_pretrained(UpperCAmelCase_      )
           # update_kwargs was used to update the config on valid attributes
           self.assertEqual(new_config.foo     ,"bar"      )

           lowercase__		       =						GenerationConfig.from_model_config(UpperCAmelCase_      )
           assert not hasattr(UpperCAmelCase_     ,"foo"      )  # no new kwargs should be initialized if from config







       def 							_a      (				self      )  ->							int:
           lowercase__		       =						GenerationConfig()
           self.assertEqual(default_config.temperature     ,1.0      )
           self.assertEqual(default_config.do_sample     ,UpperCAmelCase_      )
           self.assertEqual(default_config.num_beams     ,1      )

           lowercase__		       =						GenerationConfig(
               do_sample=UpperCAmelCase_     ,temperature=0.7     ,length_penalty=1.0     ,bad_words_ids=[[1, 2, 3], [4, 5]]     ,)
           self.assertEqual(config.temperature     ,0.7      )
           self.assertEqual(config.do_sample     ,UpperCAmelCase_      )
           self.assertEqual(config.num_beams     ,1      )

           with tempfile.TemporaryDirectory() as tmp_dir:
               config.save_pretrained(UpperCAmelCase_      )
               lowercase__		       =						GenerationConfig.from_pretrained(UpperCAmelCase_     ,temperature=1.0      )

           self.assertEqual(loaded_config.temperature     ,1.0      )
           self.assertEqual(loaded_config.do_sample     ,UpperCAmelCase_      )
           self.assertEqual(loaded_config.num_beams     ,1      )  # default value





@is_staging_test
class 				snake_case (unittest.TestCase   ):



       @classmethod
       def 							_a      (				cls      )  ->							Any:
           lowercase__		       =						TOKEN
           HfFolder.save_token(UpperCAmelCase_      )



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

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



       def 							_a      (				self      )  ->							Any:
           lowercase__		       =						GenerationConfig(
               do_sample=UpperCAmelCase_     ,temperature=0.7     ,length_penalty=1.0     ,)
           config.push_to_hub("test-generation-config"     ,use_auth_token=self._token      )

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

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

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

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







       def 							_a      (				self      )  ->							List[Any]:
           lowercase__		       =						GenerationConfig(
               do_sample=UpperCAmelCase_     ,temperature=0.7     ,length_penalty=1.0     ,)
           config.push_to_hub("valid_org/test-generation-config-org"     ,use_auth_token=self._token      )

           lowercase__		       =						GenerationConfig.from_pretrained("valid_org/test-generation-config-org"      )
           for k, v in config.to_dict().items():
               if k != "transformers_version":
                   self.assertEqual(UpperCAmelCase_     ,getattr(UpperCAmelCase_     ,UpperCAmelCase_      )      )

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

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

           lowercase__		       =						GenerationConfig.from_pretrained("valid_org/test-generation-config-org"      )
           for k, v in config.to_dict().items():
               if k != "transformers_version":
                   self.assertEqual(UpperCAmelCase_     ,getattr(UpperCAmelCase_     ,UpperCAmelCase_      )      )









'''simple docstring'''





import copy
import os
from typing import TYPE_CHECKING, List, Union


if TYPE_CHECKING:
 pass

from ...configuration_utils import PretrainedConfig
from ...utils import logging


SCREAMING_SNAKE_CASE__      					=     logging.get_logger(__name__)

SCREAMING_SNAKE_CASE__      					=     {
    "kakaobrain/align-base": "https://huggingface.co/kakaobrain/align-base/resolve/main/config.json",
}


class 				snake_case (UpperCamelCase   ):
       lowerCAmelCase__  :Optional[int]						   =					"align_text_model"



       def __init__(				self     ,UpperCAmelCase_=30_522     ,UpperCAmelCase_=768     ,UpperCAmelCase_=12     ,UpperCAmelCase_=12     ,UpperCAmelCase_=3_072     ,UpperCAmelCase_="gelu"     ,UpperCAmelCase_=0.1     ,UpperCAmelCase_=0.1     ,UpperCAmelCase_=512     ,UpperCAmelCase_=2     ,UpperCAmelCase_=0.02     ,UpperCAmelCase_=1E-1_2     ,UpperCAmelCase_=0     ,UpperCAmelCase_="absolute"     ,UpperCAmelCase_=True     ,**UpperCAmelCase_     ,)  ->							List[str]:
           super().__init__(**UpperCAmelCase_      )

           lowercase__		       =						vocab_size
           lowercase__		       =						hidden_size
           lowercase__		       =						num_hidden_layers
           lowercase__		       =						num_attention_heads
           lowercase__		       =						hidden_act
           lowercase__		       =						intermediate_size
           lowercase__		       =						hidden_dropout_prob
           lowercase__		       =						attention_probs_dropout_prob
           lowercase__		       =						max_position_embeddings
           lowercase__		       =						type_vocab_size
           lowercase__		       =						initializer_range
           lowercase__		       =						layer_norm_eps
           lowercase__		       =						position_embedding_type
           lowercase__		       =						use_cache
           lowercase__		       =						pad_token_id







       @classmethod
       def 							_a      (				cls     ,UpperCAmelCase_     ,**UpperCAmelCase_      )  ->							"PretrainedConfig":
           cls._set_token_in_kwargs(UpperCAmelCase_      )

           lowercase__       ,       lowercase__		       =						cls.get_config_dict(UpperCAmelCase_     ,**UpperCAmelCase_      )

           # get the text config dict if we are loading from AlignConfig
           if config_dict.get("model_type"      ) == "align":
               lowercase__		       =						config_dict["text_config"]

           if "model_type" in config_dict and hasattr(cls     ,"model_type"      ) and config_dict["model_type"] != cls.model_type:
               logger.warning(
                   F'''You are using a model of type {config_dict['model_type']} to instantiate a model of type '''
                   F'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.'''      )

           return cls.from_dict(UpperCAmelCase_     ,**UpperCAmelCase_      )





class 				snake_case (UpperCamelCase   ):
       lowerCAmelCase__  :Tuple						   =					"align_vision_model"



       def __init__(				self     ,UpperCAmelCase_ = 3     ,UpperCAmelCase_ = 600     ,UpperCAmelCase_ = 2.0     ,UpperCAmelCase_ = 3.1     ,UpperCAmelCase_ = 8     ,UpperCAmelCase_ = [3, 3, 5, 3, 5, 5, 3]     ,UpperCAmelCase_ = [32, 16, 24, 40, 80, 112, 192]     ,UpperCAmelCase_ = [16, 24, 40, 80, 112, 192, 320]     ,UpperCAmelCase_ = []     ,UpperCAmelCase_ = [1, 2, 2, 2, 1, 2, 1]     ,UpperCAmelCase_ = [1, 2, 2, 3, 3, 4, 1]     ,UpperCAmelCase_ = [1, 6, 6, 6, 6, 6, 6]     ,UpperCAmelCase_ = 0.25     ,UpperCAmelCase_ = "swish"     ,UpperCAmelCase_ = 2_560     ,UpperCAmelCase_ = "mean"     ,UpperCAmelCase_ = 0.02     ,UpperCAmelCase_ = 0.0_01     ,UpperCAmelCase_ = 0.99     ,UpperCAmelCase_ = 0.2     ,**UpperCAmelCase_     ,)  ->							Union[str, Any]:
           super().__init__(**UpperCAmelCase_      )

           lowercase__		       =						num_channels
           lowercase__		       =						image_size
           lowercase__		       =						width_coefficient
           lowercase__		       =						depth_coefficient
           lowercase__		       =						depth_divisor
           lowercase__		       =						kernel_sizes
           lowercase__		       =						in_channels
           lowercase__		       =						out_channels
           lowercase__		       =						depthwise_padding
           lowercase__		       =						strides
           lowercase__		       =						num_block_repeats
           lowercase__		       =						expand_ratios
           lowercase__		       =						squeeze_expansion_ratio
           lowercase__		       =						hidden_act
           lowercase__		       =						hidden_dim
           lowercase__		       =						pooling_type
           lowercase__		       =						initializer_range
           lowercase__		       =						batch_norm_eps
           lowercase__		       =						batch_norm_momentum
           lowercase__		       =						drop_connect_rate
           lowercase__		       =						sum(UpperCAmelCase_      ) * 4







       @classmethod
       def 							_a      (				cls     ,UpperCAmelCase_     ,**UpperCAmelCase_      )  ->							"PretrainedConfig":
           cls._set_token_in_kwargs(UpperCAmelCase_      )

           lowercase__       ,       lowercase__		       =						cls.get_config_dict(UpperCAmelCase_     ,**UpperCAmelCase_      )

           # get the vision config dict if we are loading from AlignConfig
           if config_dict.get("model_type"      ) == "align":
               lowercase__		       =						config_dict["vision_config"]

           if "model_type" in config_dict and hasattr(cls     ,"model_type"      ) and config_dict["model_type"] != cls.model_type:
               logger.warning(
                   F'''You are using a model of type {config_dict['model_type']} to instantiate a model of type '''
                   F'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.'''      )

           return cls.from_dict(UpperCAmelCase_     ,**UpperCAmelCase_      )





class 				snake_case (UpperCamelCase   ):
       lowerCAmelCase__  :Union[str, Any]						   =					"align"
       lowerCAmelCase__  :Tuple						   =					True



       def __init__(				self     ,UpperCAmelCase_=None     ,UpperCAmelCase_=None     ,UpperCAmelCase_=640     ,UpperCAmelCase_=1.0     ,UpperCAmelCase_=0.02     ,**UpperCAmelCase_     ,)  ->							Union[str, Any]:
           super().__init__(**UpperCAmelCase_      )

           if text_config is None:
               lowercase__		       =						{}
               logger.info("text_config is None. Initializing the AlignTextConfig with default values."      )

           if vision_config is None:
               lowercase__		       =						{}
               logger.info("vision_config is None. Initializing the AlignVisionConfig with default values."      )

           lowercase__		       =						AlignTextConfig(**UpperCAmelCase_      )
           lowercase__		       =						AlignVisionConfig(**UpperCAmelCase_      )

           lowercase__		       =						projection_dim
           lowercase__		       =						temperature_init_value
           lowercase__		       =						initializer_range



       @classmethod
       def 							_a      (				cls     ,UpperCAmelCase_     ,UpperCAmelCase_     ,**UpperCAmelCase_      )  ->							List[str]:
           return cls(text_config=text_config.to_dict()     ,vision_config=vision_config.to_dict()     ,**UpperCAmelCase_      )







       def 							_a      (				self      )  ->							List[Any]:
           lowercase__		       =						copy.deepcopy(self.__dict__      )
           lowercase__		       =						self.text_config.to_dict()
           lowercase__		       =						self.vision_config.to_dict()
           lowercase__		       =						self.__class__.model_type
           return output




