





"""simple docstring"""
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 lowerCamelCase__	(     unittest.TestCase					):
   __UpperCAmelCase										=       MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING
   __UpperCAmelCase										=       TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING



   def  _UpperCAmelCase						(							self   , snake_case   , snake_case   , snake_case						)			->     int:







      """simple docstring"""
      lowercase     :      Tuple	=							AudioClassificationPipeline(model=A_   , feature_extractor=A_						)

      # test with a raw waveform
      lowercase     :      Union[str, Any]	=							np.zeros((3_4_0_0_0,)						)
      lowercase     :      Union[str, Any]	=							np.zeros((1_4_0_0_0,)						)
      return audio_classifier, [audioa, audio]



   def  _UpperCAmelCase						(							self   , snake_case   , snake_case						)			->     List[Any]:







      """simple docstring"""
      lowercase     :      int	=							examples
      lowercase     :      Dict	=							audio_classifier(A_						)
      # by default a model is initialized with num_labels=2
      self.assertEqual(
          A_   , [
              {"""score""": ANY(A_						), """label""": ANY(A_						)},
              {"""score""": ANY(A_						), """label""": ANY(A_						)},
          ]   , )
      lowercase     :      int	=							audio_classifier(A_   , top_k=1						)
      self.assertEqual(
          A_   , [
              {"""score""": ANY(A_						), """label""": ANY(A_						)},
          ]   , )

      self.run_torchaudio(A_						)



   @require_torchaudio
   def  _UpperCAmelCase						(							self   , snake_case						)			->     int:







      """simple docstring"""
      import datasets

      # test with a local file
      lowercase     :      Any	=							datasets.load_dataset("""hf-internal-testing/librispeech_asr_dummy"""   , """clean"""   , split="""validation"""						)
      lowercase     :      Optional[int]	=							dataset[0]["""audio"""]["""array"""]
      lowercase     :      Dict	=							audio_classifier(A_						)
      self.assertEqual(
          A_   , [
              {"""score""": ANY(A_						), """label""": ANY(A_						)},
              {"""score""": ANY(A_						), """label""": ANY(A_						)},
          ]   , )



   @require_torch
   def  _UpperCAmelCase						(							self						)			->     Optional[Any]:







      """simple docstring"""
      lowercase     :      Optional[Any]	=							"""anton-l/wav2vec2-random-tiny-classifier"""

      lowercase     :      Tuple	=							pipeline("""audio-classification"""   , model=A_						)

      lowercase     :      Dict	=							np.ones((8_0_0_0,)						)
      lowercase     :      Union[str, Any]	=							audio_classifier(A_   , top_k=4						)

      lowercase     :      str	=							[
          {"""score""": 0.08_42, """label""": """no"""},
          {"""score""": 0.08_38, """label""": """up"""},
          {"""score""": 0.08_37, """label""": """go"""},
          {"""score""": 0.08_34, """label""": """right"""},
      ]
      lowercase     :      int	=							[
          {"""score""": 0.08_45, """label""": """stop"""},
          {"""score""": 0.08_44, """label""": """on"""},
          {"""score""": 0.08_41, """label""": """right"""},
          {"""score""": 0.08_34, """label""": """left"""},
      ]
      self.assertIn(nested_simplify(A_   , decimals=4						)   , [EXPECTED_OUTPUT, EXPECTED_OUTPUT_PT_2]						)

      lowercase     :      Optional[Any]	=							{"""array""": np.ones((8_0_0_0,)						), """sampling_rate""": audio_classifier.feature_extractor.sampling_rate}
      lowercase     :      Tuple	=							audio_classifier(A_   , top_k=4						)
      self.assertIn(nested_simplify(A_   , decimals=4						)   , [EXPECTED_OUTPUT, EXPECTED_OUTPUT_PT_2]						)



   @require_torch
   @slow
   def  _UpperCAmelCase						(							self						)			->     str:







      """simple docstring"""
      import datasets

      lowercase     :      int	=							"""superb/wav2vec2-base-superb-ks"""

      lowercase     :      int	=							pipeline("""audio-classification"""   , model=A_						)
      lowercase     :      Tuple	=							datasets.load_dataset("""anton-l/superb_dummy"""   , """ks"""   , split="""test"""						)

      lowercase     :      Dict	=							np.array(dataset[3]["""speech"""]   , dtype=np.floataa						)
      lowercase     :      List[Any]	=							audio_classifier(A_   , top_k=4						)
      self.assertEqual(
          nested_simplify(A_   , decimals=3						)   , [
              {"""score""": 0.9_81, """label""": """go"""},
              {"""score""": 0.0_07, """label""": """up"""},
              {"""score""": 0.0_06, """label""": """_unknown_"""},
              {"""score""": 0.0_01, """label""": """down"""},
          ]   , )





   @require_tf
   @unittest.skip("""Audio classification is not implemented for TF"""						)
   def  _UpperCAmelCase						(							self						)			->     Tuple:







      """simple docstring"""
      pass






import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ....tokenization_utils_fast import PreTrainedTokenizerFast
from ....utils import logging
from .tokenization_retribert import RetriBertTokenizer


SCREAMING_SNAKE_CASE__					:     List[str]       =     logging.get_logger(__name__)

SCREAMING_SNAKE_CASE__					:     Optional[int]       =     {'vocab_file': 'vocab.txt', 'tokenizer_file': 'tokenizer.json'}

SCREAMING_SNAKE_CASE__					:     List[Any]       =     {
    'vocab_file': {
        'yjernite/retribert-base-uncased': (
            'https://huggingface.co/yjernite/retribert-base-uncased/resolve/main/vocab.txt'
        ),
    },
    'tokenizer_file': {
        'yjernite/retribert-base-uncased': (
            'https://huggingface.co/yjernite/retribert-base-uncased/resolve/main/tokenizer.json'
        ),
    },
}

SCREAMING_SNAKE_CASE__					:     Tuple       =     {
    'yjernite/retribert-base-uncased': 512,
}


SCREAMING_SNAKE_CASE__					:     Optional[Any]       =     {
    'yjernite/retribert-base-uncased': {'do_lower_case': True},
}


class 		_SCREAMING_SNAKE_CASE     (						A     ):
     __SCREAMING_SNAKE_CASE     					=    VOCAB_FILES_NAMES
     __SCREAMING_SNAKE_CASE     					=    PRETRAINED_VOCAB_FILES_MAP
     __SCREAMING_SNAKE_CASE     					=    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     __SCREAMING_SNAKE_CASE     					=    PRETRAINED_INIT_CONFIGURATION
     __SCREAMING_SNAKE_CASE     					=    RetriBertTokenizer
     __SCREAMING_SNAKE_CASE     					=    ['''input_ids''', '''attention_mask''']


     def __init__(  self							,					A_=None							,					A_=None							,					A_=True							,					A_="[UNK]"							,					A_="[SEP]"							,					A_="[PAD]"							,					A_="[CLS]"							,					A_="[MASK]"							,					A_=True							,					A_=None							,					**A_							,					):
       super().__init__(
           A_							,					tokenizer_file=A_							,					do_lower_case=A_							,					unk_token=A_							,					sep_token=A_							,					pad_token=A_							,					cls_token=A_							,					mask_token=A_							,					tokenize_chinese_chars=A_							,					strip_accents=A_							,					**A_							,					)

       _UpperCAmelCase		:							List[str]							=     json.loads(self.backend_tokenizer.normalizer.__getstate__()    )
       if (
           normalizer_state.get("""lowercase"""							,					A_    ) != do_lower_case
           or normalizer_state.get("""strip_accents"""							,					A_    ) != strip_accents
           or normalizer_state.get("""handle_chinese_chars"""							,					A_    ) != tokenize_chinese_chars
       ):
         _UpperCAmelCase		:							str							=     getattr(A_							,					normalizer_state.pop("""type"""    )    )
         _UpperCAmelCase		:							Optional[int]							=     do_lower_case
         _UpperCAmelCase		:							List[Any]							=     strip_accents
         _UpperCAmelCase		:							List[str]							=     tokenize_chinese_chars
         _UpperCAmelCase		:							Dict							=     normalizer_class(**A_    )

       _UpperCAmelCase		:							Dict							=     do_lower_case


     def        __snake_case(  self							,					A_							,					A_=None    ):
       _UpperCAmelCase		:							Tuple							=     [self.cls_token_id] + token_ids_a + [self.sep_token_id]

       if token_ids_a:
         output += token_ids_a + [self.sep_token_id]

       return output


     def        __snake_case(  self							,					A_							,					A_ = None    ):
       _UpperCAmelCase		:							List[Any]							=     [self.sep_token_id]
       _UpperCAmelCase		:							Tuple							=     [self.cls_token_id]
       if token_ids_a is None:
         return len(cls + token_ids_a + sep    ) * [0]
       return len(cls + token_ids_a + sep    ) * [0] + len(token_ids_a + sep    ) * [1]




     def        __snake_case(  self							,					A_							,					A_ = None    ):
       _UpperCAmelCase		:							Dict							=     self._tokenizer.model.save(A_							,					name=A_    )
       return tuple(A_    )





