


'''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				:  Tuple    		=      WebClient(token=os.environ['CI_SLACK_BOT_TOKEN'])

def _SCREAMING_SNAKE_CASE (A			)			->			Tuple:






       """simple docstring"""







       lowercase__      =					test_results.split(''' '''			)

       lowercase__      =					0
       lowercase__      =					0

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






       """simple docstring"""







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

       return failures
class     __lowerCAmelCase		:





      '''simple docstring'''






      def __init__(self       :       Tuple  ,		UpperCamelCase       :       str  ,		UpperCamelCase       :       Dict					):

             '''simple docstring'''







             lowercase__      =					title

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

             # Failures and success of the modeling tests
             lowercase__      =					doc_test_results



      @property
      def  UpperCamelCase__						(self       :       Optional[Any]					):

             '''simple docstring'''







             lowercase__      =					[self._time_spent]
             lowercase__      =					0

             for time in time_spent:
                    lowercase__      =					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(UpperCamelCase					) == 1:
                           lowercase__      =					[0, 0, time_parts[0]]

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

             lowercase__     ,lowercase__     ,lowercase__      =					total_secs // 3600, (total_secs % 3600) // 60, total_secs % 60
             return f"{int(UpperCamelCase					)}h{int(UpperCamelCase					)}m{int(UpperCamelCase					)}s"



      @property
      def  UpperCamelCase__						(self       :       List[Any]					):

             '''simple docstring'''







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



      @property
      def  UpperCamelCase__						(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  UpperCamelCase__						(self       :       List[str]					):

             '''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  UpperCamelCase__						(self       :       int					):

             '''simple docstring'''







             lowercase__      =					40
             lowercase__      =					{k: v['''failed'''] for k, v in doc_test_results.items() if isinstance(UpperCamelCase  ,		UpperCamelCase					)}

             lowercase__      =					''''''
             for category, failures in category_failures.items():
                    if len(UpperCamelCase					) == 0:
                           continue

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

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

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



      @property
      def  UpperCamelCase__						(self       :       int					):

             '''simple docstring'''







             lowercase__      =					[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(UpperCamelCase					)



      @staticmethod
      def  UpperCamelCase__						():

             '''simple docstring'''







             lowercase__      =					[
                 {
                     '''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(UpperCamelCase					)}					)					)

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



      def  UpperCamelCase__						(self       :       List[str]					):

             '''simple docstring'''







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

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

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



      def  UpperCamelCase__						(self       :       List[str]  ,		UpperCamelCase       :       str  ,		UpperCamelCase       :       List[str]  ,		UpperCamelCase       :       List[str]  ,		UpperCamelCase       :       Union[str, Any]					):

             '''simple docstring'''







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

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

             if job_link is not None:
                    lowercase__      =					{
                        '''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  UpperCamelCase__						(self       :       List[str]					):

             '''simple docstring'''







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

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

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

                           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=UpperCamelCase  ,		thread_ts=self.thread_ts['''ts''']  ,		)

                           time.sleep(1					)






def _SCREAMING_SNAKE_CASE ()			->			Optional[int]:






       """simple docstring"""







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

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

              for i in range(A			):
                     lowercase__      =					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 _SCREAMING_SNAKE_CASE (A			)			->			List[Any]:






       """simple docstring"""







       lowercase__      =					{}

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

       return _artifact

def _SCREAMING_SNAKE_CASE ()			->			Optional[int]:






       """simple docstring"""







       class     __lowerCAmelCase		:





             '''simple docstring'''






             def __init__(self       :       List[str]  ,		UpperCamelCase       :       str					):

                    '''simple docstring'''







                    lowercase__      =					name
                    lowercase__      =					[]



             def __str__(self       :       List[str]					):

                    '''simple docstring'''







                    return self.name






             def  UpperCamelCase__						(self       :       List[Any]  ,		UpperCamelCase       :       str					):

                    '''simple docstring'''







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






       lowercase__      =					{}

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

                     _available_artifacts[artifact_name].add_path(A			)

       return _available_artifacts


if __name__ == "__main__":
 lowerCamelCase				:  Optional[Any]    		=      get_job_links()
 lowerCamelCase				:  Optional[Any]    		=      retrieve_available_artifacts()

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

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

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

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

    if "::" in line:
     lowerCamelCase		,    lowerCamelCase				:  List[str]    		=      line.split('::')
    else:
     lowerCamelCase		,    lowerCamelCase				:  Optional[int]    		=      line, line

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

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

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








'''simple docstring'''

import unittest

from transformers import RoFormerTokenizer, RoFormerTokenizerFast
from transformers.testing_utils import require_rjieba, require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin
@require_rjieba
@require_tokenizers
class     __lowerCAmelCase		(lowercase_    ,	unittest.TestCase	):





      '''simple docstring'''






      lowerCAmelCase__   :	str       =				RoFormerTokenizer
      lowerCAmelCase__   :	Dict       =				RoFormerTokenizerFast
      lowerCAmelCase__   :	List[str]       =				True
      lowerCAmelCase__   :	List[str]       =				True



      def  UpperCamelCase__						(self       :       Dict					):

             '''simple docstring'''







             super().setUp()



      def  UpperCamelCase__						(self       :       List[str]  ,		**UpperCamelCase       :       Dict					):

             '''simple docstring'''







             return self.tokenizer_class.from_pretrained('''junnyu/roformer_chinese_base'''  ,		**UpperCamelCase					)



      def  UpperCamelCase__						(self       :       List[str]  ,		**UpperCamelCase       :       int					):

             '''simple docstring'''







             return self.rust_tokenizer_class.from_pretrained('''junnyu/roformer_chinese_base'''  ,		**UpperCamelCase					)



      def  UpperCamelCase__						(self       :       List[str]					):

             '''simple docstring'''







             lowercase__      =					'''永和服装饰品有限公司,今天天气非常好'''
             lowercase__      =					'''永和 服装 饰品 有限公司 , 今 天 天 气 非常 好'''
             return input_text, output_text



      def  UpperCamelCase__						(self       :       int					):

             '''simple docstring'''







             lowercase__      =					self.get_tokenizer()
             lowercase__     ,lowercase__      =					self.get_chinese_input_output_texts()
             lowercase__      =					tokenizer.tokenize(UpperCamelCase					)

             self.assertListEqual(UpperCamelCase  ,		output_text.split()					)

             lowercase__      =					tokens + [tokenizer.unk_token]
             lowercase__      =					[22943, 21332, 34431, 45904, 117, 306, 1231, 1231, 2653, 33994, 1266, 100]
             self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCamelCase					)  ,		UpperCamelCase					)



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

             '''simple docstring'''







             lowercase__      =					self.get_rust_tokenizer()
             lowercase__     ,lowercase__      =					self.get_chinese_input_output_texts()
             lowercase__      =					tokenizer.tokenize(UpperCamelCase					)
             self.assertListEqual(UpperCamelCase  ,		output_text.split()					)
             lowercase__      =					tokens + [tokenizer.unk_token]
             lowercase__      =					[22943, 21332, 34431, 45904, 117, 306, 1231, 1231, 2653, 33994, 1266, 100]
             self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCamelCase					)  ,		UpperCamelCase					)



      def  UpperCamelCase__						(self       :       str					):

             '''simple docstring'''







             pass



      def  UpperCamelCase__						(self       :       Any					):

             '''simple docstring'''







             pass






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

             '''simple docstring'''







             pass




