"""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


UpperCAmelCase__  		=						get_tests_dir("""fixtures/dummy_feature_extractor_config.json""")
UpperCAmelCase__  		=						get_tests_dir("""fixtures/vocab.json""")
UpperCAmelCase__  		=						get_tests_dir("""fixtures""")


class        a				(		unittest.TestCase   ):
    _snake_case     :  Union[str, Any]     							=							['[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', 'bla', 'blou']


    def      lowerCAmelCase_  (					self	:  Any					):
      _UpperCAmelCase						 =      0


    def      lowerCAmelCase_  (					self	:  Optional[Any]					):
      _UpperCAmelCase						 =      AutoProcessor.from_pretrained("""facebook/wav2vec2-base-960h"""					)
      self.assertIsInstance(__lowerCAmelCase   ,				__lowerCAmelCase					)


    def      lowerCAmelCase_  (					self	:  Optional[int]					):
      with tempfile.TemporaryDirectory() as tmpdirname:
        _UpperCAmelCase						 =      WavaVecaConfig()
        _UpperCAmelCase						 =      AutoProcessor.from_pretrained("""facebook/wav2vec2-base-960h"""					)

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

        _UpperCAmelCase						 =      AutoProcessor.from_pretrained(__lowerCAmelCase					)

      self.assertIsInstance(__lowerCAmelCase   ,				__lowerCAmelCase					)


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

        _UpperCAmelCase						 =      AutoProcessor.from_pretrained(__lowerCAmelCase					)

      self.assertIsInstance(__lowerCAmelCase   ,				__lowerCAmelCase					)


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

        _UpperCAmelCase						 =      WavaVecaProcessor(__lowerCAmelCase   ,				__lowerCAmelCase					)

        # save in new folder
        processor.save_pretrained(__lowerCAmelCase					)

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

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

        _UpperCAmelCase						 =      AutoProcessor.from_pretrained(__lowerCAmelCase					)

      self.assertIsInstance(__lowerCAmelCase   ,				__lowerCAmelCase					)


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

        _UpperCAmelCase						 =      WavaVecaProcessor(__lowerCAmelCase   ,				__lowerCAmelCase					)

        # save in new folder
        processor.save_pretrained(__lowerCAmelCase					)

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

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

        _UpperCAmelCase						 =      AutoProcessor.from_pretrained(__lowerCAmelCase					)

      self.assertIsInstance(__lowerCAmelCase   ,				__lowerCAmelCase					)


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

        _UpperCAmelCase						 =      AutoProcessor.from_pretrained(__lowerCAmelCase					)

      self.assertIsInstance(__lowerCAmelCase   ,				__lowerCAmelCase					)


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

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

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

      _UpperCAmelCase						 =      processor.tokenizer
      self.assertTrue(tokenizer.special_attribute_present					)
      if is_tokenizers_available():
        self.assertEqual(tokenizer.__class__.__name__   ,				"""NewTokenizerFast"""					)

        # Test we can also load the slow version
        _UpperCAmelCase						 =      AutoProcessor.from_pretrained(
            """hf-internal-testing/test_dynamic_processor"""   ,				trust_remote_code=__lowerCAmelCase   ,				use_fast=__lowerCAmelCase					)
        _UpperCAmelCase						 =      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	:  List[Any]					):
      try:
        AutoConfig.register("""custom"""   ,				__lowerCAmelCase					)
        AutoFeatureExtractor.register(__lowerCAmelCase   ,				__lowerCAmelCase					)
        AutoTokenizer.register(__lowerCAmelCase   ,				slow_tokenizer_class=__lowerCAmelCase					)
        AutoProcessor.register(__lowerCAmelCase   ,				__lowerCAmelCase					)
        # Trying to register something existing in the Transformers library will raise an error
        with self.assertRaises(__lowerCAmelCase					):
          AutoProcessor.register(__lowerCAmelCase   ,				__lowerCAmelCase					)

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

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

        _UpperCAmelCase						 =      CustomProcessor(__lowerCAmelCase   ,				__lowerCAmelCase					)

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


      class        a				(		lowerCAmelCase_   ):
          _snake_case     :  List[str]     							=							False



      class        a				(		lowerCAmelCase_   ):
          _snake_case     :  List[str]     							=							False



      class        a				(		lowerCAmelCase_   ):
          _snake_case     :  Optional[int]     							=							'AutoFeatureExtractor'
          _snake_case     :  Tuple     							=							'AutoTokenizer'
          _snake_case     :  Any     							=							False

      try:
        AutoConfig.register("""custom"""   ,				__lowerCAmelCase					)
        AutoFeatureExtractor.register(__lowerCAmelCase   ,				__lowerCAmelCase					)
        AutoTokenizer.register(__lowerCAmelCase   ,				slow_tokenizer_class=__lowerCAmelCase					)
        AutoProcessor.register(__lowerCAmelCase   ,				__lowerCAmelCase					)
        # If remote code is not set, the default is to use local classes.
        _UpperCAmelCase						 =      AutoProcessor.from_pretrained("""hf-internal-testing/test_dynamic_processor"""					)
        self.assertEqual(processor.__class__.__name__   ,				"""NewProcessor"""					)
        self.assertFalse(processor.special_attribute_present					)
        self.assertFalse(processor.feature_extractor.special_attribute_present					)
        self.assertFalse(processor.tokenizer.special_attribute_present					)

        # If remote code is disabled, we load the local ones.
        _UpperCAmelCase						 =      AutoProcessor.from_pretrained(
            """hf-internal-testing/test_dynamic_processor"""   ,				trust_remote_code=__lowerCAmelCase					)
        self.assertEqual(processor.__class__.__name__   ,				"""NewProcessor"""					)
        self.assertFalse(processor.special_attribute_present					)
        self.assertFalse(processor.feature_extractor.special_attribute_present					)
        self.assertFalse(processor.tokenizer.special_attribute_present					)

        # If remote is enabled, we load from the Hub.
        _UpperCAmelCase						 =      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      lowerCAmelCase_  (					self	:  List[str]					):
      _UpperCAmelCase						 =      AutoProcessor.from_pretrained("""hf-internal-testing/tiny-random-bert"""					)
      self.assertEqual(processor.__class__.__name__   ,				"""BertTokenizerFast"""					)


    def      lowerCAmelCase_  (					self	:  Any					):
      _UpperCAmelCase						 =      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      lowerCAmelCase_  (					cls	:  List[Any]					):
      _UpperCAmelCase						 =      TOKEN
      HfFolder.save_token(__lowerCAmelCase					)


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

        _UpperCAmelCase						 =      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      lowerCAmelCase_  (					self	:  Dict					):
      _UpperCAmelCase						 =      WavaVecaProcessor.from_pretrained(__lowerCAmelCase					)

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

        _UpperCAmelCase						 =      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      lowerCAmelCase_  (					self	:  Dict					):
      CustomFeatureExtractor.register_for_auto_class()
      CustomTokenizer.register_for_auto_class()
      CustomProcessor.register_for_auto_class()

      _UpperCAmelCase						 =      CustomFeatureExtractor.from_pretrained(__lowerCAmelCase					)

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

      _UpperCAmelCase						 =      CustomProcessor(__lowerCAmelCase   ,				__lowerCAmelCase					)

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

        # This has added the proper auto_map field to the feature extractor config
        self.assertDictEqual(
            processor.feature_extractor.auto_map   ,				{
                """AutoFeatureExtractor""": """custom_feature_extraction.CustomFeatureExtractor""",
                """AutoProcessor""": """custom_processing.CustomProcessor""",
            }   ,				)

        # This has added the proper auto_map field to the tokenizer config
        with open(os.path.join(__lowerCAmelCase   ,				"""tokenizer_config.json"""					)					) as f:
          _UpperCAmelCase						 =      json.load(__lowerCAmelCase					)
        self.assertDictEqual(
            tokenizer_config["""auto_map"""]   ,				{
                """AutoTokenizer""": ["""custom_tokenization.CustomTokenizer""", None],
                """AutoProcessor""": """custom_processing.CustomProcessor""",
            }   ,				)

        # The code has been copied from fixtures
        self.assertTrue(os.path.isfile(os.path.join(__lowerCAmelCase   ,				"""custom_feature_extraction.py"""					)					)					)
        self.assertTrue(os.path.isfile(os.path.join(__lowerCAmelCase   ,				"""custom_tokenization.py"""					)					)					)
        self.assertTrue(os.path.isfile(os.path.join(__lowerCAmelCase   ,				"""custom_processing.py"""					)					)					)

        repo.push_to_hub()

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

"""simple docstring"""


import unittest

from knapsack import knapsack as k


class        a				(		unittest.TestCase   ):


    def      lowerCAmelCase_  (					self	:  List[Any]					):
      _UpperCAmelCase						 =      0
      _UpperCAmelCase						 =      [0]
      _UpperCAmelCase						 =      [0]
      _UpperCAmelCase						 =      len(__lowerCAmelCase					)
      self.assertEqual(k.knapsack(__lowerCAmelCase   ,				__lowerCAmelCase   ,				__lowerCAmelCase   ,				__lowerCAmelCase					)   ,				0					)

      _UpperCAmelCase						 =      [60]
      _UpperCAmelCase						 =      [10]
      _UpperCAmelCase						 =      len(__lowerCAmelCase					)
      self.assertEqual(k.knapsack(__lowerCAmelCase   ,				__lowerCAmelCase   ,				__lowerCAmelCase   ,				__lowerCAmelCase					)   ,				0					)


    def      lowerCAmelCase_  (					self	:  Optional[int]					):
      _UpperCAmelCase						 =      3
      _UpperCAmelCase						 =      [1, 2, 3]
      _UpperCAmelCase						 =      [3, 2, 1]
      _UpperCAmelCase						 =      len(__lowerCAmelCase					)
      self.assertEqual(k.knapsack(__lowerCAmelCase   ,				__lowerCAmelCase   ,				__lowerCAmelCase   ,				__lowerCAmelCase					)   ,				5					)


    def      lowerCAmelCase_  (					self	:  Optional[Any]					):
      _UpperCAmelCase						 =      50
      _UpperCAmelCase						 =      [60, 100, 120]
      _UpperCAmelCase						 =      [10, 20, 30]
      _UpperCAmelCase						 =      len(__lowerCAmelCase					)
      self.assertEqual(k.knapsack(__lowerCAmelCase   ,				__lowerCAmelCase   ,				__lowerCAmelCase   ,				__lowerCAmelCase					)   ,				220					)


if __name__ == "__main__":
    unittest.main()
