"""simple docstring"""






import json
import pathlib
import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision, slow
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
       import torch

if is_vision_available():
       from PIL import Image

       from transformers import YolosImageProcessor





class 					_A		(			unittest.TestCase      ):

      def __init__(		self						,			__lowerCAmelCase						,			__lowerCAmelCase=7						,			__lowerCAmelCase=3						,			__lowerCAmelCase=30						,			__lowerCAmelCase=400						,			__lowerCAmelCase=True						,			__lowerCAmelCase=None						,			__lowerCAmelCase=True						,			__lowerCAmelCase=[0.5, 0.5, 0.5]						,			__lowerCAmelCase=[0.5, 0.5, 0.5]						,			__lowerCAmelCase=True						,			__lowerCAmelCase=1 / 255						,			__lowerCAmelCase=True						,			):







            """simple docstring"""



            lowercase								=      size if size is not None else {"""shortest_edge""": 18, """longest_edge""": 1333}
            lowercase								=      parent
            lowercase								=      batch_size
            lowercase								=      num_channels
            lowercase								=      min_resolution
            lowercase								=      max_resolution
            lowercase								=      do_resize
            lowercase								=      size
            lowercase								=      do_normalize
            lowercase								=      image_mean
            lowercase								=      image_std
            lowercase								=      do_rescale
            lowercase								=      rescale_factor
            lowercase								=      do_pad

      def 							A__			(		self		):







            """simple docstring"""



            return {
                "do_resize": self.do_resize,
                "size": self.size,
                "do_normalize": self.do_normalize,
                "image_mean": self.image_mean,
                "image_std": self.image_std,
                "do_rescale": self.do_rescale,
                "rescale_factor": self.rescale_factor,
                "do_pad": self.do_pad,
            }







      def 							A__			(		self						,			__lowerCAmelCase						,			__lowerCAmelCase=False		):







            """simple docstring"""



            if not batched:
                  lowercase								=      image_inputs[0]
                  if isinstance(__lowerCAmelCase						,			Image.Image		):
                        lowercase				,				lowercase								=      image.size
                  else:
                        lowercase				,				lowercase								=      image.shape[1], image.shape[2]
                  if w < h:
                        lowercase								=      int(self.size["""shortest_edge"""] * h / w		)
                        lowercase								=      self.size["""shortest_edge"""]
                  elif w > h:
                        lowercase								=      self.size["""shortest_edge"""]
                        lowercase								=      int(self.size["""shortest_edge"""] * w / h		)
                  else:
                        lowercase								=      self.size["""shortest_edge"""]
                        lowercase								=      self.size["""shortest_edge"""]

            else:
                  lowercase								=      []
                  for image in image_inputs:
                        lowercase				,				lowercase								=      self.get_expected_values([image]		)
                        expected_values.append((expected_height, expected_width)		)
                  lowercase								=      max(__lowerCAmelCase						,			key=lambda __lowerCAmelCase		: item[0]		)[0]
                  lowercase								=      max(__lowerCAmelCase						,			key=lambda __lowerCAmelCase		: item[1]		)[1]

            return expected_height, expected_width






@require_torch
@require_vision
class 					_A		(			lowerCAmelCase    ,       unittest.TestCase      ):
      snake_case__     :  List[Any]				    =      YolosImageProcessor if is_vision_available() else None

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      YolosImageProcessingTester(self		)

      @property
      def 							A__			(		self		):







            """simple docstring"""



            return self.image_processor_tester.prepare_image_processor_dict()

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.image_processing_class(**self.image_processor_dict		)
            self.assertTrue(hasattr(__lowerCAmelCase						,			"""image_mean"""		)		)
            self.assertTrue(hasattr(__lowerCAmelCase						,			"""image_std"""		)		)
            self.assertTrue(hasattr(__lowerCAmelCase						,			"""do_normalize"""		)		)
            self.assertTrue(hasattr(__lowerCAmelCase						,			"""do_resize"""		)		)
            self.assertTrue(hasattr(__lowerCAmelCase						,			"""size"""		)		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.image_processing_class.from_dict(self.image_processor_dict		)
            self.assertEqual(image_processor.size						,			{"""shortest_edge""": 18, """longest_edge""": 1333}		)
            self.assertEqual(image_processor.do_pad						,			__lowerCAmelCase		)

            lowercase								=      self.image_processing_class.from_dict(
                self.image_processor_dict						,			size=42						,			max_size=84						,			pad_and_return_pixel_mask=__lowerCAmelCase		)
            self.assertEqual(image_processor.size						,			{"""shortest_edge""": 42, """longest_edge""": 84}		)
            self.assertEqual(image_processor.do_pad						,			__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            pass

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.image_processing_class(**self.image_processor_dict		)
            # create random PIL images
            lowercase								=      prepare_image_inputs(self.image_processor_tester						,			equal_resolution=__lowerCAmelCase		)
            for image in image_inputs:
                  self.assertIsInstance(__lowerCAmelCase						,			Image.Image		)

            # Test not batched input
            lowercase								=      image_processing(image_inputs[0]						,			return_tensors="""pt"""		).pixel_values

            lowercase				,				lowercase								=      self.image_processor_tester.get_expected_values(__lowerCAmelCase		)

            self.assertEqual(
                encoded_images.shape						,			(1, self.image_processor_tester.num_channels, expected_height, expected_width)						,			)

            # Test batched
            lowercase				,				lowercase								=      self.image_processor_tester.get_expected_values(__lowerCAmelCase						,			batched=__lowerCAmelCase		)

            lowercase								=      image_processing(__lowerCAmelCase						,			return_tensors="""pt"""		).pixel_values
            self.assertEqual(
                encoded_images.shape						,			(
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    expected_height,
                    expected_width,
                )						,			)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.image_processing_class(**self.image_processor_dict		)
            # create random numpy tensors
            lowercase								=      prepare_image_inputs(self.image_processor_tester						,			equal_resolution=__lowerCAmelCase						,			numpify=__lowerCAmelCase		)
            for image in image_inputs:
                  self.assertIsInstance(__lowerCAmelCase						,			np.ndarray		)

            # Test not batched input
            lowercase								=      image_processing(image_inputs[0]						,			return_tensors="""pt"""		).pixel_values

            lowercase				,				lowercase								=      self.image_processor_tester.get_expected_values(__lowerCAmelCase		)

            self.assertEqual(
                encoded_images.shape						,			(1, self.image_processor_tester.num_channels, expected_height, expected_width)						,			)

            # Test batched
            lowercase								=      image_processing(__lowerCAmelCase						,			return_tensors="""pt"""		).pixel_values

            lowercase				,				lowercase								=      self.image_processor_tester.get_expected_values(__lowerCAmelCase						,			batched=__lowerCAmelCase		)

            self.assertEqual(
                encoded_images.shape						,			(
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    expected_height,
                    expected_width,
                )						,			)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.image_processing_class(**self.image_processor_dict		)
            # create random PyTorch tensors
            lowercase								=      prepare_image_inputs(self.image_processor_tester						,			equal_resolution=__lowerCAmelCase						,			torchify=__lowerCAmelCase		)
            for image in image_inputs:
                  self.assertIsInstance(__lowerCAmelCase						,			torch.Tensor		)

            # Test not batched input
            lowercase								=      image_processing(image_inputs[0]						,			return_tensors="""pt"""		).pixel_values

            lowercase				,				lowercase								=      self.image_processor_tester.get_expected_values(__lowerCAmelCase		)

            self.assertEqual(
                encoded_images.shape						,			(1, self.image_processor_tester.num_channels, expected_height, expected_width)						,			)

            # Test batched
            lowercase								=      image_processing(__lowerCAmelCase						,			return_tensors="""pt"""		).pixel_values

            lowercase				,				lowercase								=      self.image_processor_tester.get_expected_values(__lowerCAmelCase						,			batched=__lowerCAmelCase		)

            self.assertEqual(
                encoded_images.shape						,			(
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    expected_height,
                    expected_width,
                )						,			)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.image_processing_class(**self.image_processor_dict		)
            lowercase								=      self.image_processing_class(do_resize=__lowerCAmelCase						,			do_normalize=__lowerCAmelCase						,			do_rescale=__lowerCAmelCase		)
            # create random PyTorch tensors
            lowercase								=      prepare_image_inputs(self.image_processor_tester						,			equal_resolution=__lowerCAmelCase						,			torchify=__lowerCAmelCase		)
            for image in image_inputs:
                  self.assertIsInstance(__lowerCAmelCase						,			torch.Tensor		)

            # Test whether the method "pad" and calling the image processor return the same tensors
            lowercase								=      image_processing_a.pad(__lowerCAmelCase						,			return_tensors="""pt"""		)
            lowercase								=      image_processing_a(__lowerCAmelCase						,			return_tensors="""pt"""		)

            self.assertTrue(
                torch.allclose(encoded_images_with_method["""pixel_values"""]						,			encoded_images["""pixel_values"""]						,			atol=1E-4		)		)

      @slow
      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""		)
            with open("""./tests/fixtures/tests_samples/COCO/coco_annotations.txt"""						,			"""r"""		) as f:
                  lowercase								=      json.loads(f.read()		)

            lowercase								=      {"""image_id""": 3_9769, """annotations""": target}

            # encode them
            lowercase								=      YolosImageProcessor.from_pretrained("""hustvl/yolos-small"""		)
            lowercase								=      image_processing(images=__lowerCAmelCase						,			annotations=__lowerCAmelCase						,			return_tensors="""pt"""		)

            # verify pixel values
            lowercase								=      torch.Size([1, 3, 800, 1066]		)
            self.assertEqual(encoding["""pixel_values"""].shape						,			__lowerCAmelCase		)

            lowercase								=      torch.tensor([0.2_7_9_6, 0.3_1_3_8, 0.3_4_8_1]		)
            self.assertTrue(torch.allclose(encoding["""pixel_values"""][0, 0, 0, :3]						,			__lowerCAmelCase						,			atol=1E-4		)		)

            # verify area
            lowercase								=      torch.tensor([5_8_8_7.9_6_0_0, 1_1_2_5_0.2_0_6_1, 4_8_9_3_5_3.8_4_3_8, 8_3_7_1_2_2.7_5_0_0, 1_4_7_9_6_7.5_1_5_6, 1_6_5_7_3_2.3_4_3_8]		)
            self.assertTrue(torch.allclose(encoding["""labels"""][0]["""area"""]						,			__lowerCAmelCase		)		)
            # verify boxes
            lowercase								=      torch.Size([6, 4]		)
            self.assertEqual(encoding["""labels"""][0]["""boxes"""].shape						,			__lowerCAmelCase		)
            lowercase								=      torch.tensor([0.5_5_0_3, 0.2_7_6_5, 0.0_6_0_4, 0.2_2_1_5]		)
            self.assertTrue(torch.allclose(encoding["""labels"""][0]["""boxes"""][0]						,			__lowerCAmelCase						,			atol=1E-3		)		)
            # verify image_id
            lowercase								=      torch.tensor([3_9769]		)
            self.assertTrue(torch.allclose(encoding["""labels"""][0]["""image_id"""]						,			__lowerCAmelCase		)		)
            # verify is_crowd
            lowercase								=      torch.tensor([0, 0, 0, 0, 0, 0]		)
            self.assertTrue(torch.allclose(encoding["""labels"""][0]["""iscrowd"""]						,			__lowerCAmelCase		)		)
            # verify class_labels
            lowercase								=      torch.tensor([75, 75, 63, 65, 17, 17]		)
            self.assertTrue(torch.allclose(encoding["""labels"""][0]["""class_labels"""]						,			__lowerCAmelCase		)		)
            # verify orig_size
            lowercase								=      torch.tensor([480, 640]		)
            self.assertTrue(torch.allclose(encoding["""labels"""][0]["""orig_size"""]						,			__lowerCAmelCase		)		)
            # verify size
            lowercase								=      torch.tensor([800, 1066]		)
            self.assertTrue(torch.allclose(encoding["""labels"""][0]["""size"""]						,			__lowerCAmelCase		)		)







      @slow
      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""		)
            with open("""./tests/fixtures/tests_samples/COCO/coco_panoptic_annotations.txt"""						,			"""r"""		) as f:
                  lowercase								=      json.loads(f.read()		)

            lowercase								=      {"""file_name""": """000000039769.png""", """image_id""": 3_9769, """segments_info""": target}

            lowercase								=      pathlib.Path("""./tests/fixtures/tests_samples/COCO/coco_panoptic"""		)

            # encode them
            lowercase								=      YolosImageProcessor(format="""coco_panoptic"""		)
            lowercase								=      image_processing(images=__lowerCAmelCase						,			annotations=__lowerCAmelCase						,			masks_path=__lowerCAmelCase						,			return_tensors="""pt"""		)

            # verify pixel values
            lowercase								=      torch.Size([1, 3, 800, 1066]		)
            self.assertEqual(encoding["""pixel_values"""].shape						,			__lowerCAmelCase		)

            lowercase								=      torch.tensor([0.2_7_9_6, 0.3_1_3_8, 0.3_4_8_1]		)
            self.assertTrue(torch.allclose(encoding["""pixel_values"""][0, 0, 0, :3]						,			__lowerCAmelCase						,			atol=1E-4		)		)

            # verify area
            lowercase								=      torch.tensor([1_4_7_9_7_9.6_8_7_5, 1_6_5_5_2_7.0_4_6_9, 4_8_4_6_3_8.5_9_3_8, 1_1_2_9_2.9_3_7_5, 5_8_7_9.6_5_6_2, 7_6_3_4.1_1_4_7]		)
            self.assertTrue(torch.allclose(encoding["""labels"""][0]["""area"""]						,			__lowerCAmelCase		)		)
            # verify boxes
            lowercase								=      torch.Size([6, 4]		)
            self.assertEqual(encoding["""labels"""][0]["""boxes"""].shape						,			__lowerCAmelCase		)
            lowercase								=      torch.tensor([0.2_6_2_5, 0.5_4_3_7, 0.4_6_8_8, 0.8_6_2_5]		)
            self.assertTrue(torch.allclose(encoding["""labels"""][0]["""boxes"""][0]						,			__lowerCAmelCase						,			atol=1E-3		)		)
            # verify image_id
            lowercase								=      torch.tensor([3_9769]		)
            self.assertTrue(torch.allclose(encoding["""labels"""][0]["""image_id"""]						,			__lowerCAmelCase		)		)
            # verify is_crowd
            lowercase								=      torch.tensor([0, 0, 0, 0, 0, 0]		)
            self.assertTrue(torch.allclose(encoding["""labels"""][0]["""iscrowd"""]						,			__lowerCAmelCase		)		)
            # verify class_labels
            lowercase								=      torch.tensor([17, 17, 63, 75, 75, 93]		)
            self.assertTrue(torch.allclose(encoding["""labels"""][0]["""class_labels"""]						,			__lowerCAmelCase		)		)
            # verify masks
            lowercase								=      82_2873
            self.assertEqual(encoding["""labels"""][0]["""masks"""].sum().item()						,			__lowerCAmelCase		)
            # verify orig_size
            lowercase								=      torch.tensor([480, 640]		)
            self.assertTrue(torch.allclose(encoding["""labels"""][0]["""orig_size"""]						,			__lowerCAmelCase		)		)
            # verify size
            lowercase								=      torch.tensor([800, 1066]		)
            self.assertTrue(torch.allclose(encoding["""labels"""][0]["""size"""]						,			__lowerCAmelCase		)		)




"""simple docstring"""






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       :			str   	=get_tests_dir("""fixtures/dummy_feature_extractor_config.json""")
__lowerCAmelCase       :			Tuple   	=get_tests_dir("""fixtures/vocab.json""")
__lowerCAmelCase       :			Tuple   	=get_tests_dir("""fixtures""")





class 					_A		(			unittest.TestCase      ):
      snake_case__     :  List[Any]				    =      ['[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', 'bla', 'blou']

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      0

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      AutoProcessor.from_pretrained("""facebook/wav2vec2-base-960h"""		)
            self.assertIsInstance(__lowerCAmelCase						,			__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            with tempfile.TemporaryDirectory() as tmpdirname:
                  lowercase								=      WavaVecaConfig()
                  lowercase								=      AutoProcessor.from_pretrained("""facebook/wav2vec2-base-960h"""		)

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

                  lowercase								=      AutoProcessor.from_pretrained(__lowerCAmelCase		)

            self.assertIsInstance(__lowerCAmelCase						,			__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



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

                  lowercase								=      AutoProcessor.from_pretrained(__lowerCAmelCase		)

            self.assertIsInstance(__lowerCAmelCase						,			__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            with tempfile.TemporaryDirectory() as tmpdirname:
                  lowercase								=      WavaVecaFeatureExtractor()
                  lowercase								=      AutoTokenizer.from_pretrained("""facebook/wav2vec2-base-960h"""		)

                  lowercase								=      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:
                        lowercase								=      json.load(__lowerCAmelCase		)
                        config_dict.pop("""processor_class"""		)

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

                  lowercase								=      AutoProcessor.from_pretrained(__lowerCAmelCase		)

            self.assertIsInstance(__lowerCAmelCase						,			__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            with tempfile.TemporaryDirectory() as tmpdirname:
                  lowercase								=      WavaVecaFeatureExtractor()
                  lowercase								=      AutoTokenizer.from_pretrained("""facebook/wav2vec2-base-960h"""		)

                  lowercase								=      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:
                        lowercase								=      json.load(__lowerCAmelCase		)
                        config_dict.pop("""processor_class"""		)

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

                  lowercase								=      AutoProcessor.from_pretrained(__lowerCAmelCase		)

            self.assertIsInstance(__lowerCAmelCase						,			__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            with tempfile.TemporaryDirectory() as tmpdirname:
                  lowercase								=      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("""{}"""		)

                  lowercase								=      AutoProcessor.from_pretrained(__lowerCAmelCase		)

            self.assertIsInstance(__lowerCAmelCase						,			__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            with self.assertRaises(__lowerCAmelCase		):
                  lowercase								=      AutoProcessor.from_pretrained("""hf-internal-testing/test_dynamic_processor"""		)
            # If remote code is disabled, we can't load this config.
            with self.assertRaises(__lowerCAmelCase		):
                  lowercase								=      AutoProcessor.from_pretrained(
                      """hf-internal-testing/test_dynamic_processor"""						,			trust_remote_code=__lowerCAmelCase		)

            lowercase								=      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"""		)

            lowercase								=      processor.feature_extractor
            self.assertTrue(feature_extractor.special_attribute_present		)
            self.assertEqual(feature_extractor.__class__.__name__						,			"""NewFeatureExtractor"""		)

            lowercase								=      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
                  lowercase								=      AutoProcessor.from_pretrained(
                      """hf-internal-testing/test_dynamic_processor"""						,			trust_remote_code=__lowerCAmelCase						,			use_fast=__lowerCAmelCase		)
                  lowercase								=      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 							A__			(		self		):







            """simple docstring"""



            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
                  lowercase								=      CustomFeatureExtractor.from_pretrained(__lowerCAmelCase		)

                  with tempfile.TemporaryDirectory() as tmp_dir:
                        lowercase								=      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]		)		)
                        lowercase								=      CustomTokenizer(__lowerCAmelCase		)

                  lowercase								=      CustomProcessor(__lowerCAmelCase						,			__lowerCAmelCase		)

                  with tempfile.TemporaryDirectory() as tmp_dir:
                        processor.save_pretrained(__lowerCAmelCase		)
                        lowercase								=      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 							A__			(		self		):







            """simple docstring"""



            class 					_A		(			lowerCAmelCase      ):
                  snake_case__     :  Optional[Any]				    =      False






            class 					_A		(			lowerCAmelCase      ):
                  snake_case__     :  int				    =      False






            class 					_A		(			lowerCAmelCase      ):
                  snake_case__     :  List[Any]				    =      'AutoFeatureExtractor'
                  snake_case__     :  List[str]				    =      'AutoTokenizer'
                  snake_case__     :  List[str]				    =      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.
                  lowercase								=      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.
                  lowercase								=      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.
                  lowercase								=      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 							A__			(		self		):







            """simple docstring"""



            lowercase								=      AutoProcessor.from_pretrained("""hf-internal-testing/tiny-random-bert"""		)
            self.assertEqual(processor.__class__.__name__						,			"""BertTokenizerFast"""		)







      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      AutoProcessor.from_pretrained("""hf-internal-testing/tiny-random-convnext"""		)
            self.assertEqual(processor.__class__.__name__						,			"""ConvNextImageProcessor"""		)






@is_staging_test
class 					_A		(			unittest.TestCase      ):
      snake_case__     :  Dict				    =      ['[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', 'bla', 'blou']

      @classmethod
      def 							A__			(		cls		):







            """simple docstring"""



            lowercase								=      TOKEN
            HfFolder.save_token(__lowerCAmelCase		)

      @classmethod
      def 							A__			(		cls		):







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







            """simple docstring"""



            lowercase								=      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		)

                  lowercase								=      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 							A__			(		self		):







            """simple docstring"""



            lowercase								=      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"""						,			)

                  lowercase								=      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 							A__			(		self		):







            """simple docstring"""



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

            lowercase								=      CustomFeatureExtractor.from_pretrained(__lowerCAmelCase		)

            with tempfile.TemporaryDirectory() as tmp_dir:
                  lowercase								=      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]		)		)
                  lowercase								=      CustomTokenizer(__lowerCAmelCase		)

            lowercase								=      CustomProcessor(__lowerCAmelCase						,			__lowerCAmelCase		)

            with tempfile.TemporaryDirectory() as tmp_dir:
                  create_repo(f'{USER}/test-dynamic-processor'						,			token=self._token		)
                  lowercase								=      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:
                        lowercase								=      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()

            lowercase								=      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"""		)



