


"""simple docstring"""







import json
import os
from datetime import date
from pathlib import Path

from tabulate import DataRow, TableFormat, tabulate


lowerCAmelCase__				    =       TableFormat(
    lineabove=None,
    linebelowheader=None,
    linebetweenrows=None,
    linebelow=None,
    headerrow=DataRow('''''', '''|''', '''|'''),
    datarow=DataRow('''''', '''|''', '''|'''),
    padding=1,
    with_header_hide=None,
)


lowerCAmelCase__				    =       []
lowerCAmelCase__				    =       []

lowerCAmelCase__				    =       {'''type''': '''section''', '''text''': {'''type''': '''plain_text''', '''text''': '''No failed tests! 🤗''', '''emoji''': True}}

lowerCAmelCase__				    =       [
    {
        '''type''': '''header''',
        '''text''': {
            '''type''': '''plain_text''',
            '''text''': F"🤗 Accelerate nightly {os.environ.get('TEST_TYPE', '')} test results",
            '''emoji''': True,
        },
    }
]

lowerCAmelCase__				    =       0
for log in Path().glob('''*.log'''):
     lowerCAmelCase__				    =       0
     with open(log, '''r''') as f:
          for line in f:
               lowerCAmelCase__				    =       json.loads(line)
               if line.get('''nodeid''', '''''') != "":
                    lowerCAmelCase__				    =       line['''nodeid''']
                    if line.get('''duration''', None) is not None:
                         lowerCAmelCase__				    =       F"{line['duration']:.4f}"
                         if line.get('''outcome''', '''''') == "failed":
                              section_num_failed += 1
                              failed.append([test, duration, log.name.split('''_''')[0]])
                              total_num_failed += 1
     group_info.append([str(log), section_num_failed, failed])
     lowerCAmelCase__				    =       []
     log.unlink()

lowerCAmelCase__				    =       ''''''
lowerCAmelCase__				    =       []
if total_num_failed > 0:
     for name, num_failed, failed_tests in group_info:
          if num_failed > 0:
               if num_failed == 1:
                    message += F"*{name[1:]}: {num_failed} failed test*\n"
               else:
                    message += F"*{name[1:]}: {num_failed} failed tests*\n"
               lowerCAmelCase__				    =       []
               lowerCAmelCase__				    =       {}
               for test in failed_tests:
                    lowerCAmelCase__				    =       test[0].split('''::''')
                    lowerCAmelCase__				    =       data[0].split('''/''')[-1]
                    if data[0] not in filesafailed:
                         lowerCAmelCase__				    =       [data[1:]]
                    else:
                         filesafailed[data[0]] += [data[1:]]
                    failed_table.append(data)

               lowerCAmelCase__				    =       [test[0] for test in failed_table]
               lowerCAmelCase__				    =       list(set(files))
               # Count number of instances in failed_tests
               lowerCAmelCase__				    =       []
               for file in individual_files:
                    table.append([file, len(filesafailed[file])])

               lowerCAmelCase__				    =       tabulate(
                   table,
                   headers=['''Test Location''', '''Num Failed'''],
                   tablefmt=hf_table_format,
                   stralign='''right''',
               )
               message += F"\n```\n{failed_table}\n```"
               all_filesafailed.append(filesafailed)
     if len(message) > 3_000:
          lowerCAmelCase__				    =       '''Too many failed tests, please see the full report in the Action results.'''
          lowerCAmelCase__				    =       len(err) + 10
          lowerCAmelCase__				    =       message[: 3_000 - offset] + F"\n...\n```\n{err}"
     print(F"### {message}")
else:
     lowerCAmelCase__				    =       '''No failed tests! 🤗'''
     print(F"## {message}")
     payload.append(no_error_payload)

if os.environ.get('''TEST_TYPE''', '''''') != "":
     from slack_sdk import WebClient

     lowerCAmelCase__				    =       WebClient(token=os.environ['''SLACK_API_TOKEN'''])
     if message != "No failed tests! 🤗":
          lowerCAmelCase__				    =       {
              '''type''': '''section''',
              '''text''': {
                  '''type''': '''mrkdwn''',
                  '''text''': message,
              },
          }
          payload.append(md_report)
          lowerCAmelCase__				    =       {
              '''type''': '''section''',
              '''text''': {
                  '''type''': '''mrkdwn''',
                  '''text''': '''*For more details:*''',
              },
              '''accessory''': {
                  '''type''': '''button''',
                  '''text''': {
                      '''type''': '''plain_text''',
                      '''text''': '''Check Action results''',
                      '''emoji''': True,
                  },
                  '''url''': F"https://github.com/{os.environ['GITHUB_REPOSITORY']}/actions/runs/{os.environ['GITHUB_RUN_ID']}",
              },
          }
          payload.append(action_button)
          lowerCAmelCase__				    =       {
              '''type''': '''context''',
              '''elements''': [
                  {
                      '''type''': '''plain_text''',
                      '''text''': F"Nightly {os.environ.get('TEST_TYPE')} test results for {date.today()}",
                  }
              ],
          }
          payload.append(date_report)
     lowerCAmelCase__				    =       client.chat_postMessage(channel='''#accelerate-ci-daily''', text=message, blocks=payload)
     lowerCAmelCase__				    =       response.data['''ts''']
     for failed_file in all_filesafailed:
          for test_location, test_failures in failed_file.items():
               # Keep only the first instance of the test name
               lowerCAmelCase__				    =       ''''''
               for i, row in enumerate(test_failures):
                    if row[0] != test_class:
                         lowerCAmelCase__				    =       row[0]
                    else:
                         lowerCAmelCase__				    =       ''''''

               lowerCAmelCase__				    =       {
                   '''type''': '''section''',
                   '''text''': {
                       '''type''': '''mrkdwn''',
                       '''text''': F"Test location: {test_location}\n```\n{tabulate(test_failures, headers=['Class', 'Test'], tablefmt=hf_table_format, stralign='right')}\n```",
                   },
               }

               client.chat_postMessage(
                   channel='''#accelerate-ci-daily''',
                   thread_ts=ts,
                   blocks=[payload],
               )









"""simple docstring"""







import unittest

from transformers import MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING, is_vision_available, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
     from PIL import Image
else:


     class 				SCREAMING_SNAKE_CASE__    :
            """simple docstring"""


            @staticmethod
            def 	lowercase__							(						*snake_case__		,					**snake_case__						):






              """simple docstring"""





              pass


@is_pipeline_test
@require_vision
@require_torch
class 				SCREAMING_SNAKE_CASE__    (		unittest.TestCase    ):
       """simple docstring"""


       a  :    Optional[Any]       =MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING

       def 	lowercase__							(						self		,					snake_case__		,					snake_case__		,					snake_case__						):






         """simple docstring"""





         lowerCAmelCase					:					str								=							pipeline(
             "zero-shot-object-detection"		,					model="hf-internal-testing/tiny-random-owlvit-object-detection"						)

         lowerCAmelCase					:					Dict								=							[
             {
                 "image": "./tests/fixtures/tests_samples/COCO/000000039769.png",
                 "candidate_labels": ["cat", "remote", "couch"],
             }
         ]
         return object_detector, examples

       def 	lowercase__							(						self		,					snake_case__		,					snake_case__						):






         """simple docstring"""





         lowerCAmelCase					:					Optional[Any]								=							object_detector(examples[0]		,					threshold=0.0						)

         lowerCAmelCase					:					Dict								=							len(snake_case__						)
         self.assertGreater(snake_case__		,					0						)
         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__						)},
                 }
                 for i in range(snake_case__						)
             ]		,					)

       @require_tf
       @unittest.skip("Zero Shot Object Detection not implemented in TF"						)
       def 	lowercase__							(						self						):






         """simple docstring"""





         pass

       @require_torch
       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					str								=							pipeline(
             "zero-shot-object-detection"		,					model="hf-internal-testing/tiny-random-owlvit-object-detection"						)

         lowerCAmelCase					:					Tuple								=							object_detector(
             "./tests/fixtures/tests_samples/COCO/000000039769.png"		,					candidate_labels=["cat", "remote", "couch"]		,					threshold=0.64		,					)

         self.assertEqual(
             nested_simplify(snake_case__		,					decimals=4						)		,					[
                 {"score": 0.7235, "label": "cat", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                 {"score": 0.7218, "label": "remote", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                 {"score": 0.7184, "label": "couch", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                 {"score": 0.6748, "label": "remote", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                 {"score": 0.6656, "label": "cat", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                 {"score": 0.6614, "label": "couch", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                 {"score": 0.6456, "label": "remote", "box": {"xmin": 494, "ymin": 105, "xmax": 521, "ymax": 127}},
                 {"score": 0.642, "label": "remote", "box": {"xmin": 67, "ymin": 274, "xmax": 93, "ymax": 297}},
                 {"score": 0.6419, "label": "cat", "box": {"xmin": 494, "ymin": 105, "xmax": 521, "ymax": 127}},
             ]		,					)

         lowerCAmelCase					:					Optional[Any]								=							object_detector(
             [
                 {
                     "image": "./tests/fixtures/tests_samples/COCO/000000039769.png",
                     "candidate_labels": ["cat", "remote", "couch"],
                 }
             ]		,					threshold=0.64		,					)

         self.assertEqual(
             nested_simplify(snake_case__		,					decimals=4						)		,					[
                 [
                     {"score": 0.7235, "label": "cat", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                     {"score": 0.7218, "label": "remote", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                     {"score": 0.7184, "label": "couch", "box": {"xmin": 204, "ymin": 167, "xmax": 232, "ymax": 190}},
                     {"score": 0.6748, "label": "remote", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                     {"score": 0.6656, "label": "cat", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                     {"score": 0.6614, "label": "couch", "box": {"xmin": 571, "ymin": 83, "xmax": 598, "ymax": 103}},
                     {"score": 0.6456, "label": "remote", "box": {"xmin": 494, "ymin": 105, "xmax": 521, "ymax": 127}},
                     {"score": 0.642, "label": "remote", "box": {"xmin": 67, "ymin": 274, "xmax": 93, "ymax": 297}},
                     {"score": 0.6419, "label": "cat", "box": {"xmin": 494, "ymin": 105, "xmax": 521, "ymax": 127}},
                 ]
             ]		,					)

       @require_torch
       @slow
       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					Dict								=							pipeline("zero-shot-object-detection"						)

         lowerCAmelCase					:					Dict								=							object_detector(
             "http://images.cocodataset.org/val2017/000000039769.jpg"		,					candidate_labels=["cat", "remote", "couch"]		,					)
         self.assertEqual(
             nested_simplify(snake_case__		,					decimals=4						)		,					[
                 {"score": 0.2868, "label": "cat", "box": {"xmin": 324, "ymin": 20, "xmax": 640, "ymax": 373}},
                 {"score": 0.277, "label": "remote", "box": {"xmin": 40, "ymin": 72, "xmax": 177, "ymax": 115}},
                 {"score": 0.2537, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
                 {"score": 0.1474, "label": "remote", "box": {"xmin": 335, "ymin": 74, "xmax": 371, "ymax": 187}},
                 {"score": 0.1208, "label": "couch", "box": {"xmin": 4, "ymin": 0, "xmax": 642, "ymax": 476}},
             ]		,					)

         lowerCAmelCase					:					Dict								=							object_detector(
             [
                 {
                     "image": "http://images.cocodataset.org/val2017/000000039769.jpg",
                     "candidate_labels": ["cat", "remote", "couch"],
                 },
                 {
                     "image": "http://images.cocodataset.org/val2017/000000039769.jpg",
                     "candidate_labels": ["cat", "remote", "couch"],
                 },
             ]		,					)
         self.assertEqual(
             nested_simplify(snake_case__		,					decimals=4						)		,					[
                 [
                     {"score": 0.2868, "label": "cat", "box": {"xmin": 324, "ymin": 20, "xmax": 640, "ymax": 373}},
                     {"score": 0.277, "label": "remote", "box": {"xmin": 40, "ymin": 72, "xmax": 177, "ymax": 115}},
                     {"score": 0.2537, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
                     {"score": 0.1474, "label": "remote", "box": {"xmin": 335, "ymin": 74, "xmax": 371, "ymax": 187}},
                     {"score": 0.1208, "label": "couch", "box": {"xmin": 4, "ymin": 0, "xmax": 642, "ymax": 476}},
                 ],
                 [
                     {"score": 0.2868, "label": "cat", "box": {"xmin": 324, "ymin": 20, "xmax": 640, "ymax": 373}},
                     {"score": 0.277, "label": "remote", "box": {"xmin": 40, "ymin": 72, "xmax": 177, "ymax": 115}},
                     {"score": 0.2537, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
                     {"score": 0.1474, "label": "remote", "box": {"xmin": 335, "ymin": 74, "xmax": 371, "ymax": 187}},
                     {"score": 0.1208, "label": "couch", "box": {"xmin": 4, "ymin": 0, "xmax": 642, "ymax": 476}},
                 ],
             ]		,					)

       @require_tf
       @unittest.skip("Zero Shot Object Detection not implemented in TF"						)
       def 	lowercase__							(						self						):






         """simple docstring"""





         pass

       @require_torch
       @slow
       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					Dict								=							0.2
         lowerCAmelCase					:					List[Any]								=							pipeline("zero-shot-object-detection"						)

         lowerCAmelCase					:					Union[str, Any]								=							object_detector(
             "http://images.cocodataset.org/val2017/000000039769.jpg"		,					candidate_labels=["cat", "remote", "couch"]		,					threshold=snake_case__		,					)
         self.assertEqual(
             nested_simplify(snake_case__		,					decimals=4						)		,					[
                 {"score": 0.2868, "label": "cat", "box": {"xmin": 324, "ymin": 20, "xmax": 640, "ymax": 373}},
                 {"score": 0.277, "label": "remote", "box": {"xmin": 40, "ymin": 72, "xmax": 177, "ymax": 115}},
                 {"score": 0.2537, "label": "cat", "box": {"xmin": 1, "ymin": 55, "xmax": 315, "ymax": 472}},
             ]		,					)







       @require_torch
       @slow
       def 	lowercase__							(						self						):






         """simple docstring"""





         lowerCAmelCase					:					int								=							2
         lowerCAmelCase					:					Any								=							pipeline("zero-shot-object-detection"						)

         lowerCAmelCase					:					Any								=							object_detector(
             "http://images.cocodataset.org/val2017/000000039769.jpg"		,					candidate_labels=["cat", "remote", "couch"]		,					top_k=snake_case__		,					)
         self.assertEqual(
             nested_simplify(snake_case__		,					decimals=4						)		,					[
                 {"score": 0.2868, "label": "cat", "box": {"xmin": 324, "ymin": 20, "xmax": 640, "ymax": 373}},
                 {"score": 0.277, "label": "remote", "box": {"xmin": 40, "ymin": 72, "xmax": 177, "ymax": 115}},
             ]		,					)





