






import os
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from huggingface_hub.file_download import http_get
from requests.exceptions import HTTPError

from transformers import (
    AlbertTokenizer,
    AutoTokenizer,
    BertTokenizer,
    BertTokenizerFast,
    GPTaTokenizerFast,
    is_tokenizers_available,
)
from transformers.testing_utils import TOKEN, USER, is_staging_test, require_tokenizers
from transformers.tokenization_utils import Trie


sys.path.append(str(Path(__file__).parent.parent / 'utils'))

from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
							from test_module.custom_tokenization_fast import CustomTokenizerFast
class  _UpperCAmelCase   (			unittest.TestCase      ):

				"""simple docstring"""




				def 							lowercase__  (	self		:       Any    ):

								'''simple docstring'''
								# A mock response for an HTTP head request to emulate server down
								lowercase__  					=     mock.Mock()
								lowercase__  					=     500
								lowercase__  					=     {}
								lowercase__  					=     HTTPError
								lowercase__  					=     {}

								# Download this model to make sure it's in the cache.
								lowercase__  					=     BertTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert'''    )

								# Under the mock environment we get a 500 error when trying to reach the tokenizer.
								with mock.patch('''requests.Session.request''',    return_value=lowerCamelCase    ) as mock_head:
												lowercase__  					=     BertTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bert'''    )
												# This check we did call the fake head request
												mock_head.assert_called()




				@require_tokenizers
				def 							lowercase__  (	self		:       int    ):

								'''simple docstring'''
								# A mock response for an HTTP head request to emulate server down
								lowercase__  					=     mock.Mock()
								lowercase__  					=     500
								lowercase__  					=     {}
								lowercase__  					=     HTTPError
								lowercase__  					=     {}

								# Download this model to make sure it's in the cache.
								lowercase__  					=     GPTaTokenizerFast.from_pretrained('''gpt2'''    )

								# Under the mock environment we get a 500 error when trying to reach the tokenizer.
								with mock.patch('''requests.Session.request''',    return_value=lowerCamelCase    ) as mock_head:
												lowercase__  					=     GPTaTokenizerFast.from_pretrained('''gpt2'''    )
												# This check we did call the fake head request
												mock_head.assert_called()




				def 							lowercase__  (	self		:       Optional[int]    ):

								'''simple docstring'''
								# This test is for deprecated behavior and can be removed in v5
								try:
												lowercase__  					=     tempfile.mktemp()
												with open(lowerCamelCase,    '''wb'''    ) as f:
																http_get('''https://huggingface.co/albert-base-v1/resolve/main/spiece.model''',    lowerCamelCase    )

												lowercase__  					=     AlbertTokenizer.from_pretrained(lowerCamelCase    )
								finally:
												os.remove(lowerCamelCase    )

								# Supporting this legacy load introduced a weird bug where the tokenizer would load local files if they are in
								# the current folder and have the right name.
								if os.path.isfile('''tokenizer.json'''    ):
												# We skip the test if the user has a `tokenizer.json` in this folder to avoid deleting it.
												return
								try:
												with open('''tokenizer.json''',    '''wb'''    ) as f:
																http_get('''https://huggingface.co/hf-internal-testing/tiny-random-bert/blob/main/tokenizer.json''',    lowerCamelCase    )
												lowercase__  					=     AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''    )
												# The tiny random BERT has a vocab size of 1024, tiny gpt2 as a vocab size of 1000
												self.assertEqual(tokenizer.vocab_size,    1_000    )
												# Tokenizer should depend on the remote checkpoint, not the local tokenizer.json file.

								finally:
												os.remove('''tokenizer.json'''    )




				def 							lowercase__  (	self		:       Any    ):

								'''simple docstring'''
								# This test is for deprecated behavior and can be removed in v5
								lowercase__  					=     AlbertTokenizer.from_pretrained('''https://huggingface.co/albert-base-v1/resolve/main/spiece.model'''    )



@is_staging_test
class  _UpperCAmelCase   (			unittest.TestCase      ):

				"""simple docstring"""




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




				@classmethod
				def 							lowercase__  (	cls		:       Tuple    ):

								'''simple docstring'''
								lowercase__  					=     TOKEN
								HfFolder.save_token(lowerCamelCase    )




				@classmethod
				def 							lowercase__  (	cls		:       List[str]    ):

								'''simple docstring'''
								try:
												delete_repo(token=cls._token,    repo_id='''test-tokenizer'''    )
								except HTTPError:
												pass

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

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




				def 							lowercase__  (	self		:       List[Any]    ):

								'''simple docstring'''
								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__  					=     BertTokenizer(lowerCamelCase    )

								tokenizer.push_to_hub('''test-tokenizer''',    use_auth_token=self._token    )
								lowercase__  					=     BertTokenizer.from_pretrained(F"""{USER}/test-tokenizer"""    )
								self.assertDictEqual(new_tokenizer.vocab,    tokenizer.vocab    )

								# Reset repo
								delete_repo(token=self._token,    repo_id='''test-tokenizer'''    )

								# Push to hub via save_pretrained
								with tempfile.TemporaryDirectory() as tmp_dir:
												tokenizer.save_pretrained(lowerCamelCase,    repo_id='''test-tokenizer''',    push_to_hub=lowerCamelCase,    use_auth_token=self._token    )

								lowercase__  					=     BertTokenizer.from_pretrained(F"""{USER}/test-tokenizer"""    )
								self.assertDictEqual(new_tokenizer.vocab,    tokenizer.vocab    )




				def 							lowercase__  (	self		:       List[str]    ):

								'''simple docstring'''
								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__  					=     BertTokenizer(lowerCamelCase    )

								tokenizer.push_to_hub('''valid_org/test-tokenizer-org''',    use_auth_token=self._token    )
								lowercase__  					=     BertTokenizer.from_pretrained('''valid_org/test-tokenizer-org'''    )
								self.assertDictEqual(new_tokenizer.vocab,    tokenizer.vocab    )

								# Reset repo
								delete_repo(token=self._token,    repo_id='''valid_org/test-tokenizer-org'''    )

								# Push to hub via save_pretrained
								with tempfile.TemporaryDirectory() as tmp_dir:
												tokenizer.save_pretrained(
												    lowerCamelCase,    repo_id='''valid_org/test-tokenizer-org''',    push_to_hub=lowerCamelCase,    use_auth_token=self._token    )

								lowercase__  					=     BertTokenizer.from_pretrained('''valid_org/test-tokenizer-org'''    )
								self.assertDictEqual(new_tokenizer.vocab,    tokenizer.vocab    )




				@require_tokenizers
				def 							lowercase__  (	self		:       int    ):

								'''simple docstring'''
								CustomTokenizer.register_for_auto_class()
								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    )

								# No fast custom tokenizer
								tokenizer.push_to_hub('''test-dynamic-tokenizer''',    use_auth_token=self._token    )

								lowercase__  					=     AutoTokenizer.from_pretrained(F"""{USER}/test-dynamic-tokenizer""",    trust_remote_code=lowerCamelCase    )
								# Can't make an isinstance check because the new_model.config is from the CustomTokenizer class of a dynamic module
								self.assertEqual(tokenizer.__class__.__name__,    '''CustomTokenizer'''    )

								# Fast and slow custom tokenizer
								CustomTokenizerFast.register_for_auto_class()
								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__  					=     BertTokenizerFast.from_pretrained(lowerCamelCase    )
												bert_tokenizer.save_pretrained(lowerCamelCase    )
												lowercase__  					=     CustomTokenizerFast.from_pretrained(lowerCamelCase    )

								tokenizer.push_to_hub('''test-dynamic-tokenizer''',    use_auth_token=self._token    )

								lowercase__  					=     AutoTokenizer.from_pretrained(F"""{USER}/test-dynamic-tokenizer""",    trust_remote_code=lowerCamelCase    )
								# Can't make an isinstance check because the new_model.config is from the FakeConfig class of a dynamic module
								self.assertEqual(tokenizer.__class__.__name__,    '''CustomTokenizerFast'''    )
								lowercase__  					=     AutoTokenizer.from_pretrained(
								    F"""{USER}/test-dynamic-tokenizer""",    use_fast=lowerCamelCase,    trust_remote_code=lowerCamelCase    )
								# Can't make an isinstance check because the new_model.config is from the FakeConfig class of a dynamic module
								self.assertEqual(tokenizer.__class__.__name__,    '''CustomTokenizer'''    )



class  _UpperCAmelCase   (			unittest.TestCase      ):

				"""simple docstring"""




				def 							lowercase__  (	self		:       str    ):

								'''simple docstring'''
								lowercase__  					=     Trie()
								trie.add('''Hello 友達'''    )
								self.assertEqual(trie.data,    {'''H''': {'''e''': {'''l''': {'''l''': {'''o''': {''' ''': {'''友''': {'''達''': {'''''': 1}}}}}}}}}    )
								trie.add('''Hello'''    )
								trie.data
								self.assertEqual(trie.data,    {'''H''': {'''e''': {'''l''': {'''l''': {'''o''': {'''''': 1, ''' ''': {'''友''': {'''達''': {'''''': 1}}}}}}}}}    )




				def 							lowercase__  (	self		:       List[str]    ):

								'''simple docstring'''
								lowercase__  					=     Trie()
								self.assertEqual(trie.split('''[CLS] This is a extra_id_100'''    ),    ['''[CLS] This is a extra_id_100''']    )
								trie.add('''[CLS]'''    )
								trie.add('''extra_id_1'''    )
								trie.add('''extra_id_100'''    )
								self.assertEqual(trie.split('''[CLS] This is a extra_id_100'''    ),    ['''[CLS]''', ''' This is a ''', '''extra_id_100''']    )




				def 							lowercase__  (	self		:       Optional[Any]    ):

								'''simple docstring'''
								lowercase__  					=     Trie()
								trie.add('''A'''    )
								self.assertEqual(trie.split('''ABC'''    ),    ['''A''', '''BC''']    )
								self.assertEqual(trie.split('''BCA'''    ),    ['''BC''', '''A''']    )




				def 							lowercase__  (	self		:       List[Any]    ):

								'''simple docstring'''
								lowercase__  					=     Trie()
								trie.add('''TOKEN]'''    )
								trie.add('''[SPECIAL_TOKEN]'''    )
								self.assertEqual(trie.split('''This is something [SPECIAL_TOKEN]'''    ),    ['''This is something ''', '''[SPECIAL_TOKEN]''']    )




				def 							lowercase__  (	self		:       Dict    ):

								'''simple docstring'''
								lowercase__  					=     Trie()
								trie.add('''A'''    )
								trie.add('''P'''    )
								trie.add('''[SPECIAL_TOKEN]'''    )
								self.assertEqual(trie.split('''This is something [SPECIAL_TOKEN]'''    ),    ['''This is something ''', '''[SPECIAL_TOKEN]''']    )




				def 							lowercase__  (	self		:       Optional[int]    ):

								'''simple docstring'''
								lowercase__  					=     Trie()
								trie.add('''AB'''    )
								trie.add('''B'''    )
								trie.add('''C'''    )
								self.assertEqual(trie.split('''ABC'''    ),    ['''AB''', '''C''']    )




				def 							lowercase__  (	self		:       Tuple    ):

								'''simple docstring'''
								lowercase__  					=     Trie()
								trie.add('''ABC'''    )
								trie.add('''B'''    )
								trie.add('''CD'''    )
								self.assertEqual(trie.split('''ABCD'''    ),    ['''ABC''', '''D''']    )




				def 							lowercase__  (	self		:       Tuple    ):

								'''simple docstring'''
								# Even if the offsets are wrong, we necessarily output correct string
								# parts.
								lowercase__  					=     Trie()
								lowercase__  					=     trie.cut_text('''ABC''',    [0, 0, 2, 1, 2, 3]    )
								self.assertEqual(lowerCamelCase,    ['''AB''', '''C''']    )












import unittest

import numpy as np

from transformers import MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING, TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING
from transformers.pipelines import AudioClassificationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_torchaudio,
    slow,
)

from .test_pipelines_common import ANY
@is_pipeline_test
class  _UpperCAmelCase   (			unittest.TestCase      ):

				"""simple docstring"""




				lowercase__											=			MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING
				lowercase__											=			TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING




				def 							lowercase__  (	self		:       Any,    lowerCamelCase		:       Optional[Any],    lowerCamelCase		:       Any,    lowerCamelCase		:       Tuple    ):

								'''simple docstring'''
								lowercase__  					=     AudioClassificationPipeline(model=lowerCamelCase,    feature_extractor=lowerCamelCase    )

								# test with a raw waveform
								lowercase__  					=     np.zeros((34_000,)    )
								lowercase__  					=     np.zeros((14_000,)    )
								return audio_classifier, [audioa, audio]




				def 							lowercase__  (	self		:       str,    lowerCamelCase		:       Dict,    lowerCamelCase		:       Union[str, Any]    ):

								'''simple docstring'''
								lowercase__					,		lowercase__  					=     examples
								lowercase__  					=     audio_classifier(lowerCamelCase    )
								# by default a model is initialized with num_labels=2
								self.assertEqual(
								    lowerCamelCase,    [
								        {'''score''': ANY(lowerCamelCase    ), '''label''': ANY(lowerCamelCase    )},
								        {'''score''': ANY(lowerCamelCase    ), '''label''': ANY(lowerCamelCase    )},
								    ],    )
								lowercase__  					=     audio_classifier(lowerCamelCase,    top_k=1    )
								self.assertEqual(
								    lowerCamelCase,    [
								        {'''score''': ANY(lowerCamelCase    ), '''label''': ANY(lowerCamelCase    )},
								    ],    )

								self.run_torchaudio(lowerCamelCase    )




				@require_torchaudio
				def 							lowercase__  (	self		:       Optional[int],    lowerCamelCase		:       List[Any]    ):

								'''simple docstring'''
								import datasets

								# test with a local file
								lowercase__  					=     datasets.load_dataset('''hf-internal-testing/librispeech_asr_dummy''',    '''clean''',    split='''validation'''    )
								lowercase__  					=     dataset[0]['''audio''']['''array''']
								lowercase__  					=     audio_classifier(lowerCamelCase    )
								self.assertEqual(
								    lowerCamelCase,    [
								        {'''score''': ANY(lowerCamelCase    ), '''label''': ANY(lowerCamelCase    )},
								        {'''score''': ANY(lowerCamelCase    ), '''label''': ANY(lowerCamelCase    )},
								    ],    )




				@require_torch
				def 							lowercase__  (	self		:       int    ):

								'''simple docstring'''
								lowercase__  					=     '''anton-l/wav2vec2-random-tiny-classifier'''

								lowercase__  					=     pipeline('''audio-classification''',    model=lowerCamelCase    )

								lowercase__  					=     np.ones((8_000,)    )
								lowercase__  					=     audio_classifier(lowerCamelCase,    top_k=4    )

								lowercase__  					=     [
								    {'''score''': 0.0842, '''label''': '''no'''},
								    {'''score''': 0.0838, '''label''': '''up'''},
								    {'''score''': 0.0837, '''label''': '''go'''},
								    {'''score''': 0.0834, '''label''': '''right'''},
								]
								lowercase__  					=     [
								    {'''score''': 0.0845, '''label''': '''stop'''},
								    {'''score''': 0.0844, '''label''': '''on'''},
								    {'''score''': 0.0841, '''label''': '''right'''},
								    {'''score''': 0.0834, '''label''': '''left'''},
								]
								self.assertIn(nested_simplify(lowerCamelCase,    decimals=4    ),    [EXPECTED_OUTPUT, EXPECTED_OUTPUT_PT_2]    )

								lowercase__  					=     {'''array''': np.ones((8_000,)    ), '''sampling_rate''': audio_classifier.feature_extractor.sampling_rate}
								lowercase__  					=     audio_classifier(lowerCamelCase,    top_k=4    )
								self.assertIn(nested_simplify(lowerCamelCase,    decimals=4    ),    [EXPECTED_OUTPUT, EXPECTED_OUTPUT_PT_2]    )




				@require_torch
				@slow
				def 							lowercase__  (	self		:       List[str]    ):

								'''simple docstring'''
								import datasets

								lowercase__  					=     '''superb/wav2vec2-base-superb-ks'''

								lowercase__  					=     pipeline('''audio-classification''',    model=lowerCamelCase    )
								lowercase__  					=     datasets.load_dataset('''anton-l/superb_dummy''',    '''ks''',    split='''test'''    )

								lowercase__  					=     np.array(dataset[3]['''speech'''],    dtype=np.floataa    )
								lowercase__  					=     audio_classifier(lowerCamelCase,    top_k=4    )
								self.assertEqual(
								    nested_simplify(lowerCamelCase,    decimals=3    ),    [
								        {'''score''': 0.981, '''label''': '''go'''},
								        {'''score''': 0.007, '''label''': '''up'''},
								        {'''score''': 0.006, '''label''': '''_unknown_'''},
								        {'''score''': 0.001, '''label''': '''down'''},
								    ],    )




				@require_tf
				@unittest.skip('''Audio classification is not implemented for TF'''    )
				def 							lowercase__  (	self		:       Optional[int]    ):

								'''simple docstring'''
								pass




