

'''simple docstring'''


import json
import os
import shutil
import tempfile
import unittest
from multiprocessing import get_context
from pathlib import Path

import datasets
import numpy as np
from datasets import load_dataset
from parameterized import parameterized

from transformers import AutoProcessor
from transformers.models.wavaveca import WavaVecaCTCTokenizer, WavaVecaFeatureExtractor
from transformers.models.wavaveca.tokenization_wavaveca import VOCAB_FILES_NAMES
from transformers.testing_utils import require_pyctcdecode, require_torch, require_torchaudio, slow
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_pyctcdecode_available, is_torch_available

from ..wavaveca.test_feature_extraction_wavaveca import floats_list


if is_pyctcdecode_available():
					from huggingface_hub import snapshot_download
					from pyctcdecode import BeamSearchDecoderCTC

					from transformers.models.wavaveca_with_lm import WavaVecaProcessorWithLM
					from transformers.models.wavaveca_with_lm.processing_wavaveca_with_lm import WavaVecaDecoderWithLMOutput

if is_torch_available():
					from transformers import WavaVecaForCTC




@require_pyctcdecode
class     a			(				unittest.TestCase       ):






						"""simple docstring"""




						def       __magic_name__							(							self					:      Optional[Any]  ):



								'''simple docstring'''



								snake_case__						:       Any       						=  '''| <pad> <unk> <s> </s> a b c d e f g h i j k'''.split()
								snake_case__						:       List[Any]       						=  dict(zip(snake_case_			,			range(len(snake_case_  )  )  )  )

								snake_case__						:       Union[str, Any]       						=  {
								    '''unk_token''': '''<unk>''',
								    '''bos_token''': '''<s>''',
								    '''eos_token''': '''</s>''',
								}
								snake_case__						:       Optional[Any]       						=  {
								    '''feature_size''': 1,
								    '''padding_value''': 0.0,
								    '''sampling_rate''': 1_6_0_0_0,
								    '''return_attention_mask''': False,
								    '''do_normalize''': True,
								}

								snake_case__						:       Union[str, Any]       						=  tempfile.mkdtemp()
								snake_case__						:       List[str]       						=  os.path.join(self.tmpdirname			,			VOCAB_FILES_NAMES['''vocab_file''']  )
								snake_case__						:       Optional[Any]       						=  os.path.join(self.tmpdirname			,			snake_case_  )
								with open(self.vocab_file			,			'''w'''			,			encoding='''utf-8'''  ) as fp:
										fp.write(json.dumps(snake_case_  ) + '''\n'''  )

								with open(self.feature_extraction_file			,			'''w'''			,			encoding='''utf-8'''  ) as fp:
										fp.write(json.dumps(snake_case_  ) + '''\n'''  )

								# load decoder from hub
								snake_case__						:       List[str]       						=  '''hf-internal-testing/ngram-beam-search-decoder'''







						def       __magic_name__							(							self					:      List[str]			,			**snake_case_					:      str  ):



								'''simple docstring'''



								snake_case__						:       Optional[int]       						=  self.add_kwargs_tokens_map.copy()
								kwargs.update(snake_case_  )
								return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname			,			**snake_case_  )







						def       __magic_name__							(							self					:      Dict			,			**snake_case_					:      int  ):



								'''simple docstring'''



								return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname			,			**snake_case_  )







						def       __magic_name__							(							self					:      Any			,			**snake_case_					:      Union[str, Any]  ):



								'''simple docstring'''



								return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name			,			**snake_case_  )







						def       __magic_name__							(							self					:      Dict  ):



								'''simple docstring'''



								shutil.rmtree(self.tmpdirname  )







						def       __magic_name__							(							self					:      List[str]  ):



								'''simple docstring'''



								snake_case__						:       Optional[Any]       						=  self.get_tokenizer()
								snake_case__						:       int       						=  self.get_feature_extractor()
								snake_case__						:       List[Any]       						=  self.get_decoder()

								snake_case__						:       Optional[int]       						=  WavaVecaProcessorWithLM(tokenizer=snake_case_			,			feature_extractor=snake_case_			,			decoder=snake_case_  )

								processor.save_pretrained(self.tmpdirname  )
								snake_case__						:       int       						=  WavaVecaProcessorWithLM.from_pretrained(self.tmpdirname  )

								# tokenizer
								self.assertEqual(processor.tokenizer.get_vocab()			,			tokenizer.get_vocab()  )
								self.assertIsInstance(processor.tokenizer			,			snake_case_  )

								# feature extractor
								self.assertEqual(processor.feature_extractor.to_json_string()			,			feature_extractor.to_json_string()  )
								self.assertIsInstance(processor.feature_extractor			,			snake_case_  )

								# decoder
								self.assertEqual(processor.decoder._alphabet.labels			,			decoder._alphabet.labels  )
								self.assertEqual(
								    processor.decoder.model_container[decoder._model_key]._unigram_set			,			decoder.model_container[decoder._model_key]._unigram_set			,			)
								self.assertIsInstance(processor.decoder			,			snake_case_  )







						def       __magic_name__							(							self					:      Union[str, Any]  ):



								'''simple docstring'''



								snake_case__						:       Optional[Any]       						=  WavaVecaProcessorWithLM(
								    tokenizer=self.get_tokenizer()			,			feature_extractor=self.get_feature_extractor()			,			decoder=self.get_decoder()  )
								processor.save_pretrained(self.tmpdirname  )

								# make sure that error is thrown when decoder alphabet doesn't match
								snake_case__						:       List[str]       						=  WavaVecaProcessorWithLM.from_pretrained(
								    self.tmpdirname			,			alpha=5.0			,			beta=3.0			,			score_boundary=-7.0			,			unk_score_offset=3  )

								# decoder
								self.assertEqual(processor.language_model.alpha			,			5.0  )
								self.assertEqual(processor.language_model.beta			,			3.0  )
								self.assertEqual(processor.language_model.score_boundary			,			-7.0  )
								self.assertEqual(processor.language_model.unk_score_offset			,			3  )







						def       __magic_name__							(							self					:      Dict  ):



								'''simple docstring'''



								snake_case__						:       Any       						=  self.get_tokenizer()
								# add token to trigger raise
								tokenizer.add_tokens(['''xx''']  )
								with self.assertRaisesRegex(snake_case_			,			'''include'''  ):
										WavaVecaProcessorWithLM(
										    tokenizer=snake_case_			,			feature_extractor=self.get_feature_extractor()			,			decoder=self.get_decoder()  )







						def       __magic_name__							(							self					:      Tuple  ):



								'''simple docstring'''



								snake_case__						:       Optional[int]       						=  self.get_feature_extractor()
								snake_case__						:       List[str]       						=  self.get_tokenizer()
								snake_case__						:       str       						=  self.get_decoder()

								snake_case__						:       Any       						=  WavaVecaProcessorWithLM(tokenizer=snake_case_			,			feature_extractor=snake_case_			,			decoder=snake_case_  )

								snake_case__						:       Dict       						=  floats_list((3, 1_0_0_0)  )

								snake_case__						:       List[Any]       						=  feature_extractor(snake_case_			,			return_tensors='''np'''  )
								snake_case__						:       Union[str, Any]       						=  processor(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       __magic_name__							(							self					:      List[Any]  ):



								'''simple docstring'''



								snake_case__						:       Optional[Any]       						=  self.get_feature_extractor()
								snake_case__						:       Optional[Any]       						=  self.get_tokenizer()
								snake_case__						:       int       						=  self.get_decoder()

								snake_case__						:       Optional[int]       						=  WavaVecaProcessorWithLM(tokenizer=snake_case_			,			feature_extractor=snake_case_			,			decoder=snake_case_  )

								snake_case__						:       Any       						=  '''This is a test string'''

								snake_case__						:       List[Any]       						=  processor(text=snake_case_  )

								snake_case__						:       str       						=  tokenizer(snake_case_  )

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







						def       __magic_name__							(							self					:      Union[str, Any]			,			snake_case_					:      Dict=(2, 1_0, 1_6)			,			snake_case_					:      int=7_7  ):



								'''simple docstring'''



								np.random.seed(snake_case_  )
								return np.random.rand(*snake_case_  )







						def       __magic_name__							(							self					:      Union[str, Any]  ):



								'''simple docstring'''



								snake_case__						:       int       						=  self.get_feature_extractor()
								snake_case__						:       Union[str, Any]       						=  self.get_tokenizer()
								snake_case__						:       List[str]       						=  self.get_decoder()

								snake_case__						:       List[Any]       						=  WavaVecaProcessorWithLM(tokenizer=snake_case_			,			feature_extractor=snake_case_			,			decoder=snake_case_  )

								snake_case__						:       int       						=  self._get_dummy_logits(shape=(1_0, 1_6)			,			seed=1_3  )

								snake_case__						:       Any       						=  processor.decode(snake_case_  )

								snake_case__						:       List[str]       						=  decoder.decode_beams(snake_case_  )[0]

								self.assertEqual(decoded_decoder[0]			,			decoded_processor.text  )
								self.assertEqual('''</s> <s> </s>'''			,			decoded_processor.text  )
								self.assertEqual(decoded_decoder[-2]			,			decoded_processor.logit_score  )
								self.assertEqual(decoded_decoder[-1]			,			decoded_processor.lm_score  )







						@parameterized.expand([[None], ['''fork'''], ['''spawn''']]  )
						def       __magic_name__							(							self					:      str			,			snake_case_					:      str  ):



								'''simple docstring'''



								snake_case__						:       List[Any]       						=  self.get_feature_extractor()
								snake_case__						:       Union[str, Any]       						=  self.get_tokenizer()
								snake_case__						:       List[str]       						=  self.get_decoder()

								snake_case__						:       List[Any]       						=  WavaVecaProcessorWithLM(tokenizer=snake_case_			,			feature_extractor=snake_case_			,			decoder=snake_case_  )

								snake_case__						:       Dict       						=  self._get_dummy_logits()

								# note: pool should be instantiated *after* Wav2Vec2ProcessorWithLM.
								#       otherwise, the LM won't be available to the pool's sub-processes.
								# manual logic used to allow parameterized test for both pool=None and pool=Pool(...)
								if pool_context is None:
										snake_case__						:       List[str]       						=  processor.batch_decode(snake_case_  )
								else:
										with get_context(snake_case_  ).Pool() as pool:
												snake_case__						:       Optional[Any]       						=  processor.batch_decode(snake_case_			,			snake_case_  )

								snake_case__						:       List[Any]       						=  list(snake_case_  )

								with get_context('''fork'''  ).Pool() as p:
										snake_case__						:       Tuple       						=  decoder.decode_beams_batch(snake_case_			,			snake_case_  )

								snake_case__						,       snake_case__						,       snake_case__						:       Dict       						=  [], [], []
								for beams in decoded_beams:
										texts_decoder.append(beams[0][0]  )
										logit_scores_decoder.append(beams[0][-2]  )
										lm_scores_decoder.append(beams[0][-1]  )

								self.assertListEqual(snake_case_			,			decoded_processor.text  )
								self.assertListEqual(['''<s> <s> </s>''', '''<s> <s> <s>''']			,			decoded_processor.text  )
								self.assertListEqual(snake_case_			,			decoded_processor.logit_score  )
								self.assertListEqual(snake_case_			,			decoded_processor.lm_score  )







						def       __magic_name__							(							self					:      Optional[int]  ):



								'''simple docstring'''



								snake_case__						:       str       						=  self.get_feature_extractor()
								snake_case__						:       List[str]       						=  self.get_tokenizer()
								snake_case__						:       int       						=  self.get_decoder()

								snake_case__						:       Dict       						=  WavaVecaProcessorWithLM(tokenizer=snake_case_			,			feature_extractor=snake_case_			,			decoder=snake_case_  )

								snake_case__						:       Dict       						=  self._get_dummy_logits()

								snake_case__						:       Tuple       						=  1_5
								snake_case__						:       Dict       						=  -2_0.0
								snake_case__						:       str       						=  -4.0

								snake_case__						:       List[Any]       						=  processor.batch_decode(
								    snake_case_			,			beam_width=snake_case_			,			beam_prune_logp=snake_case_			,			token_min_logp=snake_case_			,			)
								snake_case__						:       str       						=  decoded_processor_out.text

								snake_case__						:       Optional[Any]       						=  list(snake_case_  )

								with get_context('''fork'''  ).Pool() as pool:
										snake_case__						:       str       						=  decoder.decode_beams_batch(
										    snake_case_			,			snake_case_			,			beam_width=snake_case_			,			beam_prune_logp=snake_case_			,			token_min_logp=snake_case_			,			)

								snake_case__						:       str       						=  [d[0][0] for d in decoded_decoder_out]
								snake_case__						:       str       						=  [d[0][2] for d in decoded_decoder_out]
								snake_case__						:       Union[str, Any]       						=  [d[0][3] for d in decoded_decoder_out]

								self.assertListEqual(snake_case_			,			snake_case_  )
								self.assertListEqual(['''</s> <s> <s>''', '''<s> <s> <s>''']			,			snake_case_  )

								self.assertTrue(np.array_equal(snake_case_			,			decoded_processor_out.logit_score  )  )
								self.assertTrue(np.allclose([-2_0.0_5_4, -1_8.4_4_7]			,			snake_case_			,			atol=1e-3  )  )

								self.assertTrue(np.array_equal(snake_case_			,			decoded_processor_out.lm_score  )  )
								self.assertTrue(np.allclose([-1_5.5_5_4, -1_3.9_4_7_4]			,			snake_case_			,			atol=1e-3  )  )







						def       __magic_name__							(							self					:      Optional[Any]  ):



								'''simple docstring'''



								snake_case__						:       int       						=  self.get_feature_extractor()
								snake_case__						:       List[str]       						=  self.get_tokenizer()
								snake_case__						:       int       						=  self.get_decoder()

								snake_case__						:       Optional[int]       						=  WavaVecaProcessorWithLM(tokenizer=snake_case_			,			feature_extractor=snake_case_			,			decoder=snake_case_  )

								snake_case__						:       Optional[Any]       						=  self._get_dummy_logits()

								snake_case__						:       Tuple       						=  2.0
								snake_case__						:       Tuple       						=  5.0
								snake_case__						:       Optional[Any]       						=  -2_0.0
								snake_case__						:       Union[str, Any]       						=  True

								snake_case__						:       Optional[int]       						=  processor.batch_decode(
								    snake_case_			,			alpha=snake_case_			,			beta=snake_case_			,			unk_score_offset=snake_case_			,			lm_score_boundary=snake_case_			,			)
								snake_case__						:       Union[str, Any]       						=  decoded_processor_out.text

								snake_case__						:       List[Any]       						=  list(snake_case_  )
								decoder.reset_params(
								    alpha=snake_case_			,			beta=snake_case_			,			unk_score_offset=snake_case_			,			lm_score_boundary=snake_case_			,			)

								with get_context('''fork'''  ).Pool() as pool:
										snake_case__						:       Any       						=  decoder.decode_beams_batch(
										    snake_case_			,			snake_case_			,			)

								snake_case__						:       Optional[Any]       						=  [d[0][0] for d in decoded_decoder_out]

								self.assertListEqual(snake_case_			,			snake_case_  )
								self.assertListEqual(['''<s> </s> <s> </s> </s>''', '''</s> </s> <s> </s> </s>''']			,			snake_case_  )
								snake_case__						:       List[str]       						=  processor.decoder.model_container[processor.decoder._model_key]
								self.assertEqual(lm_model.alpha			,			2.0  )
								self.assertEqual(lm_model.beta			,			5.0  )
								self.assertEqual(lm_model.unk_score_offset			,			-2_0.0  )
								self.assertEqual(lm_model.score_boundary			,			snake_case_  )







						def       __magic_name__							(							self					:      Any  ):



								'''simple docstring'''



								snake_case__						:       List[Any]       						=  WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''  )

								snake_case__						:       Dict       						=  processor.decoder.model_container[processor.decoder._model_key]
								snake_case__						:       str       						=  Path(language_model._kenlm_model.path.decode('''utf-8'''  )  ).parent.parent.absolute()

								snake_case__						:       Optional[Any]       						=  os.listdir(snake_case_  )
								snake_case__						:       List[Any]       						=  ['''alphabet.json''', '''language_model''']

								downloaded_decoder_files.sort()
								expected_decoder_files.sort()

								# test that only decoder relevant files from
								# https://huggingface.co/hf-internal-testing/processor_with_lm/tree/main
								# are downloaded and none of the rest (e.g. README.md, ...)
								self.assertListEqual(snake_case_			,			snake_case_  )







						def       __magic_name__							(							self					:      List[Any]  ):



								'''simple docstring'''



								snake_case__						:       List[Any]       						=  snapshot_download('''hf-internal-testing/processor_with_lm'''  )

								snake_case__						:       Union[str, Any]       						=  WavaVecaProcessorWithLM.from_pretrained(snake_case_  )

								snake_case__						:       List[Any]       						=  processor.decoder.model_container[processor.decoder._model_key]
								snake_case__						:       Union[str, Any]       						=  Path(language_model._kenlm_model.path.decode('''utf-8'''  )  ).parent.parent.absolute()

								snake_case__						:       List[Any]       						=  os.listdir(snake_case_  )
								snake_case__						:       Tuple       						=  os.listdir(snake_case_  )

								local_decoder_files.sort()
								expected_decoder_files.sort()

								# test that both decoder form hub and local files in cache are the same
								self.assertListEqual(snake_case_			,			snake_case_  )







						def       __magic_name__							(							self					:      List[Any]  ):



								'''simple docstring'''



								snake_case__						:       int       						=  WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''  )
								snake_case__						:       str       						=  AutoProcessor.from_pretrained('''hf-internal-testing/processor_with_lm'''  )

								snake_case__						:       Any       						=  floats_list((3, 1_0_0_0)  )

								snake_case__						:       str       						=  processor_wavaveca(snake_case_			,			return_tensors='''np'''  )
								snake_case__						:       List[Any]       						=  processor_auto(snake_case_			,			return_tensors='''np'''  )

								for key in input_wavaveca.keys():
										self.assertAlmostEqual(input_wavaveca[key].sum()			,			input_auto[key].sum()			,			delta=1e-2  )

								snake_case__						:       Union[str, Any]       						=  self._get_dummy_logits()

								snake_case__						:       Optional[Any]       						=  processor_wavaveca.batch_decode(snake_case_  )
								snake_case__						:       List[Any]       						=  processor_auto.batch_decode(snake_case_  )

								self.assertListEqual(decoded_wavaveca.text			,			decoded_auto.text  )







						def       __magic_name__							(							self					:      Optional[Any]  ):



								'''simple docstring'''



								snake_case__						:       List[str]       						=  self.get_feature_extractor()
								snake_case__						:       Dict       						=  self.get_tokenizer()
								snake_case__						:       Tuple       						=  self.get_decoder()

								snake_case__						:       Any       						=  WavaVecaProcessorWithLM(tokenizer=snake_case_			,			feature_extractor=snake_case_			,			decoder=snake_case_  )

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







						@staticmethod
						def       __magic_name__							(							snake_case_					:      Dict			,			snake_case_					:      Union[str, Any]  ):



								'''simple docstring'''



								snake_case__						:       Union[str, Any]       						=  [d[key] for d in offsets]
								return retrieved_list







						def       __magic_name__							(							self					:      Dict  ):



								'''simple docstring'''



								snake_case__						:       List[Any]       						=  WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''  )
								snake_case__						:       Dict       						=  self._get_dummy_logits()[0]

								snake_case__						:       List[Any]       						=  processor.decode(snake_case_			,			output_word_offsets=snake_case_  )
								# check Wav2Vec2CTCTokenizerOutput keys for word
								self.assertEqual(len(outputs.keys()  )			,			4  )
								self.assertTrue('''text''' in outputs  )
								self.assertTrue('''word_offsets''' in outputs  )
								self.assertTrue(isinstance(snake_case_			,			snake_case_  )  )

								self.assertEqual(''' '''.join(self.get_from_offsets(outputs['''word_offsets''']			,			'''word'''  )  )			,			outputs.text  )
								self.assertListEqual(self.get_from_offsets(outputs['''word_offsets''']			,			'''word'''  )			,			['''<s>''', '''<s>''', '''</s>''']  )
								self.assertListEqual(self.get_from_offsets(outputs['''word_offsets''']			,			'''start_offset'''  )			,			[0, 2, 4]  )
								self.assertListEqual(self.get_from_offsets(outputs['''word_offsets''']			,			'''end_offset'''  )			,			[1, 3, 5]  )







						def       __magic_name__							(							self					:      Optional[Any]  ):



								'''simple docstring'''



								snake_case__						:       Union[str, Any]       						=  WavaVecaProcessorWithLM.from_pretrained('''hf-internal-testing/processor_with_lm'''  )
								snake_case__						:       Dict       						=  self._get_dummy_logits()

								snake_case__						:       Any       						=  processor.batch_decode(snake_case_			,			output_word_offsets=snake_case_  )

								# check Wav2Vec2CTCTokenizerOutput keys for word
								self.assertEqual(len(outputs.keys()  )			,			4  )
								self.assertTrue('''text''' in outputs  )
								self.assertTrue('''word_offsets''' in outputs  )
								self.assertTrue(isinstance(snake_case_			,			snake_case_  )  )

								self.assertListEqual(
								    [''' '''.join(self.get_from_offsets(snake_case_			,			'''word'''  )  ) for o in outputs['''word_offsets''']]			,			outputs.text  )
								self.assertListEqual(self.get_from_offsets(outputs['''word_offsets'''][0]			,			'''word'''  )			,			['''<s>''', '''<s>''', '''</s>''']  )
								self.assertListEqual(self.get_from_offsets(outputs['''word_offsets'''][0]			,			'''start_offset'''  )			,			[0, 2, 4]  )
								self.assertListEqual(self.get_from_offsets(outputs['''word_offsets'''][0]			,			'''end_offset'''  )			,			[1, 3, 5]  )







						@slow
						@require_torch
						@require_torchaudio
						def       __magic_name__							(							self					:      str  ):



								'''simple docstring'''



								import torch

								snake_case__						:       List[Any]       						=  load_dataset('''common_voice'''			,			'''en'''			,			split='''train'''			,			streaming=snake_case_  )
								snake_case__						:       Dict       						=  ds.cast_column('''audio'''			,			datasets.Audio(sampling_rate=1_6_0_0_0  )  )
								snake_case__						:       List[str]       						=  iter(snake_case_  )
								snake_case__						:       Tuple       						=  next(snake_case_  )

								snake_case__						:       Any       						=  AutoProcessor.from_pretrained('''patrickvonplaten/wav2vec2-base-100h-with-lm'''  )
								snake_case__						:       Any       						=  WavaVecaForCTC.from_pretrained('''patrickvonplaten/wav2vec2-base-100h-with-lm'''  )

								# compare to filename `common_voice_en_100038.mp3` of dataset viewer on https://huggingface.co/datasets/common_voice/viewer/en/train
								snake_case__						:       List[Any]       						=  processor(sample['''audio''']['''array''']			,			return_tensors='''pt'''  ).input_values

								with torch.no_grad():
										snake_case__						:       int       						=  model(snake_case_  ).logits.cpu().numpy()

								snake_case__						:       str       						=  processor.decode(logits[0]			,			output_word_offsets=snake_case_  )

								snake_case__						:       Dict       						=  model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate
								snake_case__						:       Tuple       						=  [
								    {
								        '''start_time''': d['''start_offset'''] * time_offset,
								        '''end_time''': d['''end_offset'''] * time_offset,
								        '''word''': d['''word'''],
								    }
								    for d in output['''word_offsets''']
								]

								snake_case__						:       Dict       						=  '''WHY DOES MILISANDRA LOOK LIKE SHE WANTS TO CONSUME JOHN SNOW ON THE RIVER AT THE WALL'''

								# output words
								self.assertEqual(''' '''.join(self.get_from_offsets(snake_case_			,			'''word'''  )  )			,			snake_case_  )
								self.assertEqual(''' '''.join(self.get_from_offsets(snake_case_			,			'''word'''  )  )			,			output.text  )

								# output times
								snake_case__						:       int       						=  torch.tensor(self.get_from_offsets(snake_case_			,			'''start_time'''  )  )
								snake_case__						:       Tuple       						=  torch.tensor(self.get_from_offsets(snake_case_			,			'''end_time'''  )  )

								# fmt: off
								snake_case__						:       str       						=  torch.tensor([1.4_1_9_9, 1.6_5_9_9, 2.2_5_9_9, 3.0, 3.2_4, 3.5_9_9_9, 3.7_9_9_9, 4.0_9_9_9, 4.2_6, 4.9_4, 5.2_8, 5.6_5_9_9, 5.7_8, 5.9_4, 6.3_2, 6.5_3_9_9, 6.6_5_9_9]  )
								snake_case__						:       int       						=  torch.tensor([1.5_3_9_9, 1.8_9_9_9, 2.9, 3.1_6, 3.5_3_9_9, 3.7_2, 4.0_1_9_9, 4.1_7_9_9, 4.7_6, 5.1_5_9_9, 5.5_5_9_9, 5.6_9_9_9, 5.8_6, 6.1_9_9_9, 6.3_8, 6.6_1_9_9, 6.9_4]  )
								# fmt: on

								self.assertTrue(torch.allclose(snake_case_			,			snake_case_			,			atol=0.0_1  )  )
								self.assertTrue(torch.allclose(snake_case_			,			snake_case_			,			atol=0.0_1  )  )






'''simple docstring'''


import warnings

from diffusers import StableDiffusionImgaImgPipeline  # noqa F401


warnings.warn(
    """The `image_to_image.py` script is outdated. Please use directly `from diffusers import"""
    """ StableDiffusionImg2ImgPipeline` instead."""
)



