





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        __magic_name__	(				unittest.TestCase				):





     """simple docstring"""



     __UpperCamelCase            =  MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING
     __UpperCamelCase            =  TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING



     def     SCREAMING_SNAKE_CASE		(				self							:List[Any]      ,   snake_case							:List[str]      ,   snake_case							:int      ,   snake_case							:Union[str, Any]	):





        '''simple docstring'''




        A_       :					str        =      AudioClassificationPipeline(model=snake_case      ,   feature_extractor=snake_case	)

        # test with a raw waveform
        A_       :					List[Any]        =      np.zeros((34_000,)	)
        A_       :					List[str]        =      np.zeros((14_000,)	)
        return audio_classifier, [audioa, audio]



     def     SCREAMING_SNAKE_CASE		(				self							:Optional[int]      ,   snake_case							:Optional[Any]      ,   snake_case							:Tuple	):





        '''simple docstring'''




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

        self.run_torchaudio(snake_case	)



     @require_torchaudio
     def     SCREAMING_SNAKE_CASE		(				self							:Any      ,   snake_case							:List[Any]	):





        '''simple docstring'''




        import datasets

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



     @require_torch
     def     SCREAMING_SNAKE_CASE		(				self							:Union[str, Any]	):





        '''simple docstring'''




        A_       :					List[Any]        =      "anton-l/wav2vec2-random-tiny-classifier"

        A_       :					Union[str, Any]        =      pipeline("audio-classification"      ,   model=snake_case	)

        A_       :					Dict        =      np.ones((8_000,)	)
        A_       :					str        =      audio_classifier(snake_case      ,   top_k=4	)

        A_       :					List[Any]        =      [
            {"score": 0.0842, "label": "no"},
            {"score": 0.0838, "label": "up"},
            {"score": 0.0837, "label": "go"},
            {"score": 0.0834, "label": "right"},
        ]
        A_       :					Optional[int]        =      [
            {"score": 0.0845, "label": "stop"},
            {"score": 0.0844, "label": "on"},
            {"score": 0.0841, "label": "right"},
            {"score": 0.0834, "label": "left"},
        ]
        self.assertIn(nested_simplify(snake_case      ,   decimals=4	)      ,   [EXPECTED_OUTPUT, EXPECTED_OUTPUT_PT_2]	)

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



     @require_torch
     @slow
     def     SCREAMING_SNAKE_CASE		(				self							:str	):





        '''simple docstring'''




        import datasets

        A_       :					str        =      "superb/wav2vec2-base-superb-ks"

        A_       :					Union[str, Any]        =      pipeline("audio-classification"      ,   model=snake_case	)
        A_       :					Optional[int]        =      datasets.load_dataset("anton-l/superb_dummy"      ,   "ks"      ,   split="test"	)

        A_       :					Tuple        =      np.array(dataset[3]["speech"]      ,   dtype=np.floataa	)
        A_       :					Union[str, Any]        =      audio_classifier(snake_case      ,   top_k=4	)
        self.assertEqual(
            nested_simplify(snake_case      ,   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     SCREAMING_SNAKE_CASE		(				self							:List[str]	):





        '''simple docstring'''




        pass







from collections import defaultdict


class        __magic_name__	:





     """simple docstring"""



     def __init__(				self							:int      ,   snake_case							:Dict      ,   snake_case							:Optional[Any]	):





        '''simple docstring'''




        A_       :					Optional[int]        =      total  # total no of tasks (N)

        # DP table will have a dimension of (2^M)*N
        # initially all values are set to -1
        A_       :					str        =      [
            [-1 for i in range(total + 1	)] for j in range(2 ** len(snake_case	)	)
        ]

        A_       :					Optional[int]        =      defaultdict(snake_case	)  # stores the list of persons for each task

        # final_mask is used to check if all persons are included by setting all bits
        # to 1
        A_       :					Dict        =      (1 << len(snake_case	)) - 1



     def     SCREAMING_SNAKE_CASE		(				self							:Union[str, Any]      ,   snake_case							:Union[str, Any]      ,   snake_case							:str	):





        '''simple docstring'''




        if mask == self.final_mask:
           return 1

        # if not everyone gets the task and no more tasks are available, return 0
        if task_no > self.total_tasks:
           return 0

        # if case already considered
        if self.dp[mask][task_no] != -1:
           return self.dp[mask][task_no]

        # Number of ways when we don't this task in the arrangement
        A_       :					Tuple        =      self.count_ways_until(snake_case      ,   task_no + 1	)

        # now assign the tasks one by one to all possible persons and recursively
        # assign for the remaining tasks.
        if task_no in self.task:
           for p in self.task[task_no]:
              # if p is already given a task
              if mask & (1 << p):
                 continue

              # assign this task to p and change the mask value. And recursively
              # assign tasks with the new mask value.
              total_ways_util += self.count_ways_until(mask | (1 << p)      ,   task_no + 1	)

        # save the value.
        A_       :					Any        =      total_ways_util

        return self.dp[mask][task_no]





     def     SCREAMING_SNAKE_CASE		(				self							:int      ,   snake_case							:List[str]	):





        '''simple docstring'''




        for i in range(len(snake_case	)	):
           for j in task_performed[i]:
              self.task[j].append(snake_case	)

        # call the function to fill the DP table, final answer is stored in dp[0][1]
        return self.count_ways_until(0      ,   1	)


if __name__ == "__main__":
 _lowerCAmelCase				:   Dict						       =						5  # total no of tasks (the value of N)

 # the list of tasks that can be done by M persons.
 _lowerCAmelCase				:   str						       =						[[1, 3, 4], [1, 2, 5], [3, 4]]
 print(
     AssignmentUsingBitmask(task_performed, total_tasks).count_no_of_ways(
         task_performed
     )
 )
