

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


_SCREAMING_SNAKE_CASE					:  Tuple             =      WebClient(token=os.environ['''CI_SLACK_BOT_TOKEN'''])
def     UpperCAmelCase_       (						_A    ):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__   =   test_results.split(''' '''    )

     SCREAMING_SNAKE_CASE__   =   0
     SCREAMING_SNAKE_CASE__   =   0

     # When the output is short enough, the output is surrounded by = signs: "== OUTPUT =="
     # When it is too long, those signs are not present.
     SCREAMING_SNAKE_CASE__   =   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_       (						_A    ):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__   =   {}
     SCREAMING_SNAKE_CASE__   =   None
     SCREAMING_SNAKE_CASE__   =   False
     for line in failures_short_lines.split('''\n'''    ):
          if re.search(R'''_ \[doctest\]'''				,		_A    ):
               SCREAMING_SNAKE_CASE__   =   True
               SCREAMING_SNAKE_CASE__   =   line.split(''' '''    )[2]
          elif in_error and not line.split(''' '''    )[0].isdigit():
               SCREAMING_SNAKE_CASE__   =   line
               SCREAMING_SNAKE_CASE__   =   False

     return failures






class 	UpperCAmelCase__		:






  """simple docstring"""


  def __init__(							self						:		Any     ,       __lowerCamelCase						:		str     ,       __lowerCamelCase						:		Dict )		->							Optional[Any]:
       SCREAMING_SNAKE_CASE__   =   title

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

       # Failures and success of the modeling tests
       SCREAMING_SNAKE_CASE__   =   doc_test_results






  @property
  def 				lowercase_		(							self						:		int )		->							str:
       SCREAMING_SNAKE_CASE__   =   [self._time_spent]
       SCREAMING_SNAKE_CASE__   =   0

       for time in time_spent:
            SCREAMING_SNAKE_CASE__   =   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:
                 SCREAMING_SNAKE_CASE__   =   [0, 0, time_parts[0]]

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

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






  @property
  def 				lowercase_		(							self						:		Dict )		->							Dict:
       return {"type": "header", "text": {"type": "plain_text", "text": self.title}}






  @property
  def 				lowercase_		(							self						:		List[Any] )		->							Dict:
       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 				lowercase_		(							self						:		List[str] )		->							Dict:
       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 				lowercase_		(							self						:		Tuple )		->							Dict:
       SCREAMING_SNAKE_CASE__   =   40
       SCREAMING_SNAKE_CASE__   =   {k: v['''failed'''] for k, v in doc_test_results.items() if isinstance(__lowerCamelCase     ,       __lowerCamelCase )}

       SCREAMING_SNAKE_CASE__   =   ''''''
       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 				lowercase_		(							self						:		List[str] )		->							str:
       SCREAMING_SNAKE_CASE__   =   [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 				lowercase_		(							)		->							List[str]:
       SCREAMING_SNAKE_CASE__   =   [
           {
               '''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 				lowercase_		(							self						:		Any )		->							int:
       print('''Sending the following payload''' )
       print(json.dumps({'''blocks''': json.loads(self.payload )} ) )

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

       SCREAMING_SNAKE_CASE__   =   client.chat_postMessage(
           channel=os.environ['''CI_SLACK_CHANNEL_ID_DAILY''']     ,       blocks=self.payload     ,       text=__lowerCamelCase     ,       )






  def 				lowercase_		(							self						:		Optional[int]     ,       __lowerCamelCase						:		Optional[Any]     ,       __lowerCamelCase						:		str     ,       __lowerCamelCase						:		str     ,       __lowerCamelCase						:		Union[str, Any] )		->							Any:
       SCREAMING_SNAKE_CASE__   =   ''''''
       for key, value in failures.items():
            SCREAMING_SNAKE_CASE__   =   value[:200] + ''' [Truncated]''' if len(__lowerCamelCase ) > 250 else value
            failures_text += f'''*{key}*\n_{value}_\n\n'''

       SCREAMING_SNAKE_CASE__   =   job_name
       SCREAMING_SNAKE_CASE__   =   {'''type''': '''section''', '''text''': {'''type''': '''mrkdwn''', '''text''': text}}

       if job_link is not None:
            SCREAMING_SNAKE_CASE__   =   {
                '''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 				lowercase_		(							self						:		List[Any] )		->							Tuple:
       if self.thread_ts is None:
            raise ValueError('''Can only post reply if a post has been made.''' )

       SCREAMING_SNAKE_CASE__   =   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''' )

       SCREAMING_SNAKE_CASE__   =   sorted(self.doc_test_results.items()     ,       key=lambda __lowerCamelCase : t[0] )
       for job, job_result in sorted_dict:
            if len(job_result['''failures'''] ):
                 SCREAMING_SNAKE_CASE__   =   f'''*Num failures* :{len(job_result["failed"] )} \n'''
                 SCREAMING_SNAKE_CASE__   =   job_result['''failures''']
                 SCREAMING_SNAKE_CASE__   =   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_       (						):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__   =   os.environ['''GITHUB_RUN_ID''']
     SCREAMING_SNAKE_CASE__   =   F'''https://api.github.com/repos/huggingface/transformers/actions/runs/{run_id}/jobs?per_page=100'''
     SCREAMING_SNAKE_CASE__   =   requests.get(_A    ).json()
     SCREAMING_SNAKE_CASE__   =   {}

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

          for i in range(_A    ):
               SCREAMING_SNAKE_CASE__   =   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_       (						_A    ):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__   =   {}

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

     return _artifact
def     UpperCAmelCase_       (						):





     '''simple docstring'''




     class 	UpperCAmelCase__		:






       """simple docstring"""


       def __init__(							self						:		Optional[Any]     ,       __lowerCamelCase						:		str )		->							Tuple:
            SCREAMING_SNAKE_CASE__   =   name
            SCREAMING_SNAKE_CASE__   =   []






       def __str__(							self						:		Optional[Any] )		->							int:
            return self.name







       def 				lowercase_		(							self						:		List[Any]     ,       __lowerCamelCase						:		str )		->							List[str]:
            self.paths.append({'''name''': self.name, '''path''': path} )



     SCREAMING_SNAKE_CASE__   =   {}

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

               _available_artifacts[artifact_name].add_path(_A    )

     return _available_artifacts


if __name__ == "__main__":
       _SCREAMING_SNAKE_CASE					:  Dict             =      get_job_links()
       _SCREAMING_SNAKE_CASE					:  List[Any]             =      retrieve_available_artifacts()

       _SCREAMING_SNAKE_CASE					:  int             =      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'
       _SCREAMING_SNAKE_CASE					:  Dict             =      {
           v: {
               '''failed''': [],
               '''failures''': {},
           }
           for v in docs.values()
       }

       # Link to the GitHub Action job
       _SCREAMING_SNAKE_CASE					:  Union[str, Any]             =      github_actions_job_links.get('''run_doctests''')

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

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

                            if "::" in line:
                                   _SCREAMING_SNAKE_CASE      ,							_SCREAMING_SNAKE_CASE					:  Optional[Any]             =      line.split('''::''')
                            else:
                                   _SCREAMING_SNAKE_CASE      ,							_SCREAMING_SNAKE_CASE					:  Optional[Any]             =      line, line

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

                                          _SCREAMING_SNAKE_CASE					:  Any             =      all_failures[test] if test in all_failures else '''N/A'''
                                          _SCREAMING_SNAKE_CASE					:  int             =      failure
                                          break

       _SCREAMING_SNAKE_CASE					:  List[str]             =      Message('''🤗 Results of the doc tests.''', doc_test_results)
       message.post()
       message.post_reply()





import warnings

from .generation import TFGenerationMixin






class 	UpperCAmelCase__		(	A__	):






  """simple docstring"""


  warnings.warn(
      "Importing `TFGenerationMixin` from `src/transformers/generation_tf_utils.py` is deprecated and will "
      "be removed in Transformers v5. Import as `from transformers import TFGenerationMixin` instead."						,					A__						,					)


