






'''simple docstring'''





from dataclasses import dataclass
from enum import Enum
from typing import List, Optional, Union

import numpy as np
import PIL
from PIL import Image

from ...utils import BaseOutput, is_torch_available, is_transformers_available

@dataclass
class 					snake_case_							(       _a      ):







   """simple docstring"""



   __lowerCAmelCase      =						{
       'sld_warmup_steps': 15,
       'sld_guidance_scale': 20,
       'sld_threshold': 0.0,
       'sld_momentum_scale': 0.0,
       'sld_mom_beta': 0.0,
   }
   __lowerCAmelCase      =						{
       'sld_warmup_steps': 10,
       'sld_guidance_scale': 10_00,
       'sld_threshold': 0.01,
       'sld_momentum_scale': 0.3,
       'sld_mom_beta': 0.4,
   }
   __lowerCAmelCase      =						{
       'sld_warmup_steps': 7,
       'sld_guidance_scale': 20_00,
       'sld_threshold': 0.025,
       'sld_momentum_scale': 0.5,
       'sld_mom_beta': 0.7,
   }
   __lowerCAmelCase      =						{
       'sld_warmup_steps': 0,
       'sld_guidance_scale': 50_00,
       'sld_threshold': 1.0,
       'sld_momentum_scale': 0.5,
       'sld_mom_beta': 0.7,
   }






@dataclass
class 					snake_case_							(       _a      ):







   """simple docstring"""



   __lowerCAmelCase      =						42
   __lowerCAmelCase      =						42
   __lowerCAmelCase      =						42
   __lowerCAmelCase      =						42


if is_transformers_available() and is_torch_available():
   from .pipeline_stable_diffusion_safe import StableDiffusionPipelineSafe
   from .safety_checker import SafeStableDiffusionSafetyChecker








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


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

@require_torch
class 					snake_case_							(       unittest.TestCase      ):







   """simple docstring"""



   def 			SCREAMING_SNAKE_CASE__				(    self:	List[str]	)  ->		Union[str, Any]:


       """simple docstring"""



       _lowercase     =	tempfile.mkdtemp()

       _lowercase     =	SpeechTaTokenizer(snake_case__	)
       tokenizer.save_pretrained(self.tmpdirname	)

       _lowercase     =	{
           'feature_size': 1,
           'padding_value': 0.0,
           'sampling_rate': 16_000,
           'do_normalize': False,
           'num_mel_bins': 80,
           'hop_length': 16,
           'win_length': 64,
           'win_function': 'hann_window',
           'fmin': 80,
           'fmax': 7_600,
           'mel_floor': 1E-10,
           'reduction_factor': 2,
           'return_attention_mask': True,
       }

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

   def 			SCREAMING_SNAKE_CASE__				(    self:	Union[str, Any]   ,       **snake_case__:	Union[str, Any]	)  ->		Union[str, Any]:


       """simple docstring"""



       return SpeechTaTokenizer.from_pretrained(self.tmpdirname   ,       **snake_case__	)

   def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[int]   ,       **snake_case__:	str	)  ->		int:


       """simple docstring"""



       return SpeechTaFeatureExtractor.from_pretrained(self.tmpdirname   ,       **snake_case__	)

   def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[Any]	)  ->		Optional[int]:


       """simple docstring"""



       shutil.rmtree(self.tmpdirname	)

   def 			SCREAMING_SNAKE_CASE__				(    self:	int	)  ->		List[str]:


       """simple docstring"""



       _lowercase     =	self.get_tokenizer()
       _lowercase     =	self.get_feature_extractor()

       _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)

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

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

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

   def 			SCREAMING_SNAKE_CASE__				(    self:	int	)  ->		Any:


       """simple docstring"""



       _lowercase     =	SpeechTaProcessor(tokenizer=self.get_tokenizer()   ,       feature_extractor=self.get_feature_extractor()	)
       processor.save_pretrained(self.tmpdirname	)

       _lowercase     =	self.get_tokenizer(bos_token='(BOS)'   ,       eos_token='(EOS)'	)
       _lowercase     =	self.get_feature_extractor(do_normalize=snake_case__   ,       padding_value=1.0	)

       _lowercase     =	SpeechTaProcessor.from_pretrained(
           self.tmpdirname   ,       bos_token='(BOS)'   ,       eos_token='(EOS)'   ,       do_normalize=snake_case__   ,       padding_value=1.0	)

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

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

   def 			SCREAMING_SNAKE_CASE__				(    self:	Union[str, Any]	)  ->		int:


       """simple docstring"""



       _lowercase     =	self.get_feature_extractor()
       _lowercase     =	self.get_tokenizer()

       _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)

       _lowercase     =	floats_list((3, 1_000)	)

       _lowercase     =	feature_extractor(audio=snake_case__   ,       return_tensors='np'	)
       _lowercase     =	processor(audio=snake_case__   ,       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 			SCREAMING_SNAKE_CASE__				(    self:	Tuple	)  ->		List[str]:


       """simple docstring"""



       _lowercase     =	self.get_feature_extractor()
       _lowercase     =	self.get_tokenizer()

       _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)

       _lowercase     =	floats_list((3, 1_000)	)

       _lowercase     =	feature_extractor(audio_target=snake_case__   ,       return_tensors='np'	)
       _lowercase     =	processor(audio_target=snake_case__   ,       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 			SCREAMING_SNAKE_CASE__				(    self:	Dict	)  ->		Dict:


       """simple docstring"""



       _lowercase     =	self.get_feature_extractor()
       _lowercase     =	self.get_tokenizer()

       _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)

       _lowercase     =	'This is a test string'

       _lowercase     =	processor(text=snake_case__	)
       _lowercase     =	tokenizer(snake_case__	)

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

   def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[int]	)  ->		int:


       """simple docstring"""



       _lowercase     =	self.get_feature_extractor()
       _lowercase     =	self.get_tokenizer()

       _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)

       _lowercase     =	'This is a test string'

       _lowercase     =	processor(text_target=snake_case__	)
       _lowercase     =	tokenizer(snake_case__	)

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

   def 			SCREAMING_SNAKE_CASE__				(    self:	Dict	)  ->		int:


       """simple docstring"""



       _lowercase     =	self.get_feature_extractor()
       _lowercase     =	self.get_tokenizer()

       _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)

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

       _lowercase     =	processor.batch_decode(snake_case__	)
       _lowercase     =	tokenizer.batch_decode(snake_case__	)

       self.assertListEqual(snake_case__   ,       snake_case__	)

   def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[Any]	)  ->		List[Any]:


       """simple docstring"""



       _lowercase     =	self.get_feature_extractor()
       _lowercase     =	self.get_tokenizer()

       _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)

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