


'''simple docstring'''
import os
import shutil
import sys
import tempfile
import unittest
from pathlib import Path

import pytest

import transformers
from transformers import (
    BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    AutoTokenizer,
    BertConfig,
    BertTokenizer,
    BertTokenizerFast,
    CTRLTokenizer,
    GPTaTokenizer,
    GPTaTokenizerFast,
    PreTrainedTokenizerFast,
    RobertaTokenizer,
    RobertaTokenizerFast,
    is_tokenizers_available,
)
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.auto.tokenization_auto import (
    TOKENIZER_MAPPING,
    get_tokenizer_config,
    tokenizer_class_from_name,
)
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import (
    DUMMY_DIFF_TOKENIZER_IDENTIFIER,
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tokenizers,
    slow,
)


sys.path.append(str(Path(__file__).parent.parent.parent.parent / """utils"""))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
    from test_module.custom_tokenization_fast import CustomTokenizerFast






class        lowerCAmelCase_  (     unittest.TestCase	):






       def   UpperCamelCase						( self   )->      str:
            _A				=							0






       @slow
       def   UpperCamelCase						( self   )->      int:
            for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
                 _A				=							AutoTokenizer.from_pretrained(_UpperCamelCase   )
                 self.assertIsNotNone(_UpperCamelCase   )
                 self.assertIsInstance(_UpperCamelCase			,     (BertTokenizer, BertTokenizerFast)   )
                 self.assertGreater(len(_UpperCamelCase   )			,     0   )

            for model_name in GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP.keys():
                 _A				=							AutoTokenizer.from_pretrained(_UpperCamelCase   )
                 self.assertIsNotNone(_UpperCamelCase   )
                 self.assertIsInstance(_UpperCamelCase			,     (GPTaTokenizer, GPTaTokenizerFast)   )
                 self.assertGreater(len(_UpperCamelCase   )			,     0   )






       def   UpperCamelCase						( self   )->      Optional[Any]:
            _A				=							AutoTokenizer.from_pretrained(_UpperCamelCase   )
            self.assertIsInstance(_UpperCamelCase			,     (BertTokenizer, BertTokenizerFast)   )
            self.assertEqual(tokenizer.vocab_size			,     12   )






       def   UpperCamelCase						( self   )->      str:
            _A				=							AutoTokenizer.from_pretrained(_UpperCamelCase   )
            self.assertIsInstance(_UpperCamelCase			,     (RobertaTokenizer, RobertaTokenizerFast)   )
            self.assertEqual(tokenizer.vocab_size			,     20   )






       def   UpperCamelCase						( self   )->      List[Any]:
            _A				=							AutoConfig.from_pretrained(_UpperCamelCase   )
            self.assertIsInstance(_UpperCamelCase			,     _UpperCamelCase   )
            # Check that tokenizer_type ≠ model_type
            _A				=							AutoTokenizer.from_pretrained(_UpperCamelCase			,     config=_UpperCamelCase   )
            self.assertIsInstance(_UpperCamelCase			,     (BertTokenizer, BertTokenizerFast)   )
            self.assertEqual(tokenizer.vocab_size			,     12   )






       def   UpperCamelCase						( self   )->      List[str]:
            with tempfile.TemporaryDirectory() as tmp_dir:
                 shutil.copy('./tests/fixtures/vocab.txt'			,     os.path.join(_UpperCamelCase			,     'vocab.txt'   )   )

                 _A				=							AutoTokenizer.from_pretrained(_UpperCamelCase			,     tokenizer_type='bert'			,     use_fast=_UpperCamelCase   )
                 self.assertIsInstance(_UpperCamelCase			,     _UpperCamelCase   )

            with tempfile.TemporaryDirectory() as tmp_dir:
                 shutil.copy('./tests/fixtures/vocab.json'			,     os.path.join(_UpperCamelCase			,     'vocab.json'   )   )
                 shutil.copy('./tests/fixtures/merges.txt'			,     os.path.join(_UpperCamelCase			,     'merges.txt'   )   )

                 _A				=							AutoTokenizer.from_pretrained(_UpperCamelCase			,     tokenizer_type='gpt2'			,     use_fast=_UpperCamelCase   )
                 self.assertIsInstance(_UpperCamelCase			,     _UpperCamelCase   )






       @require_tokenizers
       def   UpperCamelCase						( self   )->      Tuple:
            with tempfile.TemporaryDirectory() as tmp_dir:
                 shutil.copy('./tests/fixtures/vocab.txt'			,     os.path.join(_UpperCamelCase			,     'vocab.txt'   )   )

                 _A				=							AutoTokenizer.from_pretrained(_UpperCamelCase			,     tokenizer_type='bert'   )
                 self.assertIsInstance(_UpperCamelCase			,     _UpperCamelCase   )

            with tempfile.TemporaryDirectory() as tmp_dir:
                 shutil.copy('./tests/fixtures/vocab.json'			,     os.path.join(_UpperCamelCase			,     'vocab.json'   )   )
                 shutil.copy('./tests/fixtures/merges.txt'			,     os.path.join(_UpperCamelCase			,     'merges.txt'   )   )

                 _A				=							AutoTokenizer.from_pretrained(_UpperCamelCase			,     tokenizer_type='gpt2'   )
                 self.assertIsInstance(_UpperCamelCase			,     _UpperCamelCase   )






       def   UpperCamelCase						( self   )->      Optional[Any]:
            with pytest.raises(_UpperCamelCase   ):
                 AutoTokenizer.from_pretrained('./'			,     tokenizer_type='xxx'   )






       @require_tokenizers
       def   UpperCamelCase						( self   )->      List[str]:
            for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
                 _A				=							tokenizer_class.from_pretrained('wietsedv/bert-base-dutch-cased'   )
                 self.assertIsInstance(_UpperCamelCase			,     (BertTokenizer, BertTokenizerFast)   )

                 if isinstance(_UpperCamelCase			,     _UpperCamelCase   ):
                      self.assertEqual(tokenizer.basic_tokenizer.do_lower_case			,     _UpperCamelCase   )
                 else:
                      self.assertEqual(tokenizer.do_lower_case			,     _UpperCamelCase   )

                 self.assertEqual(tokenizer.model_max_length			,     512   )






       @require_tokenizers
       def   UpperCamelCase						( self   )->      Any:
            for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
                 with self.assertRaisesRegex(
                     _UpperCamelCase			,     'julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier'			,     ):
                      _A				=							tokenizer_class.from_pretrained('julien-c/herlolip-not-exists'   )






       def   UpperCamelCase						( self   )->      Union[str, Any]:
            # tests: https://github.com/huggingface/transformers/pull/13251
            # 1. models with `-`, e.g. xlm-roberta -> xlm_roberta
            # 2. models that don't remap 1-1 from model-name to model file, e.g., openai-gpt -> openai
            _A				=							TOKENIZER_MAPPING.values()
            _A				=							[]

            for slow_tok, fast_tok in tokenizers:
                 if slow_tok is not None:
                      tokenizer_names.append(slow_tok.__name__   )

                 if fast_tok is not None:
                      tokenizer_names.append(fast_tok.__name__   )

            for tokenizer_name in tokenizer_names:
                 # must find the right class
                 tokenizer_class_from_name(_UpperCamelCase   )






       @require_tokenizers
       def   UpperCamelCase						( self   )->      Any:
            self.assertIsInstance(AutoTokenizer.from_pretrained('bert-base-cased'			,     use_fast=_UpperCamelCase   )			,     _UpperCamelCase   )
            self.assertIsInstance(AutoTokenizer.from_pretrained('bert-base-cased'   )			,     _UpperCamelCase   )






       @require_tokenizers
       def   UpperCamelCase						( self   )->      Tuple:
            _A				=							AutoTokenizer.from_pretrained('distilbert-base-uncased'			,     do_lower_case=_UpperCamelCase   )
            _A				=							'Hello, world. How are you?'
            _A				=							tokenizer.tokenize(_UpperCamelCase   )
            self.assertEqual('[UNK]'			,     tokens[0]   )

            _A				=							AutoTokenizer.from_pretrained('microsoft/mpnet-base'			,     do_lower_case=_UpperCamelCase   )
            _A				=							tokenizer.tokenize(_UpperCamelCase   )
            self.assertEqual('[UNK]'			,     tokens[0]   )






       @require_tokenizers
       def   UpperCamelCase						( self   )->      Optional[Any]:
            _A				=							AutoTokenizer.from_pretrained('robot-test/dummy-tokenizer-fast-with-model-config'   )
            self.assertEqual(type(_UpperCamelCase   )			,     _UpperCamelCase   )
            self.assertEqual(tokenizer.model_max_length			,     512   )
            self.assertEqual(tokenizer.vocab_size			,     3_0000   )
            self.assertEqual(tokenizer.unk_token			,     '[UNK]'   )
            self.assertEqual(tokenizer.padding_side			,     'right'   )
            self.assertEqual(tokenizer.truncation_side			,     'right'   )






       def   UpperCamelCase						( self   )->      List[Any]:
            _A				=							AutoTokenizer.from_pretrained(_UpperCamelCase   )
            self.assertIsInstance(_UpperCamelCase			,     (BertTokenizer, BertTokenizerFast)   )
            with tempfile.TemporaryDirectory() as tmp_dir:
                 tokenizer.save_pretrained(_UpperCamelCase   )
                 _A				=							AutoTokenizer.from_pretrained(_UpperCamelCase   )

            self.assertIsInstance(_UpperCamelCase			,     tokenizer.__class__   )
            self.assertEqual(tokenizera.vocab_size			,     12   )






       def   UpperCamelCase						( self   )->      Optional[int]:
            _A				=							AutoTokenizer.from_pretrained('ctrl'   )
            # There is no fast CTRL so this always gives us a slow tokenizer.
            self.assertIsInstance(_UpperCamelCase			,     _UpperCamelCase   )






       def   UpperCamelCase						( self   )->      Tuple:
            # Check we can load the tokenizer config of an online model.
            _A				=							get_tokenizer_config('bert-base-cased'   )
            _A				=							config.pop('_commit_hash'			,     _UpperCamelCase   )
            # If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
            self.assertEqual(_UpperCamelCase			,     {'do_lower_case': False}   )

            # This model does not have a tokenizer_config so we get back an empty dict.
            _A				=							get_tokenizer_config(_UpperCamelCase   )
            self.assertDictEqual(_UpperCamelCase			,     {}   )

            # A tokenizer saved with `save_pretrained` always creates a tokenizer config.
            _A				=							AutoTokenizer.from_pretrained(_UpperCamelCase   )
            with tempfile.TemporaryDirectory() as tmp_dir:
                 tokenizer.save_pretrained(_UpperCamelCase   )
                 _A				=							get_tokenizer_config(_UpperCamelCase   )

            # Check the class of the tokenizer was properly saved (note that it always saves the slow class).
            self.assertEqual(config['tokenizer_class']			,     'BertTokenizer'   )






       def   UpperCamelCase						( self   )->      Dict:
            try:
                 AutoConfig.register('custom'			,     _UpperCamelCase   )

                 AutoTokenizer.register(_UpperCamelCase			,     slow_tokenizer_class=_UpperCamelCase   )
                 # Trying to register something existing in the Transformers library will raise an error
                 with self.assertRaises(_UpperCamelCase   ):
                      AutoTokenizer.register(_UpperCamelCase			,     slow_tokenizer_class=_UpperCamelCase   )

                 _A				=							CustomTokenizer.from_pretrained(_UpperCamelCase   )
                 with tempfile.TemporaryDirectory() as tmp_dir:
                      tokenizer.save_pretrained(_UpperCamelCase   )

                      _A				=							AutoTokenizer.from_pretrained(_UpperCamelCase   )
                      self.assertIsInstance(_UpperCamelCase			,     _UpperCamelCase   )

            finally:
                 if "custom" in CONFIG_MAPPING._extra_content:
                      del CONFIG_MAPPING._extra_content["custom"]
                 if CustomConfig in TOKENIZER_MAPPING._extra_content:
                      del TOKENIZER_MAPPING._extra_content[CustomConfig]






       @require_tokenizers
       def   UpperCamelCase						( self   )->      str:
            try:
                 AutoConfig.register('custom'			,     _UpperCamelCase   )

                 # Can register in two steps
                 AutoTokenizer.register(_UpperCamelCase			,     slow_tokenizer_class=_UpperCamelCase   )
                 self.assertEqual(TOKENIZER_MAPPING[CustomConfig]			,     (CustomTokenizer, None)   )
                 AutoTokenizer.register(_UpperCamelCase			,     fast_tokenizer_class=_UpperCamelCase   )
                 self.assertEqual(TOKENIZER_MAPPING[CustomConfig]			,     (CustomTokenizer, CustomTokenizerFast)   )

                 del TOKENIZER_MAPPING._extra_content[CustomConfig]
                 # Can register in one step
                 AutoTokenizer.register(
                     _UpperCamelCase			,     slow_tokenizer_class=_UpperCamelCase			,     fast_tokenizer_class=_UpperCamelCase   )
                 self.assertEqual(TOKENIZER_MAPPING[CustomConfig]			,     (CustomTokenizer, CustomTokenizerFast)   )

                 # Trying to register something existing in the Transformers library will raise an error
                 with self.assertRaises(_UpperCamelCase   ):
                      AutoTokenizer.register(_UpperCamelCase			,     fast_tokenizer_class=_UpperCamelCase   )

                 # We pass through a bert tokenizer fast cause there is no converter slow to fast for our new toknizer
                 # and that model does not have a tokenizer.json
                 with tempfile.TemporaryDirectory() as tmp_dir:
                      _A				=							BertTokenizerFast.from_pretrained(_UpperCamelCase   )
                      bert_tokenizer.save_pretrained(_UpperCamelCase   )
                      _A				=							CustomTokenizerFast.from_pretrained(_UpperCamelCase   )

                 with tempfile.TemporaryDirectory() as tmp_dir:
                      tokenizer.save_pretrained(_UpperCamelCase   )

                      _A				=							AutoTokenizer.from_pretrained(_UpperCamelCase   )
                      self.assertIsInstance(_UpperCamelCase			,     _UpperCamelCase   )

                      _A				=							AutoTokenizer.from_pretrained(_UpperCamelCase			,     use_fast=_UpperCamelCase   )
                      self.assertIsInstance(_UpperCamelCase			,     _UpperCamelCase   )

            finally:
                 if "custom" in CONFIG_MAPPING._extra_content:
                      del CONFIG_MAPPING._extra_content["custom"]
                 if CustomConfig in TOKENIZER_MAPPING._extra_content:
                      del TOKENIZER_MAPPING._extra_content[CustomConfig]






       def   UpperCamelCase						( self   )->      List[str]:
            # If remote code is not set, we will time out when asking whether to load the model.
            with self.assertRaises(_UpperCamelCase   ):
                 _A				=							AutoTokenizer.from_pretrained('hf-internal-testing/test_dynamic_tokenizer'   )
            # If remote code is disabled, we can't load this config.
            with self.assertRaises(_UpperCamelCase   ):
                 _A				=							AutoTokenizer.from_pretrained(
                     'hf-internal-testing/test_dynamic_tokenizer'			,     trust_remote_code=_UpperCamelCase   )

            _A				=							AutoTokenizer.from_pretrained('hf-internal-testing/test_dynamic_tokenizer'			,     trust_remote_code=_UpperCamelCase   )
            self.assertTrue(tokenizer.special_attribute_present   )
            # Test tokenizer can be reloaded.
            with tempfile.TemporaryDirectory() as tmp_dir:
                 tokenizer.save_pretrained(_UpperCamelCase   )
                 _A				=							AutoTokenizer.from_pretrained(_UpperCamelCase			,     trust_remote_code=_UpperCamelCase   )
            self.assertTrue(reloaded_tokenizer.special_attribute_present   )

            if is_tokenizers_available():
                 self.assertEqual(tokenizer.__class__.__name__			,     'NewTokenizerFast'   )
                 self.assertEqual(reloaded_tokenizer.__class__.__name__			,     'NewTokenizerFast'   )

                 # Test we can also load the slow version
                 _A				=							AutoTokenizer.from_pretrained(
                     'hf-internal-testing/test_dynamic_tokenizer'			,     trust_remote_code=_UpperCamelCase			,     use_fast=_UpperCamelCase   )
                 self.assertTrue(tokenizer.special_attribute_present   )
                 self.assertEqual(tokenizer.__class__.__name__			,     'NewTokenizer'   )
                 # Test tokenizer can be reloaded.
                 with tempfile.TemporaryDirectory() as tmp_dir:
                      tokenizer.save_pretrained(_UpperCamelCase   )
                      _A				=							AutoTokenizer.from_pretrained(_UpperCamelCase			,     trust_remote_code=_UpperCamelCase			,     use_fast=_UpperCamelCase   )
                 self.assertEqual(reloaded_tokenizer.__class__.__name__			,     'NewTokenizer'   )
                 self.assertTrue(reloaded_tokenizer.special_attribute_present   )
            else:
                 self.assertEqual(tokenizer.__class__.__name__			,     'NewTokenizer'   )
                 self.assertEqual(reloaded_tokenizer.__class__.__name__			,     'NewTokenizer'   )






       @require_tokenizers
       def   UpperCamelCase						( self   )->      Optional[Any]:






            class        lowerCAmelCase_  (     UpperCAmelCase	):
                   __UpperCAmelCase					=False






            class        lowerCAmelCase_  (     UpperCAmelCase	):
                   __UpperCAmelCase					=NewTokenizer
                   __UpperCAmelCase					=False

            try:
                 AutoConfig.register('custom'			,     _UpperCamelCase   )
                 AutoTokenizer.register(_UpperCamelCase			,     slow_tokenizer_class=_UpperCamelCase   )
                 AutoTokenizer.register(_UpperCamelCase			,     fast_tokenizer_class=_UpperCamelCase   )
                 # If remote code is not set, the default is to use local
                 _A				=							AutoTokenizer.from_pretrained('hf-internal-testing/test_dynamic_tokenizer'   )
                 self.assertEqual(tokenizer.__class__.__name__			,     'NewTokenizerFast'   )
                 self.assertFalse(tokenizer.special_attribute_present   )
                 _A				=							AutoTokenizer.from_pretrained('hf-internal-testing/test_dynamic_tokenizer'			,     use_fast=_UpperCamelCase   )
                 self.assertEqual(tokenizer.__class__.__name__			,     'NewTokenizer'   )
                 self.assertFalse(tokenizer.special_attribute_present   )

                 # If remote code is disabled, we load the local one.
                 _A				=							AutoTokenizer.from_pretrained(
                     'hf-internal-testing/test_dynamic_tokenizer'			,     trust_remote_code=_UpperCamelCase   )
                 self.assertEqual(tokenizer.__class__.__name__			,     'NewTokenizerFast'   )
                 self.assertFalse(tokenizer.special_attribute_present   )
                 _A				=							AutoTokenizer.from_pretrained(
                     'hf-internal-testing/test_dynamic_tokenizer'			,     trust_remote_code=_UpperCamelCase			,     use_fast=_UpperCamelCase   )
                 self.assertEqual(tokenizer.__class__.__name__			,     'NewTokenizer'   )
                 self.assertFalse(tokenizer.special_attribute_present   )

                 # If remote is enabled, we load from the Hub
                 _A				=							AutoTokenizer.from_pretrained(
                     'hf-internal-testing/test_dynamic_tokenizer'			,     trust_remote_code=_UpperCamelCase   )
                 self.assertEqual(tokenizer.__class__.__name__			,     'NewTokenizerFast'   )
                 self.assertTrue(tokenizer.special_attribute_present   )
                 _A				=							AutoTokenizer.from_pretrained(
                     'hf-internal-testing/test_dynamic_tokenizer'			,     trust_remote_code=_UpperCamelCase			,     use_fast=_UpperCamelCase   )
                 self.assertEqual(tokenizer.__class__.__name__			,     'NewTokenizer'   )
                 self.assertTrue(tokenizer.special_attribute_present   )

            finally:
                 if "custom" in CONFIG_MAPPING._extra_content:
                      del CONFIG_MAPPING._extra_content["custom"]
                 if CustomConfig in TOKENIZER_MAPPING._extra_content:
                      del TOKENIZER_MAPPING._extra_content[CustomConfig]






       def   UpperCamelCase						( self   )->      List[str]:
            _A				=							AutoTokenizer.from_pretrained(
                'hf-internal-testing/test_dynamic_tokenizer_legacy'			,     trust_remote_code=_UpperCamelCase   )
            self.assertTrue(tokenizer.special_attribute_present   )
            if is_tokenizers_available():
                 self.assertEqual(tokenizer.__class__.__name__			,     'NewTokenizerFast'   )

                 # Test we can also load the slow version
                 _A				=							AutoTokenizer.from_pretrained(
                     'hf-internal-testing/test_dynamic_tokenizer_legacy'			,     trust_remote_code=_UpperCamelCase			,     use_fast=_UpperCamelCase   )
                 self.assertTrue(tokenizer.special_attribute_present   )
                 self.assertEqual(tokenizer.__class__.__name__			,     'NewTokenizer'   )
            else:
                 self.assertEqual(tokenizer.__class__.__name__			,     'NewTokenizer'   )






       def   UpperCamelCase						( self   )->      List[Any]:
            with self.assertRaisesRegex(
                _UpperCamelCase			,     'bert-base is not a local folder and is not a valid model identifier'   ):
                 _A				=							AutoTokenizer.from_pretrained('bert-base'   )






       def   UpperCamelCase						( self   )->      List[Any]:
            with self.assertRaisesRegex(
                _UpperCamelCase			,     R'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'   ):
                 _A				=							AutoTokenizer.from_pretrained(_UpperCamelCase			,     revision='aaaaaa'   )






       def   UpperCamelCase						( self   )->      Any:
            # Make sure we have cached the tokenizer.
            _A				=							AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-bert'   )
            with RequestCounter() as counter:
                 _A				=							AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-bert'   )
                 self.assertEqual(counter.get_request_count			,     0   )
                 self.assertEqual(counter.head_request_count			,     1   )
                 self.assertEqual(counter.other_request_count			,     0   )









'''simple docstring'''
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        lowerCAmelCase_  :






       def __init__( self			,     _UpperCamelCase			,     _UpperCamelCase=13			,     _UpperCamelCase=2			,     _UpperCamelCase=24			,     _UpperCamelCase=16			,     _UpperCamelCase=True			,     _UpperCamelCase=True			,     _UpperCamelCase=32			,     _UpperCamelCase=5			,     _UpperCamelCase=4			,     _UpperCamelCase=37			,     _UpperCamelCase="gelu"			,     _UpperCamelCase=0.1			,     _UpperCamelCase=0.1			,     _UpperCamelCase=10			,     _UpperCamelCase=0.02			,     _UpperCamelCase=None			,     _UpperCamelCase=2			,     _UpperCamelCase=2			,     )->      Tuple:
            _A				=							parent
            _A				=							batch_size
            _A				=							patch_size
            _A				=							max_length
            _A				=							num_mel_bins
            _A				=							is_training
            _A				=							use_labels
            _A				=							hidden_size
            _A				=							num_hidden_layers
            _A				=							num_attention_heads
            _A				=							intermediate_size
            _A				=							hidden_act
            _A				=							hidden_dropout_prob
            _A				=							attention_probs_dropout_prob
            _A				=							type_sequence_label_size
            _A				=							initializer_range
            _A				=							scope
            _A				=							frequency_stride
            _A				=							time_stride

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






       def   UpperCamelCase						( self   )->      int:
            _A				=							floats_tensor([self.batch_size, self.max_length, self.num_mel_bins]   )

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

            _A				=							self.get_config()

            return config, input_values, labels






       def   UpperCamelCase						( self   )->      int:
            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   UpperCamelCase						( self			,     _UpperCamelCase			,     _UpperCamelCase			,     _UpperCamelCase   )->      Optional[Any]:
            _A				=							ASTModel(config=_UpperCamelCase   )
            model.to(_UpperCamelCase   )
            model.eval()
            _A				=							model(_UpperCamelCase   )
            self.parent.assertEqual(result.last_hidden_state.shape			,     (self.batch_size, self.seq_length, self.hidden_size)   )






       def   UpperCamelCase						( self   )->      Any:
            _A				=							self.prepare_config_and_inputs()
            (
                (
                _A
            )		,				(
                _A
            )		,				(
                _A
            )		,				
            )				=							config_and_inputs
            _A				=							{'input_values': input_values}
            return config, inputs_dict






@require_torch
class        lowerCAmelCase_  (     UpperCAmelCase      ,							UpperCAmelCase      ,							unittest.TestCase	):
       __UpperCAmelCase					=(
           (
               ASTModel,
               ASTForAudioClassification,
           )
           if is_torch_available()
           else ()
       )
       __UpperCAmelCase					=(
           {'audio-classification': ASTForAudioClassification, 'feature-extraction': ASTModel}
           if is_torch_available()
           else {}
       )
       __UpperCAmelCase					=False
       __UpperCAmelCase					=False
       __UpperCAmelCase					=False
       __UpperCAmelCase					=False






       def   UpperCamelCase						( self			,     _UpperCamelCase			,     _UpperCamelCase			,     _UpperCamelCase			,     _UpperCamelCase			,     _UpperCamelCase   )->      Union[str, Any]:
            if pipeline_test_casse_name == "AudioClassificationPipelineTests":
                 return True

            return False






       def   UpperCamelCase						( self   )->      List[str]:
            _A				=							ASTModelTester(self   )
            _A				=							ConfigTester(self			,     config_class=_UpperCamelCase			,     has_text_modality=_UpperCamelCase			,     hidden_size=37   )






       def   UpperCamelCase						( self   )->      int:
            self.config_tester.run_common_tests()






       @unittest.skip(reason='AST does not use inputs_embeds'   )
       def   UpperCamelCase						( self   )->      List[Any]:
            pass






       def   UpperCamelCase						( self   )->      str:
            _A		,				_A				=							self.model_tester.prepare_config_and_inputs_for_common()

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






       def   UpperCamelCase						( self   )->      List[str]:
            _A		,				_A				=							self.model_tester.prepare_config_and_inputs_for_common()

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

                 _A				=							['input_values']
                 self.assertListEqual(arg_names[:1]			,     _UpperCamelCase   )






       def   UpperCamelCase						( self   )->      Optional[Any]:
            _A				=							self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*_UpperCamelCase   )






       @slow
       def   UpperCamelCase						( self   )->      Tuple:
            for model_name in AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 _A				=							ASTModel.from_pretrained(_UpperCamelCase   )
                 self.assertIsNotNone(_UpperCamelCase   )






def 					lowerCamelCase_ ( )					->	Union[str, Any]:







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

     _A		,				_A				=							torchaudio.load(__UpperCamelCase		)

     return audio, sampling_rate






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






       @cached_property
       def   UpperCamelCase						( self   )->      Dict:
            return (
                ASTFeatureExtractor.from_pretrained('MIT/ast-finetuned-audioset-10-10-0.4593'   )
                if is_torchaudio_available()
                else None
            )






       @slow
       def   UpperCamelCase						( self   )->      Any:
            _A				=							self.default_feature_extractor
            _A				=							ASTForAudioClassification.from_pretrained('MIT/ast-finetuned-audioset-10-10-0.4593'   ).to(_UpperCamelCase   )

            _A				=							self.default_feature_extractor
            _A		,				_A				=							prepare_audio()
            _A				=							audio.squeeze().numpy()
            _A				=							feature_extractor(_UpperCamelCase			,     sampling_rate=_UpperCamelCase			,     return_tensors='pt'   ).to(_UpperCamelCase   )

            # forward pass
            with torch.no_grad():
                 _A				=							model(**_UpperCamelCase   )

            # verify the logits
            _A				=							torch.Size((1, 527)   )
            self.assertEqual(outputs.logits.shape			,     _UpperCamelCase   )

            _A				=							torch.tensor([-0.8760, -7.0042, -8.6602]   ).to(_UpperCamelCase   )

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





