import inspect
import unittest

from huggingface_hub import hf_hub_download

from transformers import ASTConfig
from transformers.testing_utils import require_torch, require_torchaudio, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_torchaudio_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
      import torch
      from torch import nn

      from transformers import ASTForAudioClassification, ASTModel
      from transformers.models.audio_spectrogram_transformer.modeling_audio_spectrogram_transformer import (
          AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
      )


if is_torchaudio_available():
      import torchaudio

      from transformers import ASTFeatureExtractor





class      A							:


   def __init__(self     :						Dict       ,  __UpperCAmelCase     :						int       ,  __UpperCAmelCase     :						Any=1_3       ,  __UpperCAmelCase     :						Dict=2       ,  __UpperCAmelCase     :						Tuple=2_4       ,  __UpperCAmelCase     :						List[str]=1_6       ,  __UpperCAmelCase     :						List[Any]=True       ,  __UpperCAmelCase     :						Union[str, Any]=True       ,  __UpperCAmelCase     :						Dict=3_2       ,  __UpperCAmelCase     :						str=5       ,  __UpperCAmelCase     :						Dict=4       ,  __UpperCAmelCase     :						Tuple=3_7       ,  __UpperCAmelCase     :						int="gelu"       ,  __UpperCAmelCase     :						Dict=0.1       ,  __UpperCAmelCase     :						Dict=0.1       ,  __UpperCAmelCase     :						Optional[int]=1_0       ,  __UpperCAmelCase     :						Optional[Any]=0.02       ,  __UpperCAmelCase     :						List[Any]=None       ,  __UpperCAmelCase     :						Dict=2       ,  __UpperCAmelCase     :						Tuple=2       ,  )						->				Tuple:
         """simple docstring"""



         UpperCAmelCase__								=  parent
         UpperCAmelCase__								=  batch_size
         UpperCAmelCase__								=  patch_size
         UpperCAmelCase__								=  max_length
         UpperCAmelCase__								=  num_mel_bins
         UpperCAmelCase__								=  is_training
         UpperCAmelCase__								=  use_labels
         UpperCAmelCase__								=  hidden_size
         UpperCAmelCase__								=  num_hidden_layers
         UpperCAmelCase__								=  num_attention_heads
         UpperCAmelCase__								=  intermediate_size
         UpperCAmelCase__								=  hidden_act
         UpperCAmelCase__								=  hidden_dropout_prob
         UpperCAmelCase__								=  attention_probs_dropout_prob
         UpperCAmelCase__								=  type_sequence_label_size
         UpperCAmelCase__								=  initializer_range
         UpperCAmelCase__								=  scope
         UpperCAmelCase__								=  frequency_stride
         UpperCAmelCase__								=  time_stride

         # in AST, the seq length equals the number of patches + 2 (we add 2 for the [CLS] and distillation tokens)
         UpperCAmelCase__								=  (self.num_mel_bins - self.patch_size) // self.frequency_stride + 1
         UpperCAmelCase__								=  (self.max_length - self.patch_size) // self.time_stride + 1
         UpperCAmelCase__								=  frequency_out_dimension * time_out_dimension
         UpperCAmelCase__								=  num_patches + 2


   def 			lowercase_      (self     :						str		)						->				str:
         """simple docstring"""



         UpperCAmelCase__								=  floats_tensor([self.batch_size, self.max_length, self.num_mel_bins]		)

         UpperCAmelCase__								=  None
         if self.use_labels:
               UpperCAmelCase__								=  ids_tensor([self.batch_size]       ,  self.type_sequence_label_size		)

         UpperCAmelCase__								=  self.get_config()

         return config, input_values, labels


   def 			lowercase_      (self     :						Optional[Any]		)						->				Optional[Any]:
         """simple docstring"""



         return ASTConfig(
             patch_size=self.patch_size       ,  max_length=self.max_length       ,  num_mel_bins=self.num_mel_bins       ,  hidden_size=self.hidden_size       ,  num_hidden_layers=self.num_hidden_layers       ,  num_attention_heads=self.num_attention_heads       ,  intermediate_size=self.intermediate_size       ,  hidden_act=self.hidden_act       ,  hidden_dropout_prob=self.hidden_dropout_prob       ,  attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,  is_decoder=__UpperCAmelCase       ,  initializer_range=self.initializer_range       ,  frequency_stride=self.frequency_stride       ,  time_stride=self.time_stride       ,  )


   def 			lowercase_      (self     :						Union[str, Any]       ,  __UpperCAmelCase     :						List[str]       ,  __UpperCAmelCase     :						Optional[int]       ,  __UpperCAmelCase     :						Optional[int]		)						->				Optional[Any]:
         """simple docstring"""



         UpperCAmelCase__								=  ASTModel(config=__UpperCAmelCase		)
         model.to(__UpperCAmelCase		)
         model.eval()
         UpperCAmelCase__								=  model(__UpperCAmelCase		)
         self.parent.assertEqual(result.last_hidden_state.shape       ,  (self.batch_size, self.seq_length, self.hidden_size)		)





   def 			lowercase_      (self     :						Union[str, Any]		)						->				Union[str, Any]:
         """simple docstring"""



         UpperCAmelCase__								=  self.prepare_config_and_inputs()
         (
             (
             UpperCAmelCase__
         )		,      (
             UpperCAmelCase__
         )		,      (
             UpperCAmelCase__
         )		,      
         )								=  config_and_inputs
         UpperCAmelCase__								=  {"input_values": input_values}
         return config, inputs_dict





@require_torch
class      A							(				UpperCAmelCase_		,				UpperCAmelCase_		,				unittest.TestCase     ):
   __UpperCAmelCase : List[Any]      =			(
       (
           ASTModel,
           ASTForAudioClassification,
       )
       if is_torch_available()
       else ()
   )
   __UpperCAmelCase : List[str]      =			(
       {'audio-classification': ASTForAudioClassification, 'feature-extraction': ASTModel}
       if is_torch_available()
       else {}
   )
   __UpperCAmelCase : Optional[Any]      =			False
   __UpperCAmelCase : Tuple      =			False
   __UpperCAmelCase : Any      =			False
   __UpperCAmelCase : Any      =			False


   def 			lowercase_      (self     :						Union[str, Any]       ,  __UpperCAmelCase     :						Any       ,  __UpperCAmelCase     :						Optional[int]       ,  __UpperCAmelCase     :						Union[str, Any]       ,  __UpperCAmelCase     :						Dict       ,  __UpperCAmelCase     :						Tuple		)						->				Any:
         """simple docstring"""



         if pipeline_test_casse_name == "AudioClassificationPipelineTests":
               return True

         return False


   def 			lowercase_      (self     :						Optional[Any]		)						->				Tuple:
         """simple docstring"""



         UpperCAmelCase__								=  ASTModelTester(self		)
         UpperCAmelCase__								=  ConfigTester(self       ,  config_class=__UpperCAmelCase       ,  has_text_modality=__UpperCAmelCase       ,  hidden_size=3_7		)


   def 			lowercase_      (self     :						Union[str, Any]		)						->				Tuple:
         """simple docstring"""



         self.config_tester.run_common_tests()


   @unittest.skip(reason="AST does not use inputs_embeds"		)
   def 			lowercase_      (self     :						Dict		)						->				List[str]:
         """simple docstring"""



         pass


   def 			lowercase_      (self     :						int		)						->				Any:
         """simple docstring"""



         UpperCAmelCase__		,      UpperCAmelCase__								=  self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
               UpperCAmelCase__								=  model_class(__UpperCAmelCase		)
               self.assertIsInstance(model.get_input_embeddings()       ,  (nn.Module)		)
               UpperCAmelCase__								=  model.get_output_embeddings()
               self.assertTrue(x is None or isinstance(__UpperCAmelCase       ,  nn.Linear		)		)


   def 			lowercase_      (self     :						str		)						->				str:
         """simple docstring"""



         UpperCAmelCase__		,      UpperCAmelCase__								=  self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
               UpperCAmelCase__								=  model_class(__UpperCAmelCase		)
               UpperCAmelCase__								=  inspect.signature(model.forward		)
               # signature.parameters is an OrderedDict => so arg_names order is deterministic
               UpperCAmelCase__								=  [*signature.parameters.keys()]

               UpperCAmelCase__								=  ["input_values"]
               self.assertListEqual(arg_names[:1]       ,  __UpperCAmelCase		)


   def 			lowercase_      (self     :						Union[str, Any]		)						->				Optional[int]:
         """simple docstring"""



         UpperCAmelCase__								=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__UpperCAmelCase		)





   @slow
   def 			lowercase_      (self     :						Optional[Any]		)						->				Union[str, Any]:
         """simple docstring"""



         for model_name in AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               UpperCAmelCase__								=  ASTModel.from_pretrained(__UpperCAmelCase		)
               self.assertIsNotNone(__UpperCAmelCase		)




def    lowerCAmelCase_ (     )     ->				Dict:







      '''simple docstring'''


      UpperCAmelCase__								=  hf_hub_download(
          repo_id="nielsr/audio-spectogram-transformer-checkpoint",  filename="sample_audio.flac",  repo_type="dataset"							)

      UpperCAmelCase__		,      UpperCAmelCase__								=  torchaudio.load(__A							)

      return audio, sampling_rate







@require_torch
@require_torchaudio
class      A							(				unittest.TestCase     ):


   @cached_property
   def 			lowercase_      (self     :						List[Any]		)						->				List[str]:
         """simple docstring"""



         return (
             ASTFeatureExtractor.from_pretrained("MIT/ast-finetuned-audioset-10-10-0.4593"		)
             if is_torchaudio_available()
             else None
         )





   @slow
   def 			lowercase_      (self     :						Optional[int]		)						->				Any:
         """simple docstring"""



         UpperCAmelCase__								=  self.default_feature_extractor
         UpperCAmelCase__								=  ASTForAudioClassification.from_pretrained("MIT/ast-finetuned-audioset-10-10-0.4593"		).to(__UpperCAmelCase		)

         UpperCAmelCase__								=  self.default_feature_extractor
         UpperCAmelCase__		,      UpperCAmelCase__								=  prepare_audio()
         UpperCAmelCase__								=  audio.squeeze().numpy()
         UpperCAmelCase__								=  feature_extractor(__UpperCAmelCase       ,  sampling_rate=__UpperCAmelCase       ,  return_tensors="pt"		).to(__UpperCAmelCase		)

         # forward pass
         with torch.no_grad():
               UpperCAmelCase__								=  model(**__UpperCAmelCase		)

         # verify the logits
         UpperCAmelCase__								=  torch.Size((1, 5_2_7)		)
         self.assertEqual(outputs.logits.shape       ,  __UpperCAmelCase		)

         UpperCAmelCase__								=  torch.tensor([-0.8760, -7.0042, -8.6602]		).to(__UpperCAmelCase		)

         self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,  __UpperCAmelCase       ,  atol=1E-4		)		)










from __future__ import annotations




def 		lowerCAmelCase_    (  __UpperCAmelCase:			int		,   __UpperCAmelCase:			int      )      ->	list[list[int]]:
    UpperCamelCase__							:				list[list[int]]          =      []
    create_all_state(1		,   __UpperCAmelCase		,   __UpperCAmelCase		,   []		,   __UpperCAmelCase      )
    return result




def 		lowerCAmelCase_    (  __UpperCAmelCase:			int		,   __UpperCAmelCase:			int		,   __UpperCAmelCase:			int		,   __UpperCAmelCase:			list[int]		,   __UpperCAmelCase:			list[list[int]]		,   )      ->	None:
    if level == 0:
        total_list.append(current_list[:]      )
        return

    for i in range(__UpperCAmelCase		,   total_number - level + 2      ):
        current_list.append(__UpperCAmelCase      )
        create_all_state(i + 1		,   __UpperCAmelCase		,   level - 1		,   __UpperCAmelCase		,   __UpperCAmelCase      )
        current_list.pop()




def 		lowerCAmelCase_    (  __UpperCAmelCase:			list[list[int]]      )      ->	None:
    for i in total_list:
        print(*__UpperCAmelCase      )


if __name__ == "__main__":
  UpperCAmelCase_     							= 4
  UpperCAmelCase_     							= 2
  UpperCAmelCase_     							= generate_all_combinations(n, k)
  print_all_state(total_list)

