

'''simple docstring'''







import collections
import json
import math
import os
import re
import time
from fnmatch import fnmatch
from typing import Dict

import requests
from slack_sdk import WebClient


__lowerCamelCase						    =      WebClient(token=os.environ['''CI_SLACK_BOT_TOKEN'''])
def  UpperCAmelCase__      ( UpperCAmelCase__			)     ->     Union[str, Any]:
       A_		   = test_results.split(""" """			)

       A_		   = 0
       A_		   = 0

       # When the output is short enough, the output is surrounded by = signs: "== OUTPUT =="
       # When it is too long, those signs are not present.
       A_		   = expressions[-2] if "=" in expressions[-1] else expressions[-1]

       for i, expression in enumerate(a_			):
              if "failed" in expression:
                     failed += int(expressions[i - 1]			)
              if "passed" in expression:
                     success += int(expressions[i - 1]			)

       return failed, success, time_spent
def  UpperCAmelCase__      ( UpperCAmelCase__			)     ->     List[str]:
       A_		   = {}
       A_		   = None
       A_		   = False
       for line in failures_short_lines.split("""\n"""			):
              if re.search(r"""_ \[doctest\]""",    a_			):
                     A_		   = True
                     A_		   = line.split(""" """			)[2]
              elif in_error and not line.split(""" """			)[0].isdigit():
                     A_		   = line
                     A_		   = False

       return failures


class    A__ :



    def __init__(   self						,			UpperCamelCase__						,			UpperCamelCase__    )  -> Optional[Any]:





           '''simple docstring'''
           A_		   = title

           A_		   = doc_test_results["time_spent"].split(""","""    )[0]
           A_		   = doc_test_results["success"]
           A_		   = doc_test_results["failures"]
           A_		   = self.n_success + self.n_failures

           # Failures and success of the modeling tests
           A_		   = doc_test_results



    @property
    def    snake_case_     (   self    )  -> str:





           '''simple docstring'''
           A_		   = [self._time_spent]
           A_		   = 0

           for time in time_spent:
                  A_		   = time.split(""":"""    )

                  # Time can be formatted as xx:xx:xx, as .xx, or as x.xx if the time spent was less than a minute.
                  if len(lowerCAmelCase__    ) == 1:
                         A_		   = [0, 0, time_parts[0]]

                  A_		   = int(time_parts[0]    ), int(time_parts[1]    ), float(time_parts[2]    )
                  total_secs += hours * 3600 + minutes * 60 + seconds

           A_		   = total_secs // 3600, (total_secs % 3600) // 60, total_secs % 60
           return f'''{int(lowerCAmelCase__    )}h{int(lowerCAmelCase__    )}m{int(lowerCAmelCase__    )}s'''



    @property
    def    snake_case_     (   self    )  -> Dict:





           '''simple docstring'''
           return {"type": "header", "text": {"type": "plain_text", "text": self.title}}



    @property
    def    snake_case_     (   self    )  -> Dict:





           '''simple docstring'''
           return {
               "type": "section",
               "text": {
                   "type": "plain_text",
                   "text": f'''🌞 There were no failures: all {self.n_tests} tests passed. The suite ran in {self.time}.''',
                   "emoji": True,
               },
               "accessory": {
                   "type": "button",
                   "text": {"type": "plain_text", "text": "Check Action results", "emoji": True},
                   "url": f'''https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}''',
               },
           }



    @property
    def    snake_case_     (   self    )  -> Dict:





           '''simple docstring'''
           return {
               "type": "section",
               "text": {
                   "type": "plain_text",
                   "text": (
                       f'''There were {self.n_failures} failures, out of {self.n_tests} tests.\nThe suite ran in'''
                       f''' {self.time}.'''
                   ),
                   "emoji": True,
               },
               "accessory": {
                   "type": "button",
                   "text": {"type": "plain_text", "text": "Check Action results", "emoji": True},
                   "url": f'''https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}''',
               },
           }



    @property
    def    snake_case_     (   self    )  -> Dict:





           '''simple docstring'''
           A_		   = 40
           A_		   = {k: v["failed"] for k, v in doc_test_results.items() if isinstance(lowerCAmelCase__						,			lowerCAmelCase__    )}

           A_		   = ""
           for category, failures in category_failures.items():
                  if len(lowerCAmelCase__    ) == 0:
                         continue

                  if report != "":
                         report += "\n\n"

                  report += f'''*{category} failures*:'''.ljust(line_length // 2    ).rjust(line_length // 2    ) + "\n"
                  report += "`"
                  report += "`\n`".join(lowerCAmelCase__    )
                  report += "`"

           return {
               "type": "section",
               "text": {
                   "type": "mrkdwn",
                   "text": f'''The following examples had failures:\n\n\n{report}\n''',
               },
           }



    @property
    def    snake_case_     (   self    )  -> str:





           '''simple docstring'''
           A_		   = [self.header]

           if self.n_failures > 0:
                  blocks.append(self.failures    )

           if self.n_failures > 0:
                  blocks.extend([self.category_failures]    )

           if self.n_failures == 0:
                  blocks.append(self.no_failures    )

           return json.dumps(lowerCAmelCase__    )



    @staticmethod
    def    snake_case_     (   )  -> Optional[int]:





           '''simple docstring'''
           A_		   = [
               {
                   "type": "section",
                   "text": {
                       "type": "plain_text",
                       "text": "There was an issue running the tests.",
                   },
                   "accessory": {
                       "type": "button",
                       "text": {"type": "plain_text", "text": "Check Action results", "emoji": True},
                       "url": f'''https://github.com/huggingface/transformers/actions/runs/{os.environ["GITHUB_RUN_ID"]}''',
                   },
               }
           ]

           print("""Sending the following payload"""    )
           print(json.dumps({"""blocks""": json.loads(lowerCAmelCase__    )}    )    )

           client.chat_postMessage(
               channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""]						,			text="""There was an issue running the tests."""						,			blocks=lowerCAmelCase__						,			)



    def    snake_case_     (   self    )  -> Dict:





           '''simple docstring'''
           print("""Sending the following payload"""    )
           print(json.dumps({"""blocks""": json.loads(self.payload    )}    )    )

           A_		   = f'''{self.n_failures} failures out of {self.n_tests} tests,''' if self.n_failures else "All tests passed."

           A_		   = client.chat_postMessage(
               channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""]						,			blocks=self.payload						,			text=lowerCAmelCase__						,			)



    def    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__						,			UpperCamelCase__    )  -> Optional[Any]:





           '''simple docstring'''
           A_		   = ""
           for key, value in failures.items():
                  A_		   = value[:200] + " [Truncated]" if len(lowerCAmelCase__    ) > 250 else value
                  failures_text += f'''*{key}*\n_{value}_\n\n'''

           A_		   = job_name
           A_		   = {"type": "section", "text": {"type": "mrkdwn", "text": text}}

           if job_link is not None:
                  A_		   = {
                      "type": "button",
                      "text": {"type": "plain_text", "text": "GitHub Action job", "emoji": True},
                      "url": job_link,
                  }

           return [
               {"type": "header", "text": {"type": "plain_text", "text": title.upper(), "emoji": True}},
               content,
               {"type": "section", "text": {"type": "mrkdwn", "text": failures_text}},
           ]







    def    snake_case_     (   self    )  -> Union[str, Any]:





           '''simple docstring'''




           if self.thread_ts is None:
                  raise ValueError("""Can only post reply if a post has been made."""    )

           A_		   = self.doc_test_results.pop("""job_link"""    )
           self.doc_test_results.pop("""failures"""    )
           self.doc_test_results.pop("""success"""    )
           self.doc_test_results.pop("""time_spent"""    )

           A_		   = sorted(self.doc_test_results.items()						,			key=lambda UpperCamelCase__    : t[0]    )
           for job, job_result in sorted_dict:
                  if len(job_result["""failures"""]    ):
                         A_		   = f'''*Num failures* :{len(job_result["failed"]    )} \n'''
                         A_		   = job_result["failures"]
                         A_		   = self.get_reply_blocks(lowerCAmelCase__						,			lowerCAmelCase__						,			lowerCAmelCase__						,			text=lowerCAmelCase__    )

                         print("""Sending the following reply"""    )
                         print(json.dumps({"""blocks""": blocks}    )    )

                         client.chat_postMessage(
                             channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""]						,			text=f'''Results for {job}'''						,			blocks=lowerCAmelCase__						,			thread_ts=self.thread_ts["""ts"""]						,			)

                         time.sleep(1    )

def  UpperCAmelCase__      ( )     ->     int:
       A_		   = os.environ["GITHUB_RUN_ID"]
       A_		   = F'''https://api.github.com/repos/huggingface/transformers/actions/runs/{run_id}/jobs?per_page=100'''
       A_		   = requests.get(a_			).json()
       A_		   = {}

       try:
              jobs.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]}			)
              A_		   = math.ceil((result["""total_count"""] - 1_00) / 1_00			)

              for i in range(a_			):
                     A_		   = requests.get(url + F'''&page={i + 2}'''			).json()
                     jobs.update({job["""name"""]: job["""html_url"""] for job in result["""jobs"""]}			)

              return jobs
       except Exception as e:
              print("""Unknown error, could not fetch links.""",    a_			)

       return {}
def  UpperCAmelCase__      ( UpperCAmelCase__			)     ->     Optional[Any]:
       A_		   = {}

       if os.path.exists(a_			):
              A_		   = os.listdir(a_			)
              for file in files:
                     try:
                            with open(os.path.join(a_,    a_			),    encoding="""utf-8"""			) as f:
                                   A_		   = f.read()
                     except UnicodeDecodeError as e:
                            raise ValueError(F'''Could not open {os.path.join(a_,    a_			)}.'''			) from e

       return _artifact
def  UpperCAmelCase__      ( )     ->     Dict:


       class    A__ :



           def __init__(   self						,			UpperCamelCase__    )  -> Union[str, Any]:





                  '''simple docstring'''
                  A_		   = name
                  A_		   = []



           def __str__(   self    )  -> List[Any]:





                  '''simple docstring'''
                  return self.name







           def    snake_case_     (   self						,			UpperCamelCase__    )  -> List[str]:





                  '''simple docstring'''
                  self.paths.append({"""name""": self.name, """path""": path}    )

       A_		   = {}

       A_		   = filter(os.path.isdir,    os.listdir()			)
       for directory in directories:
              A_		   = directory
              if artifact_name not in _available_artifacts:
                     A_		   = Artifact(a_			)

                     _available_artifacts[artifact_name].add_path(a_			)

       return _available_artifacts


if __name__ == "__main__":
      __lowerCamelCase						    =      get_job_links()
      __lowerCamelCase						    =      retrieve_available_artifacts()

      __lowerCamelCase						    =      collections.OrderedDict(
          [
              ('''*.py''', '''API Examples'''),
              ('''*.md''', '''MD Examples'''),
          ]
      )

      # This dict will contain all the information relative to each doc test category:
      # - failed: list of failed tests
      # - failures: dict in the format 'test': 'error_message'
      __lowerCamelCase						    =      {
          v: {
              '''failed''': [],
              '''failures''': {},
          }
          for v in docs.values()
      }

      # Link to the GitHub Action job
      __lowerCamelCase						    =      github_actions_job_links.get('''run_doctests''')

      __lowerCamelCase						    =      available_artifacts['''doc_tests_gpu_test_reports'''].paths[0]
      __lowerCamelCase						    =      retrieve_artifact(artifact_path['''name'''])
      if "stats" in artifact:
            __lowerCamelCase    , __lowerCamelCase    , __lowerCamelCase						    =      handle_test_results(artifact['''stats'''])
            __lowerCamelCase						    =      failed
            __lowerCamelCase						    =      success
            __lowerCamelCase						    =      time_spent[1:-1] + ''', '''

            __lowerCamelCase						    =      extract_first_line_failure(artifact['''failures_short'''])
            for line in artifact["summary_short"].split('''\n'''):
                  if re.search('''FAILED''', line):
                        __lowerCamelCase						    =      line.replace('''FAILED ''', '''''')
                        __lowerCamelCase						    =      line.split()[0].replace('''\n''', '''''')

                        if "::" in line:
                              __lowerCamelCase    , __lowerCamelCase						    =      line.split('''::''')
                        else:
                              __lowerCamelCase    , __lowerCamelCase						    =      line, line

                        for file_regex in docs.keys():
                              if fnmatch(file_path, file_regex):
                                    __lowerCamelCase						    =      docs[file_regex]
                                    doc_test_results[category]["failed"].append(test)

                                    __lowerCamelCase						    =      all_failures[test] if test in all_failures else '''N/A'''
                                    __lowerCamelCase						    =      failure
                                    break

      __lowerCamelCase						    =      Message('''🤗 Results of the doc tests.''', doc_test_results)
      message.post()
      message.post_reply()



'''simple docstring'''







from __future__ import annotations

from typing import Any
def  UpperCAmelCase__      ( UpperCAmelCase__			)     ->     int:
       if not postfix_notation:
              return 0

       A_		   = {"""+""", """-""", """*""", """/"""}
       A_		   = []

       for token in postfix_notation:
              if token in operations:
                     A_   ,     A_		   = stack.pop(), stack.pop()
                     if token == "+":
                            stack.append(a + b			)
                     elif token == "-":
                            stack.append(a - b			)
                     elif token == "*":
                            stack.append(a * b			)
                     else:
                            if a * b < 0 and a % b != 0:
                                   stack.append(a // b + 1			)
                            else:
                                   stack.append(a // b			)
              else:
                     stack.append(int(UpperCAmelCase__			)			)

       return stack.pop()


if __name__ == "__main__":
      import doctest

      doctest.testmod()
