




'''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 	_snake_case(			unittest.TestCase      ):
 __snake_case:							Optional[Any]						=					['''[UNK]''', '''[CLS]''', '''[SEP]''', '''[PAD]''', '''[MASK]''', '''bla''', '''blou''']






 def 						_UpperCamelCase (self       :  List[Any]    )       ->   Optional[int]:






    """simple docstring"""


    A__       =     0






 def 						_UpperCamelCase (self       :  Any    )       ->   Optional[int]:






    """simple docstring"""


    A__       =     AutoProcessor.from_pretrained('facebook/wav2vec2-base-960h'    )
    self.assertIsInstance(a    ,		a    )






 def 						_UpperCamelCase (self       :  Optional[Any]    )       ->   str:






    """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(a    )
       processor.save_pretrained(a    )

       A__       =     AutoProcessor.from_pretrained(a    )

    self.assertIsInstance(a    ,		a    )






 def 						_UpperCamelCase (self       :  Any    )       ->   Optional[Any]:






    """simple docstring"""


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

       A__       =     AutoProcessor.from_pretrained(a    )

    self.assertIsInstance(a    ,		a    )






 def 						_UpperCamelCase (self       :  Any    )       ->   Dict:






    """simple docstring"""


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

       A__       =     WavaVecaProcessor(a    ,		a    )

       # save in new folder
       processor.save_pretrained(a    )

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

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

       A__       =     AutoProcessor.from_pretrained(a    )

    self.assertIsInstance(a    ,		a    )






 def 						_UpperCamelCase (self       :  Tuple    )       ->   List[str]:






    """simple docstring"""


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

       A__       =     WavaVecaProcessor(a    ,		a    )

       # save in new folder
       processor.save_pretrained(a    )

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

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

       A__       =     AutoProcessor.from_pretrained(a    )

    self.assertIsInstance(a    ,		a    )






 def 						_UpperCamelCase (self       :  Dict    )       ->   int:






    """simple docstring"""


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

       A__       =     AutoProcessor.from_pretrained(a    )

    self.assertIsInstance(a    ,		a    )






 def 						_UpperCamelCase (self       :  int    )       ->   Any:






    """simple docstring"""


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

    A__       =     AutoProcessor.from_pretrained('hf-internal-testing/test_dynamic_processor'    ,		trust_remote_code=a    )
    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=a    ,		use_fast=a    )
       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 						_UpperCamelCase (self       :  str    )       ->   List[Any]:






    """simple docstring"""


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

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

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

       A__       =     CustomProcessor(a    ,		a    )

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

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






 def 						_UpperCamelCase (self       :  Dict    )       ->   Tuple:






    """simple docstring"""


    class 	_snake_case(			UpperCAmelCase      ):
     __snake_case:							Tuple						=					False




    class 	_snake_case(			UpperCAmelCase      ):
     __snake_case:							List[Any]						=					False




    class 	_snake_case(			UpperCAmelCase      ):
     __snake_case:							Any						=					'''AutoFeatureExtractor'''
     __snake_case:							str						=					'''AutoTokenizer'''
     __snake_case:							str						=					False

    try:
       AutoConfig.register('custom'    ,		a    )
       AutoFeatureExtractor.register(a    ,		a    )
       AutoTokenizer.register(a    ,		slow_tokenizer_class=a    )
       AutoProcessor.register(a    ,		a    )
       # 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=a    )
       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=a    )
       self.assertEqual(processor.__class__.__name__    ,		'NewProcessor'    )
       self.assertTrue(processor.special_attribute_present    )
       self.assertTrue(processor.feature_extractor.special_attribute_present    )
       self.assertTrue(processor.tokenizer.special_attribute_present    )

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






 def 						_UpperCamelCase (self       :  str    )       ->   Optional[int]:






    """simple docstring"""


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






 def 						_UpperCamelCase (self       :  Union[str, Any]    )       ->   Tuple:






    """simple docstring"""


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




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






 @classmethod
 def 						_UpperCamelCase (cls       :  Optional[Any]    )       ->   Optional[int]:






    """simple docstring"""


    A__       =     TOKEN
    HfFolder.save_token(a    )






 @classmethod
 def 						_UpperCamelCase (cls       :  Union[str, Any]    )       ->   Optional[int]:






    """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 						_UpperCamelCase (self       :  List[str]    )       ->   List[Any]:






    """simple docstring"""


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

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






 def 						_UpperCamelCase (self       :  Optional[Any]    )       ->   str:






    """simple docstring"""


    A__       =     WavaVecaProcessor.from_pretrained(a    )

    with tempfile.TemporaryDirectory() as tmp_dir:
       processor.save_pretrained(
           os.path.join(a    ,		'test-processor-org'    )    ,		push_to_hub=a    ,		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(a    ,		getattr(new_processor.feature_extractor    ,		a    )    )
       self.assertDictEqual(new_processor.tokenizer.get_vocab()    ,		processor.tokenizer.get_vocab()    )






 def 						_UpperCamelCase (self       :  Optional[Any]    )       ->   List[Any]:






    """simple docstring"""


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

    A__       =     CustomFeatureExtractor.from_pretrained(a    )

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

    A__       =     CustomProcessor(a    ,		a    )

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

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

       repo.push_to_hub()

    A__       =     AutoProcessor.from_pretrained(f"""{USER}/test-dynamic-processor"""    ,		trust_remote_code=a    )
    # 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 re
import string

import numpy as np

import datasets


lowerCAmelCase_     						=				'''
Returns the rate at which the input predicted strings exactly match their references, ignoring any strings input as part of the regexes_to_ignore list.
'''

lowerCAmelCase_     						=				'''
Args:
    predictions: List of predicted texts.
    references: List of reference texts.
    regexes_to_ignore: List, defaults to None. Regex expressions of characters to
        ignore when calculating the exact matches. Note: these regexes are removed
        from the input data before the changes based on the options below (e.g. ignore_case,
        ignore_punctuation, ignore_numbers) are applied.
    ignore_case: Boolean, defaults to False. If true, turns everything
        to lowercase so that capitalization differences are ignored.
    ignore_punctuation: Boolean, defaults to False. If true, removes all punctuation before
        comparing predictions and references.
    ignore_numbers: Boolean, defaults to False. If true, removes all punctuation before
        comparing predictions and references.
Returns:
    exact_match: Dictionary containing exact_match rate. Possible values are between 0.0 and 100.0, inclusive.
Examples:
    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds)
    >>> print(round(results["exact_match"], 1))
    25.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell"], ignore_case=True, ignore_punctuation=True)
    >>> print(round(results["exact_match"], 1))
    50.0


    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True)
    >>> print(round(results["exact_match"], 1))
    75.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True, ignore_numbers=True)
    >>> print(round(results["exact_match"], 1))
    100.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["The cat sat on the mat.", "Theaters are great.", "It\'s like comparing oranges and apples."]
    >>> preds = ["The cat sat on the mat?", "Theaters are great.", "It\'s like comparing apples and oranges."]
    >>> results = exact_match.compute(references=refs, predictions=preds)
    >>> print(round(results["exact_match"], 1))
    33.3

'''

lowerCAmelCase_     						=				'''
'''

@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION       , _KWARGS_DESCRIPTION      )
class 	_snake_case(			datasets.Metric      ):






 def 						_UpperCamelCase (self       :  Optional[Any]    )       ->   Dict:






    """simple docstring"""


    return datasets.MetricInfo(
        description=_DESCRIPTION    ,		citation=_CITATION    ,		inputs_description=_KWARGS_DESCRIPTION    ,		features=datasets.Features(
            {
                'predictions': datasets.Value('string'    ,		id='sequence'    ),
                'references': datasets.Value('string'    ,		id='sequence'    ),
            }    )    ,		reference_urls=[]    ,		)






 def 						_UpperCamelCase (self       :  List[str]    ,		a       :  str    ,		a       :  Tuple    ,		a       :  Tuple=None    ,		a       :  Dict=False    ,		a       :  Dict=False    ,		a       :  List[str]=False    ,		)       ->   int:






    """simple docstring"""


    if regexes_to_ignore is not None:
       for s in regexes_to_ignore:
          A__       =     np.array([re.sub(a    ,		''    ,		a    ) for x in predictions]    )
          A__       =     np.array([re.sub(a    ,		''    ,		a    ) for x in references]    )
    else:
       A__       =     np.asarray(a    )
       A__       =     np.asarray(a    )

    if ignore_case:
       A__       =     np.char.lower(a    )
       A__       =     np.char.lower(a    )

    if ignore_punctuation:
       A__       =     string.punctuation.maketrans(''    ,		''    ,		string.punctuation    )
       A__       =     np.char.translate(a    ,		table=a    )
       A__       =     np.char.translate(a    ,		table=a    )

    if ignore_numbers:
       A__       =     string.digits.maketrans(''    ,		''    ,		string.digits    )
       A__       =     np.char.translate(a    ,		table=a    )
       A__       =     np.char.translate(a    ,		table=a    )

    A__       =     predictions == references

    return {"exact_match": np.mean(a    ) * 1_00}


