





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 					__lowerCAmelCase       :






				@staticmethod
				def 			lowerCamelCase  (*__magic_name__					,							**__magic_name__    )     ->   int:


								'''simple docstring'''



								pass



@is_pipeline_test
@require_vision
@require_timm
@require_torch
class 					__lowerCAmelCase       (			unittest.TestCase     ):
			lowerCamelCase_     :     Tuple       			=      MODEL_FOR_OBJECT_DETECTION_MAPPING






			def 			lowerCamelCase  (self					,							__magic_name__					,							__magic_name__					,							__magic_name__    )     ->   Optional[int]:


							'''simple docstring'''



							snake_case_						:    Tuple				=  ObjectDetectionPipeline(model=__magic_name__					,							image_processor=__magic_name__    )
							return object_detector, ["./tests/fixtures/tests_samples/COCO/000000039769.png"]






			def 			lowerCamelCase  (self					,							__magic_name__					,							__magic_name__    )     ->   Optional[Any]:


							'''simple docstring'''



							snake_case_						:    Dict				=  object_detector('''./tests/fixtures/tests_samples/COCO/000000039769.png'''					,							threshold=0.0    )

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

							import datasets

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

							snake_case_						:    str				=  [
							    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_						:    Any				=  object_detector(__magic_name__					,							threshold=0.0    )

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






			@require_tf
			@unittest.skip('''Object detection not implemented in TF'''    )
			def 			lowerCamelCase  (self    )     ->   Dict:


							'''simple docstring'''



							pass






			@require_torch
			def 			lowerCamelCase  (self    )     ->   Union[str, Any]:


							'''simple docstring'''



							snake_case_						:    Tuple				=  '''hf-internal-testing/tiny-detr-mobilenetsv3'''

							snake_case_						:    Any				=  AutoModelForObjectDetection.from_pretrained(__magic_name__    )
							snake_case_						:    str				=  AutoFeatureExtractor.from_pretrained(__magic_name__    )
							snake_case_						:    Optional[Any]				=  ObjectDetectionPipeline(model=__magic_name__					,							feature_extractor=__magic_name__    )

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

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

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

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






			@require_torch
			@slow
			def 			lowerCamelCase  (self    )     ->   Any:


							'''simple docstring'''



							snake_case_						:    Optional[Any]				=  '''facebook/detr-resnet-50'''

							snake_case_						:    str				=  AutoModelForObjectDetection.from_pretrained(__magic_name__    )
							snake_case_						:    Any				=  AutoFeatureExtractor.from_pretrained(__magic_name__    )
							snake_case_						:    Optional[int]				=  ObjectDetectionPipeline(model=__magic_name__					,							feature_extractor=__magic_name__    )

							snake_case_						:    str				=  object_detector('''http://images.cocodataset.org/val2017/000000039769.jpg'''    )
							self.assertEqual(
							    nested_simplify(__magic_name__					,							decimals=4    )					,							[
							        {'''score''': 0.9_982, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 70, '''xmax''': 175, '''ymax''': 117}},
							        {'''score''': 0.9_960, '''label''': '''remote''', '''box''': {'''xmin''': 333, '''ymin''': 72, '''xmax''': 368, '''ymax''': 187}},
							        {'''score''': 0.9_955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 639, '''ymax''': 473}},
							        {'''score''': 0.9_988, '''label''': '''cat''', '''box''': {'''xmin''': 13, '''ymin''': 52, '''xmax''': 314, '''ymax''': 470}},
							        {'''score''': 0.9_987, '''label''': '''cat''', '''box''': {'''xmin''': 345, '''ymin''': 23, '''xmax''': 640, '''ymax''': 368}},
							    ]					,							)

							snake_case_						:    List[str]				=  object_detector(
							    [
							        '''http://images.cocodataset.org/val2017/000000039769.jpg''',
							        '''http://images.cocodataset.org/val2017/000000039769.jpg''',
							    ]    )
							self.assertEqual(
							    nested_simplify(__magic_name__					,							decimals=4    )					,							[
							        [
							            {'''score''': 0.9_982, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 70, '''xmax''': 175, '''ymax''': 117}},
							            {'''score''': 0.9_960, '''label''': '''remote''', '''box''': {'''xmin''': 333, '''ymin''': 72, '''xmax''': 368, '''ymax''': 187}},
							            {'''score''': 0.9_955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 639, '''ymax''': 473}},
							            {'''score''': 0.9_988, '''label''': '''cat''', '''box''': {'''xmin''': 13, '''ymin''': 52, '''xmax''': 314, '''ymax''': 470}},
							            {'''score''': 0.9_987, '''label''': '''cat''', '''box''': {'''xmin''': 345, '''ymin''': 23, '''xmax''': 640, '''ymax''': 368}},
							        ],
							        [
							            {'''score''': 0.9_982, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 70, '''xmax''': 175, '''ymax''': 117}},
							            {'''score''': 0.9_960, '''label''': '''remote''', '''box''': {'''xmin''': 333, '''ymin''': 72, '''xmax''': 368, '''ymax''': 187}},
							            {'''score''': 0.9_955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 639, '''ymax''': 473}},
							            {'''score''': 0.9_988, '''label''': '''cat''', '''box''': {'''xmin''': 13, '''ymin''': 52, '''xmax''': 314, '''ymax''': 470}},
							            {'''score''': 0.9_987, '''label''': '''cat''', '''box''': {'''xmin''': 345, '''ymin''': 23, '''xmax''': 640, '''ymax''': 368}},
							        ],
							    ]					,							)






			@require_torch
			@slow
			def 			lowerCamelCase  (self    )     ->   List[Any]:


							'''simple docstring'''



							snake_case_						:    List[str]				=  '''facebook/detr-resnet-50'''

							snake_case_						:    Tuple				=  pipeline('''object-detection'''					,							model=__magic_name__    )

							snake_case_						:    str				=  object_detector('''http://images.cocodataset.org/val2017/000000039769.jpg'''    )
							self.assertEqual(
							    nested_simplify(__magic_name__					,							decimals=4    )					,							[
							        {'''score''': 0.9_982, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 70, '''xmax''': 175, '''ymax''': 117}},
							        {'''score''': 0.9_960, '''label''': '''remote''', '''box''': {'''xmin''': 333, '''ymin''': 72, '''xmax''': 368, '''ymax''': 187}},
							        {'''score''': 0.9_955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 639, '''ymax''': 473}},
							        {'''score''': 0.9_988, '''label''': '''cat''', '''box''': {'''xmin''': 13, '''ymin''': 52, '''xmax''': 314, '''ymax''': 470}},
							        {'''score''': 0.9_987, '''label''': '''cat''', '''box''': {'''xmin''': 345, '''ymin''': 23, '''xmax''': 640, '''ymax''': 368}},
							    ]					,							)

							snake_case_						:    str				=  object_detector(
							    [
							        '''http://images.cocodataset.org/val2017/000000039769.jpg''',
							        '''http://images.cocodataset.org/val2017/000000039769.jpg''',
							    ]    )
							self.assertEqual(
							    nested_simplify(__magic_name__					,							decimals=4    )					,							[
							        [
							            {'''score''': 0.9_982, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 70, '''xmax''': 175, '''ymax''': 117}},
							            {'''score''': 0.9_960, '''label''': '''remote''', '''box''': {'''xmin''': 333, '''ymin''': 72, '''xmax''': 368, '''ymax''': 187}},
							            {'''score''': 0.9_955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 639, '''ymax''': 473}},
							            {'''score''': 0.9_988, '''label''': '''cat''', '''box''': {'''xmin''': 13, '''ymin''': 52, '''xmax''': 314, '''ymax''': 470}},
							            {'''score''': 0.9_987, '''label''': '''cat''', '''box''': {'''xmin''': 345, '''ymin''': 23, '''xmax''': 640, '''ymax''': 368}},
							        ],
							        [
							            {'''score''': 0.9_982, '''label''': '''remote''', '''box''': {'''xmin''': 40, '''ymin''': 70, '''xmax''': 175, '''ymax''': 117}},
							            {'''score''': 0.9_960, '''label''': '''remote''', '''box''': {'''xmin''': 333, '''ymin''': 72, '''xmax''': 368, '''ymax''': 187}},
							            {'''score''': 0.9_955, '''label''': '''couch''', '''box''': {'''xmin''': 0, '''ymin''': 1, '''xmax''': 639, '''ymax''': 473}},
							            {'''score''': 0.9_988, '''label''': '''cat''', '''box''': {'''xmin''': 13, '''ymin''': 52, '''xmax''': 314, '''ymax''': 470}},
							            {'''score''': 0.9_987, '''label''': '''cat''', '''box''': {'''xmin''': 345, '''ymin''': 23, '''xmax''': 640, '''ymax''': 368}},
							        ],
							    ]					,							)






			@require_torch
			@slow
			def 			lowerCamelCase  (self    )     ->   Optional[int]:


							'''simple docstring'''



							snake_case_						:    Dict				=  0.9_985
							snake_case_						:    Dict				=  '''facebook/detr-resnet-50'''

							snake_case_						:    Dict				=  pipeline('''object-detection'''					,							model=__magic_name__    )

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






			@require_torch
			@require_pytesseract
			@slow
			def 			lowerCamelCase  (self    )     ->   List[str]:


							'''simple docstring'''



							snake_case_						:    List[str]				=  '''Narsil/layoutlmv3-finetuned-funsd'''
							snake_case_						:    List[str]				=  0.9_993

							snake_case_						:    Dict				=  pipeline('''object-detection'''					,							model=__magic_name__					,							threshold=__magic_name__    )

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







import unittest
from pathlib import Path
from tempfile import NamedTemporaryFile, TemporaryDirectory

from transformers import BertConfig, BertTokenizerFast, FeatureExtractionPipeline
from transformers.convert_graph_to_onnx import (
    convert,
    ensure_valid_input,
    generate_identified_filename,
    infer_shapes,
    quantize,
)
from transformers.testing_utils import require_tf, require_tokenizers, require_torch, slow



class 					__lowerCAmelCase       :






			def 			lowerCamelCase  (self					,							__magic_name__					,							__magic_name__					,							__magic_name__    )     ->   Dict:


							'''simple docstring'''



							return None




class 					__lowerCAmelCase       :






			def 			lowerCamelCase  (self					,							__magic_name__					,							__magic_name__					,							__magic_name__					,							__magic_name__    )     ->   List[str]:


							'''simple docstring'''



							return None




class 					__lowerCAmelCase       (			unittest.TestCase     ):
			lowerCamelCase_     :     Dict       			=      [
			    # (model_name, model_kwargs)
			    ('''bert-base-cased''', {}),
			    ('''gpt2''', {'''use_cache''': False}),  # We don't support exporting GPT2 past keys anymore
			]






			@require_tf
			@slow
			def 			lowerCamelCase  (self    )     ->   Union[str, Any]:


							'''simple docstring'''



							for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
											self._test_export(__magic_name__					,							'''tf'''					,							12					,							**__magic_name__    )






			@require_torch
			@slow
			def 			lowerCamelCase  (self    )     ->   int:


							'''simple docstring'''



							for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
											self._test_export(__magic_name__					,							'''pt'''					,							12					,							**__magic_name__    )






			@require_torch
			@slow
			def 			lowerCamelCase  (self    )     ->   int:


							'''simple docstring'''



							from transformers import BertModel

							snake_case_						:    str				=  ['''[UNK]''', '''[SEP]''', '''[CLS]''', '''[PAD]''', '''[MASK]''', '''some''', '''other''', '''words''']
							with NamedTemporaryFile(mode='''w+t'''    ) as vocab_file:
											vocab_file.write('''\n'''.join(__magic_name__    )    )
											vocab_file.flush()
											snake_case_						:    Optional[Any]				=  BertTokenizerFast(vocab_file.name    )

							with TemporaryDirectory() as bert_save_dir:
											snake_case_						:    str				=  BertModel(BertConfig(vocab_size=len(__magic_name__    )    )    )
											model.save_pretrained(__magic_name__    )
											self._test_export(__magic_name__					,							'''pt'''					,							12					,							__magic_name__    )






			@require_tf
			@slow
			def 			lowerCamelCase  (self    )     ->   Tuple:


							'''simple docstring'''



							for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
											snake_case_						:    Tuple				=  self._test_export(__magic_name__					,							'''tf'''					,							12					,							**__magic_name__    )
											snake_case_						:    List[str]				=  quantize(Path(__magic_name__    )    )

											# Ensure the actual quantized model is not bigger than the original one
											if quantized_path.stat().st_size >= Path(__magic_name__    ).stat().st_size:
															self.fail('''Quantized model is bigger than initial ONNX model'''    )






			@require_torch
			@slow
			def 			lowerCamelCase  (self    )     ->   Any:


							'''simple docstring'''



							for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
											snake_case_						:    Any				=  self._test_export(__magic_name__					,							'''pt'''					,							12					,							**__magic_name__    )
											snake_case_						:    Any				=  quantize(__magic_name__    )

											# Ensure the actual quantized model is not bigger than the original one
											if quantized_path.stat().st_size >= Path(__magic_name__    ).stat().st_size:
															self.fail('''Quantized model is bigger than initial ONNX model'''    )






			def 			lowerCamelCase  (self					,							__magic_name__					,							__magic_name__					,							__magic_name__					,							__magic_name__=None					,							**__magic_name__    )     ->   Tuple:


							'''simple docstring'''



							try:
											# Compute path
											with TemporaryDirectory() as tempdir:
															snake_case_						:    List[str]				=  Path(__magic_name__    ).joinpath('''model.onnx'''    )

											# Remove folder if exists
											if path.parent.exists():
															path.parent.rmdir()

											# Export
											convert(__magic_name__					,							__magic_name__					,							__magic_name__					,							__magic_name__					,							__magic_name__					,							**__magic_name__    )

											return path
							except Exception as e:
											self.fail(__magic_name__    )






			@require_torch
			@require_tokenizers
			@slow
			def 			lowerCamelCase  (self    )     ->   Optional[Any]:


							'''simple docstring'''



							from transformers import BertModel

							snake_case_						:    Optional[Any]				=  BertModel(BertConfig.from_pretrained('''lysandre/tiny-bert-random'''    )    )
							snake_case_						:    int				=  BertTokenizerFast.from_pretrained('''lysandre/tiny-bert-random'''    )
							self._test_infer_dynamic_axis(__magic_name__					,							__magic_name__					,							'''pt'''    )






			@require_tf
			@require_tokenizers
			@slow
			def 			lowerCamelCase  (self    )     ->   List[str]:


							'''simple docstring'''



							from transformers import TFBertModel

							snake_case_						:    Any				=  TFBertModel(BertConfig.from_pretrained('''lysandre/tiny-bert-random'''    )    )
							snake_case_						:    str				=  BertTokenizerFast.from_pretrained('''lysandre/tiny-bert-random'''    )
							self._test_infer_dynamic_axis(__magic_name__					,							__magic_name__					,							'''tf'''    )






			def 			lowerCamelCase  (self					,							__magic_name__					,							__magic_name__					,							__magic_name__    )     ->   int:


							'''simple docstring'''



							snake_case_						:    Tuple				=  FeatureExtractionPipeline(__magic_name__					,							__magic_name__    )

							snake_case_						:    Optional[int]				=  ['''input_ids''', '''token_type_ids''', '''attention_mask''', '''output_0''', '''output_1''']
							snake_case_			,							snake_case_			,							snake_case_			,							snake_case_						:    Optional[int]				=  infer_shapes(__magic_name__					,							__magic_name__    )

							# Assert all variables are present
							self.assertEqual(len(__magic_name__    )					,							len(__magic_name__    )    )
							self.assertTrue(all(var_name in shapes for var_name in variable_names    )    )
							self.assertSequenceEqual(variable_names[:3]					,							__magic_name__    )
							self.assertSequenceEqual(variable_names[3:]					,							__magic_name__    )

							# Assert inputs are {0: batch, 1: sequence}
							for var_name in ["input_ids", "token_type_ids", "attention_mask"]:
											self.assertDictEqual(shapes[var_name]					,							{0: '''batch''', 1: '''sequence'''}    )

							# Assert outputs are {0: batch, 1: sequence} and {0: batch}
							self.assertDictEqual(shapes['''output_0''']					,							{0: '''batch''', 1: '''sequence'''}    )
							self.assertDictEqual(shapes['''output_1''']					,							{0: '''batch'''}    )






			def 			lowerCamelCase  (self    )     ->   Optional[int]:


							'''simple docstring'''



							snake_case_						:    Tuple				=  ['''input_ids''', '''attention_mask''', '''token_type_ids''']
							snake_case_						:    List[str]				=  {'''input_ids''': [1, 2, 3, 4], '''attention_mask''': [0, 0, 0, 0], '''token_type_ids''': [1, 1, 1, 1]}
							snake_case_			,							snake_case_						:    Tuple				=  ensure_valid_input(FuncContiguousArgs()					,							__magic_name__					,							__magic_name__    )

							# Should have exactly the same number of args (all are valid)
							self.assertEqual(len(__magic_name__    )					,							3    )

							# Should have exactly the same input names
							self.assertEqual(set(__magic_name__    )					,							set(__magic_name__    )    )

							# Parameter should be reordered according to their respective place in the function:
							# (input_ids, token_type_ids, attention_mask)
							self.assertEqual(__magic_name__					,							(tokens['''input_ids'''], tokens['''token_type_ids'''], tokens['''attention_mask'''])    )

							# Generated args are interleaved with another args (for instance parameter "past" in GPT2)
							snake_case_			,							snake_case_						:    Dict				=  ensure_valid_input(FuncNonContiguousArgs()					,							__magic_name__					,							__magic_name__    )

							# Should have exactly the one arg (all before the one not provided "some_other_args")
							self.assertEqual(len(__magic_name__    )					,							1    )
							self.assertEqual(len(__magic_name__    )					,							1    )

							# Should have only "input_ids"
							self.assertEqual(inputs_args[0]					,							tokens['''input_ids''']    )
							self.assertEqual(ordered_input_names[0]					,							'''input_ids'''    )






			def 			lowerCamelCase  (self    )     ->   Any:


							'''simple docstring'''



							snake_case_						:    Optional[int]				=  generate_identified_filename(Path('''/home/something/my_fake_model.onnx'''    )					,							'''-test'''    )
							self.assertEqual('''/home/something/my_fake_model-test.onnx'''					,							generated.as_posix()    )
