



'''simple docstring'''






from __future__ import annotations

import random
import unittest

from transformers import TransfoXLConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
     import tensorflow as tf

     from transformers import (
         TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
         TFTransfoXLForSequenceClassification,
         TFTransfoXLLMHeadModel,
         TFTransfoXLModel,
     )

class 							a__:







    def __init__(   self				:						Any		,    __snake_case				:						int		,    ):
      a		:      List[Any]       =  parent
      a		:      Optional[Any]       =  13
      a		:      Dict       =  7
      a		:      Optional[Any]       =  30
      a		:      str       =  self.seq_length + self.mem_len
      a		:      Union[str, Any]       =  15
      a		:      Union[str, Any]       =  True
      a		:      Dict       =  True
      a		:      str       =  99
      a		:      List[str]       =  [10, 50, 80]
      a		:      List[str]       =  32
      a		:      Optional[int]       =  32
      a		:      Dict       =  4
      a		:      Any       =  8
      a		:      str       =  1_28
      a		:      Any       =  2
      a		:      List[Any]       =  2
      a		:      str       =  None
      a		:      str       =  1
      a		:      str       =  0
      a		:      int       =  3
      a		:      Dict       =  self.vocab_size - 1
      a		:      Dict       =  0.01







    def     lowercase_ (   self				:						Dict			):
      a		:      Tuple       =  ids_tensor([self.batch_size, self.seq_length]		,    self.vocab_size			)
      a		:      Any       =  ids_tensor([self.batch_size, self.seq_length]		,    self.vocab_size			)

      a		:      Optional[Any]       =  None
      if self.use_labels:
        a		:      List[str]       =  ids_tensor([self.batch_size, self.seq_length]		,    self.vocab_size			)

      a		:      Optional[Any]       =  TransfoXLConfig(
          vocab_size=self.vocab_size		,    mem_len=self.mem_len		,    clamp_len=self.clamp_len		,    cutoffs=self.cutoffs		,    d_model=self.hidden_size		,    d_embed=self.d_embed		,    n_head=self.num_attention_heads		,    d_head=self.d_head		,    d_inner=self.d_inner		,    div_val=self.div_val		,    n_layer=self.num_hidden_layers		,    eos_token_id=self.eos_token_id		,    pad_token_id=self.vocab_size - 1		,    init_range=self.init_range		,    num_labels=self.num_labels		,    )

      return (config, input_ids_a, input_ids_a, lm_labels)







    def     lowercase_ (   self				:						Dict			):
      random.seed(self.seed			)
      tf.random.set_seed(self.seed			)







    def     lowercase_ (   self				:						Union[str, Any]		,    __snake_case				:						Optional[int]		,    __snake_case				:						List[Any]		,    __snake_case				:						Optional[int]		,    __snake_case				:						List[Any]			):
      a		:      Union[str, Any]       =  TFTransfoXLModel(lowerCAmelCase_			)

      a     ,			a		:      str       =  model(lowerCAmelCase_			).to_tuple()

      a		:      str       =  {'input_ids': input_ids_a, 'mems': mems_a}

      a     ,			a		:      str       =  model(lowerCAmelCase_			).to_tuple()

      self.parent.assertEqual(hidden_states_a.shape		,    (self.batch_size, self.seq_length, self.hidden_size)			)
      self.parent.assertEqual(hidden_states_a.shape		,    (self.batch_size, self.seq_length, self.hidden_size)			)
      self.parent.assertListEqual(
          [mem.shape for mem in mems_a]		,    [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers		,    )
      self.parent.assertListEqual(
          [mem.shape for mem in mems_a]		,    [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers		,    )







    def     lowercase_ (   self				:						int		,    __snake_case				:						Optional[Any]		,    __snake_case				:						Union[str, Any]		,    __snake_case				:						int		,    __snake_case				:						int			):
      a		:      List[str]       =  TFTransfoXLLMHeadModel(lowerCAmelCase_			)

      a     ,			a		:      Union[str, Any]       =  model(lowerCAmelCase_			).to_tuple()

      a		:      Tuple       =  {'input_ids': input_ids_a, 'labels': lm_labels}
      a     ,			a		:      List[str]       =  model(lowerCAmelCase_			).to_tuple()

      a     ,			a		:      List[Any]       =  model([input_ids_a, mems_a]			).to_tuple()

      a		:      Optional[int]       =  {'input_ids': input_ids_a, 'mems': mems_a, 'labels': lm_labels}

      a     ,			a		:      str       =  model(lowerCAmelCase_			).to_tuple()

      self.parent.assertEqual(lm_logits_a.shape		,    (self.batch_size, self.seq_length, self.vocab_size)			)
      self.parent.assertListEqual(
          [mem.shape for mem in mems_a]		,    [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers		,    )

      self.parent.assertEqual(lm_logits_a.shape		,    (self.batch_size, self.seq_length, self.vocab_size)			)
      self.parent.assertListEqual(
          [mem.shape for mem in mems_a]		,    [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers		,    )







    def     lowercase_ (   self				:						Union[str, Any]		,    __snake_case				:						Dict		,    __snake_case				:						Optional[Any]		,    __snake_case				:						List[str]		,    __snake_case				:						List[Any]			):
      a		:      int       =  TFTransfoXLForSequenceClassification(lowerCAmelCase_			)
      a		:      Any       =  model(lowerCAmelCase_			)
      self.parent.assertEqual(result.logits.shape		,    (self.batch_size, self.num_labels)			)







    def     lowercase_ (   self				:						Tuple			):
      a		:      Union[str, Any]       =  self.prepare_config_and_inputs()
      ((a)     ,			(a)     ,			(a)     ,			(a))		:      Union[str, Any]       =  config_and_inputs
      a		:      List[Any]       =  {'input_ids': input_ids_a}
      return config, inputs_dict

@require_tf
class 							a__(      __UpperCAmelCase	,				__UpperCAmelCase	,				unittest.TestCase			):
    lowercase__				=					(
        (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
    )
    lowercase__				=					() if is_tf_available() else ()
    lowercase__				=					(
        {
            """feature-extraction""": TFTransfoXLModel,
            """text-classification""": TFTransfoXLForSequenceClassification,
            """text-generation""": TFTransfoXLLMHeadModel,
            """zero-shot""": TFTransfoXLForSequenceClassification,
        }
        if is_tf_available()
        else {}
    )
    # TODO: add this test when TFTransfoXLLMHead has a linear output layer implemented
    lowercase__				=					False
    lowercase__				=					False
    lowercase__				=					False
    lowercase__				=					False







    def     lowercase_ (   self				:						Tuple		,    __snake_case				:						List[str]		,    __snake_case				:						int		,    __snake_case				:						Union[str, Any]		,    __snake_case				:						Optional[Any]		,    __snake_case				:						Union[str, Any]			):







      if pipeline_test_casse_name == "TextGenerationPipelineTests":
        # Get `ValueError: AttributeError: 'NoneType' object has no attribute 'new_ones'` or `AssertionError`.
        # `TransfoXLConfig` was never used in pipeline tests: cannot create a simple
        # tokenizer.
        return True

      return False







    def     lowercase_ (   self				:						str			):
      a		:      int       =  TFTransfoXLModelTester(self			)
      a		:      Dict       =  ConfigTester(self		,    config_class=lowerCAmelCase_		,    d_embed=37			)







    def     lowercase_ (   self				:						str			):
      self.config_tester.run_common_tests()







    def     lowercase_ (   self				:						str			):
      self.model_tester.set_seed()
      a		:      Dict       =  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_transfo_xl_model(*lowerCAmelCase_			)







    def     lowercase_ (   self				:						Dict			):
      self.model_tester.set_seed()
      a		:      List[str]       =  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_transfo_xl_lm_head(*lowerCAmelCase_			)







    def     lowercase_ (   self				:						Any			):
      a		:      Any       =  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*lowerCAmelCase_			)







    def     lowercase_ (   self				:						List[str]			):
      a     ,			a		:      str       =  self.model_tester.prepare_config_and_inputs_for_common()
      a		:      int       =  [TFTransfoXLForSequenceClassification]

      for model_class in self.all_model_classes:
        a		:      Dict       =  model_class(lowerCAmelCase_			)
        assert isinstance(model.get_input_embeddings()		,    tf.keras.layers.Layer			)
        if model_class in list_other_models_with_output_ebd:
          a		:      Union[str, Any]       =  model.get_output_embeddings()
          assert isinstance(lowerCAmelCase_		,    tf.keras.layers.Layer			)
          a		:      str       =  model.get_bias()
          assert name is None
        else:
          a		:      List[Any]       =  model.get_output_embeddings()
          assert x is None
          a		:      Union[str, Any]       =  model.get_bias()
          assert name is None







    def     lowercase_ (   self				:						List[Any]			):
      pass







    @slow
    def     lowercase_ (   self				:						List[Any]			):







      for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        a		:      List[Any]       =  TFTransfoXLModel.from_pretrained(lowerCAmelCase_			)
        self.assertIsNotNone(lowerCAmelCase_			)







    @unittest.skip(reason='This model doesn\'t play well with fit() due to not returning a single loss.'			)
    def     lowercase_ (   self				:						Any			):
      pass

@require_tf
class 							a__(      unittest.TestCase			):







    @unittest.skip('Skip test until #12651 is resolved.'			)
    @slow
    def     lowercase_ (   self				:						int			):
      a		:      Optional[int]       =  TFTransfoXLLMHeadModel.from_pretrained('transfo-xl-wt103'			)
      # fmt: off
      a		:      Optional[Any]       =  tf.convert_to_tensor([[33,12_97,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,22,17_06,17,2_00_98,5,32_15,21,37,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,3,62_24,8_31,1_60_02,2,8,6_03,7_89_67,2_95_46,23,8_03,20,25,4_16,5,8,2_32,4,2_77,6,18_55,46_01,3,2_95_46,54,8,36_09,5,5_72_11,49,4,1,2_77,18,8,17_55,1_56_91,3,3_41,25,4_16,6_93,4_25_73,71,17,4_01,94,31,1_79_19,2,2_95_46,78_73,18,1,4_35,23,1_10_11,7_55,5,51_67,3,79_83,98,84,2,2_95_46,32_67,8,36_09,4,1,48_65,10_75,2,60_87,71,6,3_46,8,58_54,3,2_95_46,8_24,14_00,18_68,2,19,1_60,2,3_11,8,54_96,2,2_09_20,17,25,1_50_97,3,24,24,0]]		,    dtype=tf.intaa			)  # noqa: E231
      # fmt: on
      #  In 1991 , the remains of Russian Tsar Nicholas II and his family
      #  ( except for Alexei and Maria ) are discovered .
      #  The voice of Nicholas's young son , Tsarevich Alexei Nikolaevich , narrates the
      #  remainder of the story . 1883 Western Siberia ,
      #  a young Grigori Rasputin is asked by his father and a group of men to perform magic .
      #  Rasputin has a vision and denounces one of the men as a horse thief . Although his
      #  father initially slaps him for making such an accusation , Rasputin watches as the
      #  man is chased outside and beaten . Twenty years later , Rasputin sees a vision of
      #  the Virgin Mary , prompting him to become a priest . Rasputin quickly becomes famous ,
      #  with people , even a bishop , begging for his blessing . <eod> </s> <eos>

      # fmt: off
      a		:      Tuple       =  [33,12_97,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,22,17_06,17,2_00_98,5,32_15,21,37,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,3,62_24,8_31,1_60_02,2,8,6_03,7_89_67,2_95_46,23,8_03,20,25,4_16,5,8,2_32,4,2_77,6,18_55,46_01,3,2_95_46,54,8,36_09,5,5_72_11,49,4,1,2_77,18,8,17_55,1_56_91,3,3_41,25,4_16,6_93,4_25_73,71,17,4_01,94,31,1_79_19,2,2_95_46,78_73,18,1,4_35,23,1_10_11,7_55,5,51_67,3,79_83,98,84,2,2_95_46,32_67,8,36_09,4,1,48_65,10_75,2,60_87,71,6,3_46,8,58_54,3,2_95_46,8_24,14_00,18_68,2,19,1_60,2,3_11,8,54_96,2,2_09_20,17,25,1_50_97,3,24,24,0,33,1,18_57,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,28,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,3,0]  # noqa: E231
      # fmt: on
      #  In 1991, the remains of Russian Tsar Nicholas II and his family (
      #  except for Alexei and Maria ) are discovered. The voice of young son,
      #  Tsarevich Alexei Nikolaevich, narrates the remainder of the story.
      #  1883 Western Siberia, a young Grigori Rasputin is asked by his father
      #  and a group of men to perform magic. Rasputin has a vision and
      #  denounces one of the men as a horse thief. Although his father initially
      #  slaps him for making such an accusation, Rasputin watches as the man
      #  is chased outside and beaten. Twenty years later, Rasputin sees a vision
      #  of the Virgin Mary, prompting him to become a priest.
      #  Rasputin quickly becomes famous, with people, even a bishop, begging for
      #  his blessing. <unk> <unk> <eos> In the 1990s, the remains of Russian Tsar
      # Nicholas II and his family were discovered. The voice of <unk> young son,
      # Tsarevich Alexei Nikolaevich, narrates the remainder of the story.<eos>

      a		:      Union[str, Any]       =  model.generate(lowerCAmelCase_		,    max_length=2_00		,    do_sample=lowerCAmelCase_			)
      self.assertListEqual(output_ids[0].numpy().tolist()		,    lowerCAmelCase_			)




'''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     lowercase_ (   *__snake_case				:						int		,    **__snake_case				:						str			):
           pass

@is_pipeline_test
@require_vision
@require_timm
@require_torch
class 							a__(      unittest.TestCase			):
    lowercase__				=					MODEL_FOR_OBJECT_DETECTION_MAPPING







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







    def     lowercase_ (   self				:						Optional[Any]		,    __snake_case				:						str		,    __snake_case				:						Optional[Any]			):
      a		:      Any       =  object_detector('./tests/fixtures/tests_samples/COCO/000000039769.png'		,    threshold=0.0			)

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

      import datasets

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

      a		:      Tuple       =  [
          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'],
      ]
      a		:      List[Any]       =  object_detector(__snake_case		,    threshold=0.0			)

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







    @require_tf
    @unittest.skip('Object detection not implemented in TF'			)
    def     lowercase_ (   self				:						List[str]			):
      pass







    @require_torch
    def     lowercase_ (   self				:						Tuple			):
      a		:      Union[str, Any]       =  'hf-internal-testing/tiny-detr-mobilenetsv3'

      a		:      str       =  AutoModelForObjectDetection.from_pretrained(__snake_case			)
      a		:      str       =  AutoFeatureExtractor.from_pretrained(__snake_case			)
      a		:      Any       =  ObjectDetectionPipeline(model=__snake_case		,    feature_extractor=__snake_case			)

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

      self.assertEqual(
          nested_simplify(__snake_case		,    decimals=4			)		,    [
              {'score': 0.3376, 'label': 'LABEL_0', 'box': {'xmin': 1_59, 'ymin': 1_20, 'xmax': 4_80, 'ymax': 3_59}},
              {'score': 0.3376, 'label': 'LABEL_0', 'box': {'xmin': 1_59, 'ymin': 1_20, 'xmax': 4_80, 'ymax': 3_59}},
          ]		,    )

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

      self.assertEqual(
          nested_simplify(__snake_case		,    decimals=4			)		,    [
              [
                  {'score': 0.3376, 'label': 'LABEL_0', 'box': {'xmin': 1_59, 'ymin': 1_20, 'xmax': 4_80, 'ymax': 3_59}},
                  {'score': 0.3376, 'label': 'LABEL_0', 'box': {'xmin': 1_59, 'ymin': 1_20, 'xmax': 4_80, 'ymax': 3_59}},
              ],
              [
                  {'score': 0.3376, 'label': 'LABEL_0', 'box': {'xmin': 1_59, 'ymin': 1_20, 'xmax': 4_80, 'ymax': 3_59}},
                  {'score': 0.3376, 'label': 'LABEL_0', 'box': {'xmin': 1_59, 'ymin': 1_20, 'xmax': 4_80, 'ymax': 3_59}},
              ],
          ]		,    )







    @require_torch
    @slow
    def     lowercase_ (   self				:						Optional[int]			):
      a		:      Union[str, Any]       =  'facebook/detr-resnet-50'

      a		:      str       =  AutoModelForObjectDetection.from_pretrained(__snake_case			)
      a		:      List[Any]       =  AutoFeatureExtractor.from_pretrained(__snake_case			)
      a		:      str       =  ObjectDetectionPipeline(model=__snake_case		,    feature_extractor=__snake_case			)

      a		:      List[Any]       =  object_detector('http://images.cocodataset.org/val2017/000000039769.jpg'			)
      self.assertEqual(
          nested_simplify(__snake_case		,    decimals=4			)		,    [
              {'score': 0.9982, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 70, 'xmax': 1_75, 'ymax': 1_17}},
              {'score': 0.9960, 'label': 'remote', 'box': {'xmin': 3_33, 'ymin': 72, 'xmax': 3_68, 'ymax': 1_87}},
              {'score': 0.9955, 'label': 'couch', 'box': {'xmin': 0, 'ymin': 1, 'xmax': 6_39, 'ymax': 4_73}},
              {'score': 0.9988, 'label': 'cat', 'box': {'xmin': 13, 'ymin': 52, 'xmax': 3_14, 'ymax': 4_70}},
              {'score': 0.9987, 'label': 'cat', 'box': {'xmin': 3_45, 'ymin': 23, 'xmax': 6_40, 'ymax': 3_68}},
          ]		,    )

      a		:      List[str]       =  object_detector(
          [
              'http://images.cocodataset.org/val2017/000000039769.jpg',
              'http://images.cocodataset.org/val2017/000000039769.jpg',
          ]			)
      self.assertEqual(
          nested_simplify(__snake_case		,    decimals=4			)		,    [
              [
                  {'score': 0.9982, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 70, 'xmax': 1_75, 'ymax': 1_17}},
                  {'score': 0.9960, 'label': 'remote', 'box': {'xmin': 3_33, 'ymin': 72, 'xmax': 3_68, 'ymax': 1_87}},
                  {'score': 0.9955, 'label': 'couch', 'box': {'xmin': 0, 'ymin': 1, 'xmax': 6_39, 'ymax': 4_73}},
                  {'score': 0.9988, 'label': 'cat', 'box': {'xmin': 13, 'ymin': 52, 'xmax': 3_14, 'ymax': 4_70}},
                  {'score': 0.9987, 'label': 'cat', 'box': {'xmin': 3_45, 'ymin': 23, 'xmax': 6_40, 'ymax': 3_68}},
              ],
              [
                  {'score': 0.9982, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 70, 'xmax': 1_75, 'ymax': 1_17}},
                  {'score': 0.9960, 'label': 'remote', 'box': {'xmin': 3_33, 'ymin': 72, 'xmax': 3_68, 'ymax': 1_87}},
                  {'score': 0.9955, 'label': 'couch', 'box': {'xmin': 0, 'ymin': 1, 'xmax': 6_39, 'ymax': 4_73}},
                  {'score': 0.9988, 'label': 'cat', 'box': {'xmin': 13, 'ymin': 52, 'xmax': 3_14, 'ymax': 4_70}},
                  {'score': 0.9987, 'label': 'cat', 'box': {'xmin': 3_45, 'ymin': 23, 'xmax': 6_40, 'ymax': 3_68}},
              ],
          ]		,    )







    @require_torch
    @slow
    def     lowercase_ (   self				:						Any			):
      a		:      Any       =  'facebook/detr-resnet-50'

      a		:      int       =  pipeline('object-detection'		,    model=__snake_case			)

      a		:      Dict       =  object_detector('http://images.cocodataset.org/val2017/000000039769.jpg'			)
      self.assertEqual(
          nested_simplify(__snake_case		,    decimals=4			)		,    [
              {'score': 0.9982, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 70, 'xmax': 1_75, 'ymax': 1_17}},
              {'score': 0.9960, 'label': 'remote', 'box': {'xmin': 3_33, 'ymin': 72, 'xmax': 3_68, 'ymax': 1_87}},
              {'score': 0.9955, 'label': 'couch', 'box': {'xmin': 0, 'ymin': 1, 'xmax': 6_39, 'ymax': 4_73}},
              {'score': 0.9988, 'label': 'cat', 'box': {'xmin': 13, 'ymin': 52, 'xmax': 3_14, 'ymax': 4_70}},
              {'score': 0.9987, 'label': 'cat', 'box': {'xmin': 3_45, 'ymin': 23, 'xmax': 6_40, 'ymax': 3_68}},
          ]		,    )

      a		:      int       =  object_detector(
          [
              'http://images.cocodataset.org/val2017/000000039769.jpg',
              'http://images.cocodataset.org/val2017/000000039769.jpg',
          ]			)
      self.assertEqual(
          nested_simplify(__snake_case		,    decimals=4			)		,    [
              [
                  {'score': 0.9982, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 70, 'xmax': 1_75, 'ymax': 1_17}},
                  {'score': 0.9960, 'label': 'remote', 'box': {'xmin': 3_33, 'ymin': 72, 'xmax': 3_68, 'ymax': 1_87}},
                  {'score': 0.9955, 'label': 'couch', 'box': {'xmin': 0, 'ymin': 1, 'xmax': 6_39, 'ymax': 4_73}},
                  {'score': 0.9988, 'label': 'cat', 'box': {'xmin': 13, 'ymin': 52, 'xmax': 3_14, 'ymax': 4_70}},
                  {'score': 0.9987, 'label': 'cat', 'box': {'xmin': 3_45, 'ymin': 23, 'xmax': 6_40, 'ymax': 3_68}},
              ],
              [
                  {'score': 0.9982, 'label': 'remote', 'box': {'xmin': 40, 'ymin': 70, 'xmax': 1_75, 'ymax': 1_17}},
                  {'score': 0.9960, 'label': 'remote', 'box': {'xmin': 3_33, 'ymin': 72, 'xmax': 3_68, 'ymax': 1_87}},
                  {'score': 0.9955, 'label': 'couch', 'box': {'xmin': 0, 'ymin': 1, 'xmax': 6_39, 'ymax': 4_73}},
                  {'score': 0.9988, 'label': 'cat', 'box': {'xmin': 13, 'ymin': 52, 'xmax': 3_14, 'ymax': 4_70}},
                  {'score': 0.9987, 'label': 'cat', 'box': {'xmin': 3_45, 'ymin': 23, 'xmax': 6_40, 'ymax': 3_68}},
              ],
          ]		,    )







    @require_torch
    @slow
    def     lowercase_ (   self				:						Optional[int]			):
      a		:      Optional[Any]       =  0.9985
      a		:      Optional[int]       =  'facebook/detr-resnet-50'

      a		:      List[Any]       =  pipeline('object-detection'		,    model=__snake_case			)

      a		:      Any       =  object_detector('http://images.cocodataset.org/val2017/000000039769.jpg'		,    threshold=__snake_case			)
      self.assertEqual(
          nested_simplify(__snake_case		,    decimals=4			)		,    [
              {'score': 0.9988, 'label': 'cat', 'box': {'xmin': 13, 'ymin': 52, 'xmax': 3_14, 'ymax': 4_70}},
              {'score': 0.9987, 'label': 'cat', 'box': {'xmin': 3_45, 'ymin': 23, 'xmax': 6_40, 'ymax': 3_68}},
          ]		,    )







    @require_torch
    @require_pytesseract
    @slow
    def     lowercase_ (   self				:						Dict			):
      a		:      Optional[int]       =  'Narsil/layoutlmv3-finetuned-funsd'
      a		:      Optional[int]       =  0.9993

      a		:      List[Any]       =  pipeline('object-detection'		,    model=__snake_case		,    threshold=__snake_case			)

      a		:      Union[str, Any]       =  object_detector(
          'https://huggingface.co/spaces/impira/docquery/resolve/2359223c1837a7587402bda0f2643382a6eefeab/invoice.png'			)
      self.assertEqual(
          nested_simplify(__snake_case		,    decimals=4			)		,    [
              {'score': 0.9993, 'label': 'I-ANSWER', 'box': {'xmin': 2_94, 'ymin': 2_54, 'xmax': 3_43, 'ymax': 2_64}},
              {'score': 0.9993, 'label': 'I-ANSWER', 'box': {'xmin': 2_94, 'ymin': 2_54, 'xmax': 3_43, 'ymax': 2_64}},
          ]		,    )