


from sklearn.metrics import mean_squared_error

import datasets


lowerCamelCase		   =			'\\n@article{scikit-learn,\n title={Scikit-learn: Machine Learning in {P}ython},\n author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n         and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n         and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n         Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n journal={Journal of Machine Learning Research},\n volume={12},\n pages={2825--2830},\n year={2011}\n}\n'

lowerCamelCase		   =			'\\nMean Squared Error(MSE) is the average of the square of difference between the predicted\nand actual values.\n'


lowerCamelCase		   =			'\nArgs:\n    predictions: array-like of shape (n_samples,) or (n_samples, n_outputs)\n        Estimated target values.\n    references: array-like of shape (n_samples,) or (n_samples, n_outputs)\n        Ground truth (correct) target values.\n    sample_weight: array-like of shape (n_samples,), default=None\n        Sample weights.\n    multioutput: {"raw_values", "uniform_average"} or array-like of shape (n_outputs,), default="uniform_average"\n        Defines aggregating of multiple output values. Array-like value defines weights used to average errors.\n\n        "raw_values" : Returns a full set of errors in case of multioutput input.\n\n        "uniform_average" : Errors of all outputs are averaged with uniform weight.\n\n    squared : bool, default=True\n        If True returns MSE value, if False returns RMSE (Root Mean Squared Error) value.\n\nReturns:\n    mse : mean squared error.\nExamples:\n\n    >>> mse_metric = datasets.load_metric("mse")\n    >>> predictions = [2.5, 0.0, 2, 8]\n    >>> references = [3, -0.5, 2, 7]\n    >>> results = mse_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'mse\': 0.375}\n    >>> rmse_result = mse_metric.compute(predictions=predictions, references=references, squared=False)\n    >>> print(rmse_result)\n    {\'mse\': 0.6123724356957945}\n\n    If you\'re using multi-dimensional lists, then set the config as follows :\n\n    >>> mse_metric = datasets.load_metric("mse", "multilist")\n    >>> predictions = [[0.5, 1], [-1, 1], [7, -6]]\n    >>> references = [[0, 2], [-1, 2], [8, -5]]\n    >>> results = mse_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {\'mse\': 0.7083333333333334}\n    >>> results = mse_metric.compute(predictions=predictions, references=references, multioutput=\'raw_values\')\n    >>> print(results) # doctest: +NORMALIZE_WHITESPACE\n    {\'mse\': array([0.41666667, 1. ])}\n'




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






      def 			lowerCamelCase			(   self		:	List[Any]					)   ->		Optional[int]:
             """simple docstring"""




             return datasets.MetricInfo(
                 description=_DESCRIPTION     ,  citation=_CITATION     ,  inputs_description=_KWARGS_DESCRIPTION     ,  features=datasets.Features(self._get_feature_types()					)     ,  reference_urls=[
                     'https://scikit-learn.org/stable/modules/generated/sklearn.metrics.mean_squared_error.html'
                 ]     ,  )






      def 			lowerCamelCase			(   self		:	Any					)   ->		Union[str, Any]:
             """simple docstring"""




             if self.config_name == "multilist":
                    return {
                        "predictions": datasets.Sequence(datasets.Value('float'					)					),
                        "references": datasets.Sequence(datasets.Value('float'					)					),
                    }
             else:
                    return {
                        "predictions": datasets.Value('float'					),
                        "references": datasets.Value('float'					),
                    }






      def 			lowerCamelCase			(   self		:	Union[str, Any]     ,  lowercase_		:	Optional[int]     ,  lowercase_		:	str     ,  lowercase_		:	Optional[Any]=None     ,  lowercase_		:	Dict="uniform_average"     ,  lowercase_		:	Optional[Any]=True					)   ->		Dict:
             """simple docstring"""




             _lowerCamelCase			:						Tuple            =mean_squared_error(
                 lowercase_     ,  lowercase_     ,  sample_weight=lowercase_     ,  multioutput=lowercase_     ,  squared=lowercase_					)

             return {"mse": mse}






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 A    (  unittest.TestCase	):
      UpperCamelCase__				:    Dict =['[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', 'bla', 'blou']






      def 			lowerCamelCase			(   self		:	str					)   ->		Optional[Any]:
             """simple docstring"""




             _lowerCamelCase			:						Dict            =0






      def 			lowerCamelCase			(   self		:	str					)   ->		List[str]:
             """simple docstring"""




             _lowerCamelCase			:						List[Any]            =AutoProcessor.from_pretrained('facebook/wav2vec2-base-960h'					)
             self.assertIsInstance(lowercase_     ,  lowercase_					)






      def 			lowerCamelCase			(   self		:	int					)   ->		Tuple:
             """simple docstring"""




             with tempfile.TemporaryDirectory() as tmpdirname:
                    _lowerCamelCase			:						int            =WavaVecaConfig()
                    _lowerCamelCase			:						Dict            =AutoProcessor.from_pretrained('facebook/wav2vec2-base-960h'					)

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

                    _lowerCamelCase			:						Any            =AutoProcessor.from_pretrained(lowercase_					)

             self.assertIsInstance(lowercase_     ,  lowercase_					)






      def 			lowerCamelCase			(   self		:	str					)   ->		Union[str, Any]:
             """simple docstring"""




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

                    _lowerCamelCase			:						Union[str, Any]            =AutoProcessor.from_pretrained(lowercase_					)

             self.assertIsInstance(lowercase_     ,  lowercase_					)






      def 			lowerCamelCase			(   self		:	Any					)   ->		Optional[Any]:
             """simple docstring"""




             with tempfile.TemporaryDirectory() as tmpdirname:
                    _lowerCamelCase			:						List[Any]            =WavaVecaFeatureExtractor()
                    _lowerCamelCase			:						List[str]            =AutoTokenizer.from_pretrained('facebook/wav2vec2-base-960h'					)

                    _lowerCamelCase			:						str            =WavaVecaProcessor(lowercase_     ,  lowercase_					)

                    # save in new folder
                    processor.save_pretrained(lowercase_					)

                    # drop `processor_class` in tokenizer
                    with open(os.path.join(lowercase_     ,  lowercase_					)     ,  'r'					) as f:
                           _lowerCamelCase			:						Optional[int]            =json.load(lowercase_					)
                           config_dict.pop('processor_class'					)

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

                    _lowerCamelCase			:						Optional[int]            =AutoProcessor.from_pretrained(lowercase_					)

             self.assertIsInstance(lowercase_     ,  lowercase_					)






      def 			lowerCamelCase			(   self		:	Dict					)   ->		Optional[int]:
             """simple docstring"""




             with tempfile.TemporaryDirectory() as tmpdirname:
                    _lowerCamelCase			:						Optional[Any]            =WavaVecaFeatureExtractor()
                    _lowerCamelCase			:						Tuple            =AutoTokenizer.from_pretrained('facebook/wav2vec2-base-960h'					)

                    _lowerCamelCase			:						Dict            =WavaVecaProcessor(lowercase_     ,  lowercase_					)

                    # save in new folder
                    processor.save_pretrained(lowercase_					)

                    # drop `processor_class` in feature extractor
                    with open(os.path.join(lowercase_     ,  lowercase_					)     ,  'r'					) as f:
                           _lowerCamelCase			:						Union[str, Any]            =json.load(lowercase_					)
                           config_dict.pop('processor_class'					)

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

                    _lowerCamelCase			:						Optional[int]            =AutoProcessor.from_pretrained(lowercase_					)

             self.assertIsInstance(lowercase_     ,  lowercase_					)






      def 			lowerCamelCase			(   self		:	List[str]					)   ->		List[str]:
             """simple docstring"""




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

                    _lowerCamelCase			:						int            =AutoProcessor.from_pretrained(lowercase_					)

             self.assertIsInstance(lowercase_     ,  lowercase_					)






      def 			lowerCamelCase			(   self		:	str					)   ->		Optional[int]:
             """simple docstring"""




             with self.assertRaises(lowercase_					):
                    _lowerCamelCase			:						int            =AutoProcessor.from_pretrained('hf-internal-testing/test_dynamic_processor'					)
             # If remote code is disabled, we can't load this config.
             with self.assertRaises(lowercase_					):
                    _lowerCamelCase			:						Union[str, Any]            =AutoProcessor.from_pretrained(
                        'hf-internal-testing/test_dynamic_processor'     ,  trust_remote_code=lowercase_					)

             _lowerCamelCase			:						List[str]            =AutoProcessor.from_pretrained('hf-internal-testing/test_dynamic_processor'     ,  trust_remote_code=lowercase_					)
             self.assertTrue(processor.special_attribute_present					)
             self.assertEqual(processor.__class__.__name__     ,  'NewProcessor'					)

             _lowerCamelCase			:						int            =processor.feature_extractor
             self.assertTrue(feature_extractor.special_attribute_present					)
             self.assertEqual(feature_extractor.__class__.__name__     ,  'NewFeatureExtractor'					)

             _lowerCamelCase			:						Optional[int]            =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
                    _lowerCamelCase			:						int            =AutoProcessor.from_pretrained(
                        'hf-internal-testing/test_dynamic_processor'     ,  trust_remote_code=lowercase_     ,  use_fast=lowercase_					)
                    _lowerCamelCase			:						Optional[int]            =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[int]					)   ->		Optional[int]:
             """simple docstring"""




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

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

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

                    _lowerCamelCase			:						Optional[int]            =CustomProcessor(lowercase_     ,  lowercase_					)

                    with tempfile.TemporaryDirectory() as tmp_dir:
                           processor.save_pretrained(lowercase_					)
                           _lowerCamelCase			:						List[Any]            =AutoProcessor.from_pretrained(lowercase_					)
                           self.assertIsInstance(lowercase_     ,  lowercase_					)

             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		:	Union[str, Any]					)   ->		List[str]:
             """simple docstring"""




             class A    (  UpperCamelCase_	):
                   UpperCamelCase__				:    Optional[Any] =False




             class A    (  UpperCamelCase_	):
                   UpperCamelCase__				:    int =False




             class A    (  UpperCamelCase_	):
                   UpperCamelCase__				:    Union[str, Any] ='AutoFeatureExtractor'
                   UpperCamelCase__				:    str ='AutoTokenizer'
                   UpperCamelCase__				:    List[Any] =False

             try:
                    AutoConfig.register('custom'     ,  lowercase_					)
                    AutoFeatureExtractor.register(lowercase_     ,  lowercase_					)
                    AutoTokenizer.register(lowercase_     ,  slow_tokenizer_class=lowercase_					)
                    AutoProcessor.register(lowercase_     ,  lowercase_					)
                    # If remote code is not set, the default is to use local classes.
                    _lowerCamelCase			:						int            =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.
                    _lowerCamelCase			:						int            =AutoProcessor.from_pretrained(
                        'hf-internal-testing/test_dynamic_processor'     ,  trust_remote_code=lowercase_					)
                    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.
                    _lowerCamelCase			:						str            =AutoProcessor.from_pretrained(
                        'hf-internal-testing/test_dynamic_processor'     ,  trust_remote_code=lowercase_					)
                    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		:	Optional[int]					)   ->		str:
             """simple docstring"""




             _lowerCamelCase			:						List[Any]            =AutoProcessor.from_pretrained('hf-internal-testing/tiny-random-bert'					)
             self.assertEqual(processor.__class__.__name__     ,  'BertTokenizerFast'					)






      def 			lowerCamelCase			(   self		:	Any					)   ->		Dict:
             """simple docstring"""




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




@is_staging_test
class A    (  unittest.TestCase	):
      UpperCamelCase__				:    List[Any] =['[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', 'bla', 'blou']






      @classmethod
      def 			lowerCamelCase			(   cls		:	int					)   ->		Optional[Any]:
             """simple docstring"""




             _lowerCamelCase			:						Union[str, Any]            =TOKEN
             HfFolder.save_token(lowercase_					)






      @classmethod
      def 			lowerCamelCase			(   cls		:	Optional[int]					)   ->		Union[str, Any]:
             """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		:	str					)   ->		int:
             """simple docstring"""




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

                    _lowerCamelCase			:						Union[str, Any]            =WavaVecaProcessor.from_pretrained(F'''{USER}/test-processor'''					)
                    for k, v in processor.feature_extractor.__dict__.items():
                           self.assertEqual(lowercase_     ,  getattr(new_processor.feature_extractor     ,  lowercase_					)					)
                    self.assertDictEqual(new_processor.tokenizer.get_vocab()     ,  processor.tokenizer.get_vocab()					)






      def 			lowerCamelCase			(   self		:	str					)   ->		Tuple:
             """simple docstring"""




             _lowerCamelCase			:						int            =WavaVecaProcessor.from_pretrained(lowercase_					)

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

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






      def 			lowerCamelCase			(   self		:	List[Any]					)   ->		str:
             """simple docstring"""




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

             _lowerCamelCase			:						Optional[Any]            =CustomFeatureExtractor.from_pretrained(lowercase_					)

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

             _lowerCamelCase			:						List[Any]            =CustomProcessor(lowercase_     ,  lowercase_					)

             with tempfile.TemporaryDirectory() as tmp_dir:
                    create_repo(F'''{USER}/test-dynamic-processor'''     ,  token=self._token					)
                    _lowerCamelCase			:						List[str]            =Repository(lowercase_     ,  clone_from=F'''{USER}/test-dynamic-processor'''     ,  token=self._token					)
                    processor.save_pretrained(lowercase_					)

                    # 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(lowercase_     ,  'tokenizer_config.json'					)					) as f:
                           _lowerCamelCase			:						Union[str, Any]            =json.load(lowercase_					)
                    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(lowercase_     ,  'custom_feature_extraction.py'					)					)					)
                    self.assertTrue(os.path.isfile(os.path.join(lowercase_     ,  'custom_tokenization.py'					)					)					)
                    self.assertTrue(os.path.isfile(os.path.join(lowercase_     ,  'custom_processing.py'					)					)					)

                    repo.push_to_hub()

             _lowerCamelCase			:						Tuple            =AutoProcessor.from_pretrained(F'''{USER}/test-dynamic-processor'''     ,  trust_remote_code=lowercase_					)
             # 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'					)


