






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







	def 			_a (	self   :				List[str]      )		->			str:
		"""simple docstring"""







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

		__lowercase   							=	{
		    """unk_token""": """<unk>""",
		    """bos_token""": """<s>""",
		    """eos_token""": """</s>""",
		}
		__lowercase   							=	{
		    """feature_size""": 1,
		    """padding_value""": 0.0,
		    """sampling_rate""": 1_6000,
		    """return_attention_mask""": False,
		    """do_normalize""": True,
		}

		__lowercase   							=	tempfile.mkdtemp()
		__lowercase   							=	os.path.join(self.tmpdirname							,					VOCAB_FILES_NAMES["""vocab_file"""]      )
		__lowercase   							=	os.path.join(self.tmpdirname							,					__lowerCAmelCase      )
		with open(self.vocab_file							,					"""w"""							,					encoding="""utf-8"""      ) as fp:
			fp.write(json.dumps(__lowerCAmelCase      ) + """\n"""      )

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

		# load decoder from hub
		__lowercase   							=	"""hf-internal-testing/ngram-beam-search-decoder"""







	def 			_a (	self   :				Optional[Any]							,					**_lowerCAmelCase   :				int      )		->			List[Any]:
		"""simple docstring"""







		__lowercase   							=	self.add_kwargs_tokens_map.copy()
		kwargs.update(__lowerCAmelCase      )
		return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname							,					**__lowerCAmelCase      )







	def 			_a (	self   :				List[str]							,					**_lowerCAmelCase   :				List[Any]      )		->			List[Any]:
		"""simple docstring"""







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







	def 			_a (	self   :				List[str]							,					**_lowerCAmelCase   :				str      )		->			int:
		"""simple docstring"""







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







	def 			_a (	self   :				List[str]      )		->			Union[str, Any]:
		"""simple docstring"""







		shutil.rmtree(self.tmpdirname      )







	def 			_a (	self   :				str      )		->			Optional[int]:
		"""simple docstring"""







		__lowercase   							=	self.get_tokenizer()
		__lowercase   							=	self.get_feature_extractor()
		__lowercase   							=	self.get_decoder()

		__lowercase   							=	WavaVecaProcessorWithLM(tokenizer=__lowerCAmelCase							,					feature_extractor=__lowerCAmelCase							,					decoder=__lowerCAmelCase      )

		processor.save_pretrained(self.tmpdirname      )
		__lowercase   							=	WavaVecaProcessorWithLM.from_pretrained(self.tmpdirname      )

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

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

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







	def 			_a (	self   :				str      )		->			Dict:
		"""simple docstring"""







		__lowercase   							=	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
		__lowercase   							=	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 			_a (	self   :				List[Any]      )		->			List[Any]:
		"""simple docstring"""







		__lowercase   							=	self.get_tokenizer()
		# add token to trigger raise
		tokenizer.add_tokens(["""xx"""]      )
		with self.assertRaisesRegex(__lowerCAmelCase							,					"""include"""      ):
			WavaVecaProcessorWithLM(
			    tokenizer=__lowerCAmelCase							,					feature_extractor=self.get_feature_extractor()							,					decoder=self.get_decoder()      )







	def 			_a (	self   :				Any      )		->			int:
		"""simple docstring"""







		__lowercase   							=	self.get_feature_extractor()
		__lowercase   							=	self.get_tokenizer()
		__lowercase   							=	self.get_decoder()

		__lowercase   							=	WavaVecaProcessorWithLM(tokenizer=__lowerCAmelCase							,					feature_extractor=__lowerCAmelCase							,					decoder=__lowerCAmelCase      )

		__lowercase   							=	floats_list((3, 1000)      )

		__lowercase   							=	feature_extractor(__lowerCAmelCase							,					return_tensors="""np"""      )
		__lowercase   							=	processor(__lowerCAmelCase							,					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 			_a (	self   :				List[str]      )		->			List[Any]:
		"""simple docstring"""







		__lowercase   							=	self.get_feature_extractor()
		__lowercase   							=	self.get_tokenizer()
		__lowercase   							=	self.get_decoder()

		__lowercase   							=	WavaVecaProcessorWithLM(tokenizer=__lowerCAmelCase							,					feature_extractor=__lowerCAmelCase							,					decoder=__lowerCAmelCase      )

		__lowercase   							=	"""This is a test string"""

		__lowercase   							=	processor(text=__lowerCAmelCase      )

		__lowercase   							=	tokenizer(__lowerCAmelCase      )

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







	def 			_a (	self   :				Optional[int]							,					_lowerCAmelCase   :				Any=(2, 10, 16)							,					_lowerCAmelCase   :				Optional[Any]=77      )		->			Optional[Any]:
		"""simple docstring"""







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







	def 			_a (	self   :				List[Any]      )		->			Dict:
		"""simple docstring"""







		__lowercase   							=	self.get_feature_extractor()
		__lowercase   							=	self.get_tokenizer()
		__lowercase   							=	self.get_decoder()

		__lowercase   							=	WavaVecaProcessorWithLM(tokenizer=__lowerCAmelCase							,					feature_extractor=__lowerCAmelCase							,					decoder=__lowerCAmelCase      )

		__lowercase   							=	self._get_dummy_logits(shape=(10, 16)							,					seed=13      )

		__lowercase   							=	processor.decode(__lowerCAmelCase      )

		__lowercase   							=	decoder.decode_beams(__lowerCAmelCase      )[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 			_a (	self   :				int							,					_lowerCAmelCase   :				List[Any]      )		->			Any:
		"""simple docstring"""







		__lowercase   							=	self.get_feature_extractor()
		__lowercase   							=	self.get_tokenizer()
		__lowercase   							=	self.get_decoder()

		__lowercase   							=	WavaVecaProcessorWithLM(tokenizer=__lowerCAmelCase							,					feature_extractor=__lowerCAmelCase							,					decoder=__lowerCAmelCase      )

		__lowercase   							=	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:
			__lowercase   							=	processor.batch_decode(__lowerCAmelCase      )
		else:
			with get_context(__lowerCAmelCase      ).Pool() as pool:
				__lowercase   							=	processor.batch_decode(__lowerCAmelCase							,					__lowerCAmelCase      )

		__lowercase   							=	list(__lowerCAmelCase      )

		with get_context("""fork"""      ).Pool() as p:
			__lowercase   							=	decoder.decode_beams_batch(__lowerCAmelCase							,					__lowerCAmelCase      )

		__lowercase							,    __lowercase							,    __lowercase   							=	[], [], []
		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(__lowerCAmelCase							,					decoded_processor.text      )
		self.assertListEqual(["""<s> <s> </s>""", """<s> <s> <s>"""]							,					decoded_processor.text      )
		self.assertListEqual(__lowerCAmelCase							,					decoded_processor.logit_score      )
		self.assertListEqual(__lowerCAmelCase							,					decoded_processor.lm_score      )







	def 			_a (	self   :				Any      )		->			int:
		"""simple docstring"""







		__lowercase   							=	self.get_feature_extractor()
		__lowercase   							=	self.get_tokenizer()
		__lowercase   							=	self.get_decoder()

		__lowercase   							=	WavaVecaProcessorWithLM(tokenizer=__lowerCAmelCase							,					feature_extractor=__lowerCAmelCase							,					decoder=__lowerCAmelCase      )

		__lowercase   							=	self._get_dummy_logits()

		__lowercase   							=	15
		__lowercase   							=	-20.0
		__lowercase   							=	-4.0

		__lowercase   							=	processor.batch_decode(
		    __lowerCAmelCase							,					beam_width=__lowerCAmelCase							,					beam_prune_logp=__lowerCAmelCase							,					token_min_logp=__lowerCAmelCase							,					)
		__lowercase   							=	decoded_processor_out.text

		__lowercase   							=	list(__lowerCAmelCase      )

		with get_context("""fork"""      ).Pool() as pool:
			__lowercase   							=	decoder.decode_beams_batch(
			    __lowerCAmelCase							,					__lowerCAmelCase							,					beam_width=__lowerCAmelCase							,					beam_prune_logp=__lowerCAmelCase							,					token_min_logp=__lowerCAmelCase							,					)

		__lowercase   							=	[d[0][0] for d in decoded_decoder_out]
		__lowercase   							=	[d[0][2] for d in decoded_decoder_out]
		__lowercase   							=	[d[0][3] for d in decoded_decoder_out]

		self.assertListEqual(__lowerCAmelCase							,					__lowerCAmelCase      )
		self.assertListEqual(["""</s> <s> <s>""", """<s> <s> <s>"""]							,					__lowerCAmelCase      )

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

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







	def 			_a (	self   :				Optional[int]      )		->			Dict:
		"""simple docstring"""







		__lowercase   							=	self.get_feature_extractor()
		__lowercase   							=	self.get_tokenizer()
		__lowercase   							=	self.get_decoder()

		__lowercase   							=	WavaVecaProcessorWithLM(tokenizer=__lowerCAmelCase							,					feature_extractor=__lowerCAmelCase							,					decoder=__lowerCAmelCase      )

		__lowercase   							=	self._get_dummy_logits()

		__lowercase   							=	2.0
		__lowercase   							=	5.0
		__lowercase   							=	-20.0
		__lowercase   							=	True

		__lowercase   							=	processor.batch_decode(
		    __lowerCAmelCase							,					alpha=__lowerCAmelCase							,					beta=__lowerCAmelCase							,					unk_score_offset=__lowerCAmelCase							,					lm_score_boundary=__lowerCAmelCase							,					)
		__lowercase   							=	decoded_processor_out.text

		__lowercase   							=	list(__lowerCAmelCase      )
		decoder.reset_params(
		    alpha=__lowerCAmelCase							,					beta=__lowerCAmelCase							,					unk_score_offset=__lowerCAmelCase							,					lm_score_boundary=__lowerCAmelCase							,					)

		with get_context("""fork"""      ).Pool() as pool:
			__lowercase   							=	decoder.decode_beams_batch(
			    __lowerCAmelCase							,					__lowerCAmelCase							,					)

		__lowercase   							=	[d[0][0] for d in decoded_decoder_out]

		self.assertListEqual(__lowerCAmelCase							,					__lowerCAmelCase      )
		self.assertListEqual(["""<s> </s> <s> </s> </s>""", """</s> </s> <s> </s> </s>"""]							,					__lowerCAmelCase      )
		__lowercase   							=	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							,					__lowerCAmelCase      )







	def 			_a (	self   :				List[Any]      )		->			Any:
		"""simple docstring"""







		__lowercase   							=	WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm"""      )

		__lowercase   							=	processor.decoder.model_container[processor.decoder._model_key]
		__lowercase   							=	Path(language_model._kenlm_model.path.decode("""utf-8"""      )      ).parent.parent.absolute()

		__lowercase   							=	os.listdir(__lowerCAmelCase      )
		__lowercase   							=	["""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(__lowerCAmelCase							,					__lowerCAmelCase      )







	def 			_a (	self   :				Union[str, Any]      )		->			Tuple:
		"""simple docstring"""







		__lowercase   							=	snapshot_download("""hf-internal-testing/processor_with_lm"""      )

		__lowercase   							=	WavaVecaProcessorWithLM.from_pretrained(__lowerCAmelCase      )

		__lowercase   							=	processor.decoder.model_container[processor.decoder._model_key]
		__lowercase   							=	Path(language_model._kenlm_model.path.decode("""utf-8"""      )      ).parent.parent.absolute()

		__lowercase   							=	os.listdir(__lowerCAmelCase      )
		__lowercase   							=	os.listdir(__lowerCAmelCase      )

		local_decoder_files.sort()
		expected_decoder_files.sort()

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







	def 			_a (	self   :				Optional[Any]      )		->			int:
		"""simple docstring"""







		__lowercase   							=	WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm"""      )
		__lowercase   							=	AutoProcessor.from_pretrained("""hf-internal-testing/processor_with_lm"""      )

		__lowercase   							=	floats_list((3, 1000)      )

		__lowercase   							=	processor_wavaveca(__lowerCAmelCase							,					return_tensors="""np"""      )
		__lowercase   							=	processor_auto(__lowerCAmelCase							,					return_tensors="""np"""      )

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

		__lowercase   							=	self._get_dummy_logits()

		__lowercase   							=	processor_wavaveca.batch_decode(__lowerCAmelCase      )
		__lowercase   							=	processor_auto.batch_decode(__lowerCAmelCase      )

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







	def 			_a (	self   :				Tuple      )		->			Optional[Any]:
		"""simple docstring"""







		__lowercase   							=	self.get_feature_extractor()
		__lowercase   							=	self.get_tokenizer()
		__lowercase   							=	self.get_decoder()

		__lowercase   							=	WavaVecaProcessorWithLM(tokenizer=__lowerCAmelCase							,					feature_extractor=__lowerCAmelCase							,					decoder=__lowerCAmelCase      )

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







	@staticmethod
	def 			_a (	_lowerCAmelCase   :				str							,					_lowerCAmelCase   :				List[str]      )		->			str:
		"""simple docstring"""







		__lowercase   							=	[d[key] for d in offsets]
		return retrieved_list







	def 			_a (	self   :				Optional[Any]      )		->			str:
		"""simple docstring"""







		__lowercase   							=	WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm"""      )
		__lowercase   							=	self._get_dummy_logits()[0]

		__lowercase   							=	processor.decode(__lowerCAmelCase							,					output_word_offsets=__lowerCAmelCase      )
		# 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(__lowerCAmelCase							,					__lowerCAmelCase      )      )

		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 			_a (	self   :				List[Any]      )		->			Any:
		"""simple docstring"""







		__lowercase   							=	WavaVecaProcessorWithLM.from_pretrained("""hf-internal-testing/processor_with_lm"""      )
		__lowercase   							=	self._get_dummy_logits()

		__lowercase   							=	processor.batch_decode(__lowerCAmelCase							,					output_word_offsets=__lowerCAmelCase      )

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

		self.assertListEqual(
		    [""" """.join(self.get_from_offsets(__lowerCAmelCase							,					"""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 			_a (	self   :				Optional[int]      )		->			Optional[int]:
		"""simple docstring"""







		import torch

		__lowercase   							=	load_dataset("""common_voice"""							,					"""en"""							,					split="""train"""							,					streaming=__lowerCAmelCase      )
		__lowercase   							=	ds.cast_column("""audio"""							,					datasets.Audio(sampling_rate=1_6000      )      )
		__lowercase   							=	iter(__lowerCAmelCase      )
		__lowercase   							=	next(__lowerCAmelCase      )

		__lowercase   							=	AutoProcessor.from_pretrained("""patrickvonplaten/wav2vec2-base-100h-with-lm"""      )
		__lowercase   							=	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
		__lowercase   							=	processor(sample["""audio"""]["""array"""]							,					return_tensors="""pt"""      ).input_values

		with torch.no_grad():
			__lowercase   							=	model(__lowerCAmelCase      ).logits.cpu().numpy()

		__lowercase   							=	processor.decode(logits[0]							,					output_word_offsets=__lowerCAmelCase      )

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

		__lowercase   							=	"""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(__lowerCAmelCase							,					"""word"""      )      )							,					__lowerCAmelCase      )
		self.assertEqual(""" """.join(self.get_from_offsets(__lowerCAmelCase							,					"""word"""      )      )							,					output.text      )

		# output times
		__lowercase   							=	torch.tensor(self.get_from_offsets(__lowerCAmelCase							,					"""start_time"""      )      )
		__lowercase   							=	torch.tensor(self.get_from_offsets(__lowerCAmelCase							,					"""end_time"""      )      )

		# fmt: off
		__lowercase   							=	torch.tensor([1.4_199, 1.6_599, 2.2_599, 3.0, 3.24, 3.5_999, 3.7_999, 4.0_999, 4.26, 4.94, 5.28, 5.6_599, 5.78, 5.94, 6.32, 6.5_399, 6.6_599]      )
		__lowercase   							=	torch.tensor([1.5_399, 1.8_999, 2.9, 3.16, 3.5_399, 3.72, 4.0_199, 4.1_799, 4.76, 5.1_599, 5.5_599, 5.6_999, 5.86, 6.1_999, 6.38, 6.6_199, 6.94]      )
		# fmt: on

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


'''simple docstring'''




def 							snake_case__				(     _A:   int					)       ->      list[int]:

		'''simple docstring'''


		if length <= 0 or not isinstance(_A ,  _A					):
				raise ValueError("""Length must be a positive integer."""					)
		return [n * (2 * n - 1) for n in range(_A					)]


if __name__ == "__main__":
						print(hexagonal_numbers(length=5))
						print(hexagonal_numbers(length=1_0))




