


import argparse
import json

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from torchvision import transforms

from transformers import BitImageProcessor, FocalNetConfig, FocalNetForImageClassification
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling




def       a_ (       SCREAMING_SNAKE_CASE__   : Optional[int]	):
       '''simple docstring'''





       _lowerCamelCase			:						List[Any]            =[2, 2, 6, 2] if 'tiny' in model_name else [2, 2, 18, 2]
       _lowerCamelCase			:						List[str]            =True if 'large' in model_name or 'huge' in model_name else False
       _lowerCamelCase			:						List[str]            =True if 'large' in model_name or 'huge' in model_name else False
       _lowerCamelCase			:						Dict            =True if 'large' in model_name or 'huge' in model_name else False

       if "large" in model_name or "xlarge" in model_name or "huge" in model_name:
              if "fl3" in model_name:
                     _lowerCamelCase			:						Tuple            =[3, 3, 3, 3]
                     _lowerCamelCase			:						List[str]            =[5, 5, 5, 5]
              elif "fl4" in model_name:
                     _lowerCamelCase			:						Union[str, Any]            =[4, 4, 4, 4]
                     _lowerCamelCase			:						Optional[Any]            =[3, 3, 3, 3]

       if "tiny" in model_name or "small" in model_name or "base" in model_name:
              _lowerCamelCase			:						Union[str, Any]            =[3, 3, 3, 3]
              if "lrf" in model_name:
                     _lowerCamelCase			:						str            =[3, 3, 3, 3]
              else:
                     _lowerCamelCase			:						Any            =[2, 2, 2, 2]

       if "tiny" in model_name:
              _lowerCamelCase			:						str            =96
       elif "small" in model_name:
              _lowerCamelCase			:						Any            =96
       elif "base" in model_name:
              _lowerCamelCase			:						Any            =128
       elif "large" in model_name:
              _lowerCamelCase			:						Any            =192
       elif "xlarge" in model_name:
              _lowerCamelCase			:						List[Any]            =256
       elif "huge" in model_name:
              _lowerCamelCase			:						List[Any]            =352

       # set label information
       _lowerCamelCase			:						Union[str, Any]            ='huggingface/label-files'
       if "large" in model_name or "huge" in model_name:
              _lowerCamelCase			:						Any            ='imagenet-22k-id2label.json'
       else:
              _lowerCamelCase			:						Tuple            ='imagenet-1k-id2label.json'

       _lowerCamelCase			:						Union[str, Any]            =json.load(open(hf_hub_download(SCREAMING_SNAKE_CASE__						,     SCREAMING_SNAKE_CASE__						,     repo_type='dataset'	)						,     'r'	)	)
       _lowerCamelCase			:						str            ={int(SCREAMING_SNAKE_CASE__	): v for k, v in idalabel.items()}
       _lowerCamelCase			:						Tuple            ={v: k for k, v in idalabel.items()}

       _lowerCamelCase			:						Optional[Any]            =FocalNetConfig(
           embed_dim=SCREAMING_SNAKE_CASE__						,     depths=SCREAMING_SNAKE_CASE__						,     focal_levels=SCREAMING_SNAKE_CASE__						,     focal_windows=SCREAMING_SNAKE_CASE__						,     use_conv_embed=SCREAMING_SNAKE_CASE__						,     idalabel=SCREAMING_SNAKE_CASE__						,     labelaid=SCREAMING_SNAKE_CASE__						,     use_post_layernorm=SCREAMING_SNAKE_CASE__						,     use_layerscale=SCREAMING_SNAKE_CASE__						,     )

       return config




def       a_ (       SCREAMING_SNAKE_CASE__   : Union[str, Any]	):
       '''simple docstring'''





       if "patch_embed.proj" in name:
              _lowerCamelCase			:						Optional[int]            =name.replace('patch_embed.proj'						,     'embeddings.patch_embeddings.projection'	)
       if "patch_embed.norm" in name:
              _lowerCamelCase			:						List[Any]            =name.replace('patch_embed.norm'						,     'embeddings.norm'	)
       if "layers" in name:
              _lowerCamelCase			:						Optional[int]            ='encoder.' + name
       if "encoder.layers" in name:
              _lowerCamelCase			:						Union[str, Any]            =name.replace('encoder.layers'						,     'encoder.stages'	)
       if "downsample.proj" in name:
              _lowerCamelCase			:						Tuple            =name.replace('downsample.proj'						,     'downsample.projection'	)
       if "blocks" in name:
              _lowerCamelCase			:						Any            =name.replace('blocks'						,     'layers'	)
       if "modulation.f.weight" in name or "modulation.f.bias" in name:
              _lowerCamelCase			:						Dict            =name.replace('modulation.f'						,     'modulation.projection_in'	)
       if "modulation.h.weight" in name or "modulation.h.bias" in name:
              _lowerCamelCase			:						Optional[Any]            =name.replace('modulation.h'						,     'modulation.projection_context'	)
       if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
              _lowerCamelCase			:						int            =name.replace('modulation.proj'						,     'modulation.projection_out'	)

       if name == "norm.weight":
              _lowerCamelCase			:						List[str]            ='layernorm.weight'
       if name == "norm.bias":
              _lowerCamelCase			:						List[str]            ='layernorm.bias'

       if "head" in name:
              _lowerCamelCase			:						Dict            =name.replace('head'						,     'classifier'	)
       else:
              _lowerCamelCase			:						Any            ='focalnet.' + name

       return name




def       a_ (       SCREAMING_SNAKE_CASE__   : List[str]						,     SCREAMING_SNAKE_CASE__   : Optional[Any]						,     SCREAMING_SNAKE_CASE__   : Optional[int]=False	):
       '''simple docstring'''





       _lowerCamelCase			:						Optional[int]            ={
           'focalnet-tiny': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_srf.pth',
           'focalnet-tiny-lrf': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_lrf.pth',
           'focalnet-small': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_srf.pth',
           'focalnet-small-lrf': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_lrf.pth',
           'focalnet-base': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_srf.pth',
           'focalnet-base-lrf': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_lrf.pth',
           'focalnet-large-lrf-fl3': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384.pth',
           'focalnet-large-lrf-fl4': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384_fl4.pth',
           'focalnet-xlarge-lrf-fl3': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384.pth',
           'focalnet-xlarge-lrf-fl4': 'https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384_fl4.pth',
       }
       # fmt: on

       _lowerCamelCase			:						Dict            =model_name_to_url[model_name]
       print('Checkpoint URL: '						,     SCREAMING_SNAKE_CASE__	)
       _lowerCamelCase			:						int            =torch.hub.load_state_dict_from_url(SCREAMING_SNAKE_CASE__						,     map_location='cpu'	)['model']

       # rename keys
       for key in state_dict.copy().keys():
              _lowerCamelCase			:						List[str]            =state_dict.pop(SCREAMING_SNAKE_CASE__	)
              _lowerCamelCase			:						str            =val

       _lowerCamelCase			:						int            =get_focalnet_config(SCREAMING_SNAKE_CASE__	)
       _lowerCamelCase			:						Tuple            =FocalNetForImageClassification(SCREAMING_SNAKE_CASE__	)
       model.eval()

       # load state dict
       model.load_state_dict(SCREAMING_SNAKE_CASE__	)

       # verify conversion
       _lowerCamelCase			:						Tuple            ='http://images.cocodataset.org/val2017/000000039769.jpg'

       _lowerCamelCase			:						Optional[int]            =BitImageProcessor(
           do_resize=SCREAMING_SNAKE_CASE__						,     size={'shortest_edge': 256}						,     resample=PILImageResampling.BILINEAR						,     do_center_crop=SCREAMING_SNAKE_CASE__						,     crop_size=224						,     do_normalize=SCREAMING_SNAKE_CASE__						,     image_mean=SCREAMING_SNAKE_CASE__						,     image_std=SCREAMING_SNAKE_CASE__						,     )
       _lowerCamelCase			:						Optional[int]            =Image.open(requests.get(SCREAMING_SNAKE_CASE__						,     stream=SCREAMING_SNAKE_CASE__	).raw	)
       _lowerCamelCase			:						Optional[int]            =processor(images=SCREAMING_SNAKE_CASE__						,     return_tensors='pt'	)

       _lowerCamelCase			:						Dict            =transforms.Compose(
           [
               transforms.Resize(256	),
               transforms.CenterCrop(224	),
               transforms.ToTensor(),
               transforms.Normalize(mean=[0.4_85, 0.4_56, 0.4_06]						,     std=[0.2_29, 0.2_24, 0.2_25]	),
           ]	)

       _lowerCamelCase			:						Any            =image_transforms(SCREAMING_SNAKE_CASE__	).unsqueeze(0	)

       # verify pixel_values
       assert torch.allclose(inputs.pixel_values						,     SCREAMING_SNAKE_CASE__						,     atol=1e-4	)

       _lowerCamelCase			:						int            =model(**SCREAMING_SNAKE_CASE__	)

       _lowerCamelCase			:						Union[str, Any]            =outputs.logits.argmax(-1	).item()
       print('Predicted class:'						,     model.config.idalabel[predicted_class_idx]	)

       print('First values of logits:'						,     outputs.logits[0, :3]	)

       if model_name == "focalnet-tiny":
              _lowerCamelCase			:						Optional[Any]            =torch.tensor([0.21_66, -0.43_68, 0.21_91]	)
       elif model_name == "focalnet-tiny-lrf":
              _lowerCamelCase			:						str            =torch.tensor([1.16_69, 0.01_25, -0.16_95]	)
       elif model_name == "focalnet-small":
              _lowerCamelCase			:						List[str]            =torch.tensor([0.49_17, -0.04_30, 0.13_41]	)
       elif model_name == "focalnet-small-lrf":
              _lowerCamelCase			:						Any            =torch.tensor([-0.25_88, -0.53_42, -0.23_31]	)
       elif model_name == "focalnet-base":
              _lowerCamelCase			:						List[str]            =torch.tensor([-0.16_55, -0.40_90, -0.17_30]	)
       elif model_name == "focalnet-base-lrf":
              _lowerCamelCase			:						Tuple            =torch.tensor([0.53_06, -0.04_83, -0.39_28]	)
       assert torch.allclose(outputs.logits[0, :3]						,     SCREAMING_SNAKE_CASE__						,     atol=1e-4	)
       print('Looks ok!'	)

       if pytorch_dump_folder_path is not None:
              print(F'''Saving model and processor of {model_name} to {pytorch_dump_folder_path}'''	)
              model.save_pretrained(SCREAMING_SNAKE_CASE__	)
              processor.save_pretrained(SCREAMING_SNAKE_CASE__	)

       if push_to_hub:
              print(F'''Pushing model and processor of {model_name} to the hub...'''	)
              model.push_to_hub(F'''{model_name}'''	)
              processor.push_to_hub(F'''{model_name}'''	)


if __name__ == "__main__":
 lowerCamelCase		   =			argparse.ArgumentParser()
 # Required parameters
 parser.add_argument(
     '--model_name',
     default='focalnet-tiny',
     type=str,
     help='Name of the FocalNet model you\'d like to convert.',
 )
 parser.add_argument(
     '--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model directory.'
 )
 parser.add_argument(
     '--push_to_hub',
     action='store_true',
     help='Whether to push the model and processor to the hub.',
 )

 lowerCamelCase		   =			parser.parse_args()
 convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)






import json
import os
import sys
import tempfile
import unittest
from pathlib import Path
from shutil import copyfile

from huggingface_hub import HfFolder, Repository, create_repo, delete_repo
from requests.exceptions import HTTPError

import transformers
from transformers import (
    CONFIG_MAPPING,
    FEATURE_EXTRACTOR_MAPPING,
    PROCESSOR_MAPPING,
    TOKENIZER_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    AutoProcessor,
    AutoTokenizer,
    BertTokenizer,
    ProcessorMixin,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaProcessor,
)
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test
from transformers.tokenization_utils import TOKENIZER_CONFIG_FILE
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_tokenizers_available


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

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402
from test_module.custom_processing import CustomProcessor  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


lowerCamelCase		   =			get_tests_dir('fixtures/dummy_feature_extractor_config.json')
lowerCamelCase		   =			get_tests_dir('fixtures/vocab.json')
lowerCamelCase		   =			get_tests_dir('fixtures')




class A    (  unittest.TestCase	):
      UpperCamelCase__				:    Dict =['[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', 'bla', 'blou']






      def 			lowerCamelCase			(   self		:	str					)   ->		Optional[Any]:
             """simple docstring"""




             _lowerCamelCase			:						Dict            =0






      def 			lowerCamelCase			(   self		:	str					)   ->		List[str]:
             """simple docstring"""




             _lowerCamelCase			:						List[Any]            =AutoProcessor.from_pretrained('facebook/wav2vec2-base-960h'					)
             self.assertIsInstance(lowercase_     ,  lowercase_					)






      def 			lowerCamelCase			(   self		:	int					)   ->		Tuple:
             """simple docstring"""




             with tempfile.TemporaryDirectory() as tmpdirname:
                    _lowerCamelCase			:						int            =WavaVecaConfig()
                    _lowerCamelCase			:						Dict            =AutoProcessor.from_pretrained('facebook/wav2vec2-base-960h'					)

                    # save in new folder
                    model_config.save_pretrained(lowercase_					)
                    processor.save_pretrained(lowercase_					)

                    _lowerCamelCase			:						Any            =AutoProcessor.from_pretrained(lowercase_					)

             self.assertIsInstance(lowercase_     ,  lowercase_					)






      def 			lowerCamelCase			(   self		:	str					)   ->		Union[str, Any]:
             """simple docstring"""




             with tempfile.TemporaryDirectory() as tmpdirname:
                    # copy relevant files
                    copyfile(lowercase_     ,  os.path.join(lowercase_     ,  lowercase_					)					)
                    copyfile(lowercase_     ,  os.path.join(lowercase_     ,  'vocab.json'					)					)

                    _lowerCamelCase			:						Union[str, Any]            =AutoProcessor.from_pretrained(lowercase_					)

             self.assertIsInstance(lowercase_     ,  lowercase_					)






      def 			lowerCamelCase			(   self		:	Any					)   ->		Optional[Any]:
             """simple docstring"""




             with tempfile.TemporaryDirectory() as tmpdirname:
                    _lowerCamelCase			:						List[Any]            =WavaVecaFeatureExtractor()
                    _lowerCamelCase			:						List[str]            =AutoTokenizer.from_pretrained('facebook/wav2vec2-base-960h'					)

                    _lowerCamelCase			:						str            =WavaVecaProcessor(lowercase_     ,  lowercase_					)

                    # save in new folder
                    processor.save_pretrained(lowercase_					)

                    # drop `processor_class` in tokenizer
                    with open(os.path.join(lowercase_     ,  lowercase_					)     ,  'r'					) as f:
                           _lowerCamelCase			:						Optional[int]            =json.load(lowercase_					)
                           config_dict.pop('processor_class'					)

                    with open(os.path.join(lowercase_     ,  lowercase_					)     ,  'w'					) as f:
                           f.write(json.dumps(lowercase_					)					)

                    _lowerCamelCase			:						Optional[int]            =AutoProcessor.from_pretrained(lowercase_					)

             self.assertIsInstance(lowercase_     ,  lowercase_					)






      def 			lowerCamelCase			(   self		:	Dict					)   ->		Optional[int]:
             """simple docstring"""




             with tempfile.TemporaryDirectory() as tmpdirname:
                    _lowerCamelCase			:						Optional[Any]            =WavaVecaFeatureExtractor()
                    _lowerCamelCase			:						Tuple            =AutoTokenizer.from_pretrained('facebook/wav2vec2-base-960h'					)

                    _lowerCamelCase			:						Dict            =WavaVecaProcessor(lowercase_     ,  lowercase_					)

                    # save in new folder
                    processor.save_pretrained(lowercase_					)

                    # drop `processor_class` in feature extractor
                    with open(os.path.join(lowercase_     ,  lowercase_					)     ,  'r'					) as f:
                           _lowerCamelCase			:						Union[str, Any]            =json.load(lowercase_					)
                           config_dict.pop('processor_class'					)

                    with open(os.path.join(lowercase_     ,  lowercase_					)     ,  'w'					) as f:
                           f.write(json.dumps(lowercase_					)					)

                    _lowerCamelCase			:						Optional[int]            =AutoProcessor.from_pretrained(lowercase_					)

             self.assertIsInstance(lowercase_     ,  lowercase_					)






      def 			lowerCamelCase			(   self		:	List[str]					)   ->		List[str]:
             """simple docstring"""




             with tempfile.TemporaryDirectory() as tmpdirname:
                    _lowerCamelCase			:						Optional[Any]            =WavaVecaConfig(processor_class='Wav2Vec2Processor'					)
                    model_config.save_pretrained(lowercase_					)
                    # copy relevant files
                    copyfile(lowercase_     ,  os.path.join(lowercase_     ,  'vocab.json'					)					)
                    # create emtpy sample processor
                    with open(os.path.join(lowercase_     ,  lowercase_					)     ,  'w'					) as f:
                           f.write('{}'					)

                    _lowerCamelCase			:						int            =AutoProcessor.from_pretrained(lowercase_					)

             self.assertIsInstance(lowercase_     ,  lowercase_					)






      def 			lowerCamelCase			(   self		:	str					)   ->		Optional[int]:
             """simple docstring"""




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

             _lowerCamelCase			:						List[str]            =AutoProcessor.from_pretrained('hf-internal-testing/test_dynamic_processor'     ,  trust_remote_code=lowercase_					)
             self.assertTrue(processor.special_attribute_present					)
             self.assertEqual(processor.__class__.__name__     ,  'NewProcessor'					)

             _lowerCamelCase			:						int            =processor.feature_extractor
             self.assertTrue(feature_extractor.special_attribute_present					)
             self.assertEqual(feature_extractor.__class__.__name__     ,  'NewFeatureExtractor'					)

             _lowerCamelCase			:						Optional[int]            =processor.tokenizer
             self.assertTrue(tokenizer.special_attribute_present					)
             if is_tokenizers_available():
                    self.assertEqual(tokenizer.__class__.__name__     ,  'NewTokenizerFast'					)

                    # Test we can also load the slow version
                    _lowerCamelCase			:						int            =AutoProcessor.from_pretrained(
                        'hf-internal-testing/test_dynamic_processor'     ,  trust_remote_code=lowercase_     ,  use_fast=lowercase_					)
                    _lowerCamelCase			:						Optional[int]            =new_processor.tokenizer
                    self.assertTrue(new_tokenizer.special_attribute_present					)
                    self.assertEqual(new_tokenizer.__class__.__name__     ,  'NewTokenizer'					)
             else:
                    self.assertEqual(tokenizer.__class__.__name__     ,  'NewTokenizer'					)






      def 			lowerCamelCase			(   self		:	Optional[int]					)   ->		Optional[int]:
             """simple docstring"""




             try:
                    AutoConfig.register('custom'     ,  lowercase_					)
                    AutoFeatureExtractor.register(lowercase_     ,  lowercase_					)
                    AutoTokenizer.register(lowercase_     ,  slow_tokenizer_class=lowercase_					)
                    AutoProcessor.register(lowercase_     ,  lowercase_					)
                    # Trying to register something existing in the Transformers library will raise an error
                    with self.assertRaises(lowercase_					):
                           AutoProcessor.register(lowercase_     ,  lowercase_					)

                    # Now that the config is registered, it can be used as any other config with the auto-API
                    _lowerCamelCase			:						str            =CustomFeatureExtractor.from_pretrained(lowercase_					)

                    with tempfile.TemporaryDirectory() as tmp_dir:
                           _lowerCamelCase			:						str            =os.path.join(lowercase_     ,  'vocab.txt'					)
                           with open(lowercase_     ,  'w'     ,  encoding='utf-8'					) as vocab_writer:
                                  vocab_writer.write(''.join([x + '\n' for x in self.vocab_tokens]					)					)
                           _lowerCamelCase			:						List[Any]            =CustomTokenizer(lowercase_					)

                    _lowerCamelCase			:						Optional[int]            =CustomProcessor(lowercase_     ,  lowercase_					)

                    with tempfile.TemporaryDirectory() as tmp_dir:
                           processor.save_pretrained(lowercase_					)
                           _lowerCamelCase			:						List[Any]            =AutoProcessor.from_pretrained(lowercase_					)
                           self.assertIsInstance(lowercase_     ,  lowercase_					)

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






      def 			lowerCamelCase			(   self		:	Union[str, Any]					)   ->		List[str]:
             """simple docstring"""




             class A    (  UpperCamelCase_	):
                   UpperCamelCase__				:    Optional[Any] =False




             class A    (  UpperCamelCase_	):
                   UpperCamelCase__				:    int =False




             class A    (  UpperCamelCase_	):
                   UpperCamelCase__				:    Union[str, Any] ='AutoFeatureExtractor'
                   UpperCamelCase__				:    str ='AutoTokenizer'
                   UpperCamelCase__				:    List[Any] =False

             try:
                    AutoConfig.register('custom'     ,  lowercase_					)
                    AutoFeatureExtractor.register(lowercase_     ,  lowercase_					)
                    AutoTokenizer.register(lowercase_     ,  slow_tokenizer_class=lowercase_					)
                    AutoProcessor.register(lowercase_     ,  lowercase_					)
                    # If remote code is not set, the default is to use local classes.
                    _lowerCamelCase			:						int            =AutoProcessor.from_pretrained('hf-internal-testing/test_dynamic_processor'					)
                    self.assertEqual(processor.__class__.__name__     ,  'NewProcessor'					)
                    self.assertFalse(processor.special_attribute_present					)
                    self.assertFalse(processor.feature_extractor.special_attribute_present					)
                    self.assertFalse(processor.tokenizer.special_attribute_present					)

                    # If remote code is disabled, we load the local ones.
                    _lowerCamelCase			:						int            =AutoProcessor.from_pretrained(
                        'hf-internal-testing/test_dynamic_processor'     ,  trust_remote_code=lowercase_					)
                    self.assertEqual(processor.__class__.__name__     ,  'NewProcessor'					)
                    self.assertFalse(processor.special_attribute_present					)
                    self.assertFalse(processor.feature_extractor.special_attribute_present					)
                    self.assertFalse(processor.tokenizer.special_attribute_present					)

                    # If remote is enabled, we load from the Hub.
                    _lowerCamelCase			:						str            =AutoProcessor.from_pretrained(
                        'hf-internal-testing/test_dynamic_processor'     ,  trust_remote_code=lowercase_					)
                    self.assertEqual(processor.__class__.__name__     ,  'NewProcessor'					)
                    self.assertTrue(processor.special_attribute_present					)
                    self.assertTrue(processor.feature_extractor.special_attribute_present					)
                    self.assertTrue(processor.tokenizer.special_attribute_present					)

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






      def 			lowerCamelCase			(   self		:	Optional[int]					)   ->		str:
             """simple docstring"""




             _lowerCamelCase			:						List[Any]            =AutoProcessor.from_pretrained('hf-internal-testing/tiny-random-bert'					)
             self.assertEqual(processor.__class__.__name__     ,  'BertTokenizerFast'					)






      def 			lowerCamelCase			(   self		:	Any					)   ->		Dict:
             """simple docstring"""




             _lowerCamelCase			:						Any            =AutoProcessor.from_pretrained('hf-internal-testing/tiny-random-convnext'					)
             self.assertEqual(processor.__class__.__name__     ,  'ConvNextImageProcessor'					)




@is_staging_test
class A    (  unittest.TestCase	):
      UpperCamelCase__				:    List[Any] =['[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', 'bla', 'blou']






      @classmethod
      def 			lowerCamelCase			(   cls		:	int					)   ->		Optional[Any]:
             """simple docstring"""




             _lowerCamelCase			:						Union[str, Any]            =TOKEN
             HfFolder.save_token(lowercase_					)






      @classmethod
      def 			lowerCamelCase			(   cls		:	Optional[int]					)   ->		Union[str, Any]:
             """simple docstring"""




             try:
                    delete_repo(token=cls._token     ,  repo_id='test-processor'					)
             except HTTPError:
                    pass

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

             try:
                    delete_repo(token=cls._token     ,  repo_id='test-dynamic-processor'					)
             except HTTPError:
                    pass






      def 			lowerCamelCase			(   self		:	str					)   ->		int:
             """simple docstring"""




             _lowerCamelCase			:						Tuple            =WavaVecaProcessor.from_pretrained(lowercase_					)
             with tempfile.TemporaryDirectory() as tmp_dir:
                    processor.save_pretrained(
                        os.path.join(lowercase_     ,  'test-processor'					)     ,  push_to_hub=lowercase_     ,  use_auth_token=self._token					)

                    _lowerCamelCase			:						Union[str, Any]            =WavaVecaProcessor.from_pretrained(F'''{USER}/test-processor'''					)
                    for k, v in processor.feature_extractor.__dict__.items():
                           self.assertEqual(lowercase_     ,  getattr(new_processor.feature_extractor     ,  lowercase_					)					)
                    self.assertDictEqual(new_processor.tokenizer.get_vocab()     ,  processor.tokenizer.get_vocab()					)






      def 			lowerCamelCase			(   self		:	str					)   ->		Tuple:
             """simple docstring"""




             _lowerCamelCase			:						int            =WavaVecaProcessor.from_pretrained(lowercase_					)

             with tempfile.TemporaryDirectory() as tmp_dir:
                    processor.save_pretrained(
                        os.path.join(lowercase_     ,  'test-processor-org'					)     ,  push_to_hub=lowercase_     ,  use_auth_token=self._token     ,  organization='valid_org'     ,  )

                    _lowerCamelCase			:						str            =WavaVecaProcessor.from_pretrained('valid_org/test-processor-org'					)
                    for k, v in processor.feature_extractor.__dict__.items():
                           self.assertEqual(lowercase_     ,  getattr(new_processor.feature_extractor     ,  lowercase_					)					)
                    self.assertDictEqual(new_processor.tokenizer.get_vocab()     ,  processor.tokenizer.get_vocab()					)






      def 			lowerCamelCase			(   self		:	List[Any]					)   ->		str:
             """simple docstring"""




             CustomFeatureExtractor.register_for_auto_class()
             CustomTokenizer.register_for_auto_class()
             CustomProcessor.register_for_auto_class()

             _lowerCamelCase			:						Optional[Any]            =CustomFeatureExtractor.from_pretrained(lowercase_					)

             with tempfile.TemporaryDirectory() as tmp_dir:
                    _lowerCamelCase			:						Dict            =os.path.join(lowercase_     ,  'vocab.txt'					)
                    with open(lowercase_     ,  'w'     ,  encoding='utf-8'					) as vocab_writer:
                           vocab_writer.write(''.join([x + '\n' for x in self.vocab_tokens]					)					)
                    _lowerCamelCase			:						Any            =CustomTokenizer(lowercase_					)

             _lowerCamelCase			:						List[Any]            =CustomProcessor(lowercase_     ,  lowercase_					)

             with tempfile.TemporaryDirectory() as tmp_dir:
                    create_repo(F'''{USER}/test-dynamic-processor'''     ,  token=self._token					)
                    _lowerCamelCase			:						List[str]            =Repository(lowercase_     ,  clone_from=F'''{USER}/test-dynamic-processor'''     ,  token=self._token					)
                    processor.save_pretrained(lowercase_					)

                    # This has added the proper auto_map field to the feature extractor config
                    self.assertDictEqual(
                        processor.feature_extractor.auto_map     ,  {
                            'AutoFeatureExtractor': 'custom_feature_extraction.CustomFeatureExtractor',
                            'AutoProcessor': 'custom_processing.CustomProcessor',
                        }     ,  )

                    # This has added the proper auto_map field to the tokenizer config
                    with open(os.path.join(lowercase_     ,  'tokenizer_config.json'					)					) as f:
                           _lowerCamelCase			:						Union[str, Any]            =json.load(lowercase_					)
                    self.assertDictEqual(
                        tokenizer_config['auto_map']     ,  {
                            'AutoTokenizer': ['custom_tokenization.CustomTokenizer', None],
                            'AutoProcessor': 'custom_processing.CustomProcessor',
                        }     ,  )

                    # The code has been copied from fixtures
                    self.assertTrue(os.path.isfile(os.path.join(lowercase_     ,  'custom_feature_extraction.py'					)					)					)
                    self.assertTrue(os.path.isfile(os.path.join(lowercase_     ,  'custom_tokenization.py'					)					)					)
                    self.assertTrue(os.path.isfile(os.path.join(lowercase_     ,  'custom_processing.py'					)					)					)

                    repo.push_to_hub()

             _lowerCamelCase			:						Tuple            =AutoProcessor.from_pretrained(F'''{USER}/test-dynamic-processor'''     ,  trust_remote_code=lowercase_					)
             # Can't make an isinstance check because the new_processor is from the CustomProcessor class of a dynamic module
             self.assertEqual(new_processor.__class__.__name__     ,  'CustomProcessor'					)


