




from json import JSONDecodeError  # Workaround for requests.exceptions.JSONDecodeError

import requests




def 						SCREAMING_SNAKE_CASE__					(    lowercase = "isbn/0140328726"     )  ->   List[str]:
   snake_case      :				List[str]				=       olid.strip().strip("""/"""     )  # Remove leading/trailing whitespace & slashes
   if new_olid.count("""/"""     ) != 1:
      snake_case      :				List[str]				=       f"""{olid} is not a valid Open Library olid"""
      raise ValueError(__UpperCamelCase     )
   return requests.get(f"""https://openlibrary.org/{new_olid}.json"""     ).json()




def 						SCREAMING_SNAKE_CASE__					(    lowercase     )  ->   Optional[int]:
   snake_case      :				List[Any]				=       {
       """title""": """Title""",
       """publish_date""": """Publish date""",
       """authors""": """Authors""",
       """number_of_pages""": """Number of pages:""",
       """first_sentence""": """First sentence""",
       """isbn_10""": """ISBN (10)""",
       """isbn_13""": """ISBN (13)""",
   }
   snake_case      :				List[str]				=       {better_key: ol_book_data[key] for key, better_key in desired_keys.items()}
   snake_case      :				Tuple				=       [
       get_openlibrary_data(author["""key"""]     )["""name"""] for author in data["""Authors"""]
   ]
   snake_case      :				Tuple				=       data["""First sentence"""]["""value"""]
   for key, value in data.items():
      if isinstance(__UpperCamelCase						,__UpperCamelCase     ):
         snake_case      :				int				=       """, """.join(__UpperCamelCase     )
   return data


if __name__ == "__main__":
       import doctest

       doctest.testmod()

       while True:
              lowerCamelCase       :       Optional[int]        =    input('\nEnter the ISBN code to search (or \'quit\' to stop): ').strip()
              if isbn.lower() in ("", "q", "quit", "exit", "stop"):
                     break

              if len(isbn) not in (1_0, 1_3) or not isbn.isdigit():
                     print(f"""Sorry, {isbn} is not a valid ISBN.  Please, input a valid ISBN.""")
                     continue

              print(f"""\nSearching Open Library for ISBN: {isbn}...\n""")

              try:
                     lowerCamelCase       :       Optional[Any]        =    summarize_book(get_openlibrary_data(f"""isbn/{isbn}"""))
                     print('\n'.join(f"""{key}: {value}""" for key, value in book_summary.items()))
              except JSONDecodeError:  # Workaround for requests.exceptions.RequestException:
                     print(f"""Sorry, there are no results for ISBN: {isbn}.""")






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    :
  """simple docstring"""







  def __init__(							self       :				List[Any]     ,   __magic_name__       :				Any     ,   __magic_name__       :				List[Any]=13     ,   __magic_name__       :				List[Any]=2     ,   __magic_name__       :				Tuple=24     ,   __magic_name__       :				List[str]=16     ,   __magic_name__       :				Dict=True     ,   __magic_name__       :				List[Any]=True     ,   __magic_name__       :				Optional[int]=32     ,   __magic_name__       :				Tuple=5     ,   __magic_name__       :				int=4     ,   __magic_name__       :				Tuple=37     ,   __magic_name__       :				List[str]="gelu"     ,   __magic_name__       :				Tuple=0.1     ,   __magic_name__       :				Tuple=0.1     ,   __magic_name__       :				Union[str, Any]=10     ,   __magic_name__       :				Tuple=0.02     ,   __magic_name__       :				Tuple=None     ,   __magic_name__       :				Any=2     ,   __magic_name__       :				Dict=2     ,   )     ->		int:
        SCREAMING_SNAKE_CASE_      =     parent
        SCREAMING_SNAKE_CASE_      =     batch_size
        SCREAMING_SNAKE_CASE_      =     patch_size
        SCREAMING_SNAKE_CASE_      =     max_length
        SCREAMING_SNAKE_CASE_      =     num_mel_bins
        SCREAMING_SNAKE_CASE_      =     is_training
        SCREAMING_SNAKE_CASE_      =     use_labels
        SCREAMING_SNAKE_CASE_      =     hidden_size
        SCREAMING_SNAKE_CASE_      =     num_hidden_layers
        SCREAMING_SNAKE_CASE_      =     num_attention_heads
        SCREAMING_SNAKE_CASE_      =     intermediate_size
        SCREAMING_SNAKE_CASE_      =     hidden_act
        SCREAMING_SNAKE_CASE_      =     hidden_dropout_prob
        SCREAMING_SNAKE_CASE_      =     attention_probs_dropout_prob
        SCREAMING_SNAKE_CASE_      =     type_sequence_label_size
        SCREAMING_SNAKE_CASE_      =     initializer_range
        SCREAMING_SNAKE_CASE_      =     scope
        SCREAMING_SNAKE_CASE_      =     frequency_stride
        SCREAMING_SNAKE_CASE_      =     time_stride

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







  def       __A   (							self       :				Any      )     ->		Any:
        SCREAMING_SNAKE_CASE_      =     floats_tensor([self.batch_size, self.max_length, self.num_mel_bins]      )

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

        SCREAMING_SNAKE_CASE_      =     self.get_config()

        return config, input_values, labels







  def       __A   (							self       :				Any      )     ->		Dict:
        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=__magic_name__     ,   initializer_range=self.initializer_range     ,   frequency_stride=self.frequency_stride     ,   time_stride=self.time_stride     ,   )







  def       __A   (							self       :				List[Any]     ,   __magic_name__       :				List[str]     ,   __magic_name__       :				str     ,   __magic_name__       :				List[str]      )     ->		Union[str, Any]:
        SCREAMING_SNAKE_CASE_      =     ASTModel(config=__magic_name__      )
        model.to(__magic_name__      )
        model.eval()
        SCREAMING_SNAKE_CASE_      =     model(__magic_name__      )
        self.parent.assertEqual(result.last_hidden_state.shape     ,   (self.batch_size, self.seq_length, self.hidden_size)      )







  def       __A   (							self       :				Tuple      )     ->		str:
        SCREAMING_SNAKE_CASE_      =     self.prepare_config_and_inputs()
        (
            (
            SCREAMING_SNAKE_CASE_
        )   ,       (
            SCREAMING_SNAKE_CASE_
        )   ,       (
            SCREAMING_SNAKE_CASE_
        )   ,       
        )      =     config_and_inputs
        SCREAMING_SNAKE_CASE_      =     {"input_values": input_values}
        return config, inputs_dict



@require_torch
class      lowerCamelCase    (SCREAMING_SNAKE_CASE__     ,					SCREAMING_SNAKE_CASE__     ,					unittest.TestCase    ):
  """simple docstring"""







  lowerCamelCase__   =  (
      (
          ASTModel,
          ASTForAudioClassification,
      )
      if is_torch_available()
      else ()
  )
  lowerCamelCase__   =  (
      {'''audio-classification''': ASTForAudioClassification, '''feature-extraction''': ASTModel}
      if is_torch_available()
      else {}
  )
  lowerCamelCase__   =  False
  lowerCamelCase__   =  False
  lowerCamelCase__   =  False
  lowerCamelCase__   =  False







  def       __A   (							self       :				Tuple     ,   __magic_name__       :				Union[str, Any]     ,   __magic_name__       :				Optional[Any]     ,   __magic_name__       :				Dict     ,   __magic_name__       :				Optional[int]     ,   __magic_name__       :				Tuple      )     ->		Tuple:
        if pipeline_test_casse_name == "AudioClassificationPipelineTests":
              return True

        return False







  def       __A   (							self       :				Optional[Any]      )     ->		Optional[Any]:
        SCREAMING_SNAKE_CASE_      =     ASTModelTester(self      )
        SCREAMING_SNAKE_CASE_      =     ConfigTester(self     ,   config_class=__magic_name__     ,   has_text_modality=__magic_name__     ,   hidden_size=37      )







  def       __A   (							self       :				Union[str, Any]      )     ->		Dict:
        self.config_tester.run_common_tests()







  @unittest.skip(reason="AST does not use inputs_embeds"      )
  def       __A   (							self       :				Optional[Any]      )     ->		Tuple:
        pass







  def       __A   (							self       :				int      )     ->		int:
        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     self.model_tester.prepare_config_and_inputs_for_common()

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







  def       __A   (							self       :				List[Any]      )     ->		str:
        SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     self.model_tester.prepare_config_and_inputs_for_common()

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

              SCREAMING_SNAKE_CASE_      =     ["input_values"]
              self.assertListEqual(arg_names[:1]     ,   __magic_name__      )







  def       __A   (							self       :				int      )     ->		Any:
        SCREAMING_SNAKE_CASE_      =     self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*__magic_name__      )







  @slow
  def       __A   (							self       :				int      )     ->		int:
        for model_name in AUDIO_SPECTROGRAM_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              SCREAMING_SNAKE_CASE_      =     ASTModel.from_pretrained(__magic_name__      )
              self.assertIsNotNone(__magic_name__      )



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

      SCREAMING_SNAKE_CASE_   ,       SCREAMING_SNAKE_CASE_      =     torchaudio.load(__UpperCamelCase )

      return audio, sampling_rate





@require_torch
@require_torchaudio
class      lowerCamelCase    (unittest.TestCase    ):
  """simple docstring"""







  @cached_property
  def       __A   (							self       :				List[Any]      )     ->		List[Any]:
        return (
            ASTFeatureExtractor.from_pretrained("MIT/ast-finetuned-audioset-10-10-0.4593"      )
            if is_torchaudio_available()
            else None
        )







  @slow
  def       __A   (							self       :				Union[str, Any]      )     ->		Optional[int]:
        SCREAMING_SNAKE_CASE_      =     self.default_feature_extractor
        SCREAMING_SNAKE_CASE_      =     ASTForAudioClassification.from_pretrained("MIT/ast-finetuned-audioset-10-10-0.4593"      ).to(__magic_name__      )

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

        # forward pass
        with torch.no_grad():
              SCREAMING_SNAKE_CASE_      =     model(**__magic_name__      )

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

        SCREAMING_SNAKE_CASE_      =     torch.tensor([-0.8760, -7.0042, -8.6602]      ).to(__magic_name__      )

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


