


def 		a__       (							A__							):
			SCREAMING_SNAKE_CASE_						:			int       						= len(A__							)

			# Set the gap value to be decreased by a factor of 1.3
			# after each iteration
			SCREAMING_SNAKE_CASE_						:			Any       						= 1.3

			# Continue sorting until the gap is 1
			while gap > 1:
						# Decrease the gap value
						SCREAMING_SNAKE_CASE_						:			int       						= int(gap / shrink							)

						# Sort the elements using insertion sort
						for i in range(A__,	len(A__							)							):
									SCREAMING_SNAKE_CASE_						:			Union[str, Any]       						= collection[i]
									SCREAMING_SNAKE_CASE_						:			str       						= i
									while j >= gap and collection[j - gap] > temp:
												SCREAMING_SNAKE_CASE_						:			Dict       						= collection[j - gap]
												j -= gap
									SCREAMING_SNAKE_CASE_						:			Dict       						= temp

			return collection


if __name__ == "__main__":
				import doctest

				doctest.testmod()












import unittest

from transformers import is_torch_available, load_tool

from .test_tools_common import ToolTesterMixin


if is_torch_available():
	import torch




class      UpperCamelCase_				(   unittest.TestCase ,     UpperCamelCase__			):


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					load_tool("""speech-to-text"""						)
									self.tool.setup()


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					self.tool(torch.ones(3000						)						)
									self.assertEqual(__A							, """ you"""						)


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



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					self.tool(audio=torch.ones(3000						)						)
									self.assertEqual(__A							, """ you"""						)