






'''simple docstring'''




from multiprocessing import Lock, Pipe, Process

# lock used to ensure that two processes do not access a pipe at the same time
lowerCAmelCase__          =						Lock()







def       __UpperCAmelCase						(  lowerCamelCase_     ,      lowerCamelCase_     ,      lowerCamelCase_     ,      lowerCamelCase_     ,      lowerCamelCase_     ,      lowerCamelCase_     ,      lowerCamelCase_)							->     Any:
		global process_lock

		# we perform n swaps since after n swaps we know we are sorted
		# we *could* stop early if we are sorted already, but it takes as long to
		# find out we are sorted as it does to sort the list with this algorithm
		for i in range(0     ,      10):
				if (i + position) % 2 == 0 and r_send is not None:
						# send your value to your right neighbor
						process_lock.acquire()
						r_send[1].send(lowerCamelCase_)
						process_lock.release()

						# receive your right neighbor's value
						process_lock.acquire()
						UpperCamelCase__				:					int					=					rr_cv[0].recv()
						process_lock.release()

						# take the lower value since you are on the left
						UpperCamelCase__				:					List[Any]					=					min(lowerCamelCase_     ,      lowerCamelCase_)
				elif (i + position) % 2 != 0 and l_send is not None:
						# send your value to your left neighbor
						process_lock.acquire()
						l_send[1].send(lowerCamelCase_)
						process_lock.release()

						# receive your left neighbor's value
						process_lock.acquire()
						UpperCamelCase__				:					int					=					lr_cv[0].recv()
						process_lock.release()

						# take the higher value since you are on the right
						UpperCamelCase__				:					List[Any]					=					max(lowerCamelCase_     ,      lowerCamelCase_)
    # after all swaps are performed, send the values back to main
		result_pipe[1].send(lowerCamelCase_)







def       __UpperCAmelCase						(  lowerCamelCase_)							->     List[str]:
		UpperCamelCase__				:					Tuple					=					[]
		UpperCamelCase__				:					Optional[Any]					=					[]
		# initialize the list of pipes where the values will be retrieved
		for _ in arr:
				result_pipe.append(Pipe())
		# creates the processes
		# the first and last process only have one neighbor so they are made outside
		# of the loop
		UpperCamelCase__				:					Optional[int]					=					Pipe()
		UpperCamelCase__				:					List[Any]					=					Pipe()
		process_array_.append(
		    Process(
		        target=lowerCamelCase_     ,      args=(0, arr[0], None, temp_rs, None, temp_rr, result_pipe[0])     ,      ))
		UpperCamelCase__				:					Tuple					=					temp_rs
		UpperCamelCase__				:					Tuple					=					temp_rr

		for i in range(1     ,      len(lowerCamelCase_) - 1):
				UpperCamelCase__				:					int					=					Pipe()
				UpperCamelCase__				:					Any					=					Pipe()
				process_array_.append(
				    Process(
				        target=lowerCamelCase_     ,      args=(i, arr[i], temp_ls, temp_rs, temp_lr, temp_rr, result_pipe[i])     ,      ))
				UpperCamelCase__				:					List[Any]					=					temp_rs
				UpperCamelCase__				:					int					=					temp_rr

		process_array_.append(
		    Process(
		        target=lowerCamelCase_     ,      args=(
		            len(lowerCamelCase_) - 1,
		            arr[len(lowerCamelCase_) - 1],
		            temp_ls,
		            None,
		            temp_lr,
		            None,
		            result_pipe[len(lowerCamelCase_) - 1],
		        )     ,      ))

		# start the processes
		for p in process_array_:
				p.start()

		# wait for the processes to end and write their values to the list
		for p in range(0     ,      len(lowerCamelCase_)):
				UpperCamelCase__				:					Union[str, Any]					=					result_pipe[p][0].recv()
				process_array_[p].join()
		return arr







def       __UpperCAmelCase						(  )							->     List[str]:
		UpperCamelCase__				:					Union[str, Any]					=					list(range(10     ,      0     ,      -1))
		print('Initial List')
		print(*lowerCamelCase_)
		UpperCamelCase__				:					Optional[int]					=					odd_even_transposition(lowerCamelCase_)
		print('Sorted List\n')
		print(*lowerCamelCase_)


if __name__ == "__main__":
		main()












'''simple docstring'''




import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
		from PIL import Image

		from transformers import CLIPImageProcessor, CLIPProcessor







@require_vision
class       __lowercase					(unittest.TestCase    ):

	def      __UpperCamelCase							(      self   :						List[Any]):
			UpperCamelCase__				:					int					=					tempfile.mkdtemp()

			# fmt: off
			UpperCamelCase__				:					Union[str, Any]					=					['l', 'o', 'w', 'e', 'r', 's', 't', 'i', 'd', 'n', 'lo', 'l</w>', 'w</w>', 'r</w>', 't</w>', 'low</w>', 'er</w>', 'lowest</w>', 'newer</w>', 'wider', '<unk>', '<|startoftext|>', '<|endoftext|>']
			# fmt: on
			UpperCamelCase__				:					Dict					=					dict(zip(UpperCAmelCase_  ,					range(len(UpperCAmelCase_))))
			UpperCamelCase__				:					Optional[Any]					=					['#version: 0.2', 'l o', 'lo w</w>', 'e r</w>', '']
			UpperCamelCase__				:					Union[str, Any]					=					{'unk_token': '<unk>'}

			UpperCamelCase__				:					Union[str, Any]					=					os.path.join(self.tmpdirname  ,					VOCAB_FILES_NAMES['vocab_file'])
			UpperCamelCase__				:					Optional[Any]					=					os.path.join(self.tmpdirname  ,					VOCAB_FILES_NAMES['merges_file'])
			with open(self.vocab_file  ,					'w'  ,					encoding='utf-8') as fp:
					fp.write(json.dumps(UpperCAmelCase_) + '\n')
			with open(self.merges_file  ,					'w'  ,					encoding='utf-8') as fp:
					fp.write('\n'.join(UpperCAmelCase_))

			UpperCamelCase__				:					Dict					=					{
			    'do_resize': True,
			    'size': 20,
			    'do_center_crop': True,
			    'crop_size': 18,
			    'do_normalize': True,
			    'image_mean': [0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73],
			    'image_std': [0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11],
			}
			UpperCamelCase__				:					Any					=					os.path.join(self.tmpdirname  ,					UpperCAmelCase_)
			with open(self.image_processor_file  ,					'w'  ,					encoding='utf-8') as fp:
					json.dump(UpperCAmelCase_  ,					UpperCAmelCase_)

	def      __UpperCamelCase							(      self   :						Dict  ,					**UpperCAmelCase_   :						Union[str, Any]):
			return CLIPTokenizer.from_pretrained(self.tmpdirname  ,					**UpperCAmelCase_)

	def      __UpperCamelCase							(      self   :						Optional[int]  ,					**UpperCAmelCase_   :						str):
			return CLIPTokenizerFast.from_pretrained(self.tmpdirname  ,					**UpperCAmelCase_)

	def      __UpperCamelCase							(      self   :						Optional[Any]  ,					**UpperCAmelCase_   :						Union[str, Any]):
			return CLIPImageProcessor.from_pretrained(self.tmpdirname  ,					**UpperCAmelCase_)

	def      __UpperCamelCase							(      self   :						str):
			shutil.rmtree(self.tmpdirname)

	def      __UpperCamelCase							(      self   :						Tuple):
			UpperCamelCase__				:					List[str]					=					[np.random.randint(255  ,					size=(3, 30, 400)  ,					dtype=np.uinta)]

			UpperCamelCase__				:					List[str]					=					[Image.fromarray(np.moveaxis(UpperCAmelCase_  ,					0  ,					-1)) for x in image_inputs]

			return image_inputs

	def      __UpperCamelCase							(      self   :						Dict):
			UpperCamelCase__				:					Union[str, Any]					=					self.get_tokenizer()
			UpperCamelCase__				:					Optional[Any]					=					self.get_rust_tokenizer()
			UpperCamelCase__				:					Any					=					self.get_image_processor()

			UpperCamelCase__				:					str					=					CLIPProcessor(tokenizer=UpperCAmelCase_  ,					image_processor=UpperCAmelCase_)
			processor_slow.save_pretrained(self.tmpdirname)
			UpperCamelCase__				:					Any					=					CLIPProcessor.from_pretrained(self.tmpdirname  ,					use_fast=UpperCAmelCase_)

			UpperCamelCase__				:					str					=					CLIPProcessor(tokenizer=UpperCAmelCase_  ,					image_processor=UpperCAmelCase_)
			processor_fast.save_pretrained(self.tmpdirname)
			UpperCamelCase__				:					Optional[int]					=					CLIPProcessor.from_pretrained(self.tmpdirname)

			self.assertEqual(processor_slow.tokenizer.get_vocab()  ,					tokenizer_slow.get_vocab())
			self.assertEqual(processor_fast.tokenizer.get_vocab()  ,					tokenizer_fast.get_vocab())
			self.assertEqual(tokenizer_slow.get_vocab()  ,					tokenizer_fast.get_vocab())
			self.assertIsInstance(processor_slow.tokenizer  ,					UpperCAmelCase_)
			self.assertIsInstance(processor_fast.tokenizer  ,					UpperCAmelCase_)

			self.assertEqual(processor_slow.image_processor.to_json_string()  ,					image_processor.to_json_string())
			self.assertEqual(processor_fast.image_processor.to_json_string()  ,					image_processor.to_json_string())
			self.assertIsInstance(processor_slow.image_processor  ,					UpperCAmelCase_)
			self.assertIsInstance(processor_fast.image_processor  ,					UpperCAmelCase_)

	def      __UpperCamelCase							(      self   :						List[str]):
			UpperCamelCase__				:					Union[str, Any]					=					CLIPProcessor(tokenizer=self.get_tokenizer()  ,					image_processor=self.get_image_processor())
			processor.save_pretrained(self.tmpdirname)

			UpperCamelCase__				:					List[str]					=					self.get_tokenizer(bos_token='(BOS)'  ,					eos_token='(EOS)')
			UpperCamelCase__				:					Tuple					=					self.get_image_processor(do_normalize=UpperCAmelCase_  ,					padding_value=1.0)

			UpperCamelCase__				:					Dict					=					CLIPProcessor.from_pretrained(
			    self.tmpdirname  ,					bos_token='(BOS)'  ,					eos_token='(EOS)'  ,					do_normalize=UpperCAmelCase_  ,					padding_value=1.0)

			self.assertEqual(processor.tokenizer.get_vocab()  ,					tokenizer_add_kwargs.get_vocab())
			self.assertIsInstance(processor.tokenizer  ,					UpperCAmelCase_)

			self.assertEqual(processor.image_processor.to_json_string()  ,					image_processor_add_kwargs.to_json_string())
			self.assertIsInstance(processor.image_processor  ,					UpperCAmelCase_)

	def      __UpperCamelCase							(      self   :						Dict):
			UpperCamelCase__				:					Optional[Any]					=					self.get_image_processor()
			UpperCamelCase__				:					int					=					self.get_tokenizer()

			UpperCamelCase__				:					List[Any]					=					CLIPProcessor(tokenizer=UpperCAmelCase_  ,					image_processor=UpperCAmelCase_)

			UpperCamelCase__				:					int					=					self.prepare_image_inputs()

			UpperCamelCase__				:					int					=					image_processor(UpperCAmelCase_  ,					return_tensors='np')
			UpperCamelCase__				:					Optional[int]					=					processor(images=UpperCAmelCase_  ,					return_tensors='np')

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

	def      __UpperCamelCase							(      self   :						Dict):
			UpperCamelCase__				:					Optional[Any]					=					self.get_image_processor()
			UpperCamelCase__				:					Dict					=					self.get_tokenizer()

			UpperCamelCase__				:					List[Any]					=					CLIPProcessor(tokenizer=UpperCAmelCase_  ,					image_processor=UpperCAmelCase_)

			UpperCamelCase__				:					Any					=					'lower newer'

			UpperCamelCase__				:					Union[str, Any]					=					processor(text=UpperCAmelCase_)

			UpperCamelCase__				:					Optional[Any]					=					tokenizer(UpperCAmelCase_)

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

	def      __UpperCamelCase							(      self   :						int):
			UpperCamelCase__				:					Optional[int]					=					self.get_image_processor()
			UpperCamelCase__				:					List[str]					=					self.get_tokenizer()

			UpperCamelCase__				:					List[Any]					=					CLIPProcessor(tokenizer=UpperCAmelCase_  ,					image_processor=UpperCAmelCase_)

			UpperCamelCase__				:					Optional[Any]					=					'lower newer'
			UpperCamelCase__				:					List[Any]					=					self.prepare_image_inputs()

			UpperCamelCase__				:					str					=					processor(text=UpperCAmelCase_  ,					images=UpperCAmelCase_)

			self.assertListEqual(list(inputs.keys())  ,					['input_ids', 'attention_mask', 'pixel_values'])

			# test if it raises when no input is passed
			with pytest.raises(UpperCAmelCase_):
					processor()

	def      __UpperCamelCase							(      self   :						Dict):
			UpperCamelCase__				:					Any					=					self.get_image_processor()
			UpperCamelCase__				:					Dict					=					self.get_tokenizer()

			UpperCamelCase__				:					Optional[Any]					=					CLIPProcessor(tokenizer=UpperCAmelCase_  ,					image_processor=UpperCAmelCase_)

			UpperCamelCase__				:					Optional[Any]					=					[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

			UpperCamelCase__				:					List[Any]					=					processor.batch_decode(UpperCAmelCase_)
			UpperCamelCase__				:					Optional[int]					=					tokenizer.batch_decode(UpperCAmelCase_)

			self.assertListEqual(UpperCAmelCase_  ,					UpperCAmelCase_)





	def      __UpperCamelCase							(      self   :						str):
			UpperCamelCase__				:					Union[str, Any]					=					self.get_image_processor()
			UpperCamelCase__				:					List[str]					=					self.get_tokenizer()

			UpperCamelCase__				:					Optional[Any]					=					CLIPProcessor(tokenizer=UpperCAmelCase_  ,					image_processor=UpperCAmelCase_)

			UpperCamelCase__				:					List[Any]					=					'lower newer'
			UpperCamelCase__				:					Optional[int]					=					self.prepare_image_inputs()

			UpperCamelCase__				:					List[str]					=					processor(text=UpperCAmelCase_  ,					images=UpperCAmelCase_)

			self.assertListEqual(list(inputs.keys())  ,					processor.model_input_names)




