






"""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,
)
A__       :				Optional[Any] 					=					logging.getLogger(__name__)

def  _snake_case				(     lowerCamelCase__	:    str  )				->	List[Any]:
							lowerCamelCase_       :							Optional[int]									=git.Repo(search_parent_directories=__SCREAMING_SNAKE_CASE  )
							lowerCamelCase_       :							Any									={
							    '''repo_id''': str(__SCREAMING_SNAKE_CASE  ),
							    '''repo_sha''': str(repo.head.object.hexsha  ),
							    '''repo_branch''': str(repo.active_branch  ),
							}

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

def  _snake_case				(     lowerCamelCase__	:    str  )				->	Tuple:





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

							assert torch.cuda.is_available()

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

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

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

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

							# summary
							lowerCamelCase_       :							List[Any]									=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				(     lowerCamelCase__	:    str  )				->	List[str]:
							np.random.seed(args.seed  )
							torch.manual_seed(args.seed  )
							if args.n_gpu > 0:
														torch.cuda.manual_seed_all(args.seed  )





'''simple docstring'''







import unittest

from knapsack import greedy_knapsack as kp






class  lowerCAmelCase__   (  unittest.TestCase     ):






					def 	_snake_case    (   self		):


											"""simple docstring"""





											lowercase_	:     List[str]													=       [10, 20, 30, 40, 50, 60]
											lowercase_	:     Optional[Any]													=       [2, 4, 6, 8, 10, 12]
											lowercase_	:     Union[str, Any]													=       1_00
											self.assertEqual(kp.calc_profit(__SCREAMING_SNAKE_CASE				,							__SCREAMING_SNAKE_CASE				,							__SCREAMING_SNAKE_CASE		)				,							2_10		)






					def 	_snake_case    (   self		):


											"""simple docstring"""





											self.assertRaisesRegex(__SCREAMING_SNAKE_CASE				,							'''max_weight must greater than zero.'''		)






					def 	_snake_case    (   self		):


											"""simple docstring"""





											self.assertRaisesRegex(__SCREAMING_SNAKE_CASE				,							'''Weight can not be negative.'''		)






					def 	_snake_case    (   self		):


											"""simple docstring"""





											self.assertRaisesRegex(__SCREAMING_SNAKE_CASE				,							'''Profit can not be negative.'''		)






					def 	_snake_case    (   self		):


											"""simple docstring"""





											self.assertRaisesRegex(__SCREAMING_SNAKE_CASE				,							'''max_weight must greater than zero.'''		)






					def 	_snake_case    (   self		):


											"""simple docstring"""





											self.assertRaisesRegex(
											    __SCREAMING_SNAKE_CASE				,							'''The length of profit and weight must be same.'''		)


if __name__ == "__main__":
							unittest.main()



