






'''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_				   =   get_tests_dir('''fixtures/dummy_feature_extractor_config.json''')
lowerCamelCase_				   =   get_tests_dir('''fixtures/vocab.json''')
lowerCamelCase_				   =   get_tests_dir('''fixtures''')

class   _UpperCAmelCase     (	unittest.TestCase		):




   """simple docstring"""

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

   def 		lowerCAmelCase					(						self					:      Optional[Any]						):





         '''simple docstring'''





         _A     	=      0

   def 		lowerCAmelCase					(						self					:      List[Any]						):





         '''simple docstring'''





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

   def 		lowerCAmelCase					(						self					:      Optional[int]						):





         '''simple docstring'''





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

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

               _A     	=      AutoProcessor.from_pretrained(__UpperCAmelCase						)

         self.assertIsInstance(__UpperCAmelCase , __UpperCAmelCase						)

   def 		lowerCAmelCase					(						self					:      List[str]						):





         '''simple docstring'''





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

               _A     	=      AutoProcessor.from_pretrained(__UpperCAmelCase						)

         self.assertIsInstance(__UpperCAmelCase , __UpperCAmelCase						)

   def 		lowerCAmelCase					(						self					:      Tuple						):





         '''simple docstring'''





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

               _A     	=      WavaVecaProcessor(__UpperCAmelCase , __UpperCAmelCase						)

               # save in new folder
               processor.save_pretrained(__UpperCAmelCase						)

               # drop `processor_class` in tokenizer
               with open(os.path.join(__UpperCAmelCase , __UpperCAmelCase						) , "r"						) as f:
                     _A     	=      json.load(__UpperCAmelCase						)
                     config_dict.pop("processor_class"						)

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

               _A     	=      AutoProcessor.from_pretrained(__UpperCAmelCase						)

         self.assertIsInstance(__UpperCAmelCase , __UpperCAmelCase						)

   def 		lowerCAmelCase					(						self					:      Dict						):





         '''simple docstring'''





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

               _A     	=      WavaVecaProcessor(__UpperCAmelCase , __UpperCAmelCase						)

               # save in new folder
               processor.save_pretrained(__UpperCAmelCase						)

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

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

               _A     	=      AutoProcessor.from_pretrained(__UpperCAmelCase						)

         self.assertIsInstance(__UpperCAmelCase , __UpperCAmelCase						)

   def 		lowerCAmelCase					(						self					:      Union[str, Any]						):





         '''simple docstring'''





         with tempfile.TemporaryDirectory() as tmpdirname:
               _A     	=      WavaVecaConfig(processor_class="Wav2Vec2Processor"						)
               model_config.save_pretrained(__UpperCAmelCase						)
               # copy relevant files
               copyfile(__UpperCAmelCase , os.path.join(__UpperCAmelCase , "vocab.json"						)						)
               # create emtpy sample processor
               with open(os.path.join(__UpperCAmelCase , __UpperCAmelCase						) , "w"						) as f:
                     f.write("{}"						)

               _A     	=      AutoProcessor.from_pretrained(__UpperCAmelCase						)

         self.assertIsInstance(__UpperCAmelCase , __UpperCAmelCase						)

   def 		lowerCAmelCase					(						self					:      Any						):





         '''simple docstring'''





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

         _A     	=      AutoProcessor.from_pretrained("hf-internal-testing/test_dynamic_processor" , trust_remote_code=__UpperCAmelCase						)
         self.assertTrue(processor.special_attribute_present						)
         self.assertEqual(processor.__class__.__name__ , "NewProcessor"						)

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

         _A     	=      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
               _A     	=      AutoProcessor.from_pretrained(
                   "hf-internal-testing/test_dynamic_processor" , trust_remote_code=__UpperCAmelCase , use_fast=__UpperCAmelCase						)
               _A     	=      new_processor.tokenizer
               self.assertTrue(new_tokenizer.special_attribute_present						)
               self.assertEqual(new_tokenizer.__class__.__name__ , "NewTokenizer"						)
         else:
               self.assertEqual(tokenizer.__class__.__name__ , "NewTokenizer"						)

   def 		lowerCAmelCase					(						self					:      Optional[Any]						):





         '''simple docstring'''





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

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

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

               _A     	=      CustomProcessor(__UpperCAmelCase , __UpperCAmelCase						)

               with tempfile.TemporaryDirectory() as tmp_dir:
                     processor.save_pretrained(__UpperCAmelCase						)
                     _A     	=      AutoProcessor.from_pretrained(__UpperCAmelCase						)
                     self.assertIsInstance(__UpperCAmelCase , __UpperCAmelCase						)

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

   def 		lowerCAmelCase					(						self					:      str						):





         '''simple docstring'''





         class   _UpperCAmelCase     (	UpperCAmelCase__		):




            """simple docstring"""

            snake_case       							=		False





         class   _UpperCAmelCase     (	UpperCAmelCase__		):




            """simple docstring"""

            snake_case       							=		False





         class   _UpperCAmelCase     (	UpperCAmelCase__		):




            """simple docstring"""

            snake_case       							=		"AutoFeatureExtractor"
            snake_case       							=		"AutoTokenizer"
            snake_case       							=		False

         try:
               AutoConfig.register("custom" , __UpperCAmelCase						)
               AutoFeatureExtractor.register(__UpperCAmelCase , __UpperCAmelCase						)
               AutoTokenizer.register(__UpperCAmelCase , slow_tokenizer_class=__UpperCAmelCase						)
               AutoProcessor.register(__UpperCAmelCase , __UpperCAmelCase						)
               # If remote code is not set, the default is to use local classes.
               _A     	=      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.
               _A     	=      AutoProcessor.from_pretrained(
                   "hf-internal-testing/test_dynamic_processor" , trust_remote_code=__UpperCAmelCase						)
               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.
               _A     	=      AutoProcessor.from_pretrained(
                   "hf-internal-testing/test_dynamic_processor" , trust_remote_code=__UpperCAmelCase						)
               self.assertEqual(processor.__class__.__name__ , "NewProcessor"						)
               self.assertTrue(processor.special_attribute_present						)
               self.assertTrue(processor.feature_extractor.special_attribute_present						)
               self.assertTrue(processor.tokenizer.special_attribute_present						)

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

   def 		lowerCAmelCase					(						self					:      List[Any]						):





         '''simple docstring'''





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

   def 		lowerCAmelCase					(						self					:      Optional[int]						):





         '''simple docstring'''





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





@is_staging_test
class   _UpperCAmelCase     (	unittest.TestCase		):




   """simple docstring"""

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

   @classmethod
   def 		lowerCAmelCase					(						cls					:      Dict						):





         '''simple docstring'''





         _A     	=      TOKEN
         HfFolder.save_token(__UpperCAmelCase						)

   @classmethod
   def 		lowerCAmelCase					(						cls					:      Dict						):





         '''simple docstring'''





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

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

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

   def 		lowerCAmelCase					(						self					:      Optional[int]						):





         '''simple docstring'''





         _A     	=      WavaVecaProcessor.from_pretrained(__UpperCAmelCase						)
         with tempfile.TemporaryDirectory() as tmp_dir:
               processor.save_pretrained(
                   os.path.join(__UpperCAmelCase , "test-processor"						) , push_to_hub=__UpperCAmelCase , use_auth_token=self._token						)

               _A     	=      WavaVecaProcessor.from_pretrained(f'''{USER}/test-processor'''						)
               for k, v in processor.feature_extractor.__dict__.items():
                     self.assertEqual(__UpperCAmelCase , getattr(new_processor.feature_extractor , __UpperCAmelCase						)						)
               self.assertDictEqual(new_processor.tokenizer.get_vocab() , processor.tokenizer.get_vocab()						)

   def 		lowerCAmelCase					(						self					:      Tuple						):





         '''simple docstring'''





         _A     	=      WavaVecaProcessor.from_pretrained(__UpperCAmelCase						)

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

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

   def 		lowerCAmelCase					(						self					:      Any						):





         '''simple docstring'''





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

         _A     	=      CustomFeatureExtractor.from_pretrained(__UpperCAmelCase						)

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

         _A     	=      CustomProcessor(__UpperCAmelCase , __UpperCAmelCase						)

         with tempfile.TemporaryDirectory() as tmp_dir:
               create_repo(f'''{USER}/test-dynamic-processor''' , token=self._token						)
               _A     	=      Repository(__UpperCAmelCase , clone_from=f'''{USER}/test-dynamic-processor''' , token=self._token						)
               processor.save_pretrained(__UpperCAmelCase						)

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

               repo.push_to_hub()

         _A     	=      AutoProcessor.from_pretrained(f'''{USER}/test-dynamic-processor''' , trust_remote_code=__UpperCAmelCase						)
         # 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"						)






'''simple docstring'''




def __lowerCAmelCase					(				UpperCamelCase__							,    UpperCamelCase__							,    UpperCamelCase__							)      ->       int:

    def count_of_possible_combinations(UpperCamelCase__							) -> int:
        if target < 0:
            return 0
        if target == 0:
            return 1
        return sum(count_of_possible_combinations(target - item							) for item in array							)

    return count_of_possible_combinations(UpperCamelCase__							)






def __lowerCAmelCase					(				UpperCamelCase__							,    UpperCamelCase__							,    UpperCamelCase__							)      ->       int:

    def count_of_possible_combinations_with_dp_array(
        UpperCamelCase__							,    UpperCamelCase__							) -> int:
        if target < 0:
            return 0
        if target == 0:
            return 1
        if dp_array[target] != -1:
            return dp_array[target]
        __lowerCamelCase            =    sum(
            count_of_possible_combinations_with_dp_array(target - item							,    UpperCamelCase__							)
            for item in array							)
        __lowerCamelCase            =    answer
        return answer

    __lowerCamelCase            =    [-1] * (target + 1)
    return count_of_possible_combinations_with_dp_array(UpperCamelCase__							,    UpperCamelCase__							)






def __lowerCAmelCase					(				UpperCamelCase__							,    UpperCamelCase__							,    UpperCamelCase__							)      ->       int:
    __lowerCamelCase            =    [0] * (target + 1)
    __lowerCamelCase            =    1

    for i in range(1							,    target + 1							):
        for j in range(UpperCamelCase__							):
            if i - array[j] >= 0:
                dp_array[i] += dp_array[i - array[j]]

    return dp_array[target]


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  __UpperCAmelCase					=3
  __UpperCAmelCase					=5
  __UpperCAmelCase					=[1, 2, 5]
  print(combination_sum_iv(n, array, target))
