





import argparse
import json
from collections import OrderedDict
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    SegformerConfig,
    SegformerForImageClassification,
    SegformerForSemanticSegmentation,
    SegformerImageProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
A_												=     logging.get_logger(__name__)





def    __UpperCamelCase      (    a,     a=False) ->Any:
					lowerCamelCase__       =       OrderedDict()
					for key, value in state_dict.items():
										if encoder_only and not key.startswith("head"):
															lowerCamelCase__       =       "segformer.encoder." + key
										if key.startswith("backbone"):
															lowerCamelCase__       =       key.replace("backbone",     "segformer.encoder")
										if "patch_embed" in key:
															# replace for example patch_embed1 by patch_embeddings.0
															lowerCamelCase__       =       key[key.find("patch_embed") + len("patch_embed")]
															lowerCamelCase__       =       key.replace(f"patch_embed{idx}",     f"patch_embeddings.{int(__snake_case)-1}")
										if "norm" in key:
															lowerCamelCase__       =       key.replace("norm",     "layer_norm")
										if "segformer.encoder.layer_norm" in key:
															# replace for example layer_norm1 by layer_norm.0
															lowerCamelCase__       =       key[key.find("segformer.encoder.layer_norm") + len("segformer.encoder.layer_norm")]
															lowerCamelCase__       =       key.replace(f"layer_norm{idx}",     f"layer_norm.{int(__snake_case)-1}")
										if "layer_norm1" in key:
															lowerCamelCase__       =       key.replace("layer_norm1",     "layer_norm_1")
										if "layer_norm2" in key:
															lowerCamelCase__       =       key.replace("layer_norm2",     "layer_norm_2")
										if "block" in key:
															# replace for example block1 by block.0
															lowerCamelCase__       =       key[key.find("block") + len("block")]
															lowerCamelCase__       =       key.replace(f"block{idx}",     f"block.{int(__snake_case)-1}")
										if "attn.q" in key:
															lowerCamelCase__       =       key.replace("attn.q",     "attention.self.query")
										if "attn.proj" in key:
															lowerCamelCase__       =       key.replace("attn.proj",     "attention.output.dense")
										if "attn" in key:
															lowerCamelCase__       =       key.replace("attn",     "attention.self")
										if "fc1" in key:
															lowerCamelCase__       =       key.replace("fc1",     "dense1")
										if "fc2" in key:
															lowerCamelCase__       =       key.replace("fc2",     "dense2")
										if "linear_pred" in key:
															lowerCamelCase__       =       key.replace("linear_pred",     "classifier")
										if "linear_fuse" in key:
															lowerCamelCase__       =       key.replace("linear_fuse.conv",     "linear_fuse")
															lowerCamelCase__       =       key.replace("linear_fuse.bn",     "batch_norm")
										if "linear_c" in key:
															# replace for example linear_c4 by linear_c.3
															lowerCamelCase__       =       key[key.find("linear_c") + len("linear_c")]
															lowerCamelCase__       =       key.replace(f"linear_c{idx}",     f"linear_c.{int(__snake_case)-1}")
										if key.startswith("head"):
															lowerCamelCase__       =       key.replace("head",     "classifier")
										lowerCamelCase__       =       value

					return new_state_dict





def    __UpperCamelCase      (    a,     a) ->Any:
					# for each of the encoder blocks:
					for i in range(config.num_encoder_blocks):
										for j in range(config.depths[i]):
															# read in weights + bias of keys and values (which is a single matrix in the original implementation)
															lowerCamelCase__       =       state_dict.pop(f"segformer.encoder.block.{i}.{j}.attention.self.kv.weight")
															lowerCamelCase__       =       state_dict.pop(f"segformer.encoder.block.{i}.{j}.attention.self.kv.bias")
															# next, add keys and values (in that order) to the state dict
															lowerCamelCase__       =       kv_weight[
															    : config.hidden_sizes[i], :
															]
															lowerCamelCase__       =       kv_bias[: config.hidden_sizes[i]]
															lowerCamelCase__       =       kv_weight[
															    config.hidden_sizes[i] :, :
															]
															lowerCamelCase__       =       kv_bias[
															    config.hidden_sizes[i] :
															]





def    __UpperCamelCase      (    ) ->str:
					lowerCamelCase__       =       "http://images.cocodataset.org/val2017/000000039769.jpg"
					lowerCamelCase__       =       Image.open(requests.get(__snake_case,     stream=__snake_case).raw)

					return image





@torch.no_grad()
def    __UpperCamelCase      (    a,     a,     a) ->Optional[Any]:
					lowerCamelCase__       =       SegformerConfig()
					lowerCamelCase__       =       False

					# set attributes based on model_name
					lowerCamelCase__       =       "huggingface/label-files"
					if "segformer" in model_name:
										lowerCamelCase__       =       model_name[len("segformer.") : len("segformer.") + 2]
										if "ade" in model_name:
															lowerCamelCase__       =       150
															lowerCamelCase__       =       "ade20k-id2label.json"
															lowerCamelCase__       =       (1, 150, 128, 128)
										elif "city" in model_name:
															lowerCamelCase__       =       19
															lowerCamelCase__       =       "cityscapes-id2label.json"
															lowerCamelCase__       =       (1, 19, 128, 128)
										else:
															raise ValueError(f"Model {model_name} not supported")
					elif "mit" in model_name:
										lowerCamelCase__       =       True
										lowerCamelCase__       =       model_name[4:6]
										lowerCamelCase__       =       1000
										lowerCamelCase__       =       "imagenet-1k-id2label.json"
										lowerCamelCase__       =       (1, 1000)
					else:
										raise ValueError(f"Model {model_name} not supported")

					# set config attributes
					lowerCamelCase__       =       json.load(open(hf_hub_download(__snake_case,     __snake_case,     repo_type="dataset"),     "r"))
					lowerCamelCase__       =       {int(__snake_case): v for k, v in idalabel.items()}
					lowerCamelCase__       =       idalabel
					lowerCamelCase__       =       {v: k for k, v in idalabel.items()}
					if size == "b0":
										pass
					elif size == "b1":
										lowerCamelCase__       =       [64, 128, 320, 512]
										lowerCamelCase__       =       256
					elif size == "b2":
										lowerCamelCase__       =       [64, 128, 320, 512]
										lowerCamelCase__       =       768
										lowerCamelCase__       =       [3, 4, 6, 3]
					elif size == "b3":
										lowerCamelCase__       =       [64, 128, 320, 512]
										lowerCamelCase__       =       768
										lowerCamelCase__       =       [3, 4, 18, 3]
					elif size == "b4":
										lowerCamelCase__       =       [64, 128, 320, 512]
										lowerCamelCase__       =       768
										lowerCamelCase__       =       [3, 8, 27, 3]
					elif size == "b5":
										lowerCamelCase__       =       [64, 128, 320, 512]
										lowerCamelCase__       =       768
										lowerCamelCase__       =       [3, 6, 40, 3]
					else:
										raise ValueError(f"Size {size} not supported")

					# load image processor (only resize + normalize)
					lowerCamelCase__       =       SegformerImageProcessor(
					    image_scale=(512, 512),     keep_ratio=__snake_case,     align=__snake_case,     do_random_crop=__snake_case)

					# prepare image
					lowerCamelCase__       =       prepare_img()
					lowerCamelCase__       =       image_processor(images=__snake_case,     return_tensors="pt").pixel_values

					logger.info(f"Converting model {model_name}...")

					# load original state dict
					if encoder_only:
										lowerCamelCase__       =       torch.load(__snake_case,     map_location=torch.device("cpu"))
					else:
										lowerCamelCase__       =       torch.load(__snake_case,     map_location=torch.device("cpu"))["state_dict"]

					# rename keys
					lowerCamelCase__       =       rename_keys(__snake_case,     encoder_only=__snake_case)
					if not encoder_only:
										del state_dict["decode_head.conv_seg.weight"]
										del state_dict["decode_head.conv_seg.bias"]

					# key and value matrices need special treatment
					read_in_k_v(__snake_case,     __snake_case)

					# create HuggingFace model and load state dict
					if encoder_only:
										lowerCamelCase__       =       False
										lowerCamelCase__       =       SegformerForImageClassification(__snake_case)
					else:
										lowerCamelCase__       =       SegformerForSemanticSegmentation(__snake_case)
					model.load_state_dict(__snake_case)
					model.eval()

					# forward pass
					lowerCamelCase__       =       model(__snake_case)
					lowerCamelCase__       =       outputs.logits

					# set expected_slice based on model name
					# ADE20k checkpoints
					if model_name == "segformer.b0.512x512.ade.160k":
										lowerCamelCase__       =       torch.tensor(
										    [
										        [[-4.6_3_1_0, -5.5_2_3_2, -6.2_3_5_6], [-5.1_9_2_1, -6.1_4_4_4, -6.5_9_9_6], [-5.4_4_2_4, -6.2_7_9_0, -6.7_5_7_4]],
										        [[-1_2.1_3_9_1, -1_3.3_1_2_2, -1_3.9_5_5_4], [-1_2.8_7_3_2, -1_3.9_3_5_2, -1_4.3_5_6_3], [-1_2.9_4_3_8, -1_3.8_2_2_6, -1_4.2_5_1_3]],
										        [[-1_2.5_1_3_4, -1_3.4_6_8_6, -1_4.4_9_1_5], [-1_2.8_6_6_9, -1_4.4_3_4_3, -1_4.7_7_5_8], [-1_3.2_5_2_3, -1_4.5_8_1_9, -1_5.0_6_9_4]],
										    ])
					elif model_name == "segformer.b1.512x512.ade.160k":
										lowerCamelCase__       =       torch.tensor(
										    [
										        [[-7.5_8_2_0, -8.7_2_3_1, -8.3_2_1_5], [-8.0_6_0_0, -1_0.3_5_2_9, -1_0.0_3_0_4], [-7.5_2_0_8, -9.4_1_0_3, -9.6_2_3_9]],
										        [[-1_2.6_9_1_8, -1_3.8_9_9_4, -1_3.7_1_3_7], [-1_3.3_1_9_6, -1_5.7_5_2_3, -1_5.4_7_8_9], [-1_2.9_3_4_3, -1_4.8_7_5_7, -1_4.9_6_8_9]],
										        [[-1_1.1_9_1_1, -1_1.9_4_2_1, -1_1.3_2_4_3], [-1_1.3_3_4_2, -1_3.6_8_3_9, -1_3.3_5_8_1], [-1_0.3_9_0_9, -1_2.1_8_3_2, -1_2.4_8_5_8]],
										    ])
					elif model_name == "segformer.b2.512x512.ade.160k":
										lowerCamelCase__       =       torch.tensor(
										    [
										        [[-1_1.8_1_7_3, -1_4.3_8_5_0, -1_6.3_1_2_8], [-1_4.5_6_4_8, -1_6.5_8_0_4, -1_8.6_5_6_8], [-1_4.7_2_2_3, -1_5.7_3_8_7, -1_8.4_2_1_8]],
										        [[-1_5.7_2_9_0, -1_7.9_1_7_1, -1_9.4_4_2_3], [-1_8.3_1_0_5, -1_9.9_4_4_8, -2_1.4_6_6_1], [-1_7.9_2_9_6, -1_8.6_4_9_7, -2_0.7_9_1_0]],
										        [[-1_5.0_7_8_3, -1_7.0_3_3_6, -1_8.2_7_8_9], [-1_6.8_7_7_1, -1_8.6_8_7_0, -2_0.1_6_1_2], [-1_6.2_4_5_4, -1_7.1_4_2_6, -1_9.5_0_5_5]],
										    ])
					elif model_name == "segformer.b3.512x512.ade.160k":
										lowerCamelCase__       =       torch.tensor(
										    [
										        [[-9.0_8_7_8, -1_0.2_0_8_1, -1_0.1_8_9_1], [-9.3_1_4_4, -1_0.7_9_4_1, -1_0.9_8_4_3], [-9.2_2_9_4, -1_0.3_8_5_5, -1_0.5_7_0_4]],
										        [[-1_2.2_3_1_6, -1_3.9_0_6_8, -1_3.6_1_0_2], [-1_2.9_1_6_1, -1_4.3_7_0_2, -1_4.3_2_3_5], [-1_2.5_2_3_3, -1_3.7_1_7_4, -1_3.7_9_3_2]],
										        [[-1_4.6_2_7_5, -1_5.2_4_9_0, -1_4.9_7_2_7], [-1_4.3_4_0_0, -1_5.9_6_8_7, -1_6.2_8_2_7], [-1_4.1_4_8_4, -1_5.4_0_3_3, -1_5.8_9_3_7]],
										    ])
					elif model_name == "segformer.b4.512x512.ade.160k":
										lowerCamelCase__       =       torch.tensor(
										    [
										        [[-1_2.3_1_4_4, -1_3.2_4_4_7, -1_4.0_8_0_2], [-1_3.3_6_1_4, -1_4.5_8_1_6, -1_5.6_1_1_7], [-1_3.3_3_4_0, -1_4.4_4_3_3, -1_6.2_2_1_9]],
										        [[-1_9.2_7_8_1, -2_0.4_1_2_8, -2_0.7_5_0_6], [-2_0.6_1_5_3, -2_1.6_5_6_6, -2_2.0_9_9_8], [-1_9.9_8_0_0, -2_1.0_4_3_0, -2_2.1_4_9_4]],
										        [[-1_8.8_7_3_9, -1_9.7_8_0_4, -2_1.1_8_3_4], [-2_0.1_2_3_3, -2_1.6_7_6_5, -2_3.2_9_4_4], [-2_0.0_3_1_5, -2_1.2_6_4_1, -2_3.6_9_4_4]],
										    ])
					elif model_name == "segformer.b5.640x640.ade.160k":
										lowerCamelCase__       =       torch.tensor(
										    [
										        [[-9.5_5_2_4, -1_2.0_8_3_5, -1_1.7_3_4_8], [-1_0.5_2_2_9, -1_3.6_4_4_6, -1_4.5_6_6_2], [-9.5_8_4_2, -1_2.8_8_5_1, -1_3.9_4_1_4]],
										        [[-1_5.3_4_3_2, -1_7.5_3_2_3, -1_7.0_8_1_8], [-1_6.3_3_3_0, -1_8.9_2_5_5, -1_9.2_1_0_1], [-1_5.1_3_4_0, -1_7.7_8_4_8, -1_8.3_9_7_1]],
										        [[-1_2.6_0_7_2, -1_4.9_4_8_6, -1_4.6_6_3_1], [-1_3.7_6_2_9, -1_7.0_9_0_7, -1_7.7_7_4_5], [-1_2.7_8_9_9, -1_6.1_6_9_5, -1_7.1_6_7_1]],
										    ])
					# Cityscapes checkpoints
					elif model_name == "segformer.b0.1024x1024.city.160k":
										lowerCamelCase__       =       torch.tensor(
										    [
										        [[-1_1.9_2_9_5, -1_3.4_0_5_7, -1_4.8_1_0_6], [-1_3.3_4_3_1, -1_4.8_1_7_9, -1_5.3_7_8_1], [-1_4.2_8_3_6, -1_5.5_9_4_2, -1_6.1_5_8_8]],
										        [[-1_1.4_9_0_6, -1_2.8_0_6_7, -1_3.6_5_6_4], [-1_3.1_1_8_9, -1_4.0_5_0_0, -1_4.1_5_4_3], [-1_3.8_7_4_8, -1_4.5_1_3_6, -1_4.8_7_8_9]],
										        [[0.5_3_7_4, 0.1_0_6_7, -0.4_7_4_2], [0.1_1_4_1, -0.2_2_5_5, -0.7_0_9_9], [-0.3_0_0_0, -0.5_9_2_4, -1.3_1_0_5]],
										    ])
					elif model_name == "segformer.b0.512x1024.city.160k":
										lowerCamelCase__       =       torch.tensor(
										    [
										        [[-7.8_2_1_7, -9.8_7_6_7, -1_0.1_7_1_7], [-9.4_4_3_8, -1_0.9_0_5_8, -1_1.4_0_4_7], [-9.7_9_3_9, -1_2.3_4_9_5, -1_2.1_0_7_9]],
										        [[-7.1_5_1_4, -9.5_3_3_6, -1_0.0_8_6_0], [-9.7_7_7_6, -1_1.6_8_2_2, -1_1.8_4_3_9], [-1_0.1_4_1_1, -1_2.7_6_5_5, -1_2.8_9_7_2]],
										        [[0.3_0_2_1, 0.0_8_0_5, -0.2_3_1_0], [-0.0_3_2_8, -0.1_6_0_5, -0.2_7_1_4], [-0.1_4_0_8, -0.5_4_7_7, -0.6_9_7_6]],
										    ])
					elif model_name == "segformer.b0.640x1280.city.160k":
										lowerCamelCase__       =       torch.tensor(
										    [
										        [
										            [-1.13_72E01, -1.27_87E01, -1.34_77E01],
										            [-1.25_36E01, -1.41_94E01, -1.44_09E01],
										            [-1.32_17E01, -1.48_88E01, -1.53_27E01],
										        ],
										        [
										            [-1.47_91E01, -1.71_22E01, -1.82_77E01],
										            [-1.71_63E01, -1.91_92E01, -1.95_33E01],
										            [-1.78_97E01, -1.99_91E01, -2.03_15E01],
										        ],
										        [
										            [7.67_23E-01, 4.19_21E-01, -7.78_78E-02],
										            [4.77_72E-01, 9.55_57E-03, -2.80_82E-01],
										            [3.60_32E-01, -2.48_26E-01, -5.11_68E-01],
										        ],
										    ])
					elif model_name == "segformer.b0.768x768.city.160k":
										lowerCamelCase__       =       torch.tensor(
										    [
										        [[-9.4_9_5_9, -1_1.3_0_8_7, -1_1.7_4_7_9], [-1_1.0_0_2_5, -1_2.6_5_4_0, -1_2.3_3_1_9], [-1_1.4_0_6_4, -1_3.0_4_8_7, -1_2.9_9_0_5]],
										        [[-9.8_9_0_5, -1_1.3_0_8_4, -1_2.0_8_5_4], [-1_1.1_7_2_6, -1_2.7_6_9_8, -1_2.9_5_8_3], [-1_1.5_9_8_5, -1_3.3_2_7_8, -1_4.1_7_7_4]],
										        [[0.2_2_1_3, 0.0_1_9_2, -0.2_4_6_6], [-0.1_7_3_1, -0.4_2_1_3, -0.4_8_7_4], [-0.3_1_2_6, -0.6_5_4_1, -1.1_3_8_9]],
										    ])
					elif model_name == "segformer.b1.1024x1024.city.160k":
										lowerCamelCase__       =       torch.tensor(
										    [
										        [[-1_3.5_7_4_8, -1_3.9_1_1_1, -1_2.6_5_0_0], [-1_4.3_5_0_0, -1_5.3_6_8_3, -1_4.2_3_2_8], [-1_4.7_5_3_2, -1_6.0_4_2_4, -1_5.6_0_8_7]],
										        [[-1_7.1_6_5_1, -1_5.8_7_2_5, -1_2.9_6_5_3], [-1_7.2_5_8_0, -1_7.3_7_1_8, -1_4.8_2_2_3], [-1_6.6_0_5_8, -1_6.8_7_8_3, -1_6.7_4_5_2]],
										        [[-3.6_4_5_6, -3.0_2_0_9, -1.4_2_0_3], [-3.0_7_9_7, -3.1_9_5_9, -2.0_0_0_0], [-1.8_7_5_7, -1.9_2_1_7, -1.6_9_9_7]],
										    ])
					elif model_name == "segformer.b2.1024x1024.city.160k":
										lowerCamelCase__       =       torch.tensor(
										    [
										        [[-1_6.0_9_7_6, -1_6.4_8_5_6, -1_7.3_9_6_2], [-1_6.6_2_3_4, -1_9.0_3_4_2, -1_9.7_6_8_5], [-1_6.0_9_0_0, -1_8.0_6_6_1, -1_9.1_1_8_0]],
										        [[-1_8.4_7_5_0, -1_8.8_4_8_8, -1_9.5_0_7_4], [-1_9.4_0_3_0, -2_2.1_5_7_0, -2_2.5_9_7_7], [-1_9.1_1_9_1, -2_0.8_4_8_6, -2_2.3_7_8_3]],
										        [[-4.5_1_7_8, -5.5_0_3_7, -6.5_1_0_9], [-5.0_8_8_4, -7.2_1_7_4, -8.0_3_3_4], [-4.4_1_5_6, -5.8_1_1_7, -7.2_9_7_0]],
										    ])
					elif model_name == "segformer.b3.1024x1024.city.160k":
										lowerCamelCase__       =       torch.tensor(
										    [
										        [[-1_4.2_0_8_1, -1_4.4_7_3_2, -1_4.1_9_7_7], [-1_4.5_8_6_7, -1_6.4_4_2_3, -1_6.6_3_5_6], [-1_3.4_4_4_1, -1_4.9_6_8_5, -1_6.8_6_9_6]],
										        [[-1_4.4_5_7_6, -1_4.7_0_7_3, -1_5.0_4_5_1], [-1_5.0_8_1_6, -1_7.6_2_3_7, -1_7.9_8_7_3], [-1_4.4_2_1_3, -1_6.0_1_9_9, -1_8.5_9_9_2]],
										        [[-4.7_3_4_9, -4.9_5_8_8, -5.0_9_6_6], [-4.3_2_1_0, -6.9_3_2_5, -7.2_5_9_1], [-3.4_3_1_2, -4.7_4_8_4, -7.1_9_1_7]],
										    ])
					elif model_name == "segformer.b4.1024x1024.city.160k":
										lowerCamelCase__       =       torch.tensor(
										    [
										        [[-1_1.7_7_3_7, -1_1.9_5_2_6, -1_1.3_2_7_3], [-1_3.6_6_9_2, -1_4.4_5_7_4, -1_3.8_8_7_8], [-1_3.8_9_3_7, -1_4.6_9_2_4, -1_5.9_3_4_5]],
										        [[-1_4.6_7_0_6, -1_4.5_3_3_0, -1_4.1_3_0_6], [-1_6.1_5_0_2, -1_6.8_1_8_0, -1_6.4_2_6_9], [-1_6.8_3_3_8, -1_7.8_9_3_9, -2_0.1_7_4_6]],
										        [[1.0_4_9_1, 0.8_2_8_9, 1.0_3_1_0], [1.1_0_4_4, 0.5_2_1_9, 0.8_0_5_5], [1.0_8_9_9, 0.6_9_2_6, 0.5_5_9_0]],
										    ])
					elif model_name == "segformer.b5.1024x1024.city.160k":
										lowerCamelCase__       =       torch.tensor(
										    [
										        [[-1_2.5_6_4_1, -1_3.4_7_7_7, -1_3.0_6_8_4], [-1_3.9_5_8_7, -1_5.8_9_8_3, -1_6.6_5_5_7], [-1_3.3_1_0_9, -1_5.7_3_5_0, -1_6.3_1_4_1]],
										        [[-1_4.7_0_7_4, -1_5.4_3_5_2, -1_4.5_9_4_4], [-1_6.6_3_5_3, -1_8.1_6_6_3, -1_8.6_1_2_0], [-1_5.1_7_0_2, -1_8.0_3_2_9, -1_8.1_5_4_7]],
										        [[-1.7_9_9_0, -2.0_9_5_1, -1.7_7_8_4], [-2.6_3_9_7, -3.8_2_4_5, -3.9_6_8_6], [-1.5_2_6_4, -2.8_1_2_6, -2.9_3_1_6]],
										    ])
					else:
										lowerCamelCase__       =       logits.argmax(-1).item()
										print("Predicted class:",     model.config.idalabel[predicted_class_idx])

					# verify logits
					if not encoder_only:
										assert logits.shape == expected_shape
										assert torch.allclose(logits[0, :3, :3, :3],     __snake_case,     atol=1E-2)

					# finally, save model and image processor
					logger.info(f"Saving PyTorch model and image processor to {pytorch_dump_folder_path}...")
					Path(__snake_case).mkdir(exist_ok=__snake_case)
					model.save_pretrained(__snake_case)
					image_processor.save_pretrained(__snake_case)


if __name__ == "__main__":
						A_												=     argparse.ArgumentParser()

						parser.add_argument(
						    "--model_name",
						    default="segformer.b0.512x512.ade.160k",
						    type=str,
						    help="Name of the model you'd like to convert.",
						)
						parser.add_argument(
						    "--checkpoint_path", default=None, type=str, help="Path to the original PyTorch checkpoint (.pth file)."
						)
						parser.add_argument(
						    "--pytorch_dump_folder_path", default=None, type=str, help="Path to the folder to output PyTorch model."
						)
						A_												=     parser.parse_args()
						convert_segformer_checkpoint(args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path)













from multiprocessing import Lock, Pipe, Process

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





def    __UpperCamelCase      (    a,     a,     a,     a,     a,     a,     a) ->Optional[int]:
					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()
															lowerCamelCase__       =       rr_cv[0].recv()
															process_lock.release()

															# take the lower value since you are on the left
															lowerCamelCase__       =       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()
															lowerCamelCase__       =       lr_cv[0].recv()
															process_lock.release()

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





def    __UpperCamelCase      (    a) ->Optional[Any]:
					lowerCamelCase__       =       []
					lowerCamelCase__       =       []
					# 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
					lowerCamelCase__       =       Pipe()
					lowerCamelCase__       =       Pipe()
					process_array_.append(
					    Process(
					        target=a,     args=(0, arr[0], None, temp_rs, None, temp_rr, result_pipe[0]),     ))
					lowerCamelCase__       =       temp_rs
					lowerCamelCase__       =       temp_rr

					for i in range(1,     len(a) - 1):
										lowerCamelCase__       =       Pipe()
										lowerCamelCase__       =       Pipe()
										process_array_.append(
										    Process(
										        target=a,     args=(i, arr[i], temp_ls, temp_rs, temp_lr, temp_rr, result_pipe[i]),     ))
										lowerCamelCase__       =       temp_rs
										lowerCamelCase__       =       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)):
										lowerCamelCase__       =       result_pipe[p][0].recv()
										process_array_[p].join()
					return arr





def    __UpperCamelCase      (    ) ->List[Any]:
					lowerCamelCase__       =       list(range(10,     0,     -1))
					print("Initial List")
					print(*a)
					lowerCamelCase__       =       odd_even_transposition(a)
					print("Sorted List\n")
					print(*a)


if __name__ == "__main__":
						main()

