



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  UpperCAmelCase__    (    lowercase__   ):
						__lowercase					=				git.Repo(search_parent_directories=lowercase__   )
						__lowercase					=				{
						    """repo_id""": str(lowercase__   ),
						    """repo_sha""": str(repo.head.object.hexsha   ),
						    """repo_branch""": str(repo.active_branch   ),
						}

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






def  UpperCAmelCase__    (    lowercase__   ):
						if params.n_gpu <= 0:
												__lowercase					=				0
												__lowercase					=				-1
												__lowercase					=				True
												__lowercase					=				False
												return

						assert torch.cuda.is_available()

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

												__lowercase					=				int(os.environ["""WORLD_SIZE"""]   )
												__lowercase					=				int(os.environ["""N_GPU_NODE"""]   )
												__lowercase					=				int(os.environ["""RANK"""]   )

												# number of nodes / node ID
												__lowercase					=				params.world_size // params.n_gpu_per_node
												__lowercase					=				params.global_rank // params.n_gpu_per_node
												__lowercase					=				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

												__lowercase					=				1
												__lowercase					=				0
												__lowercase					=				0
												__lowercase					=				0
												__lowercase					=				1
												__lowercase					=				1
												__lowercase					=				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
						__lowercase					=				params.node_id == 0 and params.local_rank == 0
						__lowercase					=				params.n_nodes > 1

						# summary
						__lowercase					=				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__    (    lowercase__   ):
						np.random.seed(args.seed   )
						torch.manual_seed(args.seed   )
						if args.n_gpu > 0:
												torch.cuda.manual_seed_all(args.seed   )










def  UpperCAmelCase__    (    lowercase__						,       lowercase__   ) ->      bool:
						__lowercase					=				len(lowercase__   )
						__lowercase					=				[[False] * (required_sum + 1) for _ in range(arr_len + 1   )]

						# for each arr value, a sum of zero(0) can be formed by not taking any element
						# hence True/1
						for i in range(arr_len + 1   ):
												__lowercase					=				True

						# sum is not zero and set is empty then false
						for i in range(1						,       required_sum + 1   ):
												__lowercase					=				False

						for i in range(1						,       arr_len + 1   ):
												for j in range(1						,       required_sum + 1   ):
																		if arr[i - 1] > j:
																								__lowercase					=				subset[i - 1][j]
																		if arr[i - 1] <= j:
																								__lowercase					=				subset[i - 1][j] or subset[i - 1][j - arr[i - 1]]

						return subset[arr_len][required_sum]


if __name__ == "__main__":
			import doctest

			doctest.testmod()





