



def      lowerCAmelCase__		(   lowerCamelCase_		:		list):





				'''simple docstring'''

				lowerCAmelCase__					:    List[Any]												=					False
				while is_sorted is False:  # Until all the indices are traversed keep looping
								lowerCAmelCase__					:    Dict												=					True
								for i in range(0	,len(lowerCamelCase_) - 1	,2):  # iterating over all even indices
												if input_list[i] > input_list[i + 1]:
																lowerCAmelCase__						,		lowerCAmelCase__					:    int												=					input_list[i + 1], input_list[i]
																# swapping if elements not in order
																lowerCAmelCase__					:    Union[str, Any]												=					False

								for i in range(1	,len(lowerCamelCase_) - 1	,2):  # iterating over all odd indices
												if input_list[i] > input_list[i + 1]:
																lowerCAmelCase__						,		lowerCAmelCase__					:    Optional[int]												=					input_list[i + 1], input_list[i]
																# swapping if elements not in order
																lowerCAmelCase__					:    int												=					False
				return input_list


if __name__ == "__main__":
							print('Enter list to be sorted')
							__snake_case    :		Optional[int]  =[int(x) for x in input().split()]
							# inputing elements of the list in one line
							__snake_case    :		Optional[Any]  =odd_even_sort(input_list)
							print('The sorted list is')
							print(sorted_list)






import unittest

import numpy as np

from transformers.testing_utils import is_flaky, require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
							import torch

if is_vision_available():
							from PIL import Image

							from transformers import DonutImageProcessor



class 	lowerCamelCase__      (							unittest.TestCase):




		'''simple docstring'''



		def __init__(self		,__lowerCamelCase		,__lowerCamelCase=7		,__lowerCamelCase=3		,__lowerCamelCase=18		,__lowerCamelCase=30		,__lowerCamelCase=4_00		,__lowerCamelCase=True		,__lowerCamelCase=None		,__lowerCamelCase=True		,__lowerCamelCase=False		,__lowerCamelCase=True		,__lowerCamelCase=True		,__lowerCamelCase=[0.5, 0.5, 0.5]		,__lowerCamelCase=[0.5, 0.5, 0.5]		,)					->      Union[str, Any]:

						"""simple docstring"""






						lowerCAmelCase__					:    List[Any]												=					parent
						lowerCAmelCase__					:    Optional[Any]												=					batch_size
						lowerCAmelCase__					:    str												=					num_channels
						lowerCAmelCase__					:    List[str]												=					image_size
						lowerCAmelCase__					:    List[Any]												=					min_resolution
						lowerCAmelCase__					:    Union[str, Any]												=					max_resolution
						lowerCAmelCase__					:    Union[str, Any]												=					do_resize
						lowerCAmelCase__					:    str												=					size if size is not None else {'''height''': 18, '''width''': 20}
						lowerCAmelCase__					:    List[str]												=					do_thumbnail
						lowerCAmelCase__					:    str												=					do_align_axis
						lowerCAmelCase__					:    Optional[Any]												=					do_pad
						lowerCAmelCase__					:    Tuple												=					do_normalize
						lowerCAmelCase__					:    List[Any]												=					image_mean
						lowerCAmelCase__					:    List[str]												=					image_std



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

						"""simple docstring"""






						return {
						    "do_resize": self.do_resize,
						    "size": self.size,
						    "do_thumbnail": self.do_thumbnail,
						    "do_align_long_axis": self.do_align_axis,
						    "do_pad": self.do_pad,
						    "do_normalize": self.do_normalize,
						    "image_mean": self.image_mean,
						    "image_std": self.image_std,
						}



@require_torch
@require_vision
class 	lowerCamelCase__      (							lowerCamelCase__				,    unittest.TestCase):




		'''simple docstring'''



		snake_case_     =DonutImageProcessor if is_vision_available() else None



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

						"""simple docstring"""






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



		@property
		def 		lowerCAmelCase__				(self			)					->      Any:

						"""simple docstring"""






						return self.image_processor_tester.prepare_image_processor_dict()



		def 		lowerCAmelCase__				(self			)					->      int:

						"""simple docstring"""






						lowerCAmelCase__					:    Optional[Any]												=					self.image_processing_class(**self.image_processor_dict			)
						self.assertTrue(hasattr(__lowerCamelCase		,'''do_resize'''			)			)
						self.assertTrue(hasattr(__lowerCamelCase		,'''size'''			)			)
						self.assertTrue(hasattr(__lowerCamelCase		,'''do_thumbnail'''			)			)
						self.assertTrue(hasattr(__lowerCamelCase		,'''do_align_long_axis'''			)			)
						self.assertTrue(hasattr(__lowerCamelCase		,'''do_pad'''			)			)
						self.assertTrue(hasattr(__lowerCamelCase		,'''do_normalize'''			)			)
						self.assertTrue(hasattr(__lowerCamelCase		,'''image_mean'''			)			)
						self.assertTrue(hasattr(__lowerCamelCase		,'''image_std'''			)			)



		def 		lowerCAmelCase__				(self			)					->      Tuple:

						"""simple docstring"""






						lowerCAmelCase__					:    Optional[int]												=					self.image_processing_class.from_dict(self.image_processor_dict			)
						self.assertEqual(image_processor.size		,{'''height''': 18, '''width''': 20}			)

						lowerCAmelCase__					:    int												=					self.image_processing_class.from_dict(self.image_processor_dict		,size=42			)
						self.assertEqual(image_processor.size		,{'''height''': 42, '''width''': 42}			)

						# Previous config had dimensions in (width, height) order
						lowerCAmelCase__					:    Union[str, Any]												=					self.image_processing_class.from_dict(self.image_processor_dict		,size=(42, 84)			)
						self.assertEqual(image_processor.size		,{'''height''': 84, '''width''': 42}			)



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

						"""simple docstring"""






						pass



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

						"""simple docstring"""






						lowerCAmelCase__					:    str												=					self.image_processing_class(**self.image_processor_dict			)
						# create random PIL images
						lowerCAmelCase__					:    Dict												=					prepare_image_inputs(self.image_processor_tester		,equal_resolution=__lowerCamelCase			)
						for image in image_inputs:
										self.assertIsInstance(__lowerCamelCase		,Image.Image			)

						# Test not batched input
						lowerCAmelCase__					:    Optional[Any]												=					image_processing(image_inputs[0]		,return_tensors='''pt'''			).pixel_values
						self.assertEqual(
						    encoded_images.shape		,(
						        1,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.size['''height'''],
						        self.image_processor_tester.size['''width'''],
						    )		,)

						# Test batched
						lowerCAmelCase__					:    Optional[int]												=					image_processing(__lowerCamelCase		,return_tensors='''pt'''			).pixel_values
						self.assertEqual(
						    encoded_images.shape		,(
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.size['''height'''],
						        self.image_processor_tester.size['''width'''],
						    )		,)



		@is_flaky()
		def 		lowerCAmelCase__				(self			)					->      Any:

						"""simple docstring"""






						lowerCAmelCase__					:    Optional[int]												=					self.image_processing_class(**self.image_processor_dict			)
						# create random numpy tensors
						lowerCAmelCase__					:    Any												=					prepare_image_inputs(self.image_processor_tester		,equal_resolution=__lowerCamelCase		,numpify=__lowerCamelCase			)
						for image in image_inputs:
										self.assertIsInstance(__lowerCamelCase		,np.ndarray			)

						# Test not batched input
						lowerCAmelCase__					:    Union[str, Any]												=					image_processing(image_inputs[0]		,return_tensors='''pt'''			).pixel_values
						self.assertEqual(
						    encoded_images.shape		,(
						        1,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.size['''height'''],
						        self.image_processor_tester.size['''width'''],
						    )		,)

						# Test batched
						lowerCAmelCase__					:    int												=					image_processing(__lowerCamelCase		,return_tensors='''pt'''			).pixel_values
						self.assertEqual(
						    encoded_images.shape		,(
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.size['''height'''],
						        self.image_processor_tester.size['''width'''],
						    )		,)



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

						"""simple docstring"""






						lowerCAmelCase__					:    Any												=					self.image_processing_class(**self.image_processor_dict			)
						# create random PyTorch tensors
						lowerCAmelCase__					:    int												=					prepare_image_inputs(self.image_processor_tester		,equal_resolution=__lowerCamelCase		,torchify=__lowerCamelCase			)
						for image in image_inputs:
										self.assertIsInstance(__lowerCamelCase		,torch.Tensor			)

						# Test not batched input
						lowerCAmelCase__					:    Any												=					image_processing(image_inputs[0]		,return_tensors='''pt'''			).pixel_values
						self.assertEqual(
						    encoded_images.shape		,(
						        1,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.size['''height'''],
						        self.image_processor_tester.size['''width'''],
						    )		,)

						# Test batched
						lowerCAmelCase__					:    Dict												=					image_processing(__lowerCamelCase		,return_tensors='''pt'''			).pixel_values
						self.assertEqual(
						    encoded_images.shape		,(
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.size['''height'''],
						        self.image_processor_tester.size['''width'''],
						    )		,)

