




'''simple docstring'''


import gc
import unittest

from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline
from transformers.pipelines import PipelineException
from transformers.testing_utils import (
    is_pipeline_test,
    is_torch_available,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_gpu,
    slow,
)

from .test_pipelines_common import ANY





@is_pipeline_test
class  __lowercase    (	unittest.TestCase			):
   _a    						=   MODEL_FOR_MASKED_LM_MAPPING
   _a    						=   TF_MODEL_FOR_MASKED_LM_MAPPING







   def 		UpperCamelCase__      (						self   )					->     str:
     super().tearDown()
     # clean-up as much as possible GPU memory occupied by PyTorch
     gc.collect()
     if is_torch_available():
       import torch

       torch.cuda.empty_cache()







   @require_tf
   def 		UpperCamelCase__      (						self   )					->     Any:
     __a								=       pipeline(task='fill-mask'   ,				model='sshleifer/tiny-distilroberta-base'   ,				top_k=2   ,				framework='tf'   )
     __a								=       unmasker('My name is <mask>'   )
     self.assertEqual(
         nested_simplify(UpperCamelCase   ,				decimals=6   )   ,				[
             {'sequence': 'My name is grouped', 'score': 2.1e-05, 'token': 3_8015, 'token_str': ' grouped'},
             {'sequence': 'My name is accuser', 'score': 2.1e-05, 'token': 2_5506, 'token_str': ' accuser'},
         ]   ,				)

     __a								=       unmasker('The largest city in France is <mask>'   )
     self.assertEqual(
         nested_simplify(UpperCamelCase   ,				decimals=6   )   ,				[
             {
                 'sequence': 'The largest city in France is grouped',
                 'score': 2.1e-05,
                 'token': 3_8015,
                 'token_str': ' grouped',
             },
             {
                 'sequence': 'The largest city in France is accuser',
                 'score': 2.1e-05,
                 'token': 2_5506,
                 'token_str': ' accuser',
             },
         ]   ,				)

     __a								=       unmasker('My name is <mask>'   ,				targets=[' Patrick', ' Clara', ' Teven']   ,				top_k=3   )
     self.assertEqual(
         nested_simplify(UpperCamelCase   ,				decimals=6   )   ,				[
             {'sequence': 'My name is Clara', 'score': 2e-05, 'token': 1_3606, 'token_str': ' Clara'},
             {'sequence': 'My name is Patrick', 'score': 2e-05, 'token': 3499, 'token_str': ' Patrick'},
             {'sequence': 'My name is Te', 'score': 1.9e-05, 'token': 2941, 'token_str': ' Te'},
         ]   ,				)







   @require_torch
   def 		UpperCamelCase__      (						self   )					->     Optional[Any]:
     __a								=       pipeline(task='fill-mask'   ,				model='sshleifer/tiny-distilroberta-base'   ,				top_k=2   ,				framework='pt'   )

     __a								=       unmasker('My name is <mask>'   )
     self.assertEqual(
         nested_simplify(UpperCamelCase   ,				decimals=6   )   ,				[
             {'sequence': 'My name is Maul', 'score': 2.2e-05, 'token': 3_5676, 'token_str': ' Maul'},
             {'sequence': 'My name isELS', 'score': 2.2e-05, 'token': 1_6416, 'token_str': 'ELS'},
         ]   ,				)

     __a								=       unmasker('The largest city in France is <mask>'   )
     self.assertEqual(
         nested_simplify(UpperCamelCase   ,				decimals=6   )   ,				[
             {
                 'sequence': 'The largest city in France is Maul',
                 'score': 2.2e-05,
                 'token': 3_5676,
                 'token_str': ' Maul',
             },
             {'sequence': 'The largest city in France isELS', 'score': 2.2e-05, 'token': 1_6416, 'token_str': 'ELS'},
         ]   ,				)

     __a								=       unmasker('My name is <mask>'   ,				targets=[' Patrick', ' Clara', ' Teven']   ,				top_k=3   )
     self.assertEqual(
         nested_simplify(UpperCamelCase   ,				decimals=6   )   ,				[
             {'sequence': 'My name is Patrick', 'score': 2.1e-05, 'token': 3499, 'token_str': ' Patrick'},
             {'sequence': 'My name is Te', 'score': 2e-05, 'token': 2941, 'token_str': ' Te'},
             {'sequence': 'My name is Clara', 'score': 2e-05, 'token': 1_3606, 'token_str': ' Clara'},
         ]   ,				)

     __a								=       unmasker('My name is <mask> <mask>'   ,				top_k=2   )

     self.assertEqual(
         nested_simplify(UpperCamelCase   ,				decimals=6   )   ,				[
             [
                 {
                     'score': 2.2e-05,
                     'token': 3_5676,
                     'token_str': ' Maul',
                     'sequence': '<s>My name is Maul<mask></s>',
                 },
                 {'score': 2.2e-05, 'token': 1_6416, 'token_str': 'ELS', 'sequence': '<s>My name isELS<mask></s>'},
             ],
             [
                 {
                     'score': 2.2e-05,
                     'token': 3_5676,
                     'token_str': ' Maul',
                     'sequence': '<s>My name is<mask> Maul</s>',
                 },
                 {'score': 2.2e-05, 'token': 1_6416, 'token_str': 'ELS', 'sequence': '<s>My name is<mask>ELS</s>'},
             ],
         ]   ,				)







   @require_torch_gpu
   def 		UpperCamelCase__      (						self   )					->     Any:
     __a								=       pipeline('fill-mask'   ,				model='hf-internal-testing/tiny-random-distilbert'   ,				device=0   ,				framework='pt'   )

     # convert model to fp16
     pipe.model.half()

     __a								=       pipe('Paris is the [MASK] of France.'   )
     # We actually don't care about the result, we just want to make sure
     # it works, meaning the float16 tensor got casted back to float32
     # for postprocessing.
     self.assertIsInstance(UpperCamelCase   ,				UpperCamelCase   )







   @slow
   @require_torch
   def 		UpperCamelCase__      (						self   )					->     Any:
     __a								=       pipeline(task='fill-mask'   ,				model='distilroberta-base'   ,				top_k=2   ,				framework='pt'   )
     self.run_large_test(UpperCamelCase   )







   @slow
   @require_tf
   def 		UpperCamelCase__      (						self   )					->     Optional[int]:
     __a								=       pipeline(task='fill-mask'   ,				model='distilroberta-base'   ,				top_k=2   ,				framework='tf'   )
     self.run_large_test(UpperCamelCase   )







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   )					->     Union[str, Any]:
     __a								=       unmasker('My name is <mask>'   )
     self.assertEqual(
         nested_simplify(UpperCamelCase   )   ,				[
             {'sequence': 'My name is John', 'score': 0.008, 'token': 610, 'token_str': ' John'},
             {'sequence': 'My name is Chris', 'score': 0.007, 'token': 1573, 'token_str': ' Chris'},
         ]   ,				)
     __a								=       unmasker('The largest city in France is <mask>'   )
     self.assertEqual(
         nested_simplify(UpperCamelCase   )   ,				[
             {
                 'sequence': 'The largest city in France is Paris',
                 'score': 0.251,
                 'token': 2201,
                 'token_str': ' Paris',
             },
             {
                 'sequence': 'The largest city in France is Lyon',
                 'score': 0.214,
                 'token': 1_2790,
                 'token_str': ' Lyon',
             },
         ]   ,				)

     __a								=       unmasker('My name is <mask>'   ,				targets=[' Patrick', ' Clara', ' Teven']   ,				top_k=3   )
     self.assertEqual(
         nested_simplify(UpperCamelCase   )   ,				[
             {'sequence': 'My name is Patrick', 'score': 0.005, 'token': 3499, 'token_str': ' Patrick'},
             {'sequence': 'My name is Clara', 'score': 0.000, 'token': 1_3606, 'token_str': ' Clara'},
             {'sequence': 'My name is Te', 'score': 0.000, 'token': 2941, 'token_str': ' Te'},
         ]   ,				)







   @require_torch
   def 		UpperCamelCase__      (						self   )					->     Any:
     __a								=       pipeline(task='fill-mask'   ,				model='sshleifer/tiny-distilroberta-base'   ,				framework='pt'   )
     __a								=       None
     __a								=       None
     self.run_pipeline_test(UpperCamelCase   ,				[]   )







   @require_tf
   def 		UpperCamelCase__      (						self   )					->     Optional[Any]:
     __a								=       pipeline(task='fill-mask'   ,				model='sshleifer/tiny-distilroberta-base'   ,				framework='tf'   )
     __a								=       None
     __a								=       None
     self.run_pipeline_test(UpperCamelCase   ,				[]   )







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase   ,				UpperCamelCase   )					->     List[str]:
     if tokenizer is None or tokenizer.mask_token_id is None:
       self.skipTest('The provided tokenizer has no mask token, (probably reformer or wav2vec2)'   )

     __a								=       FillMaskPipeline(model=UpperCamelCase   ,				tokenizer=UpperCamelCase   )
     __a								=       [
         f"This is another {tokenizer.mask_token} test",
     ]
     return fill_masker, examples







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase   )					->     List[Any]:
     __a								=       fill_masker.tokenizer
     __a								=       fill_masker.model

     __a								=       fill_masker(
         f"This is a {tokenizer.mask_token}"   ,				)
     self.assertEqual(
         UpperCamelCase   ,				[
             {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
             {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
             {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
             {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
             {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
         ]   ,				)

     __a								=       fill_masker([f"This is a {tokenizer.mask_token}"]   )
     self.assertEqual(
         UpperCamelCase   ,				[
             {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
             {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
             {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
             {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
             {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
         ]   ,				)

     __a								=       fill_masker([f"This is a {tokenizer.mask_token}", f"Another {tokenizer.mask_token} great test."]   )
     self.assertEqual(
         UpperCamelCase   ,				[
             [
                 {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
                 {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
                 {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
                 {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
                 {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
             ],
             [
                 {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
                 {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
                 {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
                 {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
                 {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
             ],
         ]   ,				)

     with self.assertRaises(UpperCamelCase   ):
       fill_masker([None]   )
     # No mask_token is not supported
     with self.assertRaises(UpperCamelCase   ):
       fill_masker('This is'   )

     self.run_test_top_k(UpperCamelCase   ,				UpperCamelCase   )
     self.run_test_targets(UpperCamelCase   ,				UpperCamelCase   )
     self.run_test_top_k_targets(UpperCamelCase   ,				UpperCamelCase   )
     self.fill_mask_with_duplicate_targets_and_top_k(UpperCamelCase   ,				UpperCamelCase   )
     self.fill_mask_with_multiple_masks(UpperCamelCase   ,				UpperCamelCase   )







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase   )					->     str:
     __a								=       tokenizer.get_vocab()
     __a								=       sorted(vocab.keys()   )[:2]
     # Pipeline argument
     __a								=       FillMaskPipeline(model=UpperCamelCase   ,				tokenizer=UpperCamelCase   ,				targets=UpperCamelCase   )
     __a								=       fill_masker(f"This is a {tokenizer.mask_token}"   )
     self.assertEqual(
         UpperCamelCase   ,				[
             {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
             {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
         ]   ,				)
     __a								=       {vocab[el] for el in targets}
     self.assertEqual({el['token'] for el in outputs}   ,				UpperCamelCase   )
     __a								=       [tokenizer.decode([x]   ) for x in target_ids]
     self.assertEqual({el['token_str'] for el in outputs}   ,				set(UpperCamelCase   )   )

     # Call argument
     __a								=       FillMaskPipeline(model=UpperCamelCase   ,				tokenizer=UpperCamelCase   )
     __a								=       fill_masker(f"This is a {tokenizer.mask_token}"   ,				targets=UpperCamelCase   )
     self.assertEqual(
         UpperCamelCase   ,				[
             {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
             {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
         ]   ,				)
     __a								=       {vocab[el] for el in targets}
     self.assertEqual({el['token'] for el in outputs}   ,				UpperCamelCase   )
     __a								=       [tokenizer.decode([x]   ) for x in target_ids]
     self.assertEqual({el['token_str'] for el in outputs}   ,				set(UpperCamelCase   )   )

     # Score equivalence
     __a								=       fill_masker(f"This is a {tokenizer.mask_token}"   ,				targets=UpperCamelCase   )
     __a								=       [top_mask['token_str'] for top_mask in outputs]
     __a								=       [top_mask['score'] for top_mask in outputs]

     # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
     if set(UpperCamelCase   ) == set(UpperCamelCase   ):
       __a								=       fill_masker(f"This is a {tokenizer.mask_token}"   ,				targets=UpperCamelCase   )
       __a								=       [top_mask['score'] for top_mask in unmasked_targets]
       self.assertEqual(nested_simplify(UpperCamelCase   )   ,				nested_simplify(UpperCamelCase   )   )

     # Raises with invalid
     with self.assertRaises(UpperCamelCase   ):
       __a								=       fill_masker(f"This is a {tokenizer.mask_token}"   ,				targets=[]   )
     # For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised
     if "" not in tokenizer.get_vocab():
       with self.assertRaises(UpperCamelCase   ):
         __a								=       fill_masker(f"This is a {tokenizer.mask_token}"   ,				targets=['']   )
       with self.assertRaises(UpperCamelCase   ):
         __a								=       fill_masker(f"This is a {tokenizer.mask_token}"   ,				targets=''   )







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase   )					->     Union[str, Any]:
     __a								=       FillMaskPipeline(model=UpperCamelCase   ,				tokenizer=UpperCamelCase   ,				top_k=2   )
     __a								=       fill_masker(f"This is a {tokenizer.mask_token}"   )
     self.assertEqual(
         UpperCamelCase   ,				[
             {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
             {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
         ]   ,				)

     __a								=       FillMaskPipeline(model=UpperCamelCase   ,				tokenizer=UpperCamelCase   )
     __a								=       fill_masker(f"This is a {tokenizer.mask_token}"   ,				top_k=2   )
     self.assertEqual(
         UpperCamelCase   ,				[
             {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
             {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
         ]   ,				)
     self.assertEqual(nested_simplify(UpperCamelCase   )   ,				nested_simplify(UpperCamelCase   )   )







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase   )					->     List[Any]:
     __a								=       tokenizer.get_vocab()
     __a								=       FillMaskPipeline(model=UpperCamelCase   ,				tokenizer=UpperCamelCase   )

     # top_k=2, ntargets=3
     __a								=       sorted(vocab.keys()   )[:3]
     __a								=       fill_masker(f"This is a {tokenizer.mask_token}"   ,				top_k=2   ,				targets=UpperCamelCase   )

     # If we use the most probably targets, and filter differently, we should still
     # have the same results
     __a								=       [el['token_str'] for el in sorted(UpperCamelCase   ,				key=lambda UpperCamelCase   : x["score"]   ,				reverse=UpperCamelCase   )]
     # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
     if set(UpperCamelCase   ).issubset(UpperCamelCase   ):
       __a								=       fill_masker(f"This is a {tokenizer.mask_token}"   ,				top_k=3   ,				targets=UpperCamelCase   )
       # They should yield exactly the same result
       self.assertEqual(nested_simplify(UpperCamelCase   )   ,				nested_simplify(UpperCamelCase   )   )







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase   )					->     str:
     __a								=       FillMaskPipeline(model=UpperCamelCase   ,				tokenizer=UpperCamelCase   )
     __a								=       tokenizer.get_vocab()
     # String duplicates + id duplicates
     __a								=       sorted(vocab.keys()   )[:3]
     __a								=       [targets[0], targets[1], targets[0], targets[2], targets[1]]
     __a								=       fill_masker(f"My name is {tokenizer.mask_token}"   ,				targets=UpperCamelCase   ,				top_k=10   )

     # The target list contains duplicates, so we can't output more
     # than them
     self.assertEqual(len(UpperCamelCase   )   ,				3   )







   def 		UpperCamelCase__      (						self   ,				UpperCamelCase   ,				UpperCamelCase   )					->     Dict:
     __a								=       FillMaskPipeline(model=UpperCamelCase   ,				tokenizer=UpperCamelCase   )

     __a								=       fill_masker(
         f"This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}"   ,				top_k=2   )
     self.assertEqual(
         UpperCamelCase   ,				[
             [
                 {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
                 {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
             ],
             [
                 {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
                 {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
             ],
             [
                 {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
                 {'sequence': ANY(UpperCamelCase   ), 'score': ANY(UpperCamelCase   ), 'token': ANY(UpperCamelCase   ), 'token_str': ANY(UpperCamelCase   )},
             ],
         ]   ,				)









'''simple docstring'''


from multiprocessing import Lock, Pipe, Process

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


def     SCREAMING_SNAKE_CASE							(   a_						:				str					,       a_						:				Tuple					,       a_						:				Dict					,       a_						:				Optional[Any]					,       a_						:				str					,       a_						:				Any					,       a_						:				Optional[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(a_      )
      process_lock.release()

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

      # take the lower value since you are on the left
      __a								=       min(a_					,       a_      )
    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(a_      )
      process_lock.release()

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

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


def     SCREAMING_SNAKE_CASE							(   a_						:				List[str]      ):
  __a								=       []
  __a								=       []
  # 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
  __a								=       Pipe()
  __a								=       Pipe()
  process_array_.append(
      Process(
          target=a_					,       args=(0, arr[0], None, temp_rs, None, temp_rr, result_pipe[0])					,       )      )
  __a								=       temp_rs
  __a								=       temp_rr

  for i in range(1					,       len(a_      ) - 1      ):
    __a								=       Pipe()
    __a								=       Pipe()
    process_array_.append(
        Process(
            target=a_					,       args=(i, arr[i], temp_ls, temp_rs, temp_lr, temp_rr, result_pipe[i])					,       )      )
    __a								=       temp_rs
    __a								=       temp_rr

  process_array_.append(
      Process(
          target=a_					,       args=(
              len(a_      ) - 1,
              arr[len(a_      ) - 1],
              temp_ls,
              None,
              temp_lr,
              None,
              result_pipe[len(a_      ) - 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(a_      )      ):
    __a								=       result_pipe[p][0].recv()
    process_array_[p].join()
  return arr


def     SCREAMING_SNAKE_CASE							(   ):
  __a								=       list(range(10					,       0					,       -1      )      )
  print('Initial List'      )
  print(*a_      )
  __a								=       odd_even_transposition(a_      )
  print('Sorted List\n'      )
  print(*a_      )


if __name__ == "__main__":
  main()



