





import re
from pathlib import Path
from unittest import TestCase

import pytest




@pytest.mark.integration
class   UpperCamelCase_       (     UpperCamelCase__    ):


       def      _snake_case  (							self    :int							,				__A    :str		)   ->   Optional[Any]:



         """simple docstring"""



         with open(__A							,				encoding="""utf-8"""		) as input_file:
           SCREAMING_SNAKE_CASE__			=      re.compile(r"""(?!.*\b(?:encoding|rb|w|wb|w+|wb+|ab|ab+)\b)(?<=\s)(open)\((.*)\)"""		)
           SCREAMING_SNAKE_CASE__			=      input_file.read()
           SCREAMING_SNAKE_CASE__			=      regexp.search(__A		)

         return match


       def      _snake_case  (							self    :Optional[int]							,				__A    :str		)   ->   Dict:



         """simple docstring"""



         with open(__A							,				encoding="""utf-8"""		) as input_file:
           SCREAMING_SNAKE_CASE__			=      re.compile(r"""#[^\r\n]*print\(|\"[^\r\n]*print\(|\"\"\".*?print\(.*?\"\"\"|(print\()"""							,				re.DOTALL		)
           SCREAMING_SNAKE_CASE__			=      input_file.read()
           # use `re.finditer` to handle the case where the ignored groups would be matched first by `re.search`
           SCREAMING_SNAKE_CASE__			=      regexp.finditer(__A		)

         SCREAMING_SNAKE_CASE__			=      [match for match in matches if match is not None and match.group(1		) is not None]
         return matches[0] if matches else None


       def      _snake_case  (							self    :Union[str, Any]		)   ->   Optional[Any]:



         """simple docstring"""



         SCREAMING_SNAKE_CASE__			=      Path("""./datasets"""		)
         SCREAMING_SNAKE_CASE__			=      list(dataset_paths.absolute().glob("""**/*.py"""		)		)

         for dataset in dataset_files:
           if self._no_encoding_on_file_open(str(__A		)		):
             raise AssertionError(f'''open(...) must use utf-8 encoding in {dataset}'''		)


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



         """simple docstring"""



         SCREAMING_SNAKE_CASE__			=      Path("""./datasets"""		)
         SCREAMING_SNAKE_CASE__			=      list(dataset_paths.absolute().glob("""**/*.py"""		)		)

         for dataset in dataset_files:
           if self._no_print_statements(str(__A		)		):
             raise AssertionError(f'''print statement found in {dataset}. Use datasets.logger/logging instead.'''		)






import unittest

from datasets import load_dataset

from transformers.pipelines import pipeline
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_torch, slow




@is_pipeline_test
@require_torch
class   UpperCamelCase_       (     unittest.TestCase    ):


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      pipeline(
									    task="""zero-shot-audio-classification"""							,				model="""hf-internal-testing/tiny-clap-htsat-unfused"""		)
									SCREAMING_SNAKE_CASE__			=      load_dataset("""ashraq/esc50"""		)
									SCREAMING_SNAKE_CASE__			=      dataset["""train"""]["""audio"""][-1]["""array"""]
									SCREAMING_SNAKE_CASE__			=      audio_classifier(__A							,				candidate_labels=["""Sound of a dog""", """Sound of vaccum cleaner"""]		)
									self.assertEqual(
									    nested_simplify(__A		)							,				[{"""score""": 0.5_0_1, """label""": """Sound of a dog"""}, {"""score""": 0.4_9_9, """label""": """Sound of vaccum cleaner"""}]							,				)


							@unittest.skip("""No models are available in TF"""		)
							def      _snake_case  (							self    :Dict		)   ->   List[str]:



									"""simple docstring"""



									pass


							@slow
							@require_torch
							def      _snake_case  (							self    :Any		)   ->   int:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      pipeline(
									    task="""zero-shot-audio-classification"""							,				model="""laion/clap-htsat-unfused"""							,				)
									# This is an audio of a dog
									SCREAMING_SNAKE_CASE__			=      load_dataset("""ashraq/esc50"""		)
									SCREAMING_SNAKE_CASE__			=      dataset["""train"""]["""audio"""][-1]["""array"""]
									SCREAMING_SNAKE_CASE__			=      audio_classifier(__A							,				candidate_labels=["""Sound of a dog""", """Sound of vaccum cleaner"""]		)

									self.assertEqual(
									    nested_simplify(__A		)							,				[
									        {"""score""": 0.9_9_9, """label""": """Sound of a dog"""},
									        {"""score""": 0.0_0_1, """label""": """Sound of vaccum cleaner"""},
									    ]							,				)

									SCREAMING_SNAKE_CASE__			=      audio_classifier([audio] * 5							,				candidate_labels=["""Sound of a dog""", """Sound of vaccum cleaner"""]		)
									self.assertEqual(
									    nested_simplify(__A		)							,				[
									        [
									            {"""score""": 0.9_9_9, """label""": """Sound of a dog"""},
									            {"""score""": 0.0_0_1, """label""": """Sound of vaccum cleaner"""},
									        ],
									    ]
									    * 5							,				)
									SCREAMING_SNAKE_CASE__			=      audio_classifier(
									    [audio] * 5							,				candidate_labels=["""Sound of a dog""", """Sound of vaccum cleaner"""]							,				batch_size=5		)
									self.assertEqual(
									    nested_simplify(__A		)							,				[
									        [
									            {"""score""": 0.9_9_9, """label""": """Sound of a dog"""},
									            {"""score""": 0.0_0_1, """label""": """Sound of vaccum cleaner"""},
									        ],
									    ]
									    * 5							,				)


							@unittest.skip("""No models are available in TF"""		)
							def      _snake_case  (							self    :str		)   ->   Optional[int]:



									"""simple docstring"""



									pass