




'''simple docstring'''

import json
import os
import re
import shutil
import tempfile
import unittest
from typing import Tuple

from transformers import AddedToken, BatchEncoding, ByTaTokenizer
from transformers.utils import cached_property, is_tf_available, is_torch_available

from ...test_tokenization_common import TokenizerTesterMixin


if is_torch_available():
							a  :				List[Any]									=  'pt'
elif is_tf_available():
							a  :				List[str]									=  'tf'
else:
							a  :				Tuple									=  'jax'






class 						a				(   _lowerCamelCase   ,     unittest.TestCase     ):
				snake_case_      =		ByTaTokenizer
				snake_case_      =		False


				def   A_ (		self    :					Tuple					):
									super().setUp()
									snake_case_									=				ByTaTokenizer()
									tokenizer.save_pretrained(self.tmpdirname					)


				@cached_property
				def   A_ (		self    :					List[str]					):
									return ByTaTokenizer.from_pretrained('''google/byt5-small'''					)


				def   A_ (		self    :					List[str]       ,				**lowercase_    :					Union[str, Any]					):
									return self.tokenizer_class.from_pretrained(self.tmpdirname       ,				**lowercase_					)


				def   A_ (		self    :					Any       ,				lowercase_    :					Union[str, Any]       ,				lowercase_    :					Union[str, Any]=False       ,				lowercase_    :					List[str]=20       ,				lowercase_    :					Optional[int]=5					):
									# XXX The default common tokenizer tests assume that every ID is decodable on its own.
									# This assumption is invalid for ByT5 because single bytes might not be
									# valid utf-8 (byte 128 for instance).
									# Here we're overriding the smallest possible method to provide
									# a clean sequence without making the same assumption.

									snake_case_									=				[]
									for i in range(len(lowercase_					)					):
														try:
																			snake_case_									=				tokenizer.decode([i]       ,				clean_up_tokenization_spaces=lowercase_					)
														except UnicodeDecodeError:
																			pass
														toks.append((i, tok)					)

									snake_case_									=				list(filter(lambda lowercase_					: re.match(R'''^[ a-zA-Z]+$'''       ,				t[1]					)       ,				lowercase_					)					)
									snake_case_									=				list(filter(lambda lowercase_					: [t[0]] == tokenizer.encode(t[1]       ,				add_special_tokens=lowercase_					)       ,				lowercase_					)					)
									if max_length is not None and len(lowercase_					) > max_length:
														snake_case_									=				toks[:max_length]
									if min_length is not None and len(lowercase_					) < min_length and len(lowercase_					) > 0:
														while len(lowercase_					) < min_length:
																			snake_case_									=				toks + toks
        # toks_str = [t[1] for t in toks]
									snake_case_									=				[t[0] for t in toks]

									# Ensure consistency
									snake_case_									=				tokenizer.decode(lowercase_       ,				clean_up_tokenization_spaces=lowercase_					)
									if " " not in output_txt and len(lowercase_					) > 1:
														snake_case_									=				(
														    tokenizer.decode([toks_ids[0]]       ,				clean_up_tokenization_spaces=lowercase_					)
														    + ''' '''
														    + tokenizer.decode(toks_ids[1:]       ,				clean_up_tokenization_spaces=lowercase_					)
														)
									if with_prefix_space:
														snake_case_									=				''' ''' + output_txt
									snake_case_									=				tokenizer.encode(lowercase_       ,				add_special_tokens=lowercase_					)
									return output_txt, output_ids


				def   A_ (		self    :					int					):
									snake_case_									=				self.ta_base_tokenizer
									snake_case_									=				tokenizer(['''hi</s>''', '''I went to the gym</s>''', '''</s>''']					)
									snake_case_									=				tokenizer(['''hi''', '''I went to the gym''', '''''']					)
									self.assertListEqual(batch_with_eos_added['''input_ids''']       ,				batch_without_eos_added['''input_ids''']					)


				def   A_ (		self    :					Tuple					):
									snake_case_									=				self.ta_base_tokenizer
									snake_case_									=				'''Unicode €.'''
									snake_case_									=				tokenizer(lowercase_					)
									snake_case_									=				[88, 113, 108, 102, 114, 103, 104, 35, 229, 133, 175, 49, 1]
									self.assertEqual(encoded['''input_ids''']       ,				lowercase_					)

									# decoding
									snake_case_									=				tokenizer.decode(lowercase_					)
									self.assertEqual(lowercase_       ,				'''Unicode €.</s>'''					)

									snake_case_									=				tokenizer('''e è é ê ë'''					)
									snake_case_									=				[104, 35, 198, 171, 35, 198, 172, 35, 198, 173, 35, 198, 174, 1]
									self.assertEqual(encoded['''input_ids''']       ,				lowercase_					)
									# decoding
									snake_case_									=				tokenizer.decode(lowercase_					)
									self.assertEqual(lowercase_       ,				'''e è é ê ë</s>'''					)

									# encode/decode, but with `encode` instead of `__call__`
									self.assertEqual(tokenizer.decode(tokenizer.encode('''e è é ê ë'''					)					)       ,				'''e è é ê ë</s>'''					)


				def   A_ (		self    :					int					):
									snake_case_									=				self.ta_base_tokenizer
									snake_case_									=				['''A long paragraph for summarization.''', '''Another paragraph for summarization.''']
									# fmt: off
									snake_case_									=				[68, 35, 111, 114, 113, 106, 35, 115, 100, 117, 100, 106, 117, 100, 115, 107, 35, 105, 114, 117, 35, 118, 120, 112, 112, 100, 117, 108, 125, 100, 119, 108, 114, 113, 49, 1, 0]
									# fmt: on
									snake_case_									=				tokenizer(lowercase_       ,				padding=lowercase_       ,				return_tensors=lowercase_					)
									self.assertIsInstance(lowercase_       ,				lowercase_					)

									if FRAMEWORK != "jax":
														snake_case_									=				list(batch.input_ids.numpy()[0]					)
									else:
														snake_case_									=				list(batch.input_ids.tolist()[0]					)

									self.assertListEqual(lowercase_       ,				lowercase_					)

									self.assertEqual((2, 37)       ,				batch.input_ids.shape					)
									self.assertEqual((2, 37)       ,				batch.attention_mask.shape					)


				def   A_ (		self    :					str					):
									snake_case_									=				self.ta_base_tokenizer
									snake_case_									=				['''A long paragraph for summarization.''', '''Another paragraph for summarization.''']
									snake_case_									=				tokenizer(lowercase_       ,				padding=lowercase_       ,				return_tensors=lowercase_					)
									# check if input_ids are returned and no decoder_input_ids
									self.assertIn('''input_ids'''       ,				lowercase_					)
									self.assertIn('''attention_mask'''       ,				lowercase_					)
									self.assertNotIn('''decoder_input_ids'''       ,				lowercase_					)
									self.assertNotIn('''decoder_attention_mask'''       ,				lowercase_					)


				def   A_ (		self    :					Optional[Any]					):
									snake_case_									=				self.ta_base_tokenizer
									snake_case_									=				[
									    '''Summary of the text.''',
									    '''Another summary.''',
									]
									snake_case_									=				tokenizer(
									    text_target=lowercase_       ,				max_length=32       ,				padding='''max_length'''       ,				truncation=lowercase_       ,				return_tensors=lowercase_					)
									self.assertEqual(32       ,				targets['''input_ids'''].shape[1]					)


				def   A_ (		self    :					Tuple					):
									snake_case_									=				self.ta_base_tokenizer
									snake_case_									=				['''A long paragraph for summarization. </s>''']
									snake_case_									=				['''Summary of the text. </s>''']
									# fmt: off
									snake_case_									=				[68, 35, 111, 114, 113, 106, 35, 115, 100, 117, 100, 106, 117, 100, 115, 107, 35, 105, 114, 117, 35, 118, 120, 112, 112, 100, 117, 108, 125, 100, 119, 108, 114, 113, 49, 35, 1]
									snake_case_									=				[86, 120, 112, 112, 100, 117, 124, 35, 114, 105, 35, 119, 107, 104, 35, 119, 104, 123, 119, 49, 35, 1]
									# fmt: on

									snake_case_									=				tokenizer(lowercase_       ,				text_target=lowercase_					)

									self.assertEqual(lowercase_       ,				batch['''input_ids'''][0]					)
									self.assertEqual(lowercase_       ,				batch['''labels'''][0]					)


				def   A_ (		self    :					Tuple					):
									# safety check on max_len default value so we are sure the test works
									snake_case_									=				self.get_tokenizers()
									for tokenizer in tokenizers:
														with self.subTest(F"{tokenizer.__class__.__name__}"					):
																			self.assertNotEqual(tokenizer.model_max_length       ,				42					)

        # Now let's start the test
									snake_case_									=				self.get_tokenizers()
									for tokenizer in tokenizers:
														with self.subTest(F"{tokenizer.__class__.__name__}"					):
																			# Isolate this from the other tests because we save additional tokens/etc
																			snake_case_									=				tempfile.mkdtemp()

																			snake_case_									=				''' He is very happy, UNwant\u00E9d,running'''
																			snake_case_									=				tokenizer.encode(lowercase_       ,				add_special_tokens=lowercase_					)
																			tokenizer.save_pretrained(lowercase_					)

																			snake_case_									=				tokenizer.__class__.from_pretrained(lowercase_					)
																			snake_case_									=				after_tokenizer.encode(lowercase_       ,				add_special_tokens=lowercase_					)
																			self.assertListEqual(lowercase_       ,				lowercase_					)

																			shutil.rmtree(lowercase_					)

									snake_case_									=				self.get_tokenizers(model_max_length=42					)
									for tokenizer in tokenizers:
														with self.subTest(F"{tokenizer.__class__.__name__}"					):
																			# Isolate this from the other tests because we save additional tokens/etc
																			snake_case_									=				tempfile.mkdtemp()

																			snake_case_									=				''' He is very happy, UNwant\u00E9d,running'''
																			tokenizer.add_tokens(['''bim''', '''bambam''']					)
																			snake_case_									=				tokenizer.additional_special_tokens
																			additional_special_tokens.append('''new_additional_special_token'''					)
																			tokenizer.add_special_tokens({'''additional_special_tokens''': additional_special_tokens}					)
																			snake_case_									=				tokenizer.encode(lowercase_       ,				add_special_tokens=lowercase_					)
																			tokenizer.save_pretrained(lowercase_					)

																			snake_case_									=				tokenizer.__class__.from_pretrained(lowercase_					)
																			snake_case_									=				after_tokenizer.encode(lowercase_       ,				add_special_tokens=lowercase_					)
																			self.assertListEqual(lowercase_       ,				lowercase_					)
																			self.assertIn('''new_additional_special_token'''       ,				after_tokenizer.additional_special_tokens					)
																			self.assertEqual(after_tokenizer.model_max_length       ,				42					)

																			snake_case_									=				tokenizer.__class__.from_pretrained(lowercase_       ,				model_max_length=43					)
																			self.assertEqual(tokenizer.model_max_length       ,				43					)

																			shutil.rmtree(lowercase_					)


				def   A_ (		self    :					List[str]					):
									snake_case_									=				[]
									if self.test_slow_tokenizer:
														tokenizer_list.append((self.tokenizer_class, self.get_tokenizer())					)

									if self.test_rust_tokenizer:
														tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer())					)

									for tokenizer_class, tokenizer_utils in tokenizer_list:
														with tempfile.TemporaryDirectory() as tmp_dir:
																			tokenizer_utils.save_pretrained(lowercase_					)

																			with open(os.path.join(lowercase_       ,				'''special_tokens_map.json'''					)       ,				encoding='''utf-8'''					) as json_file:
																								snake_case_									=				json.load(lowercase_					)

																			with open(os.path.join(lowercase_       ,				'''tokenizer_config.json'''					)       ,				encoding='''utf-8'''					) as json_file:
																								snake_case_									=				json.load(lowercase_					)

																			snake_case_									=				[F"<extra_id_{i}>" for i in range(125					)]

																			snake_case_									=				added_tokens_extra_ids + [
																			    '''an_additional_special_token'''
																			]
																			snake_case_									=				added_tokens_extra_ids + [
																			    '''an_additional_special_token'''
																			]

																			with open(os.path.join(lowercase_       ,				'''special_tokens_map.json'''					)       ,				'''w'''       ,				encoding='''utf-8'''					) as outfile:
																								json.dump(lowercase_       ,				lowercase_					)
																			with open(os.path.join(lowercase_       ,				'''tokenizer_config.json'''					)       ,				'''w'''       ,				encoding='''utf-8'''					) as outfile:
																								json.dump(lowercase_       ,				lowercase_					)

																			# the following checks allow us to verify that our test works as expected, i.e. that the tokenizer takes
																			# into account the new value of additional_special_tokens given in the "tokenizer_config.json" and
																			# "special_tokens_map.json" files
																			snake_case_									=				tokenizer_class.from_pretrained(
																			    lowercase_       ,				)
																			self.assertIn(
																			    '''an_additional_special_token'''       ,				tokenizer_without_change_in_init.additional_special_tokens					)
																			# self.assertIn("an_additional_special_token",tokenizer_without_change_in_init.get_vocab()) # ByT5Tokenization no vocab
																			self.assertEqual(
																			    ['''an_additional_special_token''']       ,				tokenizer_without_change_in_init.convert_ids_to_tokens(
																			        tokenizer_without_change_in_init.convert_tokens_to_ids(['''an_additional_special_token''']					)					)       ,				)

																			# Now we test that we can change the value of additional_special_tokens in the from_pretrained
																			snake_case_									=				added_tokens_extra_ids + [AddedToken('''a_new_additional_special_token'''       ,				lstrip=lowercase_					)]
																			snake_case_									=				tokenizer_class.from_pretrained(
																			    lowercase_       ,				additional_special_tokens=lowercase_       ,				)

																			self.assertIn('''a_new_additional_special_token'''       ,				tokenizer.additional_special_tokens					)
																			self.assertEqual(
																			    ['''a_new_additional_special_token''']       ,				tokenizer.convert_ids_to_tokens(
																			        tokenizer.convert_tokens_to_ids(['''a_new_additional_special_token''']					)					)       ,				)


				def   A_ (		self    :					Dict					):
									snake_case_									=				[]
									if self.test_slow_tokenizer:
														tokenizer_list.append((self.tokenizer_class, self.get_tokenizer())					)

									if self.test_rust_tokenizer:
														tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer())					)

									for tokenizer_class, tokenizer_utils in tokenizer_list:
														with tempfile.TemporaryDirectory() as tmp_dir:
																			tokenizer_utils.save_pretrained(lowercase_					)

																			snake_case_									=				tokenizer_class.from_pretrained(lowercase_					)

																			self.assertTrue(tokenizer.decode([255]					) == ''''''					)


				def   A_ (		self    :					int					):
									pass


				def   A_ (		self    :					Dict					):
									pass


				def   A_ (		self    :					Optional[Any]					):
									pass


				def   A_ (		self    :					Optional[int]					):
									pass


				def   A_ (		self    :					Optional[Any]					):
									# The default common tokenizer tests uses invalid tokens for ByT5 that can only accept one-character strings
									# and special added tokens as tokens
									snake_case_									=				self.get_tokenizers(fast=lowercase_       ,				do_lower_case=lowercase_					)
									for tokenizer in tokenizers:
														with self.subTest(F"{tokenizer.__class__.__name__}"					):
																			snake_case_									=				['''t''', '''h''', '''i''', '''s''', ''' ''', '''i''', '''s''', ''' ''', '''a''', ''' ''', '''t''', '''e''', '''x''', '''t''', '''</s>''']
																			snake_case_									=				tokenizer.convert_tokens_to_string(lowercase_					)

																			self.assertIsInstance(lowercase_       ,				lowercase_					)


				def   A_ (		self    :					Tuple					):
									snake_case_									=				self.get_tokenizers()
									for tokenizer in tokenizers:
														with self.subTest(F"{tokenizer.__class__.__name__}"					):
																			snake_case_									=				[
																			    '''bos_token''',
																			    '''eos_token''',
																			    '''unk_token''',
																			    '''sep_token''',
																			    '''pad_token''',
																			    '''cls_token''',
																			    '''mask_token''',
																			]

																			snake_case_									=				0
																			snake_case_									=				tokenizer.convert_ids_to_tokens(
																			    lowercase_       ,				skip_special_tokens=lowercase_					)

																			for attr in attributes_list:
																								setattr(lowercase_       ,				attr + '''_id'''       ,				lowercase_					)
																								self.assertEqual(getattr(lowercase_       ,				lowercase_					)       ,				lowercase_					)
																								self.assertEqual(getattr(lowercase_       ,				attr + '''_id'''					)       ,				lowercase_					)

																								setattr(lowercase_       ,				attr + '''_id'''       ,				lowercase_					)
																								self.assertEqual(getattr(lowercase_       ,				lowercase_					)       ,				lowercase_					)
																								self.assertEqual(getattr(lowercase_       ,				attr + '''_id'''					)       ,				lowercase_					)

																			setattr(lowercase_       ,				'''additional_special_tokens_ids'''       ,				[]					)
																			self.assertListEqual(getattr(lowercase_       ,				'''additional_special_tokens'''					)       ,				[]					)
																			self.assertListEqual(getattr(lowercase_       ,				'''additional_special_tokens_ids'''					)       ,				[]					)

																			setattr(lowercase_       ,				'''additional_special_tokens_ids'''       ,				[token_id_to_test_setters]					)
																			self.assertListEqual(getattr(lowercase_       ,				'''additional_special_tokens'''					)       ,				[token_to_test_setters]					)
																			self.assertListEqual(getattr(lowercase_       ,				'''additional_special_tokens_ids'''					)       ,				[token_id_to_test_setters]					)







'''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}},
									    ]       ,				)

