


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


def 				lowerCamelCase__				(	A       :      List[Any]					):




						'''simple docstring'''






						UpperCAmelCase					    =     git.Repo(search_parent_directories=_lowercase					)
						UpperCAmelCase					    =     {
						    '''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 				lowerCamelCase__				(	A       :      Optional[int]					):




						'''simple docstring'''






						if params.n_gpu <= 0:
												UpperCAmelCase					    =     0
												UpperCAmelCase					    =     -1
												UpperCAmelCase					    =     True
												UpperCAmelCase					    =     False
												return

						assert torch.cuda.is_available()

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

												UpperCAmelCase					    =     int(os.environ['''WORLD_SIZE''']					)
												UpperCAmelCase					    =     int(os.environ['''N_GPU_NODE''']					)
												UpperCAmelCase					    =     int(os.environ['''RANK''']					)

												# number of nodes / node ID
												UpperCAmelCase					    =     params.world_size // params.n_gpu_per_node
												UpperCAmelCase					    =     params.global_rank // params.n_gpu_per_node
												UpperCAmelCase					    =     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					    =     1
												UpperCAmelCase					    =     0
												UpperCAmelCase					    =     0
												UpperCAmelCase					    =     0
												UpperCAmelCase					    =     1
												UpperCAmelCase					    =     1
												UpperCAmelCase					    =     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					    =     params.node_id == 0 and params.local_rank == 0
						UpperCAmelCase					    =     params.n_nodes > 1

						# summary
						UpperCAmelCase					    =     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 				lowerCamelCase__				(	A       :      Optional[int]					):




						'''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'''



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_lowercase      :      List[Any]            =					{
    """configuration_x_clip""": [
        """XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """XCLIPConfig""",
        """XCLIPTextConfig""",
        """XCLIPVisionConfig""",
    ],
    """processing_x_clip""": ["""XCLIPProcessor"""],
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_lowercase      :      List[str]            =					[
	    """XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """XCLIPModel""",
	    """XCLIPPreTrainedModel""",
	    """XCLIPTextModel""",
	    """XCLIPVisionModel""",
	]

if TYPE_CHECKING:
	from .configuration_x_clip import (
	    XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
	    XCLIPConfig,
	    XCLIPTextConfig,
	    XCLIPVisionConfig,
	)
	from .processing_x_clip import XCLIPProcessor

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_x_clip import (
		    XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
		    XCLIPModel,
		    XCLIPPreTrainedModel,
		    XCLIPTextModel,
		    XCLIPVisionModel,
		)

else:
	import sys

	_lowercase      :      List[Any]            =					_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





