
'''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 UpperCAmelCase__      (					unittest.TestCase      ):





  """simple docstring"""

  def     __lowercase						(						self :	List[Any]			):


     '''simple docstring'''






     _a							:      Union[str, Any]     =  0


  @slow
  def     __lowercase						(						self :	List[str]			):


     '''simple docstring'''






     for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
        _a							:      Union[str, Any]     =  AutoTokenizer.from_pretrained(__lowerCAmelCase			)
        self.assertIsNotNone(__lowerCAmelCase			)
        self.assertIsInstance(__lowerCAmelCase				,(BertTokenizer, BertTokenizerFast)			)
        self.assertGreater(len(__lowerCAmelCase			)				,0			)

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


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


     '''simple docstring'''






     _a							:      List[Any]     =  AutoTokenizer.from_pretrained(__lowerCAmelCase			)
     self.assertIsInstance(__lowerCAmelCase				,(BertTokenizer, BertTokenizerFast)			)
     self.assertEqual(tokenizer.vocab_size				,12			)


  def     __lowercase						(						self :	List[str]			):


     '''simple docstring'''






     _a							:      Optional[int]     =  AutoTokenizer.from_pretrained(__lowerCAmelCase			)
     self.assertIsInstance(__lowerCAmelCase				,(RobertaTokenizer, RobertaTokenizerFast)			)
     self.assertEqual(tokenizer.vocab_size				,20			)


  def     __lowercase						(						self :	Any			):


     '''simple docstring'''






     _a							:      Tuple     =  AutoConfig.from_pretrained(__lowerCAmelCase			)
     self.assertIsInstance(__lowerCAmelCase				,__lowerCAmelCase			)
     # Check that tokenizer_type ≠ model_type
     _a							:      Optional[int]     =  AutoTokenizer.from_pretrained(__lowerCAmelCase				,config=__lowerCAmelCase			)
     self.assertIsInstance(__lowerCAmelCase				,(BertTokenizer, BertTokenizerFast)			)
     self.assertEqual(tokenizer.vocab_size				,12			)


  def     __lowercase						(						self :	List[str]			):


     '''simple docstring'''






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

        _a							:      Dict     =  AutoTokenizer.from_pretrained(__lowerCAmelCase				,tokenizer_type='bert'				,use_fast=__lowerCAmelCase			)
        self.assertIsInstance(__lowerCAmelCase				,__lowerCAmelCase			)

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

        _a							:      Tuple     =  AutoTokenizer.from_pretrained(__lowerCAmelCase				,tokenizer_type='gpt2'				,use_fast=__lowerCAmelCase			)
        self.assertIsInstance(__lowerCAmelCase				,__lowerCAmelCase			)


  @require_tokenizers
  def     __lowercase						(						self :	Tuple			):


     '''simple docstring'''






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

        _a							:      Union[str, Any]     =  AutoTokenizer.from_pretrained(__lowerCAmelCase				,tokenizer_type='bert'			)
        self.assertIsInstance(__lowerCAmelCase				,__lowerCAmelCase			)

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

        _a							:      str     =  AutoTokenizer.from_pretrained(__lowerCAmelCase				,tokenizer_type='gpt2'			)
        self.assertIsInstance(__lowerCAmelCase				,__lowerCAmelCase			)


  def     __lowercase						(						self :	List[Any]			):


     '''simple docstring'''






     with pytest.raises(__lowerCAmelCase			):
        AutoTokenizer.from_pretrained('./'				,tokenizer_type='xxx'			)


  @require_tokenizers
  def     __lowercase						(						self :	Optional[int]			):


     '''simple docstring'''






     for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
        _a							:      Dict     =  tokenizer_class.from_pretrained('wietsedv/bert-base-dutch-cased'			)
        self.assertIsInstance(__lowerCAmelCase				,(BertTokenizer, BertTokenizerFast)			)

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

        self.assertEqual(tokenizer.model_max_length				,512			)


  @require_tokenizers
  def     __lowercase						(						self :	List[str]			):


     '''simple docstring'''






     for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
        with self.assertRaisesRegex(
            __lowerCAmelCase				,'julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier'				,):
           _a							:      Union[str, Any]     =  tokenizer_class.from_pretrained('julien-c/herlolip-not-exists'			)


  def     __lowercase						(						self :	Optional[Any]			):


     '''simple docstring'''






     _a							:      Any     =  TOKENIZER_MAPPING.values()
     _a							:      List[Any]     =  []

     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(__lowerCAmelCase			)


  @require_tokenizers
  def     __lowercase						(						self :	Optional[Any]			):


     '''simple docstring'''






     self.assertIsInstance(AutoTokenizer.from_pretrained('bert-base-cased'				,use_fast=__lowerCAmelCase			)				,__lowerCAmelCase			)
     self.assertIsInstance(AutoTokenizer.from_pretrained('bert-base-cased'			)				,__lowerCAmelCase			)


  @require_tokenizers
  def     __lowercase						(						self :	int			):


     '''simple docstring'''






     _a							:      Union[str, Any]     =  AutoTokenizer.from_pretrained('distilbert-base-uncased'				,do_lower_case=__lowerCAmelCase			)
     _a							:      int     =  'Hello, world. How are you?'
     _a							:      Union[str, Any]     =  tokenizer.tokenize(__lowerCAmelCase			)
     self.assertEqual('[UNK]'				,tokens[0]			)

     _a							:      List[str]     =  AutoTokenizer.from_pretrained('microsoft/mpnet-base'				,do_lower_case=__lowerCAmelCase			)
     _a							:      List[str]     =  tokenizer.tokenize(__lowerCAmelCase			)
     self.assertEqual('[UNK]'				,tokens[0]			)


  @require_tokenizers
  def     __lowercase						(						self :	Optional[Any]			):


     '''simple docstring'''






     _a							:      Dict     =  AutoTokenizer.from_pretrained('robot-test/dummy-tokenizer-fast-with-model-config'			)
     self.assertEqual(type(__lowerCAmelCase			)				,__lowerCAmelCase			)
     self.assertEqual(tokenizer.model_max_length				,512			)
     self.assertEqual(tokenizer.vocab_size				,3_0000			)
     self.assertEqual(tokenizer.unk_token				,'[UNK]'			)
     self.assertEqual(tokenizer.padding_side				,'right'			)
     self.assertEqual(tokenizer.truncation_side				,'right'			)


  def     __lowercase						(						self :	Optional[int]			):


     '''simple docstring'''






     _a							:      Any     =  AutoTokenizer.from_pretrained(__lowerCAmelCase			)
     self.assertIsInstance(__lowerCAmelCase				,(BertTokenizer, BertTokenizerFast)			)
     with tempfile.TemporaryDirectory() as tmp_dir:
        tokenizer.save_pretrained(__lowerCAmelCase			)
        _a							:      Union[str, Any]     =  AutoTokenizer.from_pretrained(__lowerCAmelCase			)

     self.assertIsInstance(__lowerCAmelCase				,tokenizer.__class__			)
     self.assertEqual(tokenizera.vocab_size				,12			)


  def     __lowercase						(						self :	Optional[int]			):


     '''simple docstring'''






     _a							:      Any     =  AutoTokenizer.from_pretrained('ctrl'			)
     # There is no fast CTRL so this always gives us a slow tokenizer.
     self.assertIsInstance(__lowerCAmelCase				,__lowerCAmelCase			)


  def     __lowercase						(						self :	str			):


     '''simple docstring'''






     _a							:      List[str]     =  get_tokenizer_config('bert-base-cased'			)
     _a							:      Any     =  config.pop('_commit_hash'				,__lowerCAmelCase			)
     # If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
     self.assertEqual(__lowerCAmelCase				,{'do_lower_case': False}			)

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

     # A tokenizer saved with `save_pretrained` always creates a tokenizer config.
     _a							:      Any     =  AutoTokenizer.from_pretrained(__lowerCAmelCase			)
     with tempfile.TemporaryDirectory() as tmp_dir:
        tokenizer.save_pretrained(__lowerCAmelCase			)
        _a							:      Optional[Any]     =  get_tokenizer_config(__lowerCAmelCase			)

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


  def     __lowercase						(						self :	List[Any]			):


     '''simple docstring'''






     try:
        AutoConfig.register('custom'				,__lowerCAmelCase			)

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

        _a							:      Union[str, Any]     =  CustomTokenizer.from_pretrained(__lowerCAmelCase			)
        with tempfile.TemporaryDirectory() as tmp_dir:
           tokenizer.save_pretrained(__lowerCAmelCase			)

           _a							:      Any     =  AutoTokenizer.from_pretrained(__lowerCAmelCase			)
           self.assertIsInstance(__lowerCAmelCase				,__lowerCAmelCase			)

     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     __lowercase						(						self :	List[Any]			):


     '''simple docstring'''






     try:
        AutoConfig.register('custom'				,__lowerCAmelCase			)

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

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

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

        # 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:
           _a							:      List[str]     =  BertTokenizerFast.from_pretrained(__lowerCAmelCase			)
           bert_tokenizer.save_pretrained(__lowerCAmelCase			)
           _a							:      Dict     =  CustomTokenizerFast.from_pretrained(__lowerCAmelCase			)

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

           _a							:      Optional[int]     =  AutoTokenizer.from_pretrained(__lowerCAmelCase			)
           self.assertIsInstance(__lowerCAmelCase				,__lowerCAmelCase			)

           _a							:      int     =  AutoTokenizer.from_pretrained(__lowerCAmelCase				,use_fast=__lowerCAmelCase			)
           self.assertIsInstance(__lowerCAmelCase				,__lowerCAmelCase			)

     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     __lowercase						(						self :	List[str]			):


     '''simple docstring'''






     with self.assertRaises(__lowerCAmelCase			):
        _a							:      Union[str, Any]     =  AutoTokenizer.from_pretrained('hf-internal-testing/test_dynamic_tokenizer'			)
     # If remote code is disabled, we can't load this config.
     with self.assertRaises(__lowerCAmelCase			):
        _a							:      int     =  AutoTokenizer.from_pretrained(
            'hf-internal-testing/test_dynamic_tokenizer'				,trust_remote_code=__lowerCAmelCase			)

     _a							:      List[Any]     =  AutoTokenizer.from_pretrained('hf-internal-testing/test_dynamic_tokenizer'				,trust_remote_code=__lowerCAmelCase			)
     self.assertTrue(tokenizer.special_attribute_present			)
     # Test tokenizer can be reloaded.
     with tempfile.TemporaryDirectory() as tmp_dir:
        tokenizer.save_pretrained(__lowerCAmelCase			)
        _a							:      Optional[Any]     =  AutoTokenizer.from_pretrained(__lowerCAmelCase				,trust_remote_code=__lowerCAmelCase			)
     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
        _a							:      List[Any]     =  AutoTokenizer.from_pretrained(
            'hf-internal-testing/test_dynamic_tokenizer'				,trust_remote_code=__lowerCAmelCase				,use_fast=__lowerCAmelCase			)
        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(__lowerCAmelCase			)
           _a							:      Any     =  AutoTokenizer.from_pretrained(__lowerCAmelCase				,trust_remote_code=__lowerCAmelCase				,use_fast=__lowerCAmelCase			)
        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     __lowercase						(						self :	List[str]			):


     '''simple docstring'''






     class UpperCAmelCase__      (					lowerCAmelCase_      ):





       """simple docstring"""

       __UpperCAmelCase							:							Tuple    					=   False







     class UpperCAmelCase__      (					lowerCAmelCase_      ):





       """simple docstring"""

       __UpperCAmelCase							:							Optional[int]    					=   NewTokenizer
       __UpperCAmelCase							:							Any    					=   False

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

        # If remote code is disabled, we load the local one.
        _a							:      Union[str, Any]     =  AutoTokenizer.from_pretrained(
            'hf-internal-testing/test_dynamic_tokenizer'				,trust_remote_code=__lowerCAmelCase			)
        self.assertEqual(tokenizer.__class__.__name__				,'NewTokenizerFast'			)
        self.assertFalse(tokenizer.special_attribute_present			)
        _a							:      Optional[Any]     =  AutoTokenizer.from_pretrained(
            'hf-internal-testing/test_dynamic_tokenizer'				,trust_remote_code=__lowerCAmelCase				,use_fast=__lowerCAmelCase			)
        self.assertEqual(tokenizer.__class__.__name__				,'NewTokenizer'			)
        self.assertFalse(tokenizer.special_attribute_present			)

        # If remote is enabled, we load from the Hub
        _a							:      Optional[int]     =  AutoTokenizer.from_pretrained(
            'hf-internal-testing/test_dynamic_tokenizer'				,trust_remote_code=__lowerCAmelCase			)
        self.assertEqual(tokenizer.__class__.__name__				,'NewTokenizerFast'			)
        self.assertTrue(tokenizer.special_attribute_present			)
        _a							:      List[str]     =  AutoTokenizer.from_pretrained(
            'hf-internal-testing/test_dynamic_tokenizer'				,trust_remote_code=__lowerCAmelCase				,use_fast=__lowerCAmelCase			)
        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     __lowercase						(						self :	Dict			):


     '''simple docstring'''






     _a							:      Optional[int]     =  AutoTokenizer.from_pretrained(
         'hf-internal-testing/test_dynamic_tokenizer_legacy'				,trust_remote_code=__lowerCAmelCase			)
     self.assertTrue(tokenizer.special_attribute_present			)
     if is_tokenizers_available():
        self.assertEqual(tokenizer.__class__.__name__				,'NewTokenizerFast'			)

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


  def     __lowercase						(						self :	List[Any]			):


     '''simple docstring'''






     with self.assertRaisesRegex(
         __lowerCAmelCase				,'bert-base is not a local folder and is not a valid model identifier'			):
        _a							:      Tuple     =  AutoTokenizer.from_pretrained('bert-base'			)


  def     __lowercase						(						self :	int			):


     '''simple docstring'''






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


  def     __lowercase						(						self :	List[str]			):


     '''simple docstring'''






     _a							:      List[Any]     =  AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-bert'			)
     with RequestCounter() as counter:
        _a							:      Optional[Any]     =  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

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..bit import BitConfig


UpperCAmelCase__			=    logging.get_logger(__name__)

UpperCAmelCase__			=    {
    """Intel/dpt-large""": """https://huggingface.co/Intel/dpt-large/resolve/main/config.json""",
    # See all DPT models at https://huggingface.co/models?filter=dpt
}


class 							a					(		lowerCAmelCase_ ):
    _snake_case  :	int  				=				'dpt'


    def __init__(       self						:	Any ,					__lowerCAmelCase						:	Optional[Any]=768 ,					__lowerCAmelCase						:	str=12 ,					__lowerCAmelCase						:	Optional[int]=12 ,					__lowerCAmelCase						:	Dict=3072 ,					__lowerCAmelCase						:	List[Any]="gelu" ,					__lowerCAmelCase						:	Tuple=0.0 ,					__lowerCAmelCase						:	str=0.0 ,					__lowerCAmelCase						:	List[Any]=0.02 ,					__lowerCAmelCase						:	Optional[Any]=1e-1_2 ,					__lowerCAmelCase						:	List[str]=384 ,					__lowerCAmelCase						:	Tuple=16 ,					__lowerCAmelCase						:	List[str]=3 ,					__lowerCAmelCase						:	Optional[Any]=False ,					__lowerCAmelCase						:	Optional[Any]=True ,					__lowerCAmelCase						:	Optional[Any]=[2, 5, 8, 11] ,					__lowerCAmelCase						:	Any="project" ,					__lowerCAmelCase						:	Dict=[4, 2, 1, 0.5] ,					__lowerCAmelCase						:	int=[96, 192, 384, 768] ,					__lowerCAmelCase						:	Dict=256 ,					__lowerCAmelCase						:	Optional[Any]=-1 ,					__lowerCAmelCase						:	Optional[Any]=False ,					__lowerCAmelCase						:	Union[str, Any]=True ,					__lowerCAmelCase						:	List[Any]=0.4 ,					__lowerCAmelCase						:	List[str]=255 ,					__lowerCAmelCase						:	List[Any]=0.1 ,					__lowerCAmelCase						:	Optional[int]=[1, 1024, 24, 24] ,					__lowerCAmelCase						:	List[Any]=[0, 1] ,					__lowerCAmelCase						:	Dict=None ,					**__lowerCAmelCase						:	str ,					):
      super().__init__(**__lowerCAmelCase       )

      _UpperCAmelCase    			=   hidden_size
      _UpperCAmelCase    			=   is_hybrid

      if self.is_hybrid:
        if backbone_config is None:
          logger.info("""Initializing the config with a `BiT` backbone."""       )
          _UpperCAmelCase    			=   {
              """global_padding""": """same""",
              """layer_type""": """bottleneck""",
              """depths""": [3, 4, 9],
              """out_features""": ["""stage1""", """stage2""", """stage3"""],
              """embedding_dynamic_padding""": True,
          }
          _UpperCAmelCase    			=   BitConfig(**__lowerCAmelCase       )
        elif isinstance(__lowerCAmelCase ,					__lowerCAmelCase       ):
          logger.info("""Initializing the config with a `BiT` backbone."""       )
          _UpperCAmelCase    			=   BitConfig(**__lowerCAmelCase       )
        elif isinstance(__lowerCAmelCase ,					__lowerCAmelCase       ):
          _UpperCAmelCase    			=   backbone_config
        else:
          raise ValueError(
              f'''backbone_config must be a dictionary or a `PretrainedConfig`, got {backbone_config.__class__}.'''       )

        _UpperCAmelCase    			=   backbone_featmap_shape
        _UpperCAmelCase    			=   neck_ignore_stages

        if readout_type != "project":
          raise ValueError("""Readout type must be 'project' when using `DPT-hybrid` mode."""       )
      else:
        _UpperCAmelCase    			=   None
        _UpperCAmelCase    			=   None
        _UpperCAmelCase    			=   []

      _UpperCAmelCase    			=   num_hidden_layers
      _UpperCAmelCase    			=   num_attention_heads
      _UpperCAmelCase    			=   intermediate_size
      _UpperCAmelCase    			=   hidden_act
      _UpperCAmelCase    			=   hidden_dropout_prob
      _UpperCAmelCase    			=   attention_probs_dropout_prob
      _UpperCAmelCase    			=   initializer_range
      _UpperCAmelCase    			=   layer_norm_eps
      _UpperCAmelCase    			=   image_size
      _UpperCAmelCase    			=   patch_size
      _UpperCAmelCase    			=   num_channels
      _UpperCAmelCase    			=   qkv_bias
      _UpperCAmelCase    			=   backbone_out_indices
      if readout_type not in ["ignore", "add", "project"]:
        raise ValueError("""Readout_type must be one of ['ignore', 'add', 'project']"""       )
      _UpperCAmelCase    			=   readout_type
      _UpperCAmelCase    			=   reassemble_factors
      _UpperCAmelCase    			=   neck_hidden_sizes
      _UpperCAmelCase    			=   fusion_hidden_size
      _UpperCAmelCase    			=   head_in_index
      _UpperCAmelCase    			=   use_batch_norm_in_fusion_residual
      # auxiliary head attributes (semantic segmentation)
      _UpperCAmelCase    			=   use_auxiliary_head
      _UpperCAmelCase    			=   auxiliary_loss_weight
      _UpperCAmelCase    			=   semantic_loss_ignore_index
      _UpperCAmelCase    			=   semantic_classifier_dropout


    def   lowerCAmelCase_	(       self						:	List[str]       ):
      _UpperCAmelCase    			=   copy.deepcopy(self.__dict__       )

      if output["backbone_config"] is not None:
        _UpperCAmelCase    			=   self.backbone_config.to_dict()

      _UpperCAmelCase    			=   self.__class__.model_type
      return output
