

import unittest

from transformers import is_vision_available
from transformers.pipelines import pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
						from PIL import Image
else:



						class   __lowercase				:




									"""simple docstring"""







									@staticmethod
									def        _SCREAMING_SNAKE_CASE			( *lowerCAmelCase__  :     Optional[int]   ,						**lowerCAmelCase__  :     int):
															pass



@is_pipeline_test
@require_vision
class   __lowercase				( unittest.TestCase	):




			"""simple docstring"""







			@require_torch
			def        _SCREAMING_SNAKE_CASE			( self  :     Optional[int]):
									SCREAMING_SNAKE_CASE_: int  		=       pipeline(
									    model="hf-internal-testing/tiny-random-clip-zero-shot-image-classification"   ,						)
									SCREAMING_SNAKE_CASE_: Dict  		=       Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png")
									SCREAMING_SNAKE_CASE_: List[str]  		=       image_classifier(lowerCAmelCase__   ,						candidate_labels=["a", "b", "c"])

									# The floating scores are so close, we enter floating error approximation and the order is not guaranteed across
									# python and torch versions.
									self.assertIn(
									    nested_simplify(lowerCAmelCase__)   ,						[
									        [{"score": 0.333, "label": "a"}, {"score": 0.333, "label": "b"}, {"score": 0.333, "label": "c"}],
									        [{"score": 0.333, "label": "a"}, {"score": 0.333, "label": "c"}, {"score": 0.333, "label": "b"}],
									    ]   ,						)

									SCREAMING_SNAKE_CASE_: Tuple  		=       image_classifier([image] * 5   ,						candidate_labels=["A", "B", "C"]   ,						batch_size=2)
									self.assertEqual(
									    nested_simplify(lowerCAmelCase__)   ,						[
									        [
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									        ],
									        [
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									        ],
									        [
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									        ],
									        [
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									        ],
									        [
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									        ],
									    ]   ,						)



			@require_tf
			def        _SCREAMING_SNAKE_CASE			( self  :     List[Any]):
									SCREAMING_SNAKE_CASE_: Union[str, Any]  		=       pipeline(
									    model="hf-internal-testing/tiny-random-clip-zero-shot-image-classification"   ,						framework="tf")
									SCREAMING_SNAKE_CASE_: Optional[Any]  		=       Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png")
									SCREAMING_SNAKE_CASE_: Tuple  		=       image_classifier(lowerCAmelCase__   ,						candidate_labels=["a", "b", "c"])

									self.assertEqual(
									    nested_simplify(lowerCAmelCase__)   ,						[{"score": 0.333, "label": "a"}, {"score": 0.333, "label": "b"}, {"score": 0.333, "label": "c"}]   ,						)

									SCREAMING_SNAKE_CASE_: Optional[Any]  		=       image_classifier([image] * 5   ,						candidate_labels=["A", "B", "C"]   ,						batch_size=2)
									self.assertEqual(
									    nested_simplify(lowerCAmelCase__)   ,						[
									        [
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									        ],
									        [
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									        ],
									        [
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									        ],
									        [
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									        ],
									        [
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									            {"score": 0.333, "label": ANY(lowerCAmelCase__)},
									        ],
									    ]   ,						)



			@slow
			@require_torch
			def        _SCREAMING_SNAKE_CASE			( self  :     Any):
									SCREAMING_SNAKE_CASE_: str  		=       pipeline(
									    task="zero-shot-image-classification"   ,						model="openai/clip-vit-base-patch32"   ,						)
									# This is an image of 2 cats with remotes and no planes
									SCREAMING_SNAKE_CASE_: str  		=       Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png")
									SCREAMING_SNAKE_CASE_: int  		=       image_classifier(lowerCAmelCase__   ,						candidate_labels=["cat", "plane", "remote"])

									self.assertEqual(
									    nested_simplify(lowerCAmelCase__)   ,						[
									        {"score": 0.511, "label": "remote"},
									        {"score": 0.485, "label": "cat"},
									        {"score": 0.004, "label": "plane"},
									    ]   ,						)

									SCREAMING_SNAKE_CASE_: Dict  		=       image_classifier([image] * 5   ,						candidate_labels=["cat", "plane", "remote"]   ,						batch_size=2)
									self.assertEqual(
									    nested_simplify(lowerCAmelCase__)   ,						[
									        [
									            {"score": 0.511, "label": "remote"},
									            {"score": 0.485, "label": "cat"},
									            {"score": 0.004, "label": "plane"},
									        ],
									    ]
									    * 5   ,						)




			@slow
			@require_tf
			def        _SCREAMING_SNAKE_CASE			( self  :     Optional[Any]):
									SCREAMING_SNAKE_CASE_: Optional[Any]  		=       pipeline(
									    task="zero-shot-image-classification"   ,						model="openai/clip-vit-base-patch32"   ,						framework="tf")
									# This is an image of 2 cats with remotes and no planes
									SCREAMING_SNAKE_CASE_: Optional[int]  		=       Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png")
									SCREAMING_SNAKE_CASE_: str  		=       image_classifier(lowerCAmelCase__   ,						candidate_labels=["cat", "plane", "remote"])
									self.assertEqual(
									    nested_simplify(lowerCAmelCase__)   ,						[
									        {"score": 0.511, "label": "remote"},
									        {"score": 0.485, "label": "cat"},
									        {"score": 0.004, "label": "plane"},
									    ]   ,						)

									SCREAMING_SNAKE_CASE_: str  		=       image_classifier([image] * 5   ,						candidate_labels=["cat", "plane", "remote"]   ,						batch_size=2)
									self.assertEqual(
									    nested_simplify(lowerCAmelCase__)   ,						[
									        [
									            {"score": 0.511, "label": "remote"},
									            {"score": 0.485, "label": "cat"},
									            {"score": 0.004, "label": "plane"},
									        ],
									    ]
									    * 5   ,						)











"""simple docstring"""






#
# This a `torch.distributed` diagnostics script that checks that all GPUs in the cluster (one or
# many nodes) can talk to each other via nccl and allocate gpu memory.
#
# To run first adjust the number of processes and nodes:
#
# python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py
#
# You may need to add --master_addr $MASTER_ADDR --master_port $MASTER_PORT if using a custom addr:port
#
# You can also use the rdzv API: --rdzv_endpoint $MASTER_ADDR:$MASTER_PORT --rdzv_backend c10d
#
# use torch.distributed.launch instead of torch.distributed.run for torch < 1.9
#
# If you get a hanging in `barrier` calls you have some network issues, you may try to debug this with:
#
# NCCL_DEBUG=INFO python -m torch.distributed.run --nproc_per_node 2 --nnodes 1 torch-distributed-gpu-test.py
#
# which should tell you what's going on behind the scenes.
#
#
# This script can be run via `srun` in the SLURM environment as well. Here is a SLURM script that
# runs on 2 nodes of 4 gpus per node:
#
# #SBATCH --job-name=test-nodes        # name
# #SBATCH --nodes=2                    # nodes
# #SBATCH --ntasks-per-node=1          # crucial - only 1 task per dist per node!
# #SBATCH --cpus-per-task=10           # number of cores per tasks
# #SBATCH --gres=gpu:4                 # number of gpus
# #SBATCH --time 0:05:00               # maximum execution time (HH:MM:SS)
# #SBATCH --output=%x-%j.out           # output file name
#
# GPUS_PER_NODE=4
# MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)
# MASTER_PORT=6000
#
# srun --jobid $SLURM_JOBID bash -c 'python -m torch.distributed.run \
# --nproc_per_node $GPUS_PER_NODE --nnodes $SLURM_NNODES --node_rank $SLURM_PROCID \
# --master_addr $MASTER_ADDR --master_port $MASTER_PORT \
# torch-distributed-gpu-test.py'
#

import fcntl
import os
import socket

import torch
import torch.distributed as dist


def 			_lowercase				(  *__snake_case	)						->   Optional[Any]:
			with open(__snake_case					,"r"	) as fh:
						fcntl.flock(__snake_case					,fcntl.LOCK_EX	)
						try:
									print(*__snake_case	)
						finally:
									fcntl.flock(__snake_case					,fcntl.LOCK_UN	)


__snake_case							:   List[Any]      =    int(os.environ['LOCAL_RANK'])
torch.cuda.set_device(local_rank)
__snake_case							:   List[str]      =    torch.device('cuda', local_rank)
__snake_case							:   Optional[Any]      =    socket.gethostname()

__snake_case							:   str      =    F"""[{hostname}-{local_rank}]"""

try:
	# test distributed
	dist.init_process_group('nccl')
	dist.all_reduce(torch.ones(1).to(device), op=dist.ReduceOp.SUM)
	dist.barrier()

	# test cuda is available and can allocate memory
	torch.cuda.is_available()
	torch.ones(1).cuda(local_rank)

	# global rank
	__snake_case							:   Tuple      =    dist.get_rank()
	__snake_case							:   Any      =    dist.get_world_size()

	printflock(F"""{gpu} is OK (global rank: {rank}/{world_size})""")

	dist.barrier()
	if rank == 0:
		printflock(F"""pt={torch.__version__}, cuda={torch.version.cuda}, nccl={torch.cuda.nccl.version()}""")

except Exception:
	printflock(F"""{gpu} is broken""")
	raise