





import os
import unittest

from transformers.models.cpmant.tokenization_cpmant import VOCAB_FILES_NAMES, CpmAntTokenizer
from transformers.testing_utils import require_jieba, tooslow

from ...test_tokenization_common import TokenizerTesterMixin




@require_jieba
class   UpperCamelCase_       (     UpperCamelCase__				,  unittest.TestCase    ):
							lowerCamelCase_           =					CpmAntTokenizer
							lowerCamelCase_           =					False


							def      _snake_case  (							self    :Any		)   ->   List[Any]:



									"""simple docstring"""



									super().setUp()

									SCREAMING_SNAKE_CASE__			=      [
									    """<d>""",
									    """</d>""",
									    """<s>""",
									    """</s>""",
									    """</_>""",
									    """<unk>""",
									    """<pad>""",
									    """</n>""",
									    """我""",
									    """是""",
									    """C""",
									    """P""",
									    """M""",
									    """A""",
									    """n""",
									    """t""",
									]
									SCREAMING_SNAKE_CASE__			=      os.path.join(self.tmpdirname							,				VOCAB_FILES_NAMES["""vocab_file"""]		)
									with open(self.vocab_file							,				"""w"""							,				encoding="""utf-8"""		) as vocab_writer:
											vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens]		)		)


							@tooslow
							def      _snake_case  (							self    :Dict		)   ->   str:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__			=      CpmAntTokenizer.from_pretrained("""openbmb/cpm-ant-10b"""		)
									SCREAMING_SNAKE_CASE__			=      """今天天气真好！"""
									SCREAMING_SNAKE_CASE__			=      ["""今天""", """天气""", """真""", """好""", """！"""]
									SCREAMING_SNAKE_CASE__			=      tokenizer.tokenize(__A		)
									self.assertListEqual(__A							,				__A		)
									SCREAMING_SNAKE_CASE__			=      """今天天气真好！"""
									SCREAMING_SNAKE_CASE__			=      [tokenizer.bos_token] + tokens

									SCREAMING_SNAKE_CASE__			=      [6, 9802, 1_4962, 2082, 831, 244]
									self.assertListEqual(tokenizer.convert_tokens_to_ids(__A		)							,				__A		)

									SCREAMING_SNAKE_CASE__			=      tokenizer.decode(__A		)
									self.assertEqual(__A							,				__A		)






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