


import numpy as np
import torch
from torch.utils.data import Dataset

from utils import logger




class A    (  UpperCamelCase_	):






      def __init__(   self		:	Optional[Any]     ,  lowercase_		:	Any     ,  lowercase_		:	str					)   ->		Optional[Any]:
             """simple docstring"""




             _lowerCamelCase			:						Union[str, Any]            =params

             _lowerCamelCase			:						List[Any]            =np.array(lowercase_					)
             _lowerCamelCase			:						Dict            =np.array([len(lowercase_					) for t in data]					)

             self.check()
             self.remove_long_sequences()
             self.remove_empty_sequences()
             self.remove_unknown_sequences()
             self.check()
             self.print_statistics()






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




             return (self.token_ids[index], self.lengths[index])






      def __len__(   self		:	Any					)   ->		Tuple:
             """simple docstring"""




             return len(self.lengths					)






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




             assert len(self.token_ids					) == len(self.lengths					)
             assert all(self.lengths[i] == len(self.token_ids[i]					) for i in range(len(self.lengths					)					)					)






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




             _lowerCamelCase			:						Dict            =self.params.max_model_input_size
             _lowerCamelCase			:						Any            =self.lengths > max_len
             logger.info(F'''Splitting {sum(lowercase_					)} too long sequences.'''					)

             def divide_chunks(lowercase_		:	List[str]     ,  lowercase_		:	List[Any]					):
                    return [l[i : i + n] for i in range(0     ,  len(lowercase_					)     ,  lowercase_					)]

             _lowerCamelCase			:						List[str]            =[]
             _lowerCamelCase			:						Union[str, Any]            =[]
             if self.params.mlm:
                    _lowerCamelCase      ,	_lowerCamelCase			:						Tuple            =self.params.special_tok_ids['cls_token'], self.params.special_tok_ids['sep_token']
             else:
                    _lowerCamelCase      ,	_lowerCamelCase			:						List[Any]            =self.params.special_tok_ids['bos_token'], self.params.special_tok_ids['eos_token']

             for seq_, len_ in zip(self.token_ids     ,  self.lengths					):
                    assert (seq_[0] == cls_id) and (seq_[-1] == sep_id), seq_
                    if len_ <= max_len:
                           new_tok_ids.append(seq_					)
                           new_lengths.append(len_					)
                    else:
                           _lowerCamelCase			:						str            =[]
                           for sub_s in divide_chunks(seq_     ,  max_len - 2					):
                                  if sub_s[0] != cls_id:
                                         _lowerCamelCase			:						Dict            =np.insert(lowercase_     ,  0     ,  lowercase_					)
                                  if sub_s[-1] != sep_id:
                                         _lowerCamelCase			:						Optional[int]            =np.insert(lowercase_     ,  len(lowercase_					)     ,  lowercase_					)
                                  assert len(lowercase_					) <= max_len
                                  assert (sub_s[0] == cls_id) and (sub_s[-1] == sep_id), sub_s
                                  sub_seqs.append(lowercase_					)

                           new_tok_ids.extend(lowercase_					)
                           new_lengths.extend([len(lowercase_					) for l in sub_seqs]					)

             _lowerCamelCase			:						Dict            =np.array(lowercase_					)
             _lowerCamelCase			:						List[str]            =np.array(lowercase_					)






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




             _lowerCamelCase			:						Tuple            =len(self					)
             _lowerCamelCase			:						List[Any]            =self.lengths > 11
             _lowerCamelCase			:						str            =self.token_ids[indices]
             _lowerCamelCase			:						int            =self.lengths[indices]
             _lowerCamelCase			:						Any            =len(self					)
             logger.info(F'''Remove {init_size - new_size} too short (<=11 tokens) sequences.'''					)






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




             if "unk_token" not in self.params.special_tok_ids:
                    return
             else:
                    _lowerCamelCase			:						Tuple            =self.params.special_tok_ids['unk_token']
             _lowerCamelCase			:						Optional[int]            =len(self					)
             _lowerCamelCase			:						List[str]            =np.array([np.count_nonzero(a == unk_token_id					) for a in self.token_ids]					)
             _lowerCamelCase			:						Optional[Any]            =(unk_occs / self.lengths) < 0.5
             _lowerCamelCase			:						str            =self.token_ids[indices]
             _lowerCamelCase			:						int            =self.lengths[indices]
             _lowerCamelCase			:						List[str]            =len(self					)
             logger.info(F'''Remove {init_size - new_size} sequences with a high level of unknown tokens (50%).'''					)






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




             if not self.params.is_master:
                    return
             logger.info(F'''{len(self					)} sequences'''					)
             # data_len = sum(self.lengths)
             # nb_unique_tokens = len(Counter(list(chain(*self.token_ids))))
             # logger.info(f'{data_len} tokens ({nb_unique_tokens} unique)')

             # unk_idx = self.params.special_tok_ids['unk_token']
             # nb_unknown = sum([(t==unk_idx).sum() for t in self.token_ids])
             # logger.info(f'{nb_unknown} unknown tokens (covering {100*nb_unknown/data_len:.2f}% of the data)')






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




             _lowerCamelCase			:						Optional[int]            =[t[0] for t in batch]
             _lowerCamelCase			:						Any            =[t[1] for t in batch]
             assert len(lowercase_					) == len(lowercase_					)

             # Max for paddings
             _lowerCamelCase			:						Union[str, Any]            =max(lowercase_					)

             # Pad token ids
             if self.params.mlm:
                    _lowerCamelCase			:						str            =self.params.special_tok_ids['pad_token']
             else:
                    _lowerCamelCase			:						str            =self.params.special_tok_ids['unk_token']
             _lowerCamelCase			:						List[Any]            =[list(t.astype(lowercase_					)					) + [pad_idx] * (max_seq_len_ - len(lowercase_					)) for t in token_ids]
             assert len(tk_					) == len(lowercase_					)
             assert all(len(lowercase_					) == max_seq_len_ for t in tk_					)

             _lowerCamelCase			:						Dict            =torch.tensor(tk_					)  # (bs, max_seq_len_)
             _lowerCamelCase			:						List[Any]            =torch.tensor(lowercase_					)  # (bs)
             return tk_t, lg_t






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'					)


