



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  lowerCamelCase__    (							unittest.TestCase):




		'''simple docstring'''



		def 	lowerCAmelCase__   (self				)  ->    Optional[Any]:

						"""simple docstring"""






						lowerCAmelCase__  :       Any				=  "| <pad> <unk> <s> </s> a b c d e f g h i j k".split()
						lowerCAmelCase__  :       Any				=  dict(zip(__a	,range(len(__a				)				)				)				)

						lowerCAmelCase__  :       Union[str, Any]				=  {
						    "unk_token": "<unk>",
						    "bos_token": "<s>",
						    "eos_token": "</s>",
						}
						lowerCAmelCase__  :       List[str]				=  {
						    "feature_size": 1,
						    "padding_value": 0.0,
						    "sampling_rate": 1_60_00,
						    "return_attention_mask": False,
						    "do_normalize": True,
						}

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

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

						# load decoder from hub
						lowerCAmelCase__  :       List[Any]				=  "hf-internal-testing/ngram-beam-search-decoder"



		def 	lowerCAmelCase__   (self	,**__lowerCamelCase				)  ->    int:

						"""simple docstring"""






						lowerCAmelCase__  :       Tuple				=  self.add_kwargs_tokens_map.copy()
						kwargs.update(__a				)
						return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname	,**__a				)



		def 	lowerCAmelCase__   (self	,**__lowerCamelCase				)  ->    int:

						"""simple docstring"""






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



		def 	lowerCAmelCase__   (self	,**__lowerCamelCase				)  ->    Tuple:

						"""simple docstring"""






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



		def 	lowerCAmelCase__   (self				)  ->    List[str]:

						"""simple docstring"""






						shutil.rmtree(self.tmpdirname				)



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

						"""simple docstring"""






						lowerCAmelCase__  :       List[Any]				=  self.get_tokenizer()
						lowerCAmelCase__  :       Dict				=  self.get_feature_extractor()
						lowerCAmelCase__  :       Dict				=  self.get_decoder()

						lowerCAmelCase__  :       int				=  WavaVecaProcessorWithLM(tokenizer=__a	,feature_extractor=__a	,decoder=__a				)

						processor.save_pretrained(self.tmpdirname				)
						lowerCAmelCase__  :       Optional[Any]				=  WavaVecaProcessorWithLM.from_pretrained(self.tmpdirname				)

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

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

						# 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	,__a				)



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

						"""simple docstring"""






						lowerCAmelCase__  :       List[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
						lowerCAmelCase__  :       Union[str, Any]				=  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 	lowerCAmelCase__   (self				)  ->    Union[str, Any]:

						"""simple docstring"""






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



		def 	lowerCAmelCase__   (self				)  ->    List[str]:

						"""simple docstring"""






						lowerCAmelCase__  :       Any				=  self.get_feature_extractor()
						lowerCAmelCase__  :       Dict				=  self.get_tokenizer()
						lowerCAmelCase__  :       str				=  self.get_decoder()

						lowerCAmelCase__  :       Tuple				=  WavaVecaProcessorWithLM(tokenizer=__a	,feature_extractor=__a	,decoder=__a				)

						lowerCAmelCase__  :       Union[str, Any]				=  floats_list((3, 10_00)				)

						lowerCAmelCase__  :       List[Any]				=  feature_extractor(__a	,return_tensors='''np'''				)
						lowerCAmelCase__  :       Optional[Any]				=  processor(__a	,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 	lowerCAmelCase__   (self				)  ->    int:

						"""simple docstring"""






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

						lowerCAmelCase__  :       Dict				=  WavaVecaProcessorWithLM(tokenizer=__a	,feature_extractor=__a	,decoder=__a				)

						lowerCAmelCase__  :       Optional[int]				=  "This is a test string"

						lowerCAmelCase__  :       Optional[int]				=  processor(text=__a				)

						lowerCAmelCase__  :       Any				=  tokenizer(__a				)

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



		def 	lowerCAmelCase__   (self	,__lowerCamelCase=(2, 10, 16)	,__lowerCamelCase=77				)  ->    List[Any]:

						"""simple docstring"""






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



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

						"""simple docstring"""






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

						lowerCAmelCase__  :       Optional[int]				=  WavaVecaProcessorWithLM(tokenizer=__a	,feature_extractor=__a	,decoder=__a				)

						lowerCAmelCase__  :       Union[str, Any]				=  self._get_dummy_logits(shape=(10, 16)	,seed=13				)

						lowerCAmelCase__  :       List[Any]				=  processor.decode(__a				)

						lowerCAmelCase__  :       str				=  decoder.decode_beams(__a				)[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 	lowerCAmelCase__   (self	,__lowerCamelCase				)  ->    Any:

						"""simple docstring"""






						lowerCAmelCase__  :       str				=  self.get_feature_extractor()
						lowerCAmelCase__  :       int				=  self.get_tokenizer()
						lowerCAmelCase__  :       str				=  self.get_decoder()

						lowerCAmelCase__  :       Dict				=  WavaVecaProcessorWithLM(tokenizer=__a	,feature_extractor=__a	,decoder=__a				)

						lowerCAmelCase__  :       Any				=  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:
										lowerCAmelCase__  :       List[str]				=  processor.batch_decode(__a				)
						else:
										with get_context(__a				).Pool() as pool:
														lowerCAmelCase__  :       List[str]				=  processor.batch_decode(__a	,__a				)

						lowerCAmelCase__  :       Any				=  list(__a				)

						with get_context('''fork'''				).Pool() as p:
										lowerCAmelCase__  :       Optional[int]				=  decoder.decode_beams_batch(__a	,__a				)

						lowerCAmelCase__  :       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(__a	,decoded_processor.text				)
						self.assertListEqual(['''<s> <s> </s>''', '''<s> <s> <s>''']	,decoded_processor.text				)
						self.assertListEqual(__a	,decoded_processor.logit_score				)
						self.assertListEqual(__a	,decoded_processor.lm_score				)



		def 	lowerCAmelCase__   (self				)  ->    int:

						"""simple docstring"""






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

						lowerCAmelCase__  :       Optional[int]				=  WavaVecaProcessorWithLM(tokenizer=__a	,feature_extractor=__a	,decoder=__a				)

						lowerCAmelCase__  :       int				=  self._get_dummy_logits()

						lowerCAmelCase__  :       Tuple				=  15
						lowerCAmelCase__  :       List[Any]				=  -20.0
						lowerCAmelCase__  :       int				=  -4.0

						lowerCAmelCase__  :       Union[str, Any]				=  processor.batch_decode(
						    __a	,beam_width=__a	,beam_prune_logp=__a	,token_min_logp=__a	,)
						lowerCAmelCase__  :       List[str]				=  decoded_processor_out.text

						lowerCAmelCase__  :       Optional[int]				=  list(__a				)

						with get_context('''fork'''				).Pool() as pool:
										lowerCAmelCase__  :       List[str]				=  decoder.decode_beams_batch(
										    __a	,__a	,beam_width=__a	,beam_prune_logp=__a	,token_min_logp=__a	,)

						lowerCAmelCase__  :       int				=  [d[0][0] for d in decoded_decoder_out]
						lowerCAmelCase__  :       List[Any]				=  [d[0][2] for d in decoded_decoder_out]
						lowerCAmelCase__  :       Optional[Any]				=  [d[0][3] for d in decoded_decoder_out]

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

						self.assertTrue(np.array_equal(__a	,decoded_processor_out.logit_score				)				)
						self.assertTrue(np.allclose([-20.054, -18.447]	,__a	,atol=1e-3				)				)

						self.assertTrue(np.array_equal(__a	,decoded_processor_out.lm_score				)				)
						self.assertTrue(np.allclose([-15.554, -13.9474]	,__a	,atol=1e-3				)				)



		def 	lowerCAmelCase__   (self				)  ->    Any:

						"""simple docstring"""






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

						lowerCAmelCase__  :       Dict				=  WavaVecaProcessorWithLM(tokenizer=__a	,feature_extractor=__a	,decoder=__a				)

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

						lowerCAmelCase__  :       Optional[Any]				=  2.0
						lowerCAmelCase__  :       Union[str, Any]				=  5.0
						lowerCAmelCase__  :       Tuple				=  -20.0
						lowerCAmelCase__  :       str				=  True

						lowerCAmelCase__  :       Any				=  processor.batch_decode(
						    __a	,alpha=__a	,beta=__a	,unk_score_offset=__a	,lm_score_boundary=__a	,)
						lowerCAmelCase__  :       str				=  decoded_processor_out.text

						lowerCAmelCase__  :       Union[str, Any]				=  list(__a				)
						decoder.reset_params(
						    alpha=__a	,beta=__a	,unk_score_offset=__a	,lm_score_boundary=__a	,)

						with get_context('''fork'''				).Pool() as pool:
										lowerCAmelCase__  :       List[str]				=  decoder.decode_beams_batch(
										    __a	,__a	,)

						lowerCAmelCase__  :       str				=  [d[0][0] for d in decoded_decoder_out]

						self.assertListEqual(__a	,__a				)
						self.assertListEqual(['''<s> </s> <s> </s> </s>''', '''</s> </s> <s> </s> </s>''']	,__a				)
						lowerCAmelCase__  :       Tuple				=  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	,-20.0				)
						self.assertEqual(lm_model.score_boundary	,__a				)



		def 	lowerCAmelCase__   (self				)  ->    Dict:

						"""simple docstring"""






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

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

						lowerCAmelCase__  :       Dict				=  os.listdir(__a				)
						lowerCAmelCase__  :       Dict				=  ["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(__a	,__a				)



		def 	lowerCAmelCase__   (self				)  ->    Optional[Any]:

						"""simple docstring"""






						lowerCAmelCase__  :       List[str]				=  snapshot_download('''hf-internal-testing/processor_with_lm'''				)

						lowerCAmelCase__  :       int				=  WavaVecaProcessorWithLM.from_pretrained(__a				)

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

						lowerCAmelCase__  :       Dict				=  os.listdir(__a				)
						lowerCAmelCase__  :       Optional[Any]				=  os.listdir(__a				)

						local_decoder_files.sort()
						expected_decoder_files.sort()

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



		def 	lowerCAmelCase__   (self				)  ->    List[str]:

						"""simple docstring"""






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

						lowerCAmelCase__  :       Dict				=  floats_list((3, 10_00)				)

						lowerCAmelCase__  :       Optional[Any]				=  processor_wavaveca(__a	,return_tensors='''np'''				)
						lowerCAmelCase__  :       Dict				=  processor_auto(__a	,return_tensors='''np'''				)

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

						lowerCAmelCase__  :       List[str]				=  self._get_dummy_logits()

						lowerCAmelCase__  :       str				=  processor_wavaveca.batch_decode(__a				)
						lowerCAmelCase__  :       str				=  processor_auto.batch_decode(__a				)

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



		def 	lowerCAmelCase__   (self				)  ->    Optional[Any]:

						"""simple docstring"""






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

						lowerCAmelCase__  :       Tuple				=  WavaVecaProcessorWithLM(tokenizer=__a	,feature_extractor=__a	,decoder=__a				)

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



		@staticmethod
		def 	lowerCAmelCase__   (__lowerCamelCase	,__lowerCamelCase				)  ->    int:

						"""simple docstring"""






						lowerCAmelCase__  :       Dict				=  [d[key] for d in offsets]
						return retrieved_list



		def 	lowerCAmelCase__   (self				)  ->    Optional[Any]:

						"""simple docstring"""






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

						lowerCAmelCase__  :       List[str]				=  processor.decode(__a	,output_word_offsets=__a				)
						# 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(__a	,__a				)				)

						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 	lowerCAmelCase__   (self				)  ->    Optional[Any]:

						"""simple docstring"""






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

						lowerCAmelCase__  :       str				=  processor.batch_decode(__a	,output_word_offsets=__a				)

						# 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(__a	,__a				)				)

						self.assertListEqual(
						    [''' '''.join(self.get_from_offsets(__a	,'''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 	lowerCAmelCase__   (self				)  ->    Union[str, Any]:

						"""simple docstring"""






						import torch

						lowerCAmelCase__  :       Optional[int]				=  load_dataset('''common_voice'''	,'''en'''	,split='''train'''	,streaming=__a				)
						lowerCAmelCase__  :       Optional[int]				=  ds.cast_column('''audio'''	,datasets.Audio(sampling_rate=1_60_00				)				)
						lowerCAmelCase__  :       Any				=  iter(__a				)
						lowerCAmelCase__  :       Union[str, Any]				=  next(__a				)

						lowerCAmelCase__  :       Optional[Any]				=  AutoProcessor.from_pretrained('''patrickvonplaten/wav2vec2-base-100h-with-lm'''				)
						lowerCAmelCase__  :       List[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
						lowerCAmelCase__  :       int				=  processor(sample['''audio''']['''array''']	,return_tensors='''pt'''				).input_values

						with torch.no_grad():
										lowerCAmelCase__  :       Optional[Any]				=  model(__a				).logits.cpu().numpy()

						lowerCAmelCase__  :       Dict				=  processor.decode(logits[0]	,output_word_offsets=__a				)

						lowerCAmelCase__  :       Any				=  model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate
						lowerCAmelCase__  :       str				=  [
						    {
						        "start_time": d["start_offset"] * time_offset,
						        "end_time": d["end_offset"] * time_offset,
						        "word": d["word"],
						    }
						    for d in output["word_offsets"]
						]

						lowerCAmelCase__  :       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(__a	,'''word'''				)				)	,__a				)
						self.assertEqual(''' '''.join(self.get_from_offsets(__a	,'''word'''				)				)	,output.text				)

						# output times
						lowerCAmelCase__  :       List[str]				=  torch.tensor(self.get_from_offsets(__a	,'''start_time'''				)				)
						lowerCAmelCase__  :       List[Any]				=  torch.tensor(self.get_from_offsets(__a	,'''end_time'''				)				)

						# fmt: off
						lowerCAmelCase__  :       List[Any]				=  torch.tensor([1.4199, 1.6599, 2.2599, 3.0, 3.24, 3.5999, 3.7999, 4.0999, 4.26, 4.94, 5.28, 5.6599, 5.78, 5.94, 6.32, 6.5399, 6.6599]				)
						lowerCAmelCase__  :       Tuple				=  torch.tensor([1.5399, 1.8999, 2.9, 3.16, 3.5399, 3.72, 4.0199, 4.1799, 4.76, 5.1599, 5.5599, 5.6999, 5.86, 6.1999, 6.38, 6.6199, 6.94]				)
						# fmt: on

						self.assertTrue(torch.allclose(__a	,__a	,atol=0.01				)				)
						self.assertTrue(torch.allclose(__a	,__a	,atol=0.01				)				)






from __future__ import annotations

from collections.abc import Iterable, Iterator
from dataclasses import dataclass

__snake_case       :	Optional[int]            =(3, 9, -1_1, 0, 7, 5, 1, -1)
__snake_case       :	str            =(4, 6, 2, 0, 8, 1_0, 3, -2)



@dataclass
class  lowerCamelCase__    :




		'''simple docstring'''



		snake_case_			=42
		snake_case_			=42



class  lowerCamelCase__    :




		'''simple docstring'''



		def __init__(self	,__lowerCamelCase				)  ->    None:

						"""simple docstring"""






						lowerCAmelCase__  :       Node | None				=  None
						for i in sorted(__lowerCamelCase	,reverse=__lowerCamelCase				):
										lowerCAmelCase__  :       Dict				=  Node(__lowerCamelCase	,self.head				)



		def __iter__(self				)  ->    Iterator[int]:

						"""simple docstring"""






						lowerCAmelCase__  :       Optional[Any]				=  self.head
						while node:
										yield node.data
										lowerCAmelCase__  :       Dict				=  node.next_node



		def __len__(self				)  ->    int:

						"""simple docstring"""






						return sum(1 for _ in self				)



		def __str__(self				)  ->    str:

						"""simple docstring"""






						return " -> ".join([str(__lowerCamelCase				) for node in self]				)






def 			lowerCAmelCase__	(					lowerCamelCase_	:	SortedLinkedList ,lowerCamelCase_	:	SortedLinkedList):





				'''simple docstring'''

				return SortedLinkedList(list(lowerCamelCase_) + list(lowerCamelCase_))


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							__snake_case       :	Any            =SortedLinkedList
							print(merge_lists(SSL(test_data_odd), SSL(test_data_even)))

