





from __future__ import annotations
class     UpperCamelCase__					:






		'''simple docstring'''






		def __init__(							self,   snake_case__  )       -> List[str]:






									"""simple docstring"""
									lowercase_	:   List[str]  				=     TypeError(
									    """Matrices must be formed from a list of zero or more lists containing at """
									    """least one and the same number of values, each of which must be of type """
									    """int or float."""  )
									if len(__lowerCAmelCase  ) != 0:
																lowercase_	:   List[Any]  				=     len(rows[0]  )
																if cols == 0:
																							raise error
																for row in rows:
																							if len(__lowerCAmelCase  ) != cols:
																														raise error
																							for value in row:
																														if not isinstance(__lowerCAmelCase,   (int, float)  ):
																																					raise error
																lowercase_	:   Tuple  				=     rows
									else:
																lowercase_	:   Union[str, Any]  				=     []






		def 						snake_case__				(							self  )       -> Any:






									"""simple docstring"""
									return [[row[i] for row in self.rows] for i in range(len(self.rows[0]  )  )]






		@property
		def 						snake_case__				(							self  )       -> Tuple:






									"""simple docstring"""
									return len(self.rows  )






		@property
		def 						snake_case__				(							self  )       -> Optional[int]:






									"""simple docstring"""
									return len(self.rows[0]  )






		@property
		def 						snake_case__				(							self  )       -> Optional[Any]:






									"""simple docstring"""
									return (self.num_rows, self.num_columns)






		@property
		def 						snake_case__				(							self  )       -> List[Any]:






									"""simple docstring"""
									return self.order[0] == self.order[1]






		def 						snake_case__				(							self  )       -> List[Any]:






									"""simple docstring"""
									lowercase_	:   Optional[int]  				=     [
									    [0 if column_num != row_num else 1 for column_num in range(self.num_rows  )]
									    for row_num in range(self.num_rows  )
									]
									return Matrix(__lowerCAmelCase  )






		def 						snake_case__				(							self  )       -> Optional[int]:






									"""simple docstring"""



									if not self.is_square:
																return 0
									if self.order == (0, 0):
																return 1
									if self.order == (1, 1):
																return int(self.rows[0][0]  )
									if self.order == (2, 2):
																return int(
																    (self.rows[0][0] * self.rows[1][1])
																    - (self.rows[0][1] * self.rows[1][0])  )
									else:
																return sum(
																    self.rows[0][column] * self.cofactors().rows[0][column]
																    for column in range(self.num_columns  )  )






		def 						snake_case__				(							self  )       -> Dict:






									"""simple docstring"""
									return bool(self.determinant()  )






		def 						snake_case__				(							self,   snake_case__,   snake_case__  )       -> List[str]:






									"""simple docstring"""
									lowercase_	:   Optional[int]  				=     [
									    [
									        self.rows[other_row][other_column]
									        for other_column in range(self.num_columns  )
									        if other_column != column
									    ]
									    for other_row in range(self.num_rows  )
									    if other_row != row
									]
									return Matrix(__lowerCAmelCase  ).determinant()






		def 						snake_case__				(							self,   snake_case__,   snake_case__  )       -> Optional[Any]:






									"""simple docstring"""



									if (row + column) % 2 == 0:
																return self.get_minor(__lowerCAmelCase,   __lowerCAmelCase  )
									return -1 * self.get_minor(__lowerCAmelCase,   __lowerCAmelCase  )






		def 						snake_case__				(							self  )       -> Tuple:






									"""simple docstring"""
									return Matrix(
									    [
									        [self.get_minor(__lowerCAmelCase,   __lowerCAmelCase  ) for column in range(self.num_columns  )]
									        for row in range(self.num_rows  )
									    ]  )






		def 						snake_case__				(							self  )       -> Any:






									"""simple docstring"""
									return Matrix(
									    [
									        [
									            self.minors().rows[row][column]
									            if (row + column) % 2 == 0
									            else self.minors().rows[row][column] * -1
									            for column in range(self.minors().num_columns  )
									        ]
									        for row in range(self.minors().num_rows  )
									    ]  )






		def 						snake_case__				(							self  )       -> Any:






									"""simple docstring"""
									lowercase_	:   List[str]  				=     [
									    [self.cofactors().rows[column][row] for column in range(self.num_columns  )]
									    for row in range(self.num_rows  )
									]
									return Matrix(__lowerCAmelCase  )






		def 						snake_case__				(							self  )       -> List[str]:






									"""simple docstring"""
									lowercase_	:   str  				=     self.determinant()
									if not determinant:
																raise TypeError("""Only matrices with a non-zero determinant have an inverse"""  )
									return self.adjugate() * (1 / determinant)






		def __repr__(							self  )       -> int:






									"""simple docstring"""
									return str(self.rows  )






		def __str__(							self  )       -> Any:






									"""simple docstring"""



									if self.num_rows == 0:
																return "[]"
									if self.num_rows == 1:
																return "[[" + ". ".join(str(self.rows[0]  )  ) + "]]"
									return (
									    "["
									    + "\n ".join(
									        [
									            """[""" + """. """.join([str(__lowerCAmelCase  ) for value in row]  ) + """.]"""
									            for row in self.rows
									        ]  )
									    + "]"
									)






		def 						snake_case__				(							self,   snake_case__,   snake_case__ = None  )       -> List[str]:






									"""simple docstring"""
									lowercase_	:   List[str]  				=     TypeError("""Row must be a list containing all ints and/or floats"""  )
									if not isinstance(__lowerCAmelCase,   __lowerCAmelCase  ):
																raise type_error
									for value in row:
																if not isinstance(__lowerCAmelCase,   (int, float)  ):
																							raise type_error
									if len(__lowerCAmelCase  ) != self.num_columns:
																raise ValueError(
																    """Row must be equal in length to the other rows in the matrix"""  )
									if position is None:
																self.rows.append(__lowerCAmelCase  )
									else:
																lowercase_	:   Optional[int]  				=     self.rows[0:position] + [row] + self.rows[position:]






		def 						snake_case__				(							self,   snake_case__,   snake_case__ = None  )       -> List[Any]:






									"""simple docstring"""
									lowercase_	:   str  				=     TypeError(
									    """Column must be a list containing all ints and/or floats"""  )
									if not isinstance(__lowerCAmelCase,   __lowerCAmelCase  ):
																raise type_error
									for value in column:
																if not isinstance(__lowerCAmelCase,   (int, float)  ):
																							raise type_error
									if len(__lowerCAmelCase  ) != self.num_rows:
																raise ValueError(
																    """Column must be equal in length to the other columns in the matrix"""  )
									if position is None:
																lowercase_	:   Any  				=     [self.rows[i] + [column[i]] for i in range(self.num_rows  )]
									else:
																lowercase_	:   Union[str, Any]  				=     [
																    self.rows[i][0:position] + [column[i]] + self.rows[i][position:]
																    for i in range(self.num_rows  )
																]






		def __eq__(							self,   snake_case__  )       -> Optional[Any]:






									"""simple docstring"""



									if not isinstance(__lowerCAmelCase,   __lowerCAmelCase  ):
																return NotImplemented
									return self.rows == other.rows






		def __ne__(							self,   snake_case__  )       -> List[Any]:






									"""simple docstring"""
									return not self == other






		def __neg__(							self  )       -> List[Any]:






									"""simple docstring"""
									return self * -1






		def __add__(							self,   snake_case__  )       -> Any:






									"""simple docstring"""



									if self.order != other.order:
																raise ValueError("""Addition requires matrices of the same order"""  )
									return Matrix(
									    [
									        [self.rows[i][j] + other.rows[i][j] for j in range(self.num_columns  )]
									        for i in range(self.num_rows  )
									    ]  )






		def __sub__(							self,   snake_case__  )       -> List[str]:






									"""simple docstring"""



									if self.order != other.order:
																raise ValueError("""Subtraction requires matrices of the same order"""  )
									return Matrix(
									    [
									        [self.rows[i][j] - other.rows[i][j] for j in range(self.num_columns  )]
									        for i in range(self.num_rows  )
									    ]  )






		def __mul__(							self,   snake_case__  )       -> str:






									"""simple docstring"""



									if isinstance(__lowerCAmelCase,   (int, float)  ):
																return Matrix(
																    [[int(element * other  ) for element in row] for row in self.rows]  )
									elif isinstance(__lowerCAmelCase,   __lowerCAmelCase  ):
																if self.num_columns != other.num_rows:
																							raise ValueError(
																							    """The number of columns in the first matrix must """
																							    """be equal to the number of rows in the second"""  )
																return Matrix(
																    [
																        [Matrix.dot_product(__lowerCAmelCase,   __lowerCAmelCase  ) for column in other.columns()]
																        for row in self.rows
																    ]  )
									else:
																raise TypeError(
																    """A Matrix can only be multiplied by an int, float, or another matrix"""  )






		def __pow__(							self,   snake_case__  )       -> List[Any]:






									"""simple docstring"""



									if not isinstance(__lowerCAmelCase,   __lowerCAmelCase  ):
																raise TypeError("""A Matrix can only be raised to the power of an int"""  )
									if not self.is_square:
																raise ValueError("""Only square matrices can be raised to a power"""  )
									if other == 0:
																return self.identity()
									if other < 0:
																if self.is_invertable():
																							return self.inverse() ** (-other)
																raise ValueError(
																    """Only invertable matrices can be raised to a negative power"""  )
									lowercase_	:   str  				=     self
									for _ in range(other - 1  ):
																result *= self
									return result






		@classmethod
		def 						snake_case__				(							cls,   snake_case__,   snake_case__  )       -> Any:






									"""simple docstring"""
									return sum(row[i] * column[i] for i in range(len(__lowerCAmelCase  )  )  )


if __name__ == "__main__":
							import doctest

							doctest.testmod()
"""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"""		)



