





'''simple docstring'''
import os
import shutil
import sys
import tempfile
import unittest
from pathlib import Path

import pytest

import transformers
from transformers import (
    BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    AutoTokenizer,
    BertConfig,
    BertTokenizer,
    BertTokenizerFast,
    CTRLTokenizer,
    GPTaTokenizer,
    GPTaTokenizerFast,
    PreTrainedTokenizerFast,
    RobertaTokenizer,
    RobertaTokenizerFast,
    is_tokenizers_available,
)
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.auto.tokenization_auto import (
    TOKENIZER_MAPPING,
    get_tokenizer_config,
    tokenizer_class_from_name,
)
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import (
    DUMMY_DIFF_TOKENIZER_IDENTIFIER,
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tokenizers,
    slow,
)


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

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
    from test_module.custom_tokenization_fast import CustomTokenizerFast

class      snake_case     (    unittest.TestCase       ):




 """simple docstring"""



 def        _lowerCamelCase					(       self       :							Any	):
        __UpperCamelCase       =  0






 @slow
 def        _lowerCamelCase					(       self       :							Dict	):
        for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
               __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A	)
               self.assertIsNotNone(__A	)
               self.assertIsInstance(__A							,	(BertTokenizer, BertTokenizerFast)	)
               self.assertGreater(len(__A	)							,	0	)

        for model_name in GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP.keys():
               __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A	)
               self.assertIsNotNone(__A	)
               self.assertIsInstance(__A							,	(GPTaTokenizer, GPTaTokenizerFast)	)
               self.assertGreater(len(__A	)							,	0	)






 def        _lowerCamelCase					(       self       :							Dict	):
        __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A	)
        self.assertIsInstance(__A							,	(BertTokenizer, BertTokenizerFast)	)
        self.assertEqual(tokenizer.vocab_size							,	1_2	)






 def        _lowerCamelCase					(       self       :							Union[str, Any]	):
        __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A	)
        self.assertIsInstance(__A							,	(RobertaTokenizer, RobertaTokenizerFast)	)
        self.assertEqual(tokenizer.vocab_size							,	2_0	)






 def        _lowerCamelCase					(       self       :							Dict	):
        __UpperCamelCase       =  AutoConfig.from_pretrained(__A	)
        self.assertIsInstance(__A							,	__A	)
        # Check that tokenizer_type ≠ model_type
        __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A							,	config=__A	)
        self.assertIsInstance(__A							,	(BertTokenizer, BertTokenizerFast)	)
        self.assertEqual(tokenizer.vocab_size							,	1_2	)






 def        _lowerCamelCase					(       self       :							Optional[Any]	):
        with tempfile.TemporaryDirectory() as tmp_dir:
               shutil.copy('./tests/fixtures/vocab.txt'							,	os.path.join(__A							,	'vocab.txt'	)	)

               __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A							,	tokenizer_type='bert'							,	use_fast=__A	)
               self.assertIsInstance(__A							,	__A	)

        with tempfile.TemporaryDirectory() as tmp_dir:
               shutil.copy('./tests/fixtures/vocab.json'							,	os.path.join(__A							,	'vocab.json'	)	)
               shutil.copy('./tests/fixtures/merges.txt'							,	os.path.join(__A							,	'merges.txt'	)	)

               __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A							,	tokenizer_type='gpt2'							,	use_fast=__A	)
               self.assertIsInstance(__A							,	__A	)






 @require_tokenizers
 def        _lowerCamelCase					(       self       :							Optional[int]	):
        with tempfile.TemporaryDirectory() as tmp_dir:
               shutil.copy('./tests/fixtures/vocab.txt'							,	os.path.join(__A							,	'vocab.txt'	)	)

               __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A							,	tokenizer_type='bert'	)
               self.assertIsInstance(__A							,	__A	)

        with tempfile.TemporaryDirectory() as tmp_dir:
               shutil.copy('./tests/fixtures/vocab.json'							,	os.path.join(__A							,	'vocab.json'	)	)
               shutil.copy('./tests/fixtures/merges.txt'							,	os.path.join(__A							,	'merges.txt'	)	)

               __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A							,	tokenizer_type='gpt2'	)
               self.assertIsInstance(__A							,	__A	)






 def        _lowerCamelCase					(       self       :							int	):
        with pytest.raises(__A	):
               AutoTokenizer.from_pretrained('./'							,	tokenizer_type='xxx'	)






 @require_tokenizers
 def        _lowerCamelCase					(       self       :							Optional[Any]	):
        for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
               __UpperCamelCase       =  tokenizer_class.from_pretrained('wietsedv/bert-base-dutch-cased'	)
               self.assertIsInstance(__A							,	(BertTokenizer, BertTokenizerFast)	)

               if isinstance(__A							,	__A	):
                      self.assertEqual(tokenizer.basic_tokenizer.do_lower_case							,	__A	)
               else:
                      self.assertEqual(tokenizer.do_lower_case							,	__A	)

               self.assertEqual(tokenizer.model_max_length							,	5_1_2	)






 @require_tokenizers
 def        _lowerCamelCase					(       self       :							List[str]	):
        for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
               with self.assertRaisesRegex(
                   __A							,	'julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier'							,	):
                      __UpperCamelCase       =  tokenizer_class.from_pretrained('julien-c/herlolip-not-exists'	)






 def        _lowerCamelCase					(       self       :							List[Any]	):
        # tests: https://github.com/huggingface/transformers/pull/13251
        # 1. models with `-`, e.g. xlm-roberta -> xlm_roberta
        # 2. models that don't remap 1-1 from model-name to model file, e.g., openai-gpt -> openai
        __UpperCamelCase       =  TOKENIZER_MAPPING.values()
        __UpperCamelCase       =  []

        for slow_tok, fast_tok in tokenizers:
               if slow_tok is not None:
                      tokenizer_names.append(slow_tok.__name__	)

               if fast_tok is not None:
                      tokenizer_names.append(fast_tok.__name__	)

        for tokenizer_name in tokenizer_names:
               # must find the right class
               tokenizer_class_from_name(__A	)






 @require_tokenizers
 def        _lowerCamelCase					(       self       :							Optional[int]	):
        self.assertIsInstance(AutoTokenizer.from_pretrained('bert-base-cased'							,	use_fast=__A	)							,	__A	)
        self.assertIsInstance(AutoTokenizer.from_pretrained('bert-base-cased'	)							,	__A	)






 @require_tokenizers
 def        _lowerCamelCase					(       self       :							Optional[int]	):
        __UpperCamelCase       =  AutoTokenizer.from_pretrained('distilbert-base-uncased'							,	do_lower_case=__A	)
        __UpperCamelCase       =  'Hello, world. How are you?'
        __UpperCamelCase       =  tokenizer.tokenize(__A	)
        self.assertEqual('[UNK]'							,	tokens[0]	)

        __UpperCamelCase       =  AutoTokenizer.from_pretrained('microsoft/mpnet-base'							,	do_lower_case=__A	)
        __UpperCamelCase       =  tokenizer.tokenize(__A	)
        self.assertEqual('[UNK]'							,	tokens[0]	)






 @require_tokenizers
 def        _lowerCamelCase					(       self       :							List[Any]	):
        __UpperCamelCase       =  AutoTokenizer.from_pretrained('robot-test/dummy-tokenizer-fast-with-model-config'	)
        self.assertEqual(type(__A	)							,	__A	)
        self.assertEqual(tokenizer.model_max_length							,	5_1_2	)
        self.assertEqual(tokenizer.vocab_size							,	3_0_0_0_0	)
        self.assertEqual(tokenizer.unk_token							,	'[UNK]'	)
        self.assertEqual(tokenizer.padding_side							,	'right'	)
        self.assertEqual(tokenizer.truncation_side							,	'right'	)






 def        _lowerCamelCase					(       self       :							int	):
        __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A	)
        self.assertIsInstance(__A							,	(BertTokenizer, BertTokenizerFast)	)
        with tempfile.TemporaryDirectory() as tmp_dir:
               tokenizer.save_pretrained(__A	)
               __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A	)

        self.assertIsInstance(__A							,	tokenizer.__class__	)
        self.assertEqual(tokenizera.vocab_size							,	1_2	)






 def        _lowerCamelCase					(       self       :							int	):
        __UpperCamelCase       =  AutoTokenizer.from_pretrained('ctrl'	)
        # There is no fast CTRL so this always gives us a slow tokenizer.
        self.assertIsInstance(__A							,	__A	)






 def        _lowerCamelCase					(       self       :							Tuple	):
        # Check we can load the tokenizer config of an online model.
        __UpperCamelCase       =  get_tokenizer_config('bert-base-cased'	)
        __UpperCamelCase       =  config.pop('_commit_hash'							,	__A	)
        # If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
        self.assertEqual(__A							,	{'do_lower_case': False}	)

        # This model does not have a tokenizer_config so we get back an empty dict.
        __UpperCamelCase       =  get_tokenizer_config(__A	)
        self.assertDictEqual(__A							,	{}	)

        # A tokenizer saved with `save_pretrained` always creates a tokenizer config.
        __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A	)
        with tempfile.TemporaryDirectory() as tmp_dir:
               tokenizer.save_pretrained(__A	)
               __UpperCamelCase       =  get_tokenizer_config(__A	)

        # Check the class of the tokenizer was properly saved (note that it always saves the slow class).
        self.assertEqual(config['tokenizer_class']							,	'BertTokenizer'	)






 def        _lowerCamelCase					(       self       :							List[str]	):
        try:
               AutoConfig.register('custom'							,	__A	)

               AutoTokenizer.register(__A							,	slow_tokenizer_class=__A	)
               # Trying to register something existing in the Transformers library will raise an error
               with self.assertRaises(__A	):
                      AutoTokenizer.register(__A							,	slow_tokenizer_class=__A	)

               __UpperCamelCase       =  CustomTokenizer.from_pretrained(__A	)
               with tempfile.TemporaryDirectory() as tmp_dir:
                      tokenizer.save_pretrained(__A	)

                      __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A	)
                      self.assertIsInstance(__A							,	__A	)

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






 @require_tokenizers
 def        _lowerCamelCase					(       self       :							Optional[int]	):
        try:
               AutoConfig.register('custom'							,	__A	)

               # Can register in two steps
               AutoTokenizer.register(__A							,	slow_tokenizer_class=__A	)
               self.assertEqual(TOKENIZER_MAPPING[CustomConfig]							,	(CustomTokenizer, None)	)
               AutoTokenizer.register(__A							,	fast_tokenizer_class=__A	)
               self.assertEqual(TOKENIZER_MAPPING[CustomConfig]							,	(CustomTokenizer, CustomTokenizerFast)	)

               del TOKENIZER_MAPPING._extra_content[CustomConfig]
               # Can register in one step
               AutoTokenizer.register(
                   __A							,	slow_tokenizer_class=__A							,	fast_tokenizer_class=__A	)
               self.assertEqual(TOKENIZER_MAPPING[CustomConfig]							,	(CustomTokenizer, CustomTokenizerFast)	)

               # Trying to register something existing in the Transformers library will raise an error
               with self.assertRaises(__A	):
                      AutoTokenizer.register(__A							,	fast_tokenizer_class=__A	)

               # We pass through a bert tokenizer fast cause there is no converter slow to fast for our new toknizer
               # and that model does not have a tokenizer.json
               with tempfile.TemporaryDirectory() as tmp_dir:
                      __UpperCamelCase       =  BertTokenizerFast.from_pretrained(__A	)
                      bert_tokenizer.save_pretrained(__A	)
                      __UpperCamelCase       =  CustomTokenizerFast.from_pretrained(__A	)

               with tempfile.TemporaryDirectory() as tmp_dir:
                      tokenizer.save_pretrained(__A	)

                      __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A	)
                      self.assertIsInstance(__A							,	__A	)

                      __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A							,	use_fast=__A	)
                      self.assertIsInstance(__A							,	__A	)

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






 def        _lowerCamelCase					(       self       :							List[Any]	):
        # If remote code is not set, we will time out when asking whether to load the model.
        with self.assertRaises(__A	):
               __UpperCamelCase       =  AutoTokenizer.from_pretrained('hf-internal-testing/test_dynamic_tokenizer'	)
        # If remote code is disabled, we can't load this config.
        with self.assertRaises(__A	):
               __UpperCamelCase       =  AutoTokenizer.from_pretrained(
                   'hf-internal-testing/test_dynamic_tokenizer'							,	trust_remote_code=__A	)

        __UpperCamelCase       =  AutoTokenizer.from_pretrained('hf-internal-testing/test_dynamic_tokenizer'							,	trust_remote_code=__A	)
        self.assertTrue(tokenizer.special_attribute_present	)
        # Test tokenizer can be reloaded.
        with tempfile.TemporaryDirectory() as tmp_dir:
               tokenizer.save_pretrained(__A	)
               __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A							,	trust_remote_code=__A	)
        self.assertTrue(reloaded_tokenizer.special_attribute_present	)

        if is_tokenizers_available():
               self.assertEqual(tokenizer.__class__.__name__							,	'NewTokenizerFast'	)
               self.assertEqual(reloaded_tokenizer.__class__.__name__							,	'NewTokenizerFast'	)

               # Test we can also load the slow version
               __UpperCamelCase       =  AutoTokenizer.from_pretrained(
                   'hf-internal-testing/test_dynamic_tokenizer'							,	trust_remote_code=__A							,	use_fast=__A	)
               self.assertTrue(tokenizer.special_attribute_present	)
               self.assertEqual(tokenizer.__class__.__name__							,	'NewTokenizer'	)
               # Test tokenizer can be reloaded.
               with tempfile.TemporaryDirectory() as tmp_dir:
                      tokenizer.save_pretrained(__A	)
                      __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A							,	trust_remote_code=__A							,	use_fast=__A	)
               self.assertEqual(reloaded_tokenizer.__class__.__name__							,	'NewTokenizer'	)
               self.assertTrue(reloaded_tokenizer.special_attribute_present	)
        else:
               self.assertEqual(tokenizer.__class__.__name__							,	'NewTokenizer'	)
               self.assertEqual(reloaded_tokenizer.__class__.__name__							,	'NewTokenizer'	)






 @require_tokenizers
 def        _lowerCamelCase					(       self       :							Any	):

        class      snake_case     (    __lowerCamelCase       ):




         """simple docstring"""



         SCREAMING_SNAKE_CASE_	:					Any					=False






        class      snake_case     (    __lowerCamelCase       ):




         """simple docstring"""



         SCREAMING_SNAKE_CASE_	:					str					=NewTokenizer
         SCREAMING_SNAKE_CASE_	:					str					=False

        try:
               AutoConfig.register('custom'							,	__A	)
               AutoTokenizer.register(__A							,	slow_tokenizer_class=__A	)
               AutoTokenizer.register(__A							,	fast_tokenizer_class=__A	)
               # If remote code is not set, the default is to use local
               __UpperCamelCase       =  AutoTokenizer.from_pretrained('hf-internal-testing/test_dynamic_tokenizer'	)
               self.assertEqual(tokenizer.__class__.__name__							,	'NewTokenizerFast'	)
               self.assertFalse(tokenizer.special_attribute_present	)
               __UpperCamelCase       =  AutoTokenizer.from_pretrained('hf-internal-testing/test_dynamic_tokenizer'							,	use_fast=__A	)
               self.assertEqual(tokenizer.__class__.__name__							,	'NewTokenizer'	)
               self.assertFalse(tokenizer.special_attribute_present	)

               # If remote code is disabled, we load the local one.
               __UpperCamelCase       =  AutoTokenizer.from_pretrained(
                   'hf-internal-testing/test_dynamic_tokenizer'							,	trust_remote_code=__A	)
               self.assertEqual(tokenizer.__class__.__name__							,	'NewTokenizerFast'	)
               self.assertFalse(tokenizer.special_attribute_present	)
               __UpperCamelCase       =  AutoTokenizer.from_pretrained(
                   'hf-internal-testing/test_dynamic_tokenizer'							,	trust_remote_code=__A							,	use_fast=__A	)
               self.assertEqual(tokenizer.__class__.__name__							,	'NewTokenizer'	)
               self.assertFalse(tokenizer.special_attribute_present	)

               # If remote is enabled, we load from the Hub
               __UpperCamelCase       =  AutoTokenizer.from_pretrained(
                   'hf-internal-testing/test_dynamic_tokenizer'							,	trust_remote_code=__A	)
               self.assertEqual(tokenizer.__class__.__name__							,	'NewTokenizerFast'	)
               self.assertTrue(tokenizer.special_attribute_present	)
               __UpperCamelCase       =  AutoTokenizer.from_pretrained(
                   'hf-internal-testing/test_dynamic_tokenizer'							,	trust_remote_code=__A							,	use_fast=__A	)
               self.assertEqual(tokenizer.__class__.__name__							,	'NewTokenizer'	)
               self.assertTrue(tokenizer.special_attribute_present	)

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






 def        _lowerCamelCase					(       self       :							Dict	):
        __UpperCamelCase       =  AutoTokenizer.from_pretrained(
            'hf-internal-testing/test_dynamic_tokenizer_legacy'							,	trust_remote_code=__A	)
        self.assertTrue(tokenizer.special_attribute_present	)
        if is_tokenizers_available():
               self.assertEqual(tokenizer.__class__.__name__							,	'NewTokenizerFast'	)

               # Test we can also load the slow version
               __UpperCamelCase       =  AutoTokenizer.from_pretrained(
                   'hf-internal-testing/test_dynamic_tokenizer_legacy'							,	trust_remote_code=__A							,	use_fast=__A	)
               self.assertTrue(tokenizer.special_attribute_present	)
               self.assertEqual(tokenizer.__class__.__name__							,	'NewTokenizer'	)
        else:
               self.assertEqual(tokenizer.__class__.__name__							,	'NewTokenizer'	)






 def        _lowerCamelCase					(       self       :							int	):
        with self.assertRaisesRegex(
            __A							,	'bert-base is not a local folder and is not a valid model identifier'	):
               __UpperCamelCase       =  AutoTokenizer.from_pretrained('bert-base'	)






 def        _lowerCamelCase					(       self       :							str	):
        with self.assertRaisesRegex(
            __A							,	R'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'	):
               __UpperCamelCase       =  AutoTokenizer.from_pretrained(__A							,	revision='aaaaaa'	)






 def        _lowerCamelCase					(       self       :							Dict	):
        # Make sure we have cached the tokenizer.
        __UpperCamelCase       =  AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-bert'	)
        with RequestCounter() as counter:
               __UpperCamelCase       =  AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-bert'	)
               self.assertEqual(counter.get_request_count							,	0	)
               self.assertEqual(counter.head_request_count							,	1	)
               self.assertEqual(counter.other_request_count							,	0	)







'''simple docstring'''
import copy
import os
from typing import Union

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


a__							:							List[Any] =logging.get_logger(__name__)

a__							:							List[Any] ={
    '''BAAI/AltCLIP''': '''https://huggingface.co/BAAI/AltCLIP/resolve/main/config.json''',
    # See all AltCLIP models at https://huggingface.co/models?filter=altclip
}

class      snake_case     (    __lowerCamelCase       ):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_	:					Tuple					="altclip_text_model"






 def __init__(       self       :							str							,	__A       :							List[Any]=2_5_0_0_0_2							,	__A       :							Any=1_0_2_4							,	__A       :							int=2_4							,	__A       :							Dict=1_6							,	__A       :							Optional[Any]=4_0_9_6							,	__A       :							Union[str, Any]="gelu"							,	__A       :							Dict=0.1							,	__A       :							Dict=0.1							,	__A       :							List[str]=5_1_4							,	__A       :							Optional[int]=1							,	__A       :							int=0.02							,	__A       :							Optional[Any]=0.02							,	__A       :							Optional[Any]=1e-05							,	__A       :							Dict=1							,	__A       :							List[Any]=0							,	__A       :							int=2							,	__A       :							Tuple="absolute"							,	__A       :							Optional[Any]=True							,	__A       :							Optional[int]=7_6_8							,	**__A       :							List[str]							,	):
        super().__init__(pad_token_id=__A							,	bos_token_id=__A							,	eos_token_id=__A							,	**__A	)

        __UpperCamelCase       =  vocab_size
        __UpperCamelCase       =  hidden_size
        __UpperCamelCase       =  num_hidden_layers
        __UpperCamelCase       =  num_attention_heads
        __UpperCamelCase       =  hidden_act
        __UpperCamelCase       =  intermediate_size
        __UpperCamelCase       =  hidden_dropout_prob
        __UpperCamelCase       =  attention_probs_dropout_prob
        __UpperCamelCase       =  max_position_embeddings
        __UpperCamelCase       =  type_vocab_size
        __UpperCamelCase       =  initializer_range
        __UpperCamelCase       =  initializer_factor
        __UpperCamelCase       =  layer_norm_eps
        __UpperCamelCase       =  position_embedding_type
        __UpperCamelCase       =  use_cache
        __UpperCamelCase       =  project_dim






class      snake_case     (    __lowerCamelCase       ):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_	:					Tuple					="altclip_vision_model"






 def __init__(       self       :							List[Any]							,	__A       :							Union[str, Any]=7_6_8							,	__A       :							Optional[int]=3_0_7_2							,	__A       :							Optional[Any]=5_1_2							,	__A       :							Tuple=1_2							,	__A       :							Union[str, Any]=1_2							,	__A       :							Optional[int]=3							,	__A       :							Dict=2_2_4							,	__A       :							Tuple=3_2							,	__A       :							str="quick_gelu"							,	__A       :							Dict=1e-5							,	__A       :							Optional[int]=0.0							,	__A       :							List[Any]=0.02							,	__A       :							int=1.0							,	**__A       :							Optional[int]							,	):
        super().__init__(**__A	)

        __UpperCamelCase       =  hidden_size
        __UpperCamelCase       =  intermediate_size
        __UpperCamelCase       =  projection_dim
        __UpperCamelCase       =  num_hidden_layers
        __UpperCamelCase       =  num_attention_heads
        __UpperCamelCase       =  num_channels
        __UpperCamelCase       =  patch_size
        __UpperCamelCase       =  image_size
        __UpperCamelCase       =  initializer_range
        __UpperCamelCase       =  initializer_factor
        __UpperCamelCase       =  attention_dropout
        __UpperCamelCase       =  layer_norm_eps
        __UpperCamelCase       =  hidden_act






 @classmethod
 def        _lowerCamelCase					(       cls       :							Optional[Any]							,	__A       :							Union[str, os.PathLike]							,	**__A       :							Optional[Any]	):
        cls._set_token_in_kwargs(__A	)

        __UpperCamelCase       ,						__UpperCamelCase       =  cls.get_config_dict(__A							,	**__A	)

        # get the vision config dict if we are loading from AltCLIPConfig
        if config_dict.get('model_type'	) == "altclip":
               __UpperCamelCase       =  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(__A							,	**__A	)






class      snake_case     (    __lowerCamelCase       ):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_	:					List[str]					="altclip"
 SCREAMING_SNAKE_CASE_	:					Optional[int]					=True






 def __init__(       self       :							Any							,	__A       :							List[str]=None							,	__A       :							List[Any]=None							,	__A       :							List[str]=7_6_8							,	__A       :							List[str]=2.6592							,	**__A       :							Dict	):
        # If `_config_dict` exist, we use them for the backward compatibility.
        # We pop out these 2 attributes before calling `super().__init__` to avoid them being saved (which causes a lot
        # of confusion!).
        __UpperCamelCase       =  kwargs.pop('text_config_dict'							,	__A	)
        __UpperCamelCase       =  kwargs.pop('vision_config_dict'							,	__A	)

        super().__init__(**__A	)

        # Instead of simply assigning `[text|vision]_config_dict` to `[text|vision]_config`, we use the values in
        # `[text|vision]_config_dict` to update the values in `[text|vision]_config`. The values should be same in most
        # cases, but we don't want to break anything regarding `_config_dict` that existed before commit `8827e1b2`.
        if text_config_dict is not None:
               if text_config is None:
                      __UpperCamelCase       =  {}

               # This is the complete result when using `text_config_dict`.
               __UpperCamelCase       =  AltCLIPTextConfig(**__A	).to_dict()

               # Give a warning if the values exist in both `_text_config_dict` and `text_config` but being different.
               for key, value in _text_config_dict.items():
                      if key in text_config and value != text_config[key] and key not in ["transformers_version"]:
                             # If specified in `text_config_dict`
                             if key in text_config_dict:
                                    __UpperCamelCase       =  (
                                        f'''`{key}` is found in both `text_config_dict` and `text_config` but with different values. '''
                                        f'''The value `text_config_dict["{key}"]` will be used instead.'''
                                    )
                             # If inferred from default argument values (just to be super careful)
                             else:
                                    __UpperCamelCase       =  (
                                        f'''`text_config_dict` is provided which will be used to initialize `AltCLIPTextConfig`. The '''
                                        f'''value `text_config["{key}"]` will be overriden.'''
                                    )
                             logger.warning(__A	)

            # Update all values in `text_config` with the ones in `_text_config_dict`.
               text_config.update(_text_config_dict	)

        if vision_config_dict is not None:
               if vision_config is None:
                      __UpperCamelCase       =  {}

               # This is the complete result when using `vision_config_dict`.
               __UpperCamelCase       =  AltCLIPVisionConfig(**__A	).to_dict()
               # convert keys to string instead of integer
               if "id2label" in _vision_config_dict:
                      __UpperCamelCase       =  {
                          str(__A	): value for key, value in _vision_config_dict['id2label'].items()
                      }

               # Give a warning if the values exist in both `_vision_config_dict` and `vision_config` but being different.
               for key, value in _vision_config_dict.items():
                      if key in vision_config and value != vision_config[key] and key not in ["transformers_version"]:
                             # If specified in `vision_config_dict`
                             if key in vision_config_dict:
                                    __UpperCamelCase       =  (
                                        f'''`{key}` is found in both `vision_config_dict` and `vision_config` but with different '''
                                        f'''values. The value `vision_config_dict["{key}"]` will be used instead.'''
                                    )
                             # If inferred from default argument values (just to be super careful)
                             else:
                                    __UpperCamelCase       =  (
                                        f'''`vision_config_dict` is provided which will be used to initialize `AltCLIPVisionConfig`. '''
                                        f'''The value `vision_config["{key}"]` will be overriden.'''
                                    )
                             logger.warning(__A	)

            # Update all values in `vision_config` with the ones in `_vision_config_dict`.
               vision_config.update(_vision_config_dict	)

        if text_config is None:
               __UpperCamelCase       =  {}
               logger.info('`text_config` is `None`. Initializing the `AltCLIPTextConfig` with default values.'	)

        if vision_config is None:
               __UpperCamelCase       =  {}
               logger.info('`vision_config` is `None`. initializing the `AltCLIPVisionConfig` with default values.'	)

        __UpperCamelCase       =  AltCLIPTextConfig(**__A	)
        __UpperCamelCase       =  AltCLIPVisionConfig(**__A	)

        __UpperCamelCase       =  projection_dim
        __UpperCamelCase       =  logit_scale_init_value
        __UpperCamelCase       =  1.0






 @classmethod
 def        _lowerCamelCase					(       cls       :							Union[str, Any]							,	__A       :							AltCLIPTextConfig							,	__A       :							AltCLIPVisionConfig							,	**__A       :							Optional[Any]	):
        return cls(text_config=text_config.to_dict()							,	vision_config=vision_config.to_dict()							,	**__A	)






 def        _lowerCamelCase					(       self       :							List[Any]	):
        __UpperCamelCase       =  copy.deepcopy(self.__dict__	)
        __UpperCamelCase       =  self.text_config.to_dict()
        __UpperCamelCase       =  self.vision_config.to_dict()
        __UpperCamelCase       =  self.__class__.model_type
        return output
