





'''simple docstring'''

from collections import OrderedDict
from typing import Any, List, Mapping, Optional

from ... import PreTrainedTokenizer, TensorType, is_torch_available
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfigWithPast, PatchingSpec
from ...utils import logging


a   	=    logging.get_logger(__name__)


a   	=    {
    "Salesforce/codegen-350M-nl": "https://huggingface.co/Salesforce/codegen-350M-nl/resolve/main/config.json",
    "Salesforce/codegen-350M-multi": "https://huggingface.co/Salesforce/codegen-350M-multi/resolve/main/config.json",
    "Salesforce/codegen-350M-mono": "https://huggingface.co/Salesforce/codegen-350M-mono/resolve/main/config.json",
    "Salesforce/codegen-2B-nl": "https://huggingface.co/Salesforce/codegen-2B-nl/resolve/main/config.json",
    "Salesforce/codegen-2B-multi": "https://huggingface.co/Salesforce/codegen-2B-multi/resolve/main/config.json",
    "Salesforce/codegen-2B-mono": "https://huggingface.co/Salesforce/codegen-2B-mono/resolve/main/config.json",
    "Salesforce/codegen-6B-nl": "https://huggingface.co/Salesforce/codegen-6B-nl/resolve/main/config.json",
    "Salesforce/codegen-6B-multi": "https://huggingface.co/Salesforce/codegen-6B-multi/resolve/main/config.json",
    "Salesforce/codegen-6B-mono": "https://huggingface.co/Salesforce/codegen-6B-mono/resolve/main/config.json",
    "Salesforce/codegen-16B-nl": "https://huggingface.co/Salesforce/codegen-16B-nl/resolve/main/config.json",
    "Salesforce/codegen-16B-multi": "https://huggingface.co/Salesforce/codegen-16B-multi/resolve/main/config.json",
    "Salesforce/codegen-16B-mono": "https://huggingface.co/Salesforce/codegen-16B-mono/resolve/main/config.json",
}







class __a			( _snake_case      ):
   __UpperCamelCase :			str						   =						'codegen'
   __UpperCamelCase :			Tuple						   =						{
       'max_position_embeddings': 'n_positions',
       'hidden_size': 'n_embd',
       'num_attention_heads': 'n_head',
       'num_hidden_layers': 'n_layer',
   }





   def __init__(       self					:      Union[str, Any]					,lowerCamelCase					:      Dict=5_0400					,lowerCamelCase					:      Union[str, Any]=2048					,lowerCamelCase					:      Optional[int]=2048					,lowerCamelCase					:      Dict=4096					,lowerCamelCase					:      int=28					,lowerCamelCase					:      Dict=16					,lowerCamelCase					:      int=64					,lowerCamelCase					:      Optional[int]=None					,lowerCamelCase					:      List[Any]="gelu_new"					,lowerCamelCase					:      Optional[int]=0.0					,lowerCamelCase					:      str=0.0					,lowerCamelCase					:      Union[str, Any]=0.0					,lowerCamelCase					:      Optional[int]=1E-5					,lowerCamelCase					:      int=0.02					,lowerCamelCase					:      Union[str, Any]=True					,lowerCamelCase					:      Any=5_0256					,lowerCamelCase					:      Dict=5_0256					,lowerCamelCase					:      str=False					,**lowerCamelCase					:      Optional[int]					,):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							vocab_size
      __SCREAMING_SNAKE_CASE   				=							n_ctx
      __SCREAMING_SNAKE_CASE   				=							n_positions
      __SCREAMING_SNAKE_CASE   				=							n_embd
      __SCREAMING_SNAKE_CASE   				=							n_layer
      __SCREAMING_SNAKE_CASE   				=							n_head
      __SCREAMING_SNAKE_CASE   				=							n_inner
      __SCREAMING_SNAKE_CASE   				=							rotary_dim
      __SCREAMING_SNAKE_CASE   				=							activation_function
      __SCREAMING_SNAKE_CASE   				=							resid_pdrop
      __SCREAMING_SNAKE_CASE   				=							embd_pdrop
      __SCREAMING_SNAKE_CASE   				=							attn_pdrop
      __SCREAMING_SNAKE_CASE   				=							layer_norm_epsilon
      __SCREAMING_SNAKE_CASE   				=							initializer_range
      __SCREAMING_SNAKE_CASE   				=							use_cache

      __SCREAMING_SNAKE_CASE   				=							bos_token_id
      __SCREAMING_SNAKE_CASE   				=							eos_token_id

      super().__init__(
          bos_token_id=lowerCamelCase					,eos_token_id=lowerCamelCase					,tie_word_embeddings=lowerCamelCase					,**lowerCamelCase     )







class __a			( _snake_case      ):





   def __init__(       self					:      Optional[int]					,lowerCamelCase					:      PretrainedConfig					,lowerCamelCase					:      str = "default"					,lowerCamelCase					:      List[PatchingSpec] = None					,lowerCamelCase					:      bool = False					,):

      '''simple docstring'''

      super().__init__(lowerCamelCase					,task=lowerCamelCase					,patching_specs=lowerCamelCase					,use_past=lowerCamelCase     )
      if not getattr(self._config					,"""pad_token_id"""					,lowerCamelCase     ):
         # TODO: how to do that better?
         __SCREAMING_SNAKE_CASE   				=							0





   @property
   def   UpperCAmelCase__  (       self					:      Optional[int]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							OrderedDict({"""input_ids""": {0: """batch""", 1: """sequence"""}}     )
      if self.use_past:
         self.fill_with_past_key_values_(lowerCamelCase					,direction="""inputs"""     )
         __SCREAMING_SNAKE_CASE   				=							{0: """batch""", 1: """past_sequence + sequence"""}
      else:
         __SCREAMING_SNAKE_CASE   				=							{0: """batch""", 1: """sequence"""}

      return common_inputs





   @property
   def   UpperCAmelCase__  (       self					:      List[str]     ):

      '''simple docstring'''

      return self._config.n_layer





   @property
   def   UpperCAmelCase__  (       self					:      Union[str, Any]     ):

      '''simple docstring'''

      return self._config.n_head





   def   UpperCAmelCase__  (       self					:      List[Any]					,lowerCamelCase					:      PreTrainedTokenizer					,lowerCamelCase					:      int = -1					,lowerCamelCase					:      int = -1					,lowerCamelCase					:      bool = False					,lowerCamelCase					:      Optional[TensorType] = None					,):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							super(lowerCamelCase					,self     ).generate_dummy_inputs(
          lowerCamelCase					,batch_size=lowerCamelCase					,seq_length=lowerCamelCase					,is_pair=lowerCamelCase					,framework=lowerCamelCase     )

      # We need to order the input in the way they appears in the forward()
      __SCREAMING_SNAKE_CASE   				=							OrderedDict({"""input_ids""": common_inputs["""input_ids"""]}     )

      # Need to add the past_keys
      if self.use_past:
         if not is_torch_available():
            raise ValueError("""Cannot generate dummy past_keys inputs without PyTorch installed."""     )
         else:
            import torch

            __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							common_inputs["""input_ids"""].shape
            # Not using the same length for past_key_values
            __SCREAMING_SNAKE_CASE   				=							seqlen + 2
            __SCREAMING_SNAKE_CASE   				=							(
                batch,
                self.num_attention_heads,
                past_key_values_length,
                self._config.hidden_size // self.num_attention_heads,
            )
            __SCREAMING_SNAKE_CASE   				=							[
                (torch.zeros(lowerCamelCase     ), torch.zeros(lowerCamelCase     )) for _ in range(self.num_layers     )
            ]

      __SCREAMING_SNAKE_CASE   				=							common_inputs["""attention_mask"""]
      if self.use_past:
         __SCREAMING_SNAKE_CASE   				=							ordered_inputs["""attention_mask"""].dtype
         __SCREAMING_SNAKE_CASE   				=							torch.cat(
             [ordered_inputs["""attention_mask"""], torch.ones(lowerCamelCase					,lowerCamelCase					,dtype=lowerCamelCase     )]					,dim=1     )

      return ordered_inputs





   @property
   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      return 13












'''simple docstring'''

import json
import sys
import tempfile
import unittest
from pathlib import Path

import transformers
from transformers import (
    CONFIG_MAPPING,
    IMAGE_PROCESSOR_MAPPING,
    AutoConfig,
    AutoImageProcessor,
    CLIPConfig,
    CLIPImageProcessor,
)
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER


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

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_image_processing import CustomImageProcessor  # noqa E402







class __a			( unittest.TestCase      ):





   def   UpperCAmelCase__  (       self					:      Any     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							0





   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained("""openai/clip-vit-base-patch32"""     )
      self.assertIsInstance(lowerCamelCase					,lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Dict     ):

      '''simple docstring'''

      with tempfile.TemporaryDirectory() as tmpdirname:
         __SCREAMING_SNAKE_CASE   				=							Path(lowerCamelCase     ) / """preprocessor_config.json"""
         __SCREAMING_SNAKE_CASE   				=							Path(lowerCamelCase     ) / """config.json"""
         json.dump(
             {"""image_processor_type""": """CLIPImageProcessor""", """processor_class""": """CLIPProcessor"""}					,open(lowerCamelCase					,"""w"""     )					,)
         json.dump({"""model_type""": """clip"""}					,open(lowerCamelCase					,"""w"""     )     )

         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(lowerCamelCase     )
         self.assertIsInstance(lowerCamelCase					,lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Optional[Any]     ):

      '''simple docstring'''

      with tempfile.TemporaryDirectory() as tmpdirname:
         __SCREAMING_SNAKE_CASE   				=							Path(lowerCamelCase     ) / """preprocessor_config.json"""
         __SCREAMING_SNAKE_CASE   				=							Path(lowerCamelCase     ) / """config.json"""
         json.dump(
             {"""feature_extractor_type""": """CLIPFeatureExtractor""", """processor_class""": """CLIPProcessor"""}					,open(lowerCamelCase					,"""w"""     )					,)
         json.dump({"""model_type""": """clip"""}					,open(lowerCamelCase					,"""w"""     )     )

         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(lowerCamelCase     )
         self.assertIsInstance(lowerCamelCase					,lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      List[str]     ):

      '''simple docstring'''

      with tempfile.TemporaryDirectory() as tmpdirname:
         __SCREAMING_SNAKE_CASE   				=							CLIPConfig()

         # Create a dummy config file with image_proceesor_type
         __SCREAMING_SNAKE_CASE   				=							Path(lowerCamelCase     ) / """preprocessor_config.json"""
         __SCREAMING_SNAKE_CASE   				=							Path(lowerCamelCase     ) / """config.json"""
         json.dump(
             {"""image_processor_type""": """CLIPImageProcessor""", """processor_class""": """CLIPProcessor"""}					,open(lowerCamelCase					,"""w"""     )					,)
         json.dump({"""model_type""": """clip"""}					,open(lowerCamelCase					,"""w"""     )     )

         # remove image_processor_type to make sure config.json alone is enough to load image processor locally
         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(lowerCamelCase     ).to_dict()

         config_dict.pop("""image_processor_type"""     )
         __SCREAMING_SNAKE_CASE   				=							CLIPImageProcessor(**lowerCamelCase     )

         # save in new folder
         model_config.save_pretrained(lowerCamelCase     )
         config.save_pretrained(lowerCamelCase     )

         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(lowerCamelCase     )

         # make sure private variable is not incorrectly saved
         __SCREAMING_SNAKE_CASE   				=							json.loads(config.to_json_string()     )
         self.assertTrue("""_processor_class""" not in dict_as_saved     )

      self.assertIsInstance(lowerCamelCase					,lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Union[str, Any]     ):

      '''simple docstring'''

      with tempfile.TemporaryDirectory() as tmpdirname:
         __SCREAMING_SNAKE_CASE   				=							Path(lowerCamelCase     ) / """preprocessor_config.json"""
         json.dump(
             {"""image_processor_type""": """CLIPImageProcessor""", """processor_class""": """CLIPProcessor"""}					,open(lowerCamelCase					,"""w"""     )					,)

         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(lowerCamelCase     )
         self.assertIsInstance(lowerCamelCase					,lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Dict     ):

      '''simple docstring'''

      with self.assertRaisesRegex(
          lowerCamelCase					,"""clip-base is not a local folder and is not a valid model identifier"""     ):
         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained("""clip-base"""     )





   def   UpperCAmelCase__  (       self					:      Any     ):

      '''simple docstring'''

      with self.assertRaisesRegex(
          lowerCamelCase					,r"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"""     ):
         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(lowerCamelCase					,revision="""aaaaaa"""     )





   def   UpperCAmelCase__  (       self					:      List[Any]     ):

      '''simple docstring'''

      with self.assertRaisesRegex(
          lowerCamelCase					,"""hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json."""					,):
         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained("""hf-internal-testing/config-no-model"""     )





   def   UpperCAmelCase__  (       self					:      Any     ):

      '''simple docstring'''

      with self.assertRaises(lowerCamelCase     ):
         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained("""hf-internal-testing/test_dynamic_image_processor"""     )
      # If remote code is disabled, we can't load this config.
      with self.assertRaises(lowerCamelCase     ):
         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(
             """hf-internal-testing/test_dynamic_image_processor"""					,trust_remote_code=lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(
          """hf-internal-testing/test_dynamic_image_processor"""					,trust_remote_code=lowerCamelCase     )
      self.assertEqual(image_processor.__class__.__name__					,"""NewImageProcessor"""     )

      # Test image processor can be reloaded.
      with tempfile.TemporaryDirectory() as tmp_dir:
         image_processor.save_pretrained(lowerCamelCase     )
         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(lowerCamelCase					,trust_remote_code=lowerCamelCase     )
      self.assertEqual(reloaded_image_processor.__class__.__name__					,"""NewImageProcessor"""     )





   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      try:
         AutoConfig.register("""custom"""					,lowerCamelCase     )
         AutoImageProcessor.register(lowerCamelCase					,lowerCamelCase     )
         # Trying to register something existing in the Transformers library will raise an error
         with self.assertRaises(lowerCamelCase     ):
            AutoImageProcessor.register(lowerCamelCase					,lowerCamelCase     )

         with tempfile.TemporaryDirectory() as tmpdirname:
            __SCREAMING_SNAKE_CASE   				=							Path(lowerCamelCase     ) / """preprocessor_config.json"""
            __SCREAMING_SNAKE_CASE   				=							Path(lowerCamelCase     ) / """config.json"""
            json.dump(
                {"""feature_extractor_type""": """CLIPFeatureExtractor""", """processor_class""": """CLIPProcessor"""}					,open(lowerCamelCase					,"""w"""     )					,)
            json.dump({"""model_type""": """clip"""}					,open(lowerCamelCase					,"""w"""     )     )

            __SCREAMING_SNAKE_CASE   				=							CustomImageProcessor.from_pretrained(lowerCamelCase     )

         # Now that the config is registered, it can be used as any other config with the auto-API
         with tempfile.TemporaryDirectory() as tmp_dir:
            image_processor.save_pretrained(lowerCamelCase     )
            __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(lowerCamelCase     )
            self.assertIsInstance(lowerCamelCase					,lowerCamelCase     )

      finally:
         if "custom" in CONFIG_MAPPING._extra_content:
            del CONFIG_MAPPING._extra_content["custom"]
         if CustomConfig in IMAGE_PROCESSOR_MAPPING._extra_content:
            del IMAGE_PROCESSOR_MAPPING._extra_content[CustomConfig]





   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      class __a			( _snake_case      ):
         __UpperCamelCase :			int						   =						True

      try:
         AutoConfig.register("""custom"""					,lowerCamelCase     )
         AutoImageProcessor.register(lowerCamelCase					,lowerCamelCase     )
         # If remote code is not set, the default is to use local
         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained("""hf-internal-testing/test_dynamic_image_processor"""     )
         self.assertEqual(image_processor.__class__.__name__					,"""NewImageProcessor"""     )
         self.assertTrue(image_processor.is_local     )

         # If remote code is disabled, we load the local one.
         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(
             """hf-internal-testing/test_dynamic_image_processor"""					,trust_remote_code=lowerCamelCase     )
         self.assertEqual(image_processor.__class__.__name__					,"""NewImageProcessor"""     )
         self.assertTrue(image_processor.is_local     )

         # If remote is enabled, we load from the Hub
         __SCREAMING_SNAKE_CASE   				=							AutoImageProcessor.from_pretrained(
             """hf-internal-testing/test_dynamic_image_processor"""					,trust_remote_code=lowerCamelCase     )
         self.assertEqual(image_processor.__class__.__name__					,"""NewImageProcessor"""     )
         self.assertTrue(not hasattr(lowerCamelCase					,"""is_local"""     )     )

      finally:
         if "custom" in CONFIG_MAPPING._extra_content:
            del CONFIG_MAPPING._extra_content["custom"]
         if CustomConfig in IMAGE_PROCESSOR_MAPPING._extra_content:
            del IMAGE_PROCESSOR_MAPPING._extra_content[CustomConfig]





