






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,
)
__lowercase       :Tuple       =  logging.getLogger(__name__)







def       UpperCAmelCase							(     _lowerCamelCase      :  str     ):





						'''simple docstring'''


						SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					git.Repo(search_parent_directories=_lowerCamelCase     )
						SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					{
						    "repo_id": str(_lowerCamelCase     ),
						    "repo_sha": str(repo.head.object.hexsha     ),
						    "repo_branch": str(repo.active_branch     ),
						}

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







def       UpperCAmelCase							(     _lowerCamelCase      :  Tuple     ):





						'''simple docstring'''


						if params.n_gpu <= 0:
												SCREAMING_SNAKE_CASE__     :				str   =					0
												SCREAMING_SNAKE_CASE__     :				int   =					-1
												SCREAMING_SNAKE_CASE__     :				List[Any]   =					True
												SCREAMING_SNAKE_CASE__     :				Dict   =					False
												return

						assert torch.cuda.is_available()

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

												SCREAMING_SNAKE_CASE__     :				int   =					int(os.environ["WORLD_SIZE"]     )
												SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					int(os.environ["N_GPU_NODE"]     )
												SCREAMING_SNAKE_CASE__     :				List[str]   =					int(os.environ["RANK"]     )

												# number of nodes / node ID
												SCREAMING_SNAKE_CASE__     :				int   =					params.world_size // params.n_gpu_per_node
												SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					params.global_rank // params.n_gpu_per_node
												SCREAMING_SNAKE_CASE__     :				List[str]   =					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

												SCREAMING_SNAKE_CASE__     :				List[str]   =					1
												SCREAMING_SNAKE_CASE__     :				List[str]   =					0
												SCREAMING_SNAKE_CASE__     :				Tuple   =					0
												SCREAMING_SNAKE_CASE__     :				Tuple   =					0
												SCREAMING_SNAKE_CASE__     :				Optional[int]   =					1
												SCREAMING_SNAKE_CASE__     :				List[Any]   =					1
												SCREAMING_SNAKE_CASE__     :				List[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
						SCREAMING_SNAKE_CASE__     :				List[Any]   =					params.node_id == 0 and params.local_rank == 0
						SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					params.n_nodes > 1

						# summary
						SCREAMING_SNAKE_CASE__     :				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       UpperCAmelCase							(     _lowerCamelCase      :  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     )






from __future__ import annotations







def       UpperCAmelCase							(     _lowerCamelCase      :  list[int]			,   _lowerCamelCase      :  int     ):





						'''simple docstring'''


						if len(_lowerCamelCase     ) < k or k < 0:
												raise ValueError("Invalid Input"     )
						SCREAMING_SNAKE_CASE__     :				int   =					sum(array[:k]     )
						for i in range(len(_lowerCamelCase     ) - k     ):
												SCREAMING_SNAKE_CASE__     :				str   =					current_sum - array[i] + array[i + k]
												SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					max(_lowerCamelCase			,   _lowerCamelCase     )
						return max_sum


if __name__ == "__main__":
				from doctest import testmod
				from random import randint

				testmod()
				__lowercase       :List[str]       =  [randint(-1_000, 1_000) for i in range(100)]
				__lowercase       :Any       =  randint(0, 110)
				print(f"The maximum sum of {k} consecutive elements is {max_sum_in_array(array,k)}")