






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__       =     logging.getLogger(__name__)

def _UpperCAmelCase   (	a						:	str ):
							snake_case__	  =       git.Repo(search_parent_directories=a )
							snake_case__	  =       {
							    """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 _UpperCAmelCase   (	a						:	Tuple ):
							if params.n_gpu <= 0:
														snake_case__	  =       0
														snake_case__	  =       -1
														snake_case__	  =       True
														snake_case__	  =       False
														return

							assert torch.cuda.is_available()

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

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

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

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

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








from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


a__       =     {
    """configuration_clip""": [
        """CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """CLIPConfig""",
        """CLIPOnnxConfig""",
        """CLIPTextConfig""",
        """CLIPVisionConfig""",
    ],
    """processing_clip""": ["""CLIPProcessor"""],
    """tokenization_clip""": ["""CLIPTokenizer"""],
}

try:
	if not is_tokenizers_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	a__       =     ["""CLIPTokenizerFast"""]

try:
	if not is_vision_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	a__       =     ["""CLIPFeatureExtractor"""]
	a__       =     ["""CLIPImageProcessor"""]

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	a__       =     [
	    """CLIP_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """CLIPModel""",
	    """CLIPPreTrainedModel""",
	    """CLIPTextModel""",
	    """CLIPTextModelWithProjection""",
	    """CLIPVisionModel""",
	    """CLIPVisionModelWithProjection""",
	]

try:
	if not is_tf_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	a__       =     [
	    """TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """TFCLIPModel""",
	    """TFCLIPPreTrainedModel""",
	    """TFCLIPTextModel""",
	    """TFCLIPVisionModel""",
	]

try:
	if not is_flax_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	a__       =     [
	    """FlaxCLIPModel""",
	    """FlaxCLIPPreTrainedModel""",
	    """FlaxCLIPTextModel""",
	    """FlaxCLIPTextPreTrainedModel""",
	    """FlaxCLIPVisionModel""",
	    """FlaxCLIPVisionPreTrainedModel""",
	]


if TYPE_CHECKING:
	from .configuration_clip import (
	    CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
	    CLIPConfig,
	    CLIPOnnxConfig,
	    CLIPTextConfig,
	    CLIPVisionConfig,
	)
	from .processing_clip import CLIPProcessor
	from .tokenization_clip import CLIPTokenizer

	try:
		if not is_tokenizers_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_clip_fast import CLIPTokenizerFast

	try:
		if not is_vision_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .feature_extraction_clip import CLIPFeatureExtractor
		from .image_processing_clip import CLIPImageProcessor

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_clip import (
		    CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
		    CLIPModel,
		    CLIPPreTrainedModel,
		    CLIPTextModel,
		    CLIPTextModelWithProjection,
		    CLIPVisionModel,
		    CLIPVisionModelWithProjection,
		)

	try:
		if not is_tf_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tf_clip import (
		    TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFCLIPModel,
		    TFCLIPPreTrainedModel,
		    TFCLIPTextModel,
		    TFCLIPVisionModel,
		)

	try:
		if not is_flax_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_flax_clip import (
		    FlaxCLIPModel,
		    FlaxCLIPPreTrainedModel,
		    FlaxCLIPTextModel,
		    FlaxCLIPTextPreTrainedModel,
		    FlaxCLIPVisionModel,
		    FlaxCLIPVisionPreTrainedModel,
		)


else:
	import sys

	a__       =     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
