



import itertools
import random
import unittest

import numpy as np

from transformers import BatchFeature, SpeechTaFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
			import torch


snake_case__					:     List[Any]    		=   random.Random()



def    snake_case_				(    _SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE=1.0  ,	_SCREAMING_SNAKE_CASE=None  ,	_SCREAMING_SNAKE_CASE=None   ):
	if rng is None:
		__lowercase		       =			global_rng

	__lowercase		       =			[]
	for batch_idx in range(shape[0]   ):
		values.append([]   )
		for _ in range(shape[1]   ):
			values[-1].append(rng.random() * scale   )

	return values

@require_torch
class   _A   ( unittest.TestCase	):


						'''simple docstring'''





						def __init__(	self	:							Optional[int]							,      lowerCamelCase	:							str							,      lowerCamelCase	:							Union[str, Any]=7							,      lowerCamelCase	:							int=400							,      lowerCamelCase	:							Union[str, Any]=2_000							,      lowerCamelCase	:							int=1							,      lowerCamelCase	:							Union[str, Any]=0.0							,      lowerCamelCase	:							Union[str, Any]=16_000							,      lowerCamelCase	:							Optional[int]=True							,      lowerCamelCase	:							Optional[int]=80							,      lowerCamelCase	:							Union[str, Any]=16							,      lowerCamelCase	:							Union[str, Any]=64							,      lowerCamelCase	:							Any="hann_window"							,      lowerCamelCase	:							Any=80							,      lowerCamelCase	:							Union[str, Any]=7_600							,      lowerCamelCase	:							Dict=1e-10							,      lowerCamelCase	:							List[str]=True							,      ):






							'''simple docstring'''



							__lowercase		       =			parent
							__lowercase		       =			batch_size
							__lowercase		       =			min_seq_length
							__lowercase		       =			max_seq_length
							__lowercase		       =			(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
							__lowercase		       =			feature_size
							__lowercase		       =			padding_value
							__lowercase		       =			sampling_rate
							__lowercase		       =			do_normalize
							__lowercase		       =			num_mel_bins
							__lowercase		       =			hop_length
							__lowercase		       =			win_length
							__lowercase		       =			win_function
							__lowercase		       =			fmin
							__lowercase		       =			fmax
							__lowercase		       =			mel_floor
							__lowercase		       =			return_attention_mask



						def     _snake_case	(	self	:							str	):






							'''simple docstring'''



							return {
							    "feature_size": self.feature_size,
							    "padding_value": self.padding_value,
							    "sampling_rate": self.sampling_rate,
							    "do_normalize": self.do_normalize,
							    "num_mel_bins": self.num_mel_bins,
							    "hop_length": self.hop_length,
							    "win_length": self.win_length,
							    "win_function": self.win_function,
							    "fmin": self.fmin,
							    "fmax": self.fmax,
							    "mel_floor": self.mel_floor,
							    "return_attention_mask": self.return_attention_mask,
							}



						def     _snake_case	(	self	:							int							,      lowerCamelCase	:							Optional[Any]=False							,      lowerCamelCase	:							Tuple=False	):






							'''simple docstring'''



							def _flatten(lowerCamelCase	:							Any	):
								return list(itertools.chain(*__a	)	)

							if equal_length:
								__lowercase		       =			floats_list((self.batch_size, self.max_seq_length)	)
							else:
								# make sure that inputs increase in size
								__lowercase		       =			[
								    _flatten(floats_list((x, self.feature_size)	)	)
								    for x in range(self.min_seq_length							,      self.max_seq_length							,      self.seq_length_diff	)
								]

							if numpify:
								__lowercase		       =			[np.asarray(__a	) for x in speech_inputs]

							return speech_inputs



						def     _snake_case	(	self	:							Dict							,      lowerCamelCase	:							Tuple=False							,      lowerCamelCase	:							int=False	):






							'''simple docstring'''



							if equal_length:
								__lowercase		       =			[floats_list((self.max_seq_length, self.num_mel_bins)	) for _ in range(self.batch_size	)]
							else:
								# make sure that inputs increase in size
								__lowercase		       =			[
								    floats_list((x, self.num_mel_bins)	)
								    for x in range(self.min_seq_length							,      self.max_seq_length							,      self.seq_length_diff	)
								]

							if numpify:
								__lowercase		       =			[np.asarray(__a	) for x in speech_inputs]

							return speech_inputs

@require_torch
class   _A   ( __lowercase  ,						unittest.TestCase	):


						'''simple docstring'''





						_snake_case			:     Optional[int]      							=      SpeechTaFeatureExtractor



						def     _snake_case	(	self	:							Dict	):






							'''simple docstring'''



							__lowercase		       =			SpeechTaFeatureExtractionTester(self	)



						def     _snake_case	(	self	:							Tuple							,      lowerCamelCase	:							Dict	):






							'''simple docstring'''



							self.assertTrue(np.all(np.mean(__a							,      axis=0	) < 1e-3	)	)
							self.assertTrue(np.all(np.abs(np.var(__a							,      axis=0	) - 1	) < 1e-3	)	)



						def     _snake_case	(	self	:							Optional[Any]	):






							'''simple docstring'''



							__lowercase		       =			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
							# create three inputs of length 800, 1000, and 1200
							__lowercase		       =			[floats_list((1, x)	)[0] for x in range(800							,      1_400							,      200	)]
							__lowercase		       =			[np.asarray(__a	) for speech_input in speech_inputs]

							# Test not batched input
							__lowercase		       =			feat_extract(speech_inputs[0]							,      return_tensors="np"	).input_values
							__lowercase		       =			feat_extract(np_speech_inputs[0]							,      return_tensors="np"	).input_values
							self.assertTrue(np.allclose(__a							,      __a							,      atol=1e-3	)	)

							# Test batched
							__lowercase		       =			feat_extract(__a							,      return_tensors="np"	).input_values
							__lowercase		       =			feat_extract(__a							,      return_tensors="np"	).input_values
							for enc_seq_a, enc_seq_a in zip(__a							,      __a	):
								self.assertTrue(np.allclose(__a							,      __a							,      atol=1e-3	)	)



						def     _snake_case	(	self	:							Optional[int]	):






							'''simple docstring'''



							__lowercase		       =			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
							__lowercase		       =			[floats_list((1, x)	)[0] for x in range(800							,      1_400							,      200	)]

							__lowercase		       =			["""longest""", """max_length""", """do_not_pad"""]
							__lowercase		       =			[None, 1_600, None]
							for max_length, padding in zip(__a							,      __a	):
								__lowercase		       =			feat_extract(__a							,      padding=__a							,      max_length=__a							,      return_tensors="np"	)
								__lowercase		       =			processed.input_values

								self._check_zero_mean_unit_variance(input_values[0][:800]	)
								self.assertTrue(input_values[0][800:].sum() < 1e-6	)
								self._check_zero_mean_unit_variance(input_values[1][:1_000]	)
								self.assertTrue(input_values[0][1_000:].sum() < 1e-6	)
								self._check_zero_mean_unit_variance(input_values[2][:1_200]	)



						def     _snake_case	(	self	:							Any	):






							'''simple docstring'''



							__lowercase		       =			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
							__lowercase		       =			range(800							,      1_400							,      200	)
							__lowercase		       =			[floats_list((1, x)	)[0] for x in lengths]

							__lowercase		       =			["""longest""", """max_length""", """do_not_pad"""]
							__lowercase		       =			[None, 1_600, None]

							for max_length, padding in zip(__a							,      __a	):
								__lowercase		       =			feat_extract(__a							,      max_length=__a							,      padding=__a	)
								__lowercase		       =			processed.input_values

								self._check_zero_mean_unit_variance(input_values[0][:800]	)
								self._check_zero_mean_unit_variance(input_values[1][:1_000]	)
								self._check_zero_mean_unit_variance(input_values[2][:1_200]	)



						def     _snake_case	(	self	:							str	):






							'''simple docstring'''



							__lowercase		       =			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
							__lowercase		       =			[floats_list((1, x)	)[0] for x in range(800							,      1_400							,      200	)]
							__lowercase		       =			feat_extract(
							    __a							,      truncation=__a							,      max_length=1_000							,      padding="max_length"							,      return_tensors="np"	)
							__lowercase		       =			processed.input_values

							self._check_zero_mean_unit_variance(input_values[0, :800]	)
							self._check_zero_mean_unit_variance(input_values[1]	)
							self._check_zero_mean_unit_variance(input_values[2]	)



						def     _snake_case	(	self	:							Optional[int]	):






							'''simple docstring'''



							__lowercase		       =			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
							__lowercase		       =			[floats_list((1, x)	)[0] for x in range(800							,      1_400							,      200	)]
							__lowercase		       =			feat_extract(
							    __a							,      truncation=__a							,      max_length=1_000							,      padding="longest"							,      return_tensors="np"	)
							__lowercase		       =			processed.input_values

							self._check_zero_mean_unit_variance(input_values[0, :800]	)
							self._check_zero_mean_unit_variance(input_values[1, :1_000]	)
							self._check_zero_mean_unit_variance(input_values[2]	)

							# make sure that if max_length < longest -> then pad to max_length
							self.assertTrue(input_values.shape == (3, 1_000)	)

							__lowercase		       =			[floats_list((1, x)	)[0] for x in range(800							,      1_400							,      200	)]
							__lowercase		       =			feat_extract(
							    __a							,      truncation=__a							,      max_length=2_000							,      padding="longest"							,      return_tensors="np"	)
							__lowercase		       =			processed.input_values

							self._check_zero_mean_unit_variance(input_values[0, :800]	)
							self._check_zero_mean_unit_variance(input_values[1, :1_000]	)
							self._check_zero_mean_unit_variance(input_values[2]	)

							# make sure that if max_length > longest -> then pad to longest
							self.assertTrue(input_values.shape == (3, 1_200)	)



						def     _snake_case	(	self	:							List[Any]	):






							'''simple docstring'''



							__lowercase		       =			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
							__lowercase		       =			np.random.rand(100	).astype(np.floataa	)
							__lowercase		       =			np_speech_inputs.tolist()

							for inputs in [py_speech_inputs, np_speech_inputs]:
								__lowercase		       =			feature_extractor.pad([{"input_values": inputs}]							,      return_tensors="np"	)
								self.assertTrue(np_processed.input_values.dtype == np.floataa	)
								__lowercase		       =			feature_extractor.pad([{"input_values": inputs}]							,      return_tensors="pt"	)
								self.assertTrue(pt_processed.input_values.dtype == torch.floataa	)



						def     _snake_case	(	self	:							int	):






							'''simple docstring'''



							__lowercase		       =			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()	)
							# create three inputs of length 800, 1000, and 1200
							__lowercase		       =			[floats_list((1, x)	)[0] for x in range(800							,      1_400							,      200	)]
							__lowercase		       =			[np.asarray(__a	) for speech_input in speech_inputs]

							# Test feature size
							__lowercase		       =			feature_extractor(audio_target=__a							,      padding=__a							,      return_tensors="np"	).input_values
							self.assertTrue(input_values.ndim == 3	)
							self.assertTrue(input_values.shape[-1] == feature_extractor.num_mel_bins	)

							# Test not batched input
							__lowercase		       =			feature_extractor(speech_inputs[0]							,      return_tensors="np"	).input_values
							__lowercase		       =			feature_extractor(np_speech_inputs[0]							,      return_tensors="np"	).input_values
							self.assertTrue(np.allclose(__a							,      __a							,      atol=1e-3	)	)

							# Test batched
							__lowercase		       =			feature_extractor(__a							,      return_tensors="np"	).input_values
							__lowercase		       =			feature_extractor(__a							,      return_tensors="np"	).input_values
							for enc_seq_a, enc_seq_a in zip(__a							,      __a	):
								self.assertTrue(np.allclose(__a							,      __a							,      atol=1e-3	)	)

							# Test 2-D numpy arrays are batched.
							__lowercase		       =			[floats_list((1, x)	)[0] for x in (800, 800, 800)]
							__lowercase		       =			np.asarray(__a	)
							__lowercase		       =			feature_extractor(__a							,      return_tensors="np"	).input_values
							__lowercase		       =			feature_extractor(__a							,      return_tensors="np"	).input_values
							for enc_seq_a, enc_seq_a in zip(__a							,      __a	):
								self.assertTrue(np.allclose(__a							,      __a							,      atol=1e-3	)	)



						def     _snake_case	(	self	:							str	):






							'''simple docstring'''



							__lowercase		       =			self.feat_extract_tester.prepare_inputs_for_target()
							__lowercase		       =			self.feature_extraction_class(**self.feat_extract_dict	)
							__lowercase		       =			feat_extract.model_input_names[0]

							__lowercase		       =			BatchFeature({input_name: speech_inputs}	)

							self.assertTrue(all(len(__a	) == len(__a	) for x, y in zip(__a							,      processed_features[input_name]	)	)	)

							__lowercase		       =			self.feat_extract_tester.prepare_inputs_for_target(equal_length=__a	)
							__lowercase		       =			BatchFeature({input_name: speech_inputs}							,      tensor_type="np"	)

							__lowercase		       =			processed_features[input_name]

							if len(batch_features_input.shape	) < 3:
								__lowercase		       =			batch_features_input[:, :, None]

							self.assertTrue(
							    batch_features_input.shape
							    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]	), self.feat_extract_tester.num_mel_bins)	)



						@require_torch
						def     _snake_case	(	self	:							Any	):






							'''simple docstring'''



							__lowercase		       =			self.feat_extract_tester.prepare_inputs_for_target(equal_length=__a	)
							__lowercase		       =			self.feature_extraction_class(**self.feat_extract_dict	)
							__lowercase		       =			feat_extract.model_input_names[0]

							__lowercase		       =			BatchFeature({input_name: speech_inputs}							,      tensor_type="pt"	)

							__lowercase		       =			processed_features[input_name]

							if len(batch_features_input.shape	) < 3:
								__lowercase		       =			batch_features_input[:, :, None]

							self.assertTrue(
							    batch_features_input.shape
							    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]	), self.feat_extract_tester.num_mel_bins)	)



						@require_torch
						def     _snake_case	(	self	:							Optional[Any]	):






							'''simple docstring'''



							__lowercase		       =			self.feature_extraction_class(**self.feat_extract_dict	)
							__lowercase		       =			self.feat_extract_tester.prepare_inputs_for_target()
							__lowercase		       =			feat_extract.model_input_names[0]

							__lowercase		       =			BatchFeature({input_name: speech_inputs}	)

							__lowercase		       =			feat_extract.num_mel_bins  # hack!

							__lowercase		       =			feat_extract.pad(__a							,      padding="longest"							,      return_tensors="np"	)[input_name]
							__lowercase		       =			feat_extract.pad(__a							,      padding="longest"							,      return_tensors="pt"	)[input_name]

							self.assertTrue(abs(input_np.astype(np.floataa	).sum() - input_pt.numpy().astype(np.floataa	).sum()	) < 1e-2	)



						def     _snake_case	(	self	:							str	):






							'''simple docstring'''



							__lowercase		       =			self.feat_extract_dict
							__lowercase		       =			True
							__lowercase		       =			self.feature_extraction_class(**__a	)
							__lowercase		       =			self.feat_extract_tester.prepare_inputs_for_target()
							__lowercase		       =			[len(__a	) for x in speech_inputs]
							__lowercase		       =			feat_extract.model_input_names[0]

							__lowercase		       =			BatchFeature({input_name: speech_inputs}	)

							__lowercase		       =			feat_extract.num_mel_bins  # hack!

							__lowercase		       =			feat_extract.pad(__a							,      padding="longest"							,      return_tensors="np"	)
							self.assertIn("attention_mask"							,      __a	)
							self.assertListEqual(list(processed.attention_mask.shape	)							,      list(processed[input_name].shape[:2]	)	)
							self.assertListEqual(processed.attention_mask.sum(-1	).tolist()							,      __a	)



						def     _snake_case	(	self	:							int	):






							'''simple docstring'''



							__lowercase		       =			self.feat_extract_dict
							__lowercase		       =			True
							__lowercase		       =			self.feature_extraction_class(**__a	)
							__lowercase		       =			self.feat_extract_tester.prepare_inputs_for_target()
							__lowercase		       =			[len(__a	) for x in speech_inputs]
							__lowercase		       =			feat_extract.model_input_names[0]

							__lowercase		       =			BatchFeature({input_name: speech_inputs}	)
							__lowercase		       =			min(__a	)

							__lowercase		       =			feat_extract.num_mel_bins  # hack!

							__lowercase		       =			feat_extract.pad(
							    __a							,      padding="max_length"							,      max_length=__a							,      truncation=__a							,      return_tensors="np"	)
							self.assertIn("attention_mask"							,      __a	)
							self.assertListEqual(
							    list(processed_pad.attention_mask.shape	)							,      [processed_pad[input_name].shape[0], max_length]	)
							self.assertListEqual(
							    processed_pad.attention_mask[:, :max_length].sum(-1	).tolist()							,      [max_length for x in speech_inputs]	)



						def     _snake_case	(	self	:							int							,      lowerCamelCase	:							str	):






							'''simple docstring'''



							from datasets import load_dataset

							__lowercase		       =			load_dataset("hf-internal-testing/librispeech_asr_dummy"							,      "clean"							,      split="validation"	)
							# automatic decoding with librispeech
							__lowercase		       =			ds.sort("id"	).select(range(__a	)	)[:num_samples]["""audio"""]

							return [x["array"] for x in speech_samples]



						def     _snake_case	(	self	:							int	):






							'''simple docstring'''



							__lowercase		       =			torch.tensor(
							    [2.3804e-03, 2.0752e-03, 1.9836e-03, 2.1057e-03, 1.6174e-03,
							     3.0518e-04, 9.1553e-05, 3.3569e-04, 9.7656e-04, 1.8311e-03,
							     2.0142e-03, 2.1057e-03, 1.7395e-03, 4.5776e-04, -3.9673e-04,
							     4.5776e-04, 1.0071e-03, 9.1553e-05, 4.8828e-04, 1.1597e-03,
							     7.3242e-04, 9.4604e-04, 1.8005e-03, 1.8311e-03, 8.8501e-04,
							     4.2725e-04, 4.8828e-04, 7.3242e-04, 1.0986e-03, 2.1057e-03]	)
							# fmt: on

							__lowercase		       =			self._load_datasamples(1	)
							__lowercase		       =			SpeechTaFeatureExtractor()
							__lowercase		       =			feature_extractor(__a							,      return_tensors="pt"	).input_values
							self.assertEquals(input_values.shape							,      (1, 93_680)	)
							self.assertTrue(torch.allclose(input_values[0, :30]							,      __a							,      atol=1e-6	)	)



						def     _snake_case	(	self	:							List[str]	):






							'''simple docstring'''



							__lowercase		       =			torch.tensor(
							    [-2.6870, -3.0104, -3.1356, -3.5352, -3.0044, -3.0353, -3.4719, -3.6777,
							     -3.1520, -2.9435, -2.6553, -2.8795, -2.9944, -2.5921, -3.0279, -3.0386,
							     -3.0864, -3.1291, -3.2353, -2.7444, -2.6831, -2.7287, -3.1761, -3.1571,
							     -3.2726, -3.0582, -3.1007, -3.4533, -3.4695, -3.0998]	)
							# fmt: on

							__lowercase		       =			self._load_datasamples(1	)
							__lowercase		       =			SpeechTaFeatureExtractor()
							__lowercase		       =			feature_extractor(audio_target=__a							,      return_tensors="pt"	).input_values
							self.assertEquals(input_values.shape							,      (1, 366, 80)	)
							self.assertTrue(torch.allclose(input_values[0, 0, :30]							,      __a							,      atol=1e-4	)	)








from __future__ import annotations

import bisect



def    snake_case_				(    _SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE = 0  ,	_SCREAMING_SNAKE_CASE = -1   ):
	if hi < 0:
		__lowercase		       =			len(_SCREAMING_SNAKE_CASE   )

	while lo < hi:
		__lowercase		       =			lo + (hi - lo) // 2
		if sorted_collection[mid] < item:
			__lowercase		       =			mid + 1
		else:
			__lowercase		       =			mid

	return lo



def    snake_case_				(    _SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE = 0  ,	_SCREAMING_SNAKE_CASE = -1   ):
	if hi < 0:
		__lowercase		       =			len(_SCREAMING_SNAKE_CASE   )

	while lo < hi:
		__lowercase		       =			lo + (hi - lo) // 2
		if sorted_collection[mid] <= item:
			__lowercase		       =			mid + 1
		else:
			__lowercase		       =			mid

	return lo



def    snake_case_				(    _SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE = 0  ,	_SCREAMING_SNAKE_CASE = -1   ):
	sorted_collection.insert(bisect_left(_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE   )  ,	_SCREAMING_SNAKE_CASE   )



def    snake_case_				(    _SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE = 0  ,	_SCREAMING_SNAKE_CASE = -1   ):
	sorted_collection.insert(bisect_right(_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE   )  ,	_SCREAMING_SNAKE_CASE   )



def    snake_case_				(    _SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE   ):
	__lowercase		       =			0
	__lowercase		       =			len(_SCREAMING_SNAKE_CASE   ) - 1

	while left <= right:
		__lowercase		       =			left + (right - left) // 2
		__lowercase		       =			sorted_collection[midpoint]
		if current_item == item:
			return midpoint
		elif item < current_item:
			__lowercase		       =			midpoint - 1
		else:
			__lowercase		       =			midpoint + 1
	return None



def    snake_case_				(    _SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE   ):
	__lowercase		       =			bisect.bisect_left(_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE   )
	if index != len(_SCREAMING_SNAKE_CASE   ) and sorted_collection[index] == item:
		return index
	return None



def    snake_case_				(    _SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE   ):
	if right < left:
		return None

	__lowercase		       =			left + (right - left) // 2

	if sorted_collection[midpoint] == item:
		return midpoint
	elif sorted_collection[midpoint] > item:
		return binary_search_by_recursion(_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	midpoint - 1   )
	else:
		return binary_search_by_recursion(_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	midpoint + 1  ,	_SCREAMING_SNAKE_CASE   )


if __name__ == "__main__":
	snake_case__					:     Optional[Any]    		=   input("""Enter numbers separated by comma:\n""").strip()
	snake_case__					:     Any    		=   sorted(int(item) for item in user_input.split(""","""))
	snake_case__					:     Any    		=   int(input("""Enter a single number to be found in the list:\n"""))
	snake_case__					:     List[Any]    		=   binary_search(collection, target)
	if result is None:
		print(F'''{target} was not found in {collection}.''')
	else:
		print(F'''{target} was found at position {result} in {collection}.''')



