"""simple docstring"""




import contextlib
import faulthandler
import io
import multiprocessing
import os
import platform
import signal
import tempfile





def 							SCREAMING_SNAKE_CASE  (    _lowerCamelCase		: List[str]    ,_lowerCamelCase		: Tuple    ,_lowerCamelCase		: Any    ,_lowerCamelCase		: Tuple			) ->   List[Any]:
  _lowerCAmelCase		: Optional[int]						    =  multiprocessing.Manager()
  _lowerCAmelCase		: Optional[Any]						    =  manager.list()

  _lowerCAmelCase		: Dict						    =  multiprocessing.Process(target=_lowerCamelCase    ,args=(check_program, result, timeout)			)
  p.start()
  p.join(timeout=timeout + 1			)
  if p.is_alive():
    p.kill()

  if not result:
    result.append("""timed out"""			)

  return {
      "task_id": task_id,
      "passed": result[0] == "passed",
      "result": result[0],
      "completion_id": completion_id,
  }





def 							SCREAMING_SNAKE_CASE  (    _lowerCamelCase		: Dict    ,_lowerCamelCase		: Tuple    ,_lowerCamelCase		: Union[str, Any]			) ->   Any:
  with create_tempdir():
    # These system calls are needed when cleaning up tempdir.
    import os
    import shutil

    _lowerCAmelCase		: List[Any]						    =  shutil.rmtree
    _lowerCAmelCase		: List[Any]						    =  os.rmdir
    _lowerCAmelCase		: Optional[Any]						    =  os.chdir

    # Disable functionalities that can make destructive changes to the test.
    reliability_guard()

    # Run program.
    try:
      _lowerCAmelCase		: List[Any]						    =  {}
      with swallow_io():
        with time_limit(_lowerCamelCase			):
          exec(_lowerCamelCase    ,_lowerCamelCase			)
      result.append("""passed"""			)
    except TimeoutException:
      result.append("""timed out"""			)
    except BaseException as e:
      result.append(f"failed: {e}"			)

    # Needed for cleaning up.
    _lowerCAmelCase		: Tuple						    =  rmtree
    _lowerCAmelCase		: Optional[Any]						    =  rmdir
    _lowerCAmelCase		: List[Any]						    =  chdir





@contextlib.contextmanager
def 							SCREAMING_SNAKE_CASE  (    _lowerCamelCase		: Any			) ->   Union[str, Any]:
  def signal_handler(_lowerCamelCase		: List[str]    ,_lowerCamelCase		: str			):
    raise TimeoutException("""Timed out!"""			)

  signal.setitimer(signal.ITIMER_REAL    ,_lowerCamelCase			)
  signal.signal(signal.SIGALRM    ,_lowerCamelCase			)
  try:
    yield
  finally:
    signal.setitimer(signal.ITIMER_REAL    ,0			)





@contextlib.contextmanager
def 							SCREAMING_SNAKE_CASE  (    ) ->   List[Any]:
  _lowerCAmelCase		: Optional[Any]						    =  WriteOnlyStringIO()
  with contextlib.redirect_stdout(_lowerCamelCase			):
    with contextlib.redirect_stderr(_lowerCamelCase			):
      with redirect_stdin(_lowerCamelCase			):
        yield





@contextlib.contextmanager
def 							SCREAMING_SNAKE_CASE  (    ) ->   List[Any]:
  with tempfile.TemporaryDirectory() as dirname:
    with chdir(_lowerCamelCase			):
      yield dirname
class 		__A							(				SCREAMING_SNAKE_CASE_	):
     pass







class 		__A							(				io.StringIO	):






     def 					__A						(	self       ,  *a__       ,  **a__						):
       raise OSError






     def 					__A						(	self       ,  *a__       ,  **a__						):
       raise OSError






     def 					__A						(	self       ,  *a__       ,  **a__						):
       raise OSError






     def 					__A						(	self       ,  *a__       ,  **a__						):
       return False







class 		__A							(				contextlib._RedirectStream	):  # type: ignore
     _UpperCamelCase							:    Dict	      =	"stdin"







@contextlib.contextmanager
def 							SCREAMING_SNAKE_CASE  (    _lowerCamelCase		: Dict			) ->   Tuple:
  if root == ".":
    yield
    return
  _lowerCAmelCase		: List[Any]						    =  os.getcwd()
  os.chdir(_lowerCamelCase			)
  try:
    yield
  except BaseException as exc:
    raise exc
  finally:
    os.chdir(_lowerCamelCase			)






def 							SCREAMING_SNAKE_CASE  (    _lowerCamelCase		: List[Any]=None			) ->   int:

  if maximum_memory_bytes is not None:
    import resource

    resource.setrlimit(resource.RLIMIT_AS    ,(maximum_memory_bytes, maximum_memory_bytes)			)
    resource.setrlimit(resource.RLIMIT_DATA    ,(maximum_memory_bytes, maximum_memory_bytes)			)
    if not platform.uname().system == "Darwin":
      resource.setrlimit(resource.RLIMIT_STACK    ,(maximum_memory_bytes, maximum_memory_bytes)			)

  faulthandler.disable()

  import builtins

  _lowerCAmelCase		: Any						    =  None
  _lowerCAmelCase		: Tuple						    =  None

  import os

  _lowerCAmelCase		: int						    =  """1"""

  _lowerCAmelCase		: Union[str, Any]						    =  None
  _lowerCAmelCase		: int						    =  None
  _lowerCAmelCase		: Optional[int]						    =  None
  _lowerCAmelCase		: Any						    =  None
  _lowerCAmelCase		: int						    =  None
  _lowerCAmelCase		: Union[str, Any]						    =  None
  _lowerCAmelCase		: str						    =  None
  _lowerCAmelCase		: Optional[Any]						    =  None
  _lowerCAmelCase		: Dict						    =  None
  _lowerCAmelCase		: Optional[int]						    =  None
  _lowerCAmelCase		: Optional[Any]						    =  None
  _lowerCAmelCase		: Optional[int]						    =  None
  _lowerCAmelCase		: Tuple						    =  None
  _lowerCAmelCase		: str						    =  None
  _lowerCAmelCase		: Dict						    =  None
  _lowerCAmelCase		: List[str]						    =  None
  _lowerCAmelCase		: Any						    =  None
  _lowerCAmelCase		: Any						    =  None
  _lowerCAmelCase		: str						    =  None
  _lowerCAmelCase		: Any						    =  None
  _lowerCAmelCase		: str						    =  None
  _lowerCAmelCase		: Dict						    =  None
  _lowerCAmelCase		: List[Any]						    =  None
  _lowerCAmelCase		: Dict						    =  None
  _lowerCAmelCase		: Any						    =  None
  _lowerCAmelCase		: Union[str, Any]						    =  None
  _lowerCAmelCase		: Optional[Any]						    =  None

  import shutil

  _lowerCAmelCase		: Optional[Any]						    =  None
  _lowerCAmelCase		: Tuple						    =  None
  _lowerCAmelCase		: Optional[int]						    =  None

  import subprocess

  _lowerCAmelCase		: List[Any]						    =  None  # type: ignore

  _lowerCAmelCase		: Tuple						    =  None

  import sys

  _lowerCAmelCase		: Optional[Any]						    =  None
  _lowerCAmelCase		: Tuple						    =  None
  _lowerCAmelCase		: List[str]						    =  None
  _lowerCAmelCase		: List[str]						    =  None
  _lowerCAmelCase		: Dict						    =  None





"""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 		__A							(				unittest.TestCase	):
     _UpperCamelCase							:    str	      =	MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING
     _UpperCamelCase							:    Any	      =	TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING






     def 					__A						(	self       ,  a__       ,  a__       ,  a__						):
       _lowerCAmelCase		: List[Any]						    =  AudioClassificationPipeline(model=a__       ,  feature_extractor=a__						)

       # test with a raw waveform
       _lowerCAmelCase		: Optional[int]						    =  np.zeros((34000,)						)
       _lowerCAmelCase		: Optional[Any]						    =  np.zeros((14000,)						)
       return audio_classifier, [audioa, audio]






     def 					__A						(	self       ,  a__       ,  a__						):
       _lowerCAmelCase    ,			_lowerCAmelCase		: List[Any]						    =  examples
       _lowerCAmelCase		: List[Any]						    =  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__						)},
           ]       ,  )
       _lowerCAmelCase		: Tuple						    =  audio_classifier(a__       ,  top_k=1						)
       self.assertEqual(
           a__       ,  [
               {"""score""": ANY(a__						), """label""": ANY(a__						)},
           ]       ,  )

       self.run_torchaudio(a__						)






     @require_torchaudio
     def 					__A						(	self       ,  a__						):
       import datasets

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






     @require_torch
     def 					__A						(	self						):
       _lowerCAmelCase		: int						    =  """anton-l/wav2vec2-random-tiny-classifier"""

       _lowerCAmelCase		: Optional[Any]						    =  pipeline("""audio-classification"""       ,  model=a__						)

       _lowerCAmelCase		: Any						    =  np.ones((8000,)						)
       _lowerCAmelCase		: List[str]						    =  audio_classifier(a__       ,  top_k=4						)

       _lowerCAmelCase		: List[str]						    =  [
           {"""score""": 0.0_8_4_2, """label""": """no"""},
           {"""score""": 0.0_8_3_8, """label""": """up"""},
           {"""score""": 0.0_8_3_7, """label""": """go"""},
           {"""score""": 0.0_8_3_4, """label""": """right"""},
       ]
       _lowerCAmelCase		: str						    =  [
           {"""score""": 0.0_8_4_5, """label""": """stop"""},
           {"""score""": 0.0_8_4_4, """label""": """on"""},
           {"""score""": 0.0_8_4_1, """label""": """right"""},
           {"""score""": 0.0_8_3_4, """label""": """left"""},
       ]
       self.assertIn(nested_simplify(a__       ,  decimals=4						)       ,  [EXPECTED_OUTPUT, EXPECTED_OUTPUT_PT_2]						)

       _lowerCAmelCase		: int						    =  {"""array""": np.ones((8000,)						), """sampling_rate""": audio_classifier.feature_extractor.sampling_rate}
       _lowerCAmelCase		: int						    =  audio_classifier(a__       ,  top_k=4						)
       self.assertIn(nested_simplify(a__       ,  decimals=4						)       ,  [EXPECTED_OUTPUT, EXPECTED_OUTPUT_PT_2]						)






     @require_torch
     @slow
     def 					__A						(	self						):
       import datasets

       _lowerCAmelCase		: Optional[Any]						    =  """superb/wav2vec2-base-superb-ks"""

       _lowerCAmelCase		: List[str]						    =  pipeline("""audio-classification"""       ,  model=a__						)
       _lowerCAmelCase		: str						    =  datasets.load_dataset("""anton-l/superb_dummy"""       ,  """ks"""       ,  split="""test"""						)

       _lowerCAmelCase		: Optional[Any]						    =  np.array(dataset[3]["""speech"""]       ,  dtype=np.floataa						)
       _lowerCAmelCase		: List[str]						    =  audio_classifier(a__       ,  top_k=4						)
       self.assertEqual(
           nested_simplify(a__       ,  decimals=3						)       ,  [
               {"""score""": 0.9_8_1, """label""": """go"""},
               {"""score""": 0.0_0_7, """label""": """up"""},
               {"""score""": 0.0_0_6, """label""": """_unknown_"""},
               {"""score""": 0.0_0_1, """label""": """down"""},
           ]       ,  )






     @require_tf
     @unittest.skip("""Audio classification is not implemented for TF"""						)
     def 					__A						(	self						):
       pass




