


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

       '''simple docstring'''







       @staticmethod
       def   _snake_case    (  *_lowerCamelCase  : Optional[int]       ,  **_lowerCamelCase  : List[Any]							):






             '''simple docstring'''



             pass



@is_pipeline_test
@require_vision
@require_timm
@require_torch
class 							_UpperCamelCase (						unittest.TestCase						):

   '''simple docstring'''







   a_				:							List[Any]    = MODEL_FOR_OBJECT_DETECTION_MAPPING

   def   _snake_case    (  self  : Optional[int]       ,  _lowerCamelCase  : Tuple       ,  _lowerCamelCase  : Optional[int]       ,  _lowerCamelCase  : List[str]							):






         '''simple docstring'''



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

   def   _snake_case    (  self  : str       ,  _lowerCamelCase  : List[Any]       ,  _lowerCamelCase  : Any							):






         '''simple docstring'''



         __lowerCamelCase     :      Union[str, 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

         __lowerCamelCase     :      List[str]       						=						datasets.load_dataset("""hf-internal-testing/fixtures_image_utils"""       ,  """image"""       ,  split="""test"""							)

         __lowerCamelCase     :      Optional[Any]       						=						[
             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"""],
         ]
         __lowerCamelCase     :      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   _snake_case    (  self  : Union[str, Any]							):






         '''simple docstring'''



         pass

   @require_torch
   def   _snake_case    (  self  : Tuple							):






         '''simple docstring'''



         __lowerCamelCase     :      str       						=						"""hf-internal-testing/tiny-detr-mobilenetsv3"""

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

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

         self.assertEqual(
             nested_simplify(snake_case_       ,  decimals=4							)       ,  [
                 {"""score""": 0.3_376, """label""": """LABEL_0""", """box""": {"""xmin""": 1_5_9, """ymin""": 1_2_0, """xmax""": 4_8_0, """ymax""": 3_5_9}},
                 {"""score""": 0.3_376, """label""": """LABEL_0""", """box""": {"""xmin""": 1_5_9, """ymin""": 1_2_0, """xmax""": 4_8_0, """ymax""": 3_5_9}},
             ]       ,  )

         __lowerCamelCase     :      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.3_376, """label""": """LABEL_0""", """box""": {"""xmin""": 1_5_9, """ymin""": 1_2_0, """xmax""": 4_8_0, """ymax""": 3_5_9}},
                     {"""score""": 0.3_376, """label""": """LABEL_0""", """box""": {"""xmin""": 1_5_9, """ymin""": 1_2_0, """xmax""": 4_8_0, """ymax""": 3_5_9}},
                 ],
                 [
                     {"""score""": 0.3_376, """label""": """LABEL_0""", """box""": {"""xmin""": 1_5_9, """ymin""": 1_2_0, """xmax""": 4_8_0, """ymax""": 3_5_9}},
                     {"""score""": 0.3_376, """label""": """LABEL_0""", """box""": {"""xmin""": 1_5_9, """ymin""": 1_2_0, """xmax""": 4_8_0, """ymax""": 3_5_9}},
                 ],
             ]       ,  )

   @require_torch
   @slow
   def   _snake_case    (  self  : Optional[int]							):






         '''simple docstring'''



         __lowerCamelCase     :      Union[str, Any]       						=						"""facebook/detr-resnet-50"""

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

         __lowerCamelCase     :      Any       						=						object_detector("""http://images.cocodataset.org/val2017/000000039769.jpg"""							)
         self.assertEqual(
             nested_simplify(snake_case_       ,  decimals=4							)       ,  [
                 {"""score""": 0.9_982, """label""": """remote""", """box""": {"""xmin""": 4_0, """ymin""": 7_0, """xmax""": 1_7_5, """ymax""": 1_1_7}},
                 {"""score""": 0.9_960, """label""": """remote""", """box""": {"""xmin""": 3_3_3, """ymin""": 7_2, """xmax""": 3_6_8, """ymax""": 1_8_7}},
                 {"""score""": 0.9_955, """label""": """couch""", """box""": {"""xmin""": 0, """ymin""": 1, """xmax""": 6_3_9, """ymax""": 4_7_3}},
                 {"""score""": 0.9_988, """label""": """cat""", """box""": {"""xmin""": 1_3, """ymin""": 5_2, """xmax""": 3_1_4, """ymax""": 4_7_0}},
                 {"""score""": 0.9_987, """label""": """cat""", """box""": {"""xmin""": 3_4_5, """ymin""": 2_3, """xmax""": 6_4_0, """ymax""": 3_6_8}},
             ]       ,  )

         __lowerCamelCase     :      List[Any]       						=						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.9_982, """label""": """remote""", """box""": {"""xmin""": 4_0, """ymin""": 7_0, """xmax""": 1_7_5, """ymax""": 1_1_7}},
                     {"""score""": 0.9_960, """label""": """remote""", """box""": {"""xmin""": 3_3_3, """ymin""": 7_2, """xmax""": 3_6_8, """ymax""": 1_8_7}},
                     {"""score""": 0.9_955, """label""": """couch""", """box""": {"""xmin""": 0, """ymin""": 1, """xmax""": 6_3_9, """ymax""": 4_7_3}},
                     {"""score""": 0.9_988, """label""": """cat""", """box""": {"""xmin""": 1_3, """ymin""": 5_2, """xmax""": 3_1_4, """ymax""": 4_7_0}},
                     {"""score""": 0.9_987, """label""": """cat""", """box""": {"""xmin""": 3_4_5, """ymin""": 2_3, """xmax""": 6_4_0, """ymax""": 3_6_8}},
                 ],
                 [
                     {"""score""": 0.9_982, """label""": """remote""", """box""": {"""xmin""": 4_0, """ymin""": 7_0, """xmax""": 1_7_5, """ymax""": 1_1_7}},
                     {"""score""": 0.9_960, """label""": """remote""", """box""": {"""xmin""": 3_3_3, """ymin""": 7_2, """xmax""": 3_6_8, """ymax""": 1_8_7}},
                     {"""score""": 0.9_955, """label""": """couch""", """box""": {"""xmin""": 0, """ymin""": 1, """xmax""": 6_3_9, """ymax""": 4_7_3}},
                     {"""score""": 0.9_988, """label""": """cat""", """box""": {"""xmin""": 1_3, """ymin""": 5_2, """xmax""": 3_1_4, """ymax""": 4_7_0}},
                     {"""score""": 0.9_987, """label""": """cat""", """box""": {"""xmin""": 3_4_5, """ymin""": 2_3, """xmax""": 6_4_0, """ymax""": 3_6_8}},
                 ],
             ]       ,  )

   @require_torch
   @slow
   def   _snake_case    (  self  : Optional[Any]							):






         '''simple docstring'''



         __lowerCamelCase     :      str       						=						"""facebook/detr-resnet-50"""

         __lowerCamelCase     :      List[str]       						=						pipeline("""object-detection"""       ,  model=snake_case_							)

         __lowerCamelCase     :      Optional[Any]       						=						object_detector("""http://images.cocodataset.org/val2017/000000039769.jpg"""							)
         self.assertEqual(
             nested_simplify(snake_case_       ,  decimals=4							)       ,  [
                 {"""score""": 0.9_982, """label""": """remote""", """box""": {"""xmin""": 4_0, """ymin""": 7_0, """xmax""": 1_7_5, """ymax""": 1_1_7}},
                 {"""score""": 0.9_960, """label""": """remote""", """box""": {"""xmin""": 3_3_3, """ymin""": 7_2, """xmax""": 3_6_8, """ymax""": 1_8_7}},
                 {"""score""": 0.9_955, """label""": """couch""", """box""": {"""xmin""": 0, """ymin""": 1, """xmax""": 6_3_9, """ymax""": 4_7_3}},
                 {"""score""": 0.9_988, """label""": """cat""", """box""": {"""xmin""": 1_3, """ymin""": 5_2, """xmax""": 3_1_4, """ymax""": 4_7_0}},
                 {"""score""": 0.9_987, """label""": """cat""", """box""": {"""xmin""": 3_4_5, """ymin""": 2_3, """xmax""": 6_4_0, """ymax""": 3_6_8}},
             ]       ,  )

         __lowerCamelCase     :      Optional[Any]       						=						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.9_982, """label""": """remote""", """box""": {"""xmin""": 4_0, """ymin""": 7_0, """xmax""": 1_7_5, """ymax""": 1_1_7}},
                     {"""score""": 0.9_960, """label""": """remote""", """box""": {"""xmin""": 3_3_3, """ymin""": 7_2, """xmax""": 3_6_8, """ymax""": 1_8_7}},
                     {"""score""": 0.9_955, """label""": """couch""", """box""": {"""xmin""": 0, """ymin""": 1, """xmax""": 6_3_9, """ymax""": 4_7_3}},
                     {"""score""": 0.9_988, """label""": """cat""", """box""": {"""xmin""": 1_3, """ymin""": 5_2, """xmax""": 3_1_4, """ymax""": 4_7_0}},
                     {"""score""": 0.9_987, """label""": """cat""", """box""": {"""xmin""": 3_4_5, """ymin""": 2_3, """xmax""": 6_4_0, """ymax""": 3_6_8}},
                 ],
                 [
                     {"""score""": 0.9_982, """label""": """remote""", """box""": {"""xmin""": 4_0, """ymin""": 7_0, """xmax""": 1_7_5, """ymax""": 1_1_7}},
                     {"""score""": 0.9_960, """label""": """remote""", """box""": {"""xmin""": 3_3_3, """ymin""": 7_2, """xmax""": 3_6_8, """ymax""": 1_8_7}},
                     {"""score""": 0.9_955, """label""": """couch""", """box""": {"""xmin""": 0, """ymin""": 1, """xmax""": 6_3_9, """ymax""": 4_7_3}},
                     {"""score""": 0.9_988, """label""": """cat""", """box""": {"""xmin""": 1_3, """ymin""": 5_2, """xmax""": 3_1_4, """ymax""": 4_7_0}},
                     {"""score""": 0.9_987, """label""": """cat""", """box""": {"""xmin""": 3_4_5, """ymin""": 2_3, """xmax""": 6_4_0, """ymax""": 3_6_8}},
                 ],
             ]       ,  )

   @require_torch
   @slow
   def   _snake_case    (  self  : Union[str, Any]							):






         '''simple docstring'''



         __lowerCamelCase     :      Optional[Any]       						=						0.9_985
         __lowerCamelCase     :      List[str]       						=						"""facebook/detr-resnet-50"""

         __lowerCamelCase     :      List[str]       						=						pipeline("""object-detection"""       ,  model=snake_case_							)

         __lowerCamelCase     :      Dict       						=						object_detector("""http://images.cocodataset.org/val2017/000000039769.jpg"""       ,  threshold=snake_case_							)
         self.assertEqual(
             nested_simplify(snake_case_       ,  decimals=4							)       ,  [
                 {"""score""": 0.9_988, """label""": """cat""", """box""": {"""xmin""": 1_3, """ymin""": 5_2, """xmax""": 3_1_4, """ymax""": 4_7_0}},
                 {"""score""": 0.9_987, """label""": """cat""", """box""": {"""xmin""": 3_4_5, """ymin""": 2_3, """xmax""": 6_4_0, """ymax""": 3_6_8}},
             ]       ,  )


   @require_torch
   @require_pytesseract
   @slow
   def   _snake_case    (  self  : Union[str, Any]							):






         '''simple docstring'''



         __lowerCamelCase     :      Optional[int]       						=						"""Narsil/layoutlmv3-finetuned-funsd"""
         __lowerCamelCase     :      Any       						=						0.9_993

         __lowerCamelCase     :      Any       						=						pipeline("""object-detection"""       ,  model=snake_case_       ,  threshold=snake_case_							)

         __lowerCamelCase     :      int       						=						object_detector(
             """https://huggingface.co/spaces/impira/docquery/resolve/2359223c1837a7587402bda0f2643382a6eefeab/invoice.png"""							)
         self.assertEqual(
             nested_simplify(snake_case_       ,  decimals=4							)       ,  [
                 {"""score""": 0.9_993, """label""": """I-ANSWER""", """box""": {"""xmin""": 2_9_4, """ymin""": 2_5_4, """xmax""": 3_4_3, """ymax""": 2_6_4}},
                 {"""score""": 0.9_993, """label""": """I-ANSWER""", """box""": {"""xmin""": 2_9_4, """ymin""": 2_5_4, """xmax""": 3_4_3, """ymax""": 2_6_4}},
             ]       ,  )






import qiskit





def   _UpperCAmelCase       (     UpperCAmelCase      :			int						,	UpperCAmelCase      :			int      ):
      """simple docstring"""




      __lowerCamelCase     :      Dict       						=						qiskit.Aer.get_backend("""aer_simulator"""      )

      __lowerCamelCase     :      Dict       						=						qiskit.QuantumCircuit(4						,	2      )
      # encode inputs in qubits 0 and 1
      if bita == 1:
            qc_ha.x(0      )
      if bita == 1:
            qc_ha.x(1      )
      qc_ha.barrier()

      # use cnots to write XOR of the inputs on qubit2
      qc_ha.cx(0						,	2      )
      qc_ha.cx(1						,	2      )

      # use ccx / toffoli gate to write AND of the inputs on qubit3
      qc_ha.ccx(0						,	1						,	3      )
      qc_ha.barrier()

      # extract outputs
      qc_ha.measure(2						,	0      )  # extract XOR value
      qc_ha.measure(3						,	1      )  # extract AND value

      # Execute the circuit on the qasm simulator
      __lowerCamelCase     :      str       						=						qiskit.execute(UpperCAmelCase						,	UpperCAmelCase						,	shots=1_000      )

      # Return the histogram data of the results of the experiment
      return job.result().get_counts(UpperCAmelCase      )


if __name__ == "__main__":
    __UpperCamelCase    :						List[str]     =							half_adder(1, 1)
    print(F'''Half Adder Output Qubit Counts: {counts}''')



