






'''simple docstring'''

import json
import logging
import os
import socket

import git
import numpy as np
import torch


logging.basicConfig(
    format="%(asctime)s - %(levelname)s - %(name)s - PID: %(process)d -  %(message)s",
    datefmt="%m/%d/%Y %H:%M:%S",
    level=logging.INFO,
)
UpperCamelCase      					=logging.getLogger(__name__)



def 				snake_case       (  a_				:			str						)							->					Tuple:





      """simple docstring"""

      UpperCamelCase_					: Dict            =				git.Repo(search_parent_directories=a_						)
      UpperCamelCase_					: Tuple            =				{
          """repo_id""": str(a_						),
          """repo_sha""": str(repo.head.object.hexsha						),
          """repo_branch""": str(repo.active_branch						),
      }

      with open(os.path.join(a_     , """git_log.json"""						)     , """w"""						) as f:
            json.dump(a_     , a_     , indent=4						)



def 				snake_case       (  a_				:			Tuple						)							->					Optional[int]:





      """simple docstring"""

      if params.n_gpu <= 0:
            UpperCamelCase_					: Dict            =				0
            UpperCamelCase_					: Dict            =				-1
            UpperCamelCase_					: Any            =				True
            UpperCamelCase_					: Union[str, Any]            =				False
            return

      assert torch.cuda.is_available()

      logger.info("""Initializing GPUs"""						)
      if params.n_gpu > 1:
            assert params.local_rank != -1

            UpperCamelCase_					: int            =				int(os.environ["""WORLD_SIZE"""]						)
            UpperCamelCase_					: Union[str, Any]            =				int(os.environ["""N_GPU_NODE"""]						)
            UpperCamelCase_					: Tuple            =				int(os.environ["""RANK"""]						)

            # number of nodes / node ID
            UpperCamelCase_					: Union[str, Any]            =				params.world_size // params.n_gpu_per_node
            UpperCamelCase_					: int            =				params.global_rank // params.n_gpu_per_node
            UpperCamelCase_					: Dict            =				True

            assert params.n_nodes == int(os.environ["""N_NODES"""]						)
            assert params.node_id == int(os.environ["""NODE_RANK"""]						)

      # local job (single GPU)
      else:
            assert params.local_rank == -1

            UpperCamelCase_					: Tuple            =				1
            UpperCamelCase_					: List[Any]            =				0
            UpperCamelCase_					: int            =				0
            UpperCamelCase_					: str            =				0
            UpperCamelCase_					: List[str]            =				1
            UpperCamelCase_					: Optional[int]            =				1
            UpperCamelCase_					: Union[str, Any]            =				False

      # sanity checks
      assert params.n_nodes >= 1
      assert 0 <= params.node_id < params.n_nodes
      assert 0 <= params.local_rank <= params.global_rank < params.world_size
      assert params.world_size == params.n_nodes * params.n_gpu_per_node

      # define whether this is the master process / if we are in multi-node distributed mode
      UpperCamelCase_					: Optional[Any]            =				params.node_id == 0 and params.local_rank == 0
      UpperCamelCase_					: Union[str, Any]            =				params.n_nodes > 1

      # summary
      UpperCamelCase_					: Optional[int]            =				f"--- Global rank: {params.global_rank} - "
      logger.info(PREFIX + """Number of nodes: %i""" % params.n_nodes						)
      logger.info(PREFIX + """Node ID        : %i""" % params.node_id						)
      logger.info(PREFIX + """Local rank     : %i""" % params.local_rank						)
      logger.info(PREFIX + """World size     : %i""" % params.world_size						)
      logger.info(PREFIX + """GPUs per node  : %i""" % params.n_gpu_per_node						)
      logger.info(PREFIX + """Master         : %s""" % str(params.is_master						)						)
      logger.info(PREFIX + """Multi-node     : %s""" % str(params.multi_node						)						)
      logger.info(PREFIX + """Multi-GPU      : %s""" % str(params.multi_gpu						)						)
      logger.info(PREFIX + """Hostname       : %s""" % socket.gethostname()						)

      # set GPU device
      torch.cuda.set_device(params.local_rank						)

      # initialize multi-GPU
      if params.multi_gpu:
            logger.info("""Initializing PyTorch distributed"""						)
            torch.distributed.init_process_group(
                init_method="""env://"""     , backend="""nccl"""     , )



def 				snake_case       (  a_				:			Union[str, Any]						)							->					Any:





      """simple docstring"""

      np.random.seed(args.seed						)
      torch.manual_seed(args.seed						)
      if args.n_gpu > 0:
            torch.cuda.manual_seed_all(args.seed						)














'''simple docstring'''

def 				snake_case       (  a_				:			list						)							->					list:





      """simple docstring"""

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

            for i in range(1     , len(a_						) - 1     , 2						):  # iterating over all odd indices
                  if input_list[i] > input_list[i + 1]:
                        UpperCamelCase_     ,      UpperCamelCase_					: List[str]            =				input_list[i + 1], input_list[i]
                        # swapping if elements not in order
                        UpperCamelCase_					: Dict            =				False
      return input_list


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






