

import unittest

import numpy as np

from transformers import MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING, TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING
from transformers.pipelines import AudioClassificationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_torchaudio,
    slow,
)

from .test_pipelines_common import ANY

@is_pipeline_test
class __UpperCamelCase     (				unittest.TestCase		):






					'''simple docstring'''



					__magic_name__        =   MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING
					__magic_name__        =   TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING





					def    _UpperCAmelCase    (				self				,      lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__						):
						UpperCAmelCase__:	Tuple									= AudioClassificationPipeline(model=lowerCamelCase__				,      feature_extractor=lowerCamelCase__						)

						# test with a raw waveform
						UpperCAmelCase__:	Union[str, Any]									= np.zeros((3_4_0_0_0,)						)
						UpperCAmelCase__:	Tuple									= np.zeros((1_4_0_0_0,)						)
						return audio_classifier, [audioa, audio]





					def    _UpperCAmelCase    (				self				,      lowerCamelCase__				,      lowerCamelCase__						):
						UpperCAmelCase__							,						UpperCAmelCase__:	Optional[Any]									= examples
						UpperCAmelCase__:	List[Any]									= audio_classifier(lowerCamelCase__						)
						# by default a model is initialized with num_labels=2
						self.assertEqual(
						    lowerCamelCase__				,      [
						        {"score": ANY(lowerCamelCase__						), "label": ANY(lowerCamelCase__						)},
						        {"score": ANY(lowerCamelCase__						), "label": ANY(lowerCamelCase__						)},
						    ]				,      )
						UpperCAmelCase__:	Optional[int]									= audio_classifier(lowerCamelCase__				,      top_k=1						)
						self.assertEqual(
						    lowerCamelCase__				,      [
						        {"score": ANY(lowerCamelCase__						), "label": ANY(lowerCamelCase__						)},
						    ]				,      )

						self.run_torchaudio(lowerCamelCase__						)





					@require_torchaudio
					def    _UpperCAmelCase    (				self				,      lowerCamelCase__						):
						import datasets

						# test with a local file
						UpperCAmelCase__:	Dict									= datasets.load_dataset("hf-internal-testing/librispeech_asr_dummy"				,      "clean"				,      split="validation"						)
						UpperCAmelCase__:	Tuple									= dataset[0]["audio"]["array"]
						UpperCAmelCase__:	Dict									= audio_classifier(lowerCamelCase__						)
						self.assertEqual(
						    lowerCamelCase__				,      [
						        {"score": ANY(lowerCamelCase__						), "label": ANY(lowerCamelCase__						)},
						        {"score": ANY(lowerCamelCase__						), "label": ANY(lowerCamelCase__						)},
						    ]				,      )





					@require_torch
					def    _UpperCAmelCase    (				self						):
						UpperCAmelCase__:	List[Any]									= "anton-l/wav2vec2-random-tiny-classifier"

						UpperCAmelCase__:	Optional[Any]									= pipeline("audio-classification"				,      model=lowerCamelCase__						)

						UpperCAmelCase__:	str									= np.ones((8_0_0_0,)						)
						UpperCAmelCase__:	Any									= audio_classifier(lowerCamelCase__				,      top_k=4						)

						UpperCAmelCase__:	Optional[int]									= [
						    {"score": 0.0_842, "label": "no"},
						    {"score": 0.0_838, "label": "up"},
						    {"score": 0.0_837, "label": "go"},
						    {"score": 0.0_834, "label": "right"},
						]
						UpperCAmelCase__:	int									= [
						    {"score": 0.0_845, "label": "stop"},
						    {"score": 0.0_844, "label": "on"},
						    {"score": 0.0_841, "label": "right"},
						    {"score": 0.0_834, "label": "left"},
						]
						self.assertIn(nested_simplify(lowerCamelCase__				,      decimals=4						)				,      [EXPECTED_OUTPUT, EXPECTED_OUTPUT_PT_2]						)

						UpperCAmelCase__:	Any									= {"array": np.ones((8_0_0_0,)						), "sampling_rate": audio_classifier.feature_extractor.sampling_rate}
						UpperCAmelCase__:	Optional[Any]									= audio_classifier(lowerCamelCase__				,      top_k=4						)
						self.assertIn(nested_simplify(lowerCamelCase__				,      decimals=4						)				,      [EXPECTED_OUTPUT, EXPECTED_OUTPUT_PT_2]						)





					@require_torch
					@slow
					def    _UpperCAmelCase    (				self						):
						import datasets

						UpperCAmelCase__:	Tuple									= "superb/wav2vec2-base-superb-ks"

						UpperCAmelCase__:	Dict									= pipeline("audio-classification"				,      model=lowerCamelCase__						)
						UpperCAmelCase__:	Tuple									= datasets.load_dataset("anton-l/superb_dummy"				,      "ks"				,      split="test"						)

						UpperCAmelCase__:	Dict									= np.array(dataset[3]["speech"]				,      dtype=np.floataa						)
						UpperCAmelCase__:	List[str]									= audio_classifier(lowerCamelCase__				,      top_k=4						)
						self.assertEqual(
						    nested_simplify(lowerCamelCase__				,      decimals=3						)				,      [
						        {"score": 0.981, "label": "go"},
						        {"score": 0.007, "label": "up"},
						        {"score": 0.006, "label": "_unknown_"},
						        {"score": 0.001, "label": "down"},
						    ]				,      )





					@require_tf
					@unittest.skip("Audio classification is not implemented for TF"						)
					def    _UpperCAmelCase    (				self						):
						pass


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  :      List[str]			 =get_tests_dir("""fixtures/dummy_feature_extractor_config.json""")
_lowerCAmelCase  :      List[str]			 =get_tests_dir("""fixtures/vocab.json""")
_lowerCAmelCase  :      Dict			 =get_tests_dir("""fixtures""")

class __UpperCamelCase     (				unittest.TestCase		):






					'''simple docstring'''



					__magic_name__        =   ["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "bla", "blou"]





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





					def    _UpperCAmelCase    (				self						):
						UpperCAmelCase__:	Optional[int]									= AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h"						)
						self.assertIsInstance(lowerCamelCase__				,      lowerCamelCase__						)





					def    _UpperCAmelCase    (				self						):
						with tempfile.TemporaryDirectory() as tmpdirname:
							UpperCAmelCase__:	Any									= WavaVecaConfig()
							UpperCAmelCase__:	Tuple									= AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h"						)

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

							UpperCAmelCase__:	int									= AutoProcessor.from_pretrained(lowerCamelCase__						)

						self.assertIsInstance(lowerCamelCase__				,      lowerCamelCase__						)





					def    _UpperCAmelCase    (				self						):
						with tempfile.TemporaryDirectory() as tmpdirname:
							# copy relevant files
							copyfile(lowerCamelCase__				,      os.path.join(lowerCamelCase__				,      lowerCamelCase__						)						)
							copyfile(lowerCamelCase__				,      os.path.join(lowerCamelCase__				,      "vocab.json"						)						)

							UpperCAmelCase__:	Tuple									= AutoProcessor.from_pretrained(lowerCamelCase__						)

						self.assertIsInstance(lowerCamelCase__				,      lowerCamelCase__						)





					def    _UpperCAmelCase    (				self						):
						with tempfile.TemporaryDirectory() as tmpdirname:
							UpperCAmelCase__:	Optional[Any]									= WavaVecaFeatureExtractor()
							UpperCAmelCase__:	List[Any]									= AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h"						)

							UpperCAmelCase__:	Dict									= WavaVecaProcessor(lowerCamelCase__				,      lowerCamelCase__						)

							# save in new folder
							processor.save_pretrained(lowerCamelCase__						)

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

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

							UpperCAmelCase__:	Any									= AutoProcessor.from_pretrained(lowerCamelCase__						)

						self.assertIsInstance(lowerCamelCase__				,      lowerCamelCase__						)





					def    _UpperCAmelCase    (				self						):
						with tempfile.TemporaryDirectory() as tmpdirname:
							UpperCAmelCase__:	str									= WavaVecaFeatureExtractor()
							UpperCAmelCase__:	Tuple									= AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h"						)

							UpperCAmelCase__:	List[Any]									= WavaVecaProcessor(lowerCamelCase__				,      lowerCamelCase__						)

							# save in new folder
							processor.save_pretrained(lowerCamelCase__						)

							# drop `processor_class` in feature extractor
							with open(os.path.join(lowerCamelCase__				,      lowerCamelCase__						)				,      "r"						) as f:
								UpperCAmelCase__:	str									= json.load(lowerCamelCase__						)
								config_dict.pop("processor_class"						)

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

							UpperCAmelCase__:	Tuple									= AutoProcessor.from_pretrained(lowerCamelCase__						)

						self.assertIsInstance(lowerCamelCase__				,      lowerCamelCase__						)





					def    _UpperCAmelCase    (				self						):
						with tempfile.TemporaryDirectory() as tmpdirname:
							UpperCAmelCase__:	Union[str, Any]									= WavaVecaConfig(processor_class="Wav2Vec2Processor"						)
							model_config.save_pretrained(lowerCamelCase__						)
							# copy relevant files
							copyfile(lowerCamelCase__				,      os.path.join(lowerCamelCase__				,      "vocab.json"						)						)
							# create emtpy sample processor
							with open(os.path.join(lowerCamelCase__				,      lowerCamelCase__						)				,      "w"						) as f:
								f.write("{}"						)

							UpperCAmelCase__:	Union[str, Any]									= AutoProcessor.from_pretrained(lowerCamelCase__						)

						self.assertIsInstance(lowerCamelCase__				,      lowerCamelCase__						)





					def    _UpperCAmelCase    (				self						):
						# If remote code is not set, we will time out when asking whether to load the model.
						with self.assertRaises(lowerCamelCase__						):
							UpperCAmelCase__:	Optional[Any]									= AutoProcessor.from_pretrained("hf-internal-testing/test_dynamic_processor"						)
						# If remote code is disabled, we can't load this config.
						with self.assertRaises(lowerCamelCase__						):
							UpperCAmelCase__:	Optional[int]									= AutoProcessor.from_pretrained(
							    "hf-internal-testing/test_dynamic_processor"				,      trust_remote_code=lowerCamelCase__						)

						UpperCAmelCase__:	Union[str, Any]									= AutoProcessor.from_pretrained("hf-internal-testing/test_dynamic_processor"				,      trust_remote_code=lowerCamelCase__						)
						self.assertTrue(processor.special_attribute_present						)
						self.assertEqual(processor.__class__.__name__				,      "NewProcessor"						)

						UpperCAmelCase__:	Dict									= processor.feature_extractor
						self.assertTrue(feature_extractor.special_attribute_present						)
						self.assertEqual(feature_extractor.__class__.__name__				,      "NewFeatureExtractor"						)

						UpperCAmelCase__:	Any									= 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
							UpperCAmelCase__:	Dict									= AutoProcessor.from_pretrained(
							    "hf-internal-testing/test_dynamic_processor"				,      trust_remote_code=lowerCamelCase__				,      use_fast=lowerCamelCase__						)
							UpperCAmelCase__:	str									= 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    _UpperCAmelCase    (				self						):
						try:
							AutoConfig.register("custom"				,      lowerCamelCase__						)
							AutoFeatureExtractor.register(lowerCamelCase__				,      lowerCamelCase__						)
							AutoTokenizer.register(lowerCamelCase__				,      slow_tokenizer_class=lowerCamelCase__						)
							AutoProcessor.register(lowerCamelCase__				,      lowerCamelCase__						)
							# Trying to register something existing in the Transformers library will raise an error
							with self.assertRaises(lowerCamelCase__						):
								AutoProcessor.register(lowerCamelCase__				,      lowerCamelCase__						)

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

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

							UpperCAmelCase__:	Optional[int]									= CustomProcessor(lowerCamelCase__				,      lowerCamelCase__						)

							with tempfile.TemporaryDirectory() as tmp_dir:
								processor.save_pretrained(lowerCamelCase__						)
								UpperCAmelCase__:	Tuple									= AutoProcessor.from_pretrained(lowerCamelCase__						)
								self.assertIsInstance(lowerCamelCase__				,      lowerCamelCase__						)

						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    _UpperCAmelCase    (				self						):

						class __UpperCamelCase     (				_a		):






											'''simple docstring'''



											__magic_name__        =   False

						class __UpperCamelCase     (				_a		):






											'''simple docstring'''



											__magic_name__        =   False

						class __UpperCamelCase     (				_a		):






											'''simple docstring'''



											__magic_name__        =   "AutoFeatureExtractor"
											__magic_name__        =   "AutoTokenizer"
											__magic_name__        =   False

						try:
							AutoConfig.register("custom"				,      lowerCamelCase__						)
							AutoFeatureExtractor.register(lowerCamelCase__				,      lowerCamelCase__						)
							AutoTokenizer.register(lowerCamelCase__				,      slow_tokenizer_class=lowerCamelCase__						)
							AutoProcessor.register(lowerCamelCase__				,      lowerCamelCase__						)
							# If remote code is not set, the default is to use local classes.
							UpperCAmelCase__:	Any									= 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.
							UpperCAmelCase__:	Union[str, Any]									= AutoProcessor.from_pretrained(
							    "hf-internal-testing/test_dynamic_processor"				,      trust_remote_code=lowerCamelCase__						)
							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.
							UpperCAmelCase__:	Tuple									= AutoProcessor.from_pretrained(
							    "hf-internal-testing/test_dynamic_processor"				,      trust_remote_code=lowerCamelCase__						)
							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    _UpperCAmelCase    (				self						):
						UpperCAmelCase__:	Union[str, Any]									= AutoProcessor.from_pretrained("hf-internal-testing/tiny-random-bert"						)
						self.assertEqual(processor.__class__.__name__				,      "BertTokenizerFast"						)





					def    _UpperCAmelCase    (				self						):
						UpperCAmelCase__:	Tuple									= AutoProcessor.from_pretrained("hf-internal-testing/tiny-random-convnext"						)
						self.assertEqual(processor.__class__.__name__				,      "ConvNextImageProcessor"						)

@is_staging_test
class __UpperCamelCase     (				unittest.TestCase		):






					'''simple docstring'''



					__magic_name__        =   ["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "bla", "blou"]





					@classmethod
					def    _UpperCAmelCase    (				cls						):
						UpperCAmelCase__:	Dict									= TOKEN
						HfFolder.save_token(lowerCamelCase__						)





					@classmethod
					def    _UpperCAmelCase    (				cls						):
						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    _UpperCAmelCase    (				self						):
						UpperCAmelCase__:	Optional[Any]									= WavaVecaProcessor.from_pretrained(lowerCamelCase__						)
						with tempfile.TemporaryDirectory() as tmp_dir:
							processor.save_pretrained(
							    os.path.join(lowerCamelCase__				,      "test-processor"						)				,      push_to_hub=lowerCamelCase__				,      use_auth_token=self._token						)

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





					def    _UpperCAmelCase    (				self						):
						UpperCAmelCase__:	Dict									= WavaVecaProcessor.from_pretrained(lowerCamelCase__						)

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

							UpperCAmelCase__:	Optional[int]									= WavaVecaProcessor.from_pretrained("valid_org/test-processor-org"						)
							for k, v in processor.feature_extractor.__dict__.items():
								self.assertEqual(lowerCamelCase__				,      getattr(new_processor.feature_extractor				,      lowerCamelCase__						)						)
							self.assertDictEqual(new_processor.tokenizer.get_vocab()				,      processor.tokenizer.get_vocab()						)





					def    _UpperCAmelCase    (				self						):
						CustomFeatureExtractor.register_for_auto_class()
						CustomTokenizer.register_for_auto_class()
						CustomProcessor.register_for_auto_class()

						UpperCAmelCase__:	List[str]									= CustomFeatureExtractor.from_pretrained(lowerCamelCase__						)

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

						UpperCAmelCase__:	str									= CustomProcessor(lowerCamelCase__				,      lowerCamelCase__						)

						with tempfile.TemporaryDirectory() as tmp_dir:
							create_repo(F"{USER}/test-dynamic-processor"				,      token=self._token						)
							UpperCAmelCase__:	int									= Repository(lowerCamelCase__				,      clone_from=F"{USER}/test-dynamic-processor"				,      token=self._token						)
							processor.save_pretrained(lowerCamelCase__						)

							# 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(lowerCamelCase__				,      "tokenizer_config.json"						)						) as f:
								UpperCAmelCase__:	Tuple									= json.load(lowerCamelCase__						)
							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(lowerCamelCase__				,      "custom_feature_extraction.py"						)						)						)
							self.assertTrue(os.path.isfile(os.path.join(lowerCamelCase__				,      "custom_tokenization.py"						)						)						)
							self.assertTrue(os.path.isfile(os.path.join(lowerCamelCase__				,      "custom_processing.py"						)						)						)

							repo.push_to_hub()

						UpperCAmelCase__:	Union[str, Any]									= AutoProcessor.from_pretrained(F"{USER}/test-dynamic-processor"				,      trust_remote_code=lowerCamelCase__						)
						# 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"						)