
"""simple docstring"""






import json
import os
import shutil
import tempfile
import unittest

from transformers import is_speech_available, is_torch_available
from transformers.models.speechta import SpeechTaTokenizer
from transformers.testing_utils import get_tests_dir, require_torch
from transformers.utils import FEATURE_EXTRACTOR_NAME


if is_speech_available() and is_torch_available():
      from transformers import SpeechTaFeatureExtractor, SpeechTaProcessor

      from .test_feature_extraction_speechta import floats_list


UpperCamelCase_						   =   get_tests_dir('fixtures/test_sentencepiece_bpe_char.model')





@require_torch
class 							snake_case       (     unittest.TestCase		):







   def    UpperCAmelCase__	( self)   ->Tuple:
      a_						   =     tempfile.mkdtemp()

      a_						   =     SpeechTaTokenizer(__UpperCAmelCase)
      tokenizer.save_pretrained(self.tmpdirname)

      a_						   =     {
          "feature_size": 1,
          "padding_value": 0.0,
          "sampling_rate": 1_60_00,
          "do_normalize": False,
          "num_mel_bins": 80,
          "hop_length": 16,
          "win_length": 64,
          "win_function": "hann_window",
          "fmin": 80,
          "fmax": 76_00,
          "mel_floor": 1E-10,
          "reduction_factor": 2,
          "return_attention_mask": True,
      }

      a_						   =     os.path.join(self.tmpdirname       ,							__UpperCAmelCase)
      with open(self.feature_extraction_file       ,							"w"       ,							encoding="utf-8") as fp:
         fp.write(json.dumps(__UpperCAmelCase) + "\n")







   def    UpperCAmelCase__	( self       ,							**__UpperCAmelCase)   ->Dict:
      return SpeechTaTokenizer.from_pretrained(self.tmpdirname       ,							**__UpperCAmelCase)







   def    UpperCAmelCase__	( self       ,							**__UpperCAmelCase)   ->Dict:
      return SpeechTaFeatureExtractor.from_pretrained(self.tmpdirname       ,							**__UpperCAmelCase)







   def    UpperCAmelCase__	( self)   ->Tuple:
      shutil.rmtree(self.tmpdirname)







   def    UpperCAmelCase__	( self)   ->Tuple:
      a_						   =     self.get_tokenizer()
      a_						   =     self.get_feature_extractor()

      a_						   =     SpeechTaProcessor(tokenizer=__UpperCAmelCase       ,							feature_extractor=__UpperCAmelCase)

      processor.save_pretrained(self.tmpdirname)
      a_						   =     SpeechTaProcessor.from_pretrained(self.tmpdirname)

      self.assertEqual(processor.tokenizer.get_vocab()       ,							tokenizer.get_vocab())
      self.assertIsInstance(processor.tokenizer       ,							__UpperCAmelCase)

      self.assertEqual(processor.feature_extractor.to_json_string()       ,							feature_extractor.to_json_string())
      self.assertIsInstance(processor.feature_extractor       ,							__UpperCAmelCase)







   def    UpperCAmelCase__	( self)   ->str:
      a_						   =     SpeechTaProcessor(tokenizer=self.get_tokenizer()       ,							feature_extractor=self.get_feature_extractor())
      processor.save_pretrained(self.tmpdirname)

      a_						   =     self.get_tokenizer(bos_token="(BOS)"       ,							eos_token="(EOS)")
      a_						   =     self.get_feature_extractor(do_normalize=__UpperCAmelCase       ,							padding_value=1.0)

      a_						   =     SpeechTaProcessor.from_pretrained(
          self.tmpdirname       ,							bos_token="(BOS)"       ,							eos_token="(EOS)"       ,							do_normalize=__UpperCAmelCase       ,							padding_value=1.0)

      self.assertEqual(processor.tokenizer.get_vocab()       ,							tokenizer_add_kwargs.get_vocab())
      self.assertIsInstance(processor.tokenizer       ,							__UpperCAmelCase)

      self.assertEqual(processor.feature_extractor.to_json_string()       ,							feature_extractor_add_kwargs.to_json_string())
      self.assertIsInstance(processor.feature_extractor       ,							__UpperCAmelCase)







   def    UpperCAmelCase__	( self)   ->List[Any]:
      a_						   =     self.get_feature_extractor()
      a_						   =     self.get_tokenizer()

      a_						   =     SpeechTaProcessor(tokenizer=__UpperCAmelCase       ,							feature_extractor=__UpperCAmelCase)

      a_						   =     floats_list((3, 10_00))

      a_						   =     feature_extractor(audio=__UpperCAmelCase       ,							return_tensors="np")
      a_						   =     processor(audio=__UpperCAmelCase       ,							return_tensors="np")

      for key in input_feat_extract.keys():
         self.assertAlmostEqual(input_feat_extract[key].sum()       ,							input_processor[key].sum()       ,							delta=1E-2)







   def    UpperCAmelCase__	( self)   ->List[str]:
      a_						   =     self.get_feature_extractor()
      a_						   =     self.get_tokenizer()

      a_						   =     SpeechTaProcessor(tokenizer=__UpperCAmelCase       ,							feature_extractor=__UpperCAmelCase)

      a_						   =     floats_list((3, 10_00))

      a_						   =     feature_extractor(audio_target=__UpperCAmelCase       ,							return_tensors="np")
      a_						   =     processor(audio_target=__UpperCAmelCase       ,							return_tensors="np")

      for key in input_feat_extract.keys():
         self.assertAlmostEqual(input_feat_extract[key].sum()       ,							input_processor[key].sum()       ,							delta=1E-2)







   def    UpperCAmelCase__	( self)   ->Optional[int]:
      a_						   =     self.get_feature_extractor()
      a_						   =     self.get_tokenizer()

      a_						   =     SpeechTaProcessor(tokenizer=__UpperCAmelCase       ,							feature_extractor=__UpperCAmelCase)

      a_						   =     "This is a test string"

      a_						   =     processor(text=__UpperCAmelCase)
      a_						   =     tokenizer(__UpperCAmelCase)

      for key in encoded_tok.keys():
         self.assertListEqual(encoded_tok[key]       ,							encoded_processor[key])







   def    UpperCAmelCase__	( self)   ->Optional[int]:
      a_						   =     self.get_feature_extractor()
      a_						   =     self.get_tokenizer()

      a_						   =     SpeechTaProcessor(tokenizer=__UpperCAmelCase       ,							feature_extractor=__UpperCAmelCase)

      a_						   =     "This is a test string"

      a_						   =     processor(text_target=__UpperCAmelCase)
      a_						   =     tokenizer(__UpperCAmelCase)

      for key in encoded_tok.keys():
         self.assertListEqual(encoded_tok[key]       ,							encoded_processor[key])







   def    UpperCAmelCase__	( self)   ->str:
      a_						   =     self.get_feature_extractor()
      a_						   =     self.get_tokenizer()

      a_						   =     SpeechTaProcessor(tokenizer=__UpperCAmelCase       ,							feature_extractor=__UpperCAmelCase)

      a_						   =     [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

      a_						   =     processor.batch_decode(__UpperCAmelCase)
      a_						   =     tokenizer.batch_decode(__UpperCAmelCase)

      self.assertListEqual(__UpperCAmelCase       ,							__UpperCAmelCase)







   def    UpperCAmelCase__	( self)   ->List[str]:
      a_						   =     self.get_feature_extractor()
      a_						   =     self.get_tokenizer()

      a_						   =     SpeechTaProcessor(tokenizer=__UpperCAmelCase       ,							feature_extractor=__UpperCAmelCase)

      self.assertListEqual(
          processor.model_input_names       ,							feature_extractor.model_input_names       ,							msg="`processor` and `feature_extractor` model input names do not match"       ,							)

"""simple docstring"""






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


UpperCamelCase_						   =   {
    'configuration_sam': [
        'SAM_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'SamConfig',
        'SamMaskDecoderConfig',
        'SamPromptEncoderConfig',
        'SamVisionConfig',
    ],
    'processing_sam': ['SamProcessor'],
}


try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCamelCase_						   =   [
          'SAM_PRETRAINED_MODEL_ARCHIVE_LIST',
          'SamModel',
          'SamPreTrainedModel',
      ]
try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCamelCase_						   =   [
          'TF_SAM_PRETRAINED_MODEL_ARCHIVE_LIST',
          'TFSamModel',
          'TFSamPreTrainedModel',
      ]
try:
      if not is_vision_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      UpperCamelCase_						   =   ['SamImageProcessor']


if TYPE_CHECKING:
      from .configuration_sam import (
          SAM_PRETRAINED_CONFIG_ARCHIVE_MAP,
          SamConfig,
          SamMaskDecoderConfig,
          SamPromptEncoderConfig,
          SamVisionConfig,
      )
      from .processing_sam import SamProcessor

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_sam import SAM_PRETRAINED_MODEL_ARCHIVE_LIST, SamModel, SamPreTrainedModel

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_sam import TF_SAM_PRETRAINED_MODEL_ARCHIVE_LIST, TFSamModel, TFSamPreTrainedModel

      try:
            if not is_vision_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .image_processing_sam import SamImageProcessor

else:
      import sys

      UpperCamelCase_						   =   _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)