



from multiprocessing import Lock, Pipe, Process

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



def 		lowerCAmelCase__    (					UpperCamelCase_				:       Tuple ,       UpperCamelCase_				:       int ,       UpperCamelCase_				:       List[Any] ,       UpperCamelCase_				:       List[Any] ,       UpperCamelCase_				:       int ,       UpperCamelCase_				:       List[str] ,       UpperCamelCase_				:       List[str]	)->  List[str]:
    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 ,       1_0	):
        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(UpperCamelCase_	)
            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(UpperCamelCase_ ,       UpperCamelCase_	)
        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(UpperCamelCase_	)
            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(UpperCamelCase_ ,       UpperCamelCase_	)
    # after all swaps are performed, send the values back to main
    result_pipe[1].send(UpperCamelCase_	)



def 		lowerCAmelCase__    (					UpperCamelCase_				:       Union[str, Any]	)->  Optional[int]:
    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=UpperCamelCase_ ,       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(UpperCamelCase_	) - 1	):
        A__		 =					Pipe()
        A__		 =					Pipe()
        process_array_.append(
            Process(
                target=UpperCamelCase_ ,       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=UpperCamelCase_ ,       args=(
                len(UpperCamelCase_	) - 1,
                arr[len(UpperCamelCase_	) - 1],
                temp_ls,
                None,
                temp_lr,
                None,
                result_pipe[len(UpperCamelCase_	) - 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(UpperCamelCase_	)	):
        A__		 =					result_pipe[p][0].recv()
        process_array_[p].join()
    return arr



def 		lowerCAmelCase__    (					)->  Union[str, Any]:
    A__		 =					list(range(1_0 ,       0 ,       -1	)	)
    print('''Initial List'''	)
    print(*UpperCamelCase_	)
    A__		 =					odd_even_transposition(UpperCamelCase_	)
    print('''Sorted List\n'''	)
    print(*UpperCamelCase_	)


if __name__ == "__main__":
   main()





import numpy as np
from matplotlib import pyplot as plt
from sklearn.datasets import load_iris
from sklearn.metrics import ConfusionMatrixDisplay
from sklearn.model_selection import train_test_split
from xgboost import XGBClassifier



def 		lowerCAmelCase__    (					UpperCamelCase_				:       dict	)->  tuple:
    return (data["data"], data["target"])



def 		lowerCAmelCase__    (					UpperCamelCase_				:       np.ndarray ,       UpperCamelCase_				:       np.ndarray	)->  XGBClassifier:
    A__		 =					XGBClassifier()
    classifier.fit(UpperCamelCase_ ,       UpperCamelCase_	)
    return classifier



def 		lowerCAmelCase__    (					)->  None:
    A__		 =					load_iris()
    A__ ,	A__		 =					data_handling(UpperCamelCase_	)
    A__ ,	A__ ,	A__ ,	A__		 =					train_test_split(
        UpperCamelCase_ ,       UpperCamelCase_ ,       test_size=0.25	)

    A__		 =					iris['''target_names''']

    # Create an XGBoost Classifier from the training data
    A__		 =					xgboost(UpperCamelCase_ ,       UpperCamelCase_	)

    # Display the confusion matrix of the classifier with both training and test sets
    ConfusionMatrixDisplay.from_estimator(
        UpperCamelCase_ ,       UpperCamelCase_ ,       UpperCamelCase_ ,       display_labels=UpperCamelCase_ ,       cmap='''Blues''' ,       normalize='''true''' ,       )
    plt.title('''Normalized Confusion Matrix - IRIS Dataset'''	)
    plt.show()


if __name__ == "__main__":
   import doctest

   doctest.testmod(verbose=True)
   main()
