




'''simple docstring'''

import os
import sys
import tempfile

import torch

from .state import AcceleratorState
from .utils import PrecisionType, PrepareForLaunch, is_mps_available, patch_environment


def 		__magic_name__    (	__UpperCAmelCase,      __UpperCAmelCase=(),      __UpperCAmelCase=None,      __UpperCAmelCase="no",      __UpperCAmelCase="29500"	)		->					Union[str, Any]:

					'''simple docstring'''

					snake_case_									=				False
					snake_case_									=				False
					if any(key.startswith('''KAGGLE'''	) for key in os.environ.keys()	):
										snake_case_									=				True
					elif "IPython" in sys.modules:
										snake_case_									=				'''google.colab''' in str(sys.modules['''IPython'''].get_ipython()	)

					try:
										snake_case_									=				PrecisionType(mixed_precision.lower()	)
					except ValueError:
										raise ValueError(
										    F"Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}."	)

					if (in_colab or in_kaggle) and (os.environ.get('''TPU_NAME''',      __UpperCAmelCase	) is not None):
										# TPU launch
										import torch_xla.distributed.xla_multiprocessing as xmp

										if len(AcceleratorState._shared_state	) > 0:
															raise ValueError(
															    '''To train on TPU in Colab or Kaggle Kernel, the `Accelerator` should only be initialized inside '''
															    '''your training function. Restart your notebook and make sure no cells initializes an '''
															    '''`Accelerator`.'''	)
										if num_processes is None:
															snake_case_									=				8

										snake_case_									=				PrepareForLaunch(__UpperCAmelCase,      distributed_type='''TPU'''	)
										print(F"Launching a training on {num_processes} TPU cores."	)
										xmp.spawn(__UpperCAmelCase,      args=__UpperCAmelCase,      nprocs=__UpperCAmelCase,      start_method='''fork'''	)
					elif in_colab:
										# No need for a distributed launch otherwise as it's either CPU or one GPU.
										if torch.cuda.is_available():
															print('''Launching training on one GPU.'''	)
										else:
															print('''Launching training on one CPU.'''	)
										function(*__UpperCAmelCase	)
					else:
										if num_processes is None:
															raise ValueError(
															    '''You have to specify the number of GPUs you would like to use, add `num_processes=...` to your call.'''	)

										if num_processes > 1:
															# Multi-GPU launch
															from torch.multiprocessing import start_processes
															from torch.multiprocessing.spawn import ProcessRaisedException

															if len(AcceleratorState._shared_state	) > 0:
																				raise ValueError(
																				    '''To launch a multi-GPU training from your notebook, the `Accelerator` should only be initialized '''
																				    '''inside your training function. Restart your notebook and make sure no cells initializes an '''
																				    '''`Accelerator`.'''	)

															if torch.cuda.is_initialized():
																				raise ValueError(
																				    '''To launch a multi-GPU training from your notebook, you need to avoid running any instruction '''
																				    '''using `torch.cuda` in any cell. Restart your notebook and make sure no cells use any CUDA '''
																				    '''function.'''	)

															# torch.distributed will expect a few environment variable to be here. We set the ones common to each
															# process here (the other ones will be set be the launcher).
															with patch_environment(
															    world_size=__UpperCAmelCase,      master_addr='''127.0.01''',      master_port=__UpperCAmelCase,      mixed_precision=__UpperCAmelCase	):
																				snake_case_									=				PrepareForLaunch(__UpperCAmelCase,      distributed_type='''MULTI_GPU'''	)
																				print(F"Launching training on {num_processes} GPUs."	)
																				try:
																									start_processes(__UpperCAmelCase,      args=__UpperCAmelCase,      nprocs=__UpperCAmelCase,      start_method='''fork'''	)
																				except ProcessRaisedException as e:
																									if "Cannot re-initialize CUDA in forked subprocess" in e.args[0]:
																														raise RuntimeError(
																														    '''CUDA has been initialized before the `notebook_launcher` could create a forked subprocess. '''
																														    '''This likely stems from an outside import causing issues once the `notebook_launcher()` is called. '''
																														    '''Please review your imports and test them when running the `notebook_launcher()` to identify '''
																														    '''which one is problematic.'''	) from e

										else:
															# No need for a distributed launch otherwise as it's either CPU, GPU or MPS.
															if is_mps_available():
																				snake_case_									=				'''1'''
																				print('''Launching training on MPS.'''	)
															elif torch.cuda.is_available():
																				print('''Launching training on one GPU.'''	)
															else:
																				print('''Launching training on CPU.'''	)
															function(*__UpperCAmelCase	)


def 		__magic_name__    (	__UpperCAmelCase,      __UpperCAmelCase=(),      __UpperCAmelCase=2	)		->					Any:

					'''simple docstring'''

					from torch.multiprocessing import start_processes

					with tempfile.NamedTemporaryFile() as tmp_file:
										# torch.distributed will expect a few environment variable to be here. We set the ones common to each
										# process here (the other ones will be set be the launcher).
										with patch_environment(
										    world_size=__UpperCAmelCase,      master_addr='''127.0.01''',      master_port='''29500''',      accelerate_mixed_precision='''no''',      accelerate_debug_rdv_file=tmp_file.name,      accelerate_use_cpu='''yes''',      ):
															snake_case_									=				PrepareForLaunch(__UpperCAmelCase,      debug=__UpperCAmelCase	)
															start_processes(__UpperCAmelCase,      args=__UpperCAmelCase,      nprocs=__UpperCAmelCase,      start_method='''fork'''	)







'''simple docstring'''

import unittest

from transformers import (
    MODEL_FOR_OBJECT_DETECTION_MAPPING,
    AutoFeatureExtractor,
    AutoModelForObjectDetection,
    ObjectDetectionPipeline,
    is_vision_available,
    pipeline,
)
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_pytesseract,
    require_tf,
    require_timm,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
							from PIL import Image
else:






							class 						a				:


											@staticmethod
											def   A_ (		*lowercase_    :					int       ,				**lowercase_    :					str					):
																pass






@is_pipeline_test
@require_vision
@require_timm
@require_torch
class 						a				(   unittest.TestCase     ):
				snake_case_      =		MODEL_FOR_OBJECT_DETECTION_MAPPING


				def   A_ (		self    :					Any       ,				lowercase_    :					List[Any]       ,				lowercase_    :					Optional[int]       ,				lowercase_    :					List[str]					):
									snake_case_									=				ObjectDetectionPipeline(model=lowercase_       ,				image_processor=lowercase_					)
									return object_detector, ["./tests/fixtures/tests_samples/COCO/000000039769.png"]


				def   A_ (		self    :					Dict       ,				lowercase_    :					List[Any]       ,				lowercase_    :					int					):
									snake_case_									=				object_detector('''./tests/fixtures/tests_samples/COCO/000000039769.png'''       ,				threshold=0.0					)

									self.assertGreater(len(lowercase_					)       ,				0					)
									for detected_object in outputs:
														self.assertEqual(
														    lowercase_       ,				{
														        '''score''': ANY(lowercase_					),
														        '''label''': ANY(lowercase_					),
														        '''box''': {'''xmin''': ANY(lowercase_					), '''ymin''': ANY(lowercase_					), '''xmax''': ANY(lowercase_					), '''ymax''': ANY(lowercase_					)},
														    }       ,				)

									import datasets

									snake_case_									=				datasets.load_dataset('''hf-internal-testing/fixtures_image_utils'''       ,				'''image'''       ,				split='''test'''					)

									snake_case_									=				[
									    Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''					),
									    '''http://images.cocodataset.org/val2017/000000039769.jpg''',
									    # RGBA
									    dataset[0]['''file'''],
									    # LA
									    dataset[1]['''file'''],
									    # L
									    dataset[2]['''file'''],
									]
									snake_case_									=				object_detector(lowercase_       ,				threshold=0.0					)

									self.assertEqual(len(lowercase_					)       ,				len(lowercase_					)					)
									for outputs in batch_outputs:
														self.assertGreater(len(lowercase_					)       ,				0					)
														for detected_object in outputs:
																			self.assertEqual(
																			    lowercase_       ,				{
																			        '''score''': ANY(lowercase_					),
																			        '''label''': ANY(lowercase_					),
																			        '''box''': {'''xmin''': ANY(lowercase_					), '''ymin''': ANY(lowercase_					), '''xmax''': ANY(lowercase_					), '''ymax''': ANY(lowercase_					)},
																			    }       ,				)


				@require_tf
				@unittest.skip('''Object detection not implemented in TF'''					)
				def   A_ (		self    :					int					):
									pass


				@require_torch
				def   A_ (		self    :					Tuple					):
									snake_case_									=				'''hf-internal-testing/tiny-detr-mobilenetsv3'''

									snake_case_									=				AutoModelForObjectDetection.from_pretrained(lowercase_					)
									snake_case_									=				AutoFeatureExtractor.from_pretrained(lowercase_					)
									snake_case_									=				ObjectDetectionPipeline(model=lowercase_       ,				feature_extractor=lowercase_					)

									snake_case_									=				object_detector('''http://images.cocodataset.org/val2017/000000039769.jpg'''       ,				threshold=0.0					)

									self.assertEqual(
									    nested_simplify(lowercase_       ,				decimals=4					)       ,				[
									        {'''score''': 0.3376, '''label''': '''LABEL_0''', '''box''': {'''xmin''': 159, '''ymin''': 120, '''xmax''': 480, '''ymax''': 359}},
									        {'''score''': 0.3376, '''label''': '''LABEL_0''', '''box''': {'''xmin''': 159, '''ymin''': 120, '''xmax''': 480, '''ymax''': 359}},
									    ]       ,				)

									snake_case_									=				object_detector(
									    [
									        '''http://images.cocodataset.org/val2017/000000039769.jpg''',
									        '''http://images.cocodataset.org/val2017/000000039769.jpg''',
									    ]       ,				threshold=0.0       ,				)

									self.assertEqual(
									    nested_simplify(lowercase_       ,				decimals=4					)       ,				[
									        [
									            {'''score''': 0.3376, '''label''': '''LABEL_0''', '''box''': {'''xmin''': 159, '''ymin''': 120, '''xmax''': 480, '''ymax''': 359}},
									            {'''score''': 0.3376, '''label''': '''LABEL_0''', '''box''': {'''xmin''': 159, '''ymin''': 120, '''xmax''': 480, '''ymax''': 359}},
									        ],
									        [
									            {'''score''': 0.3376, '''label''': '''LABEL_0''', '''box''': {'''xmin''': 159, '''ymin''': 120, '''xmax''': 480, '''ymax''': 359}},
									            {'''score''': 0.3376, '''label''': '''LABEL_0''', '''box''': {'''xmin''': 159, '''ymin''': 120, '''xmax''': 480, '''ymax''': 359}},
									        ],
									    ]       ,				)


				@require_torch
				@slow
				def   A_ (		self    :					Optional[int]					):
									snake_case_									=				'''facebook/detr-resnet-50'''

									snake_case_									=				AutoModelForObjectDetection.from_pretrained(lowercase_					)
									snake_case_									=				AutoFeatureExtractor.from_pretrained(lowercase_					)
									snake_case_									=				ObjectDetectionPipeline(model=lowercase_       ,				feature_extractor=lowercase_					)

									snake_case_									=				object_detector('''http://images.cocodataset.org/val2017/000000039769.jpg'''					)
									self.assertEqual(
									    nested_simplify(lowercase_       ,				decimals=4					)       ,				[
									        {'''score''': 0.9982, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 70, '''xmax''': 175, '''ymax''': 117}},
									        {'''score''': 0.9960, '''label''': '''remote''', '''box''': {'''xmin''': 333, '''ymin''': 72, '''xmax''': 368, '''ymax''': 187}},
									        {'''score''': 0.9955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 639, '''ymax''': 473}},
									        {'''score''': 0.9988, '''label''': '''cat''', '''box''': {'''xmin''': 13, '''ymin''': 52, '''xmax''': 314, '''ymax''': 470}},
									        {'''score''': 0.9987, '''label''': '''cat''', '''box''': {'''xmin''': 345, '''ymin''': 23, '''xmax''': 640, '''ymax''': 368}},
									    ]       ,				)

									snake_case_									=				object_detector(
									    [
									        '''http://images.cocodataset.org/val2017/000000039769.jpg''',
									        '''http://images.cocodataset.org/val2017/000000039769.jpg''',
									    ]					)
									self.assertEqual(
									    nested_simplify(lowercase_       ,				decimals=4					)       ,				[
									        [
									            {'''score''': 0.9982, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 70, '''xmax''': 175, '''ymax''': 117}},
									            {'''score''': 0.9960, '''label''': '''remote''', '''box''': {'''xmin''': 333, '''ymin''': 72, '''xmax''': 368, '''ymax''': 187}},
									            {'''score''': 0.9955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 639, '''ymax''': 473}},
									            {'''score''': 0.9988, '''label''': '''cat''', '''box''': {'''xmin''': 13, '''ymin''': 52, '''xmax''': 314, '''ymax''': 470}},
									            {'''score''': 0.9987, '''label''': '''cat''', '''box''': {'''xmin''': 345, '''ymin''': 23, '''xmax''': 640, '''ymax''': 368}},
									        ],
									        [
									            {'''score''': 0.9982, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 70, '''xmax''': 175, '''ymax''': 117}},
									            {'''score''': 0.9960, '''label''': '''remote''', '''box''': {'''xmin''': 333, '''ymin''': 72, '''xmax''': 368, '''ymax''': 187}},
									            {'''score''': 0.9955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 639, '''ymax''': 473}},
									            {'''score''': 0.9988, '''label''': '''cat''', '''box''': {'''xmin''': 13, '''ymin''': 52, '''xmax''': 314, '''ymax''': 470}},
									            {'''score''': 0.9987, '''label''': '''cat''', '''box''': {'''xmin''': 345, '''ymin''': 23, '''xmax''': 640, '''ymax''': 368}},
									        ],
									    ]       ,				)


				@require_torch
				@slow
				def   A_ (		self    :					Tuple					):
									snake_case_									=				'''facebook/detr-resnet-50'''

									snake_case_									=				pipeline('''object-detection'''       ,				model=lowercase_					)

									snake_case_									=				object_detector('''http://images.cocodataset.org/val2017/000000039769.jpg'''					)
									self.assertEqual(
									    nested_simplify(lowercase_       ,				decimals=4					)       ,				[
									        {'''score''': 0.9982, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 70, '''xmax''': 175, '''ymax''': 117}},
									        {'''score''': 0.9960, '''label''': '''remote''', '''box''': {'''xmin''': 333, '''ymin''': 72, '''xmax''': 368, '''ymax''': 187}},
									        {'''score''': 0.9955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 639, '''ymax''': 473}},
									        {'''score''': 0.9988, '''label''': '''cat''', '''box''': {'''xmin''': 13, '''ymin''': 52, '''xmax''': 314, '''ymax''': 470}},
									        {'''score''': 0.9987, '''label''': '''cat''', '''box''': {'''xmin''': 345, '''ymin''': 23, '''xmax''': 640, '''ymax''': 368}},
									    ]       ,				)

									snake_case_									=				object_detector(
									    [
									        '''http://images.cocodataset.org/val2017/000000039769.jpg''',
									        '''http://images.cocodataset.org/val2017/000000039769.jpg''',
									    ]					)
									self.assertEqual(
									    nested_simplify(lowercase_       ,				decimals=4					)       ,				[
									        [
									            {'''score''': 0.9982, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 70, '''xmax''': 175, '''ymax''': 117}},
									            {'''score''': 0.9960, '''label''': '''remote''', '''box''': {'''xmin''': 333, '''ymin''': 72, '''xmax''': 368, '''ymax''': 187}},
									            {'''score''': 0.9955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 639, '''ymax''': 473}},
									            {'''score''': 0.9988, '''label''': '''cat''', '''box''': {'''xmin''': 13, '''ymin''': 52, '''xmax''': 314, '''ymax''': 470}},
									            {'''score''': 0.9987, '''label''': '''cat''', '''box''': {'''xmin''': 345, '''ymin''': 23, '''xmax''': 640, '''ymax''': 368}},
									        ],
									        [
									            {'''score''': 0.9982, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 70, '''xmax''': 175, '''ymax''': 117}},
									            {'''score''': 0.9960, '''label''': '''remote''', '''box''': {'''xmin''': 333, '''ymin''': 72, '''xmax''': 368, '''ymax''': 187}},
									            {'''score''': 0.9955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 639, '''ymax''': 473}},
									            {'''score''': 0.9988, '''label''': '''cat''', '''box''': {'''xmin''': 13, '''ymin''': 52, '''xmax''': 314, '''ymax''': 470}},
									            {'''score''': 0.9987, '''label''': '''cat''', '''box''': {'''xmin''': 345, '''ymin''': 23, '''xmax''': 640, '''ymax''': 368}},
									        ],
									    ]       ,				)


				@require_torch
				@slow
				def   A_ (		self    :					str					):
									snake_case_									=				0.9985
									snake_case_									=				'''facebook/detr-resnet-50'''

									snake_case_									=				pipeline('''object-detection'''       ,				model=lowercase_					)

									snake_case_									=				object_detector('''http://images.cocodataset.org/val2017/000000039769.jpg'''       ,				threshold=lowercase_					)
									self.assertEqual(
									    nested_simplify(lowercase_       ,				decimals=4					)       ,				[
									        {'''score''': 0.9988, '''label''': '''cat''', '''box''': {'''xmin''': 13, '''ymin''': 52, '''xmax''': 314, '''ymax''': 470}},
									        {'''score''': 0.9987, '''label''': '''cat''', '''box''': {'''xmin''': 345, '''ymin''': 23, '''xmax''': 640, '''ymax''': 368}},
									    ]       ,				)


				@require_torch
				@require_pytesseract
				@slow
				def   A_ (		self    :					Dict					):
									snake_case_									=				'''Narsil/layoutlmv3-finetuned-funsd'''
									snake_case_									=				0.9993

									snake_case_									=				pipeline('''object-detection'''       ,				model=lowercase_       ,				threshold=lowercase_					)

									snake_case_									=				object_detector(
									    '''https://huggingface.co/spaces/impira/docquery/resolve/2359223c1837a7587402bda0f2643382a6eefeab/invoice.png'''					)
									self.assertEqual(
									    nested_simplify(lowercase_       ,				decimals=4					)       ,				[
									        {'''score''': 0.9993, '''label''': '''I-ANSWER''', '''box''': {'''xmin''': 294, '''ymin''': 254, '''xmax''': 343, '''ymax''': 264}},
									        {'''score''': 0.9993, '''label''': '''I-ANSWER''', '''box''': {'''xmin''': 294, '''ymin''': 254, '''xmax''': 343, '''ymax''': 264}},
									    ]       ,				)

