





from __future__ import annotations

import random
import unittest

from transformers import TransfoXLConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
							import tensorflow as tf

							from transformers import (
							    TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
							    TFTransfoXLForSequenceClassification,
							    TFTransfoXLLMHeadModel,
							    TFTransfoXLModel,
							)






class        _a:







		def __init__(    self ,						__snake_case ,						)      ->      int:


							'''simple docstring'''

							_snake_case       :					List[Any]				       =   parent
							_snake_case       :					Union[str, Any]				       =   1_3
							_snake_case       :					List[Any]				       =   7
							_snake_case       :					Dict				       =   3_0
							_snake_case       :					Optional[Any]				       =   self.seq_length + self.mem_len
							_snake_case       :					Optional[int]				       =   1_5
							_snake_case       :					Any				       =   True
							_snake_case       :					str				       =   True
							_snake_case       :					Optional[int]				       =   9_9
							_snake_case       :					int				       =   [1_0, 5_0, 8_0]
							_snake_case       :					List[str]				       =   3_2
							_snake_case       :					Tuple				       =   3_2
							_snake_case       :					Union[str, Any]				       =   4
							_snake_case       :					Union[str, Any]				       =   8
							_snake_case       :					List[str]				       =   1_2_8
							_snake_case       :					Union[str, Any]				       =   2
							_snake_case       :					List[str]				       =   2
							_snake_case       :					Dict				       =   None
							_snake_case       :					Any				       =   1
							_snake_case       :					Optional[Any]				       =   0
							_snake_case       :					Optional[Any]				       =   3
							_snake_case       :					List[str]				       =   self.vocab_size - 1
							_snake_case       :					Optional[int]				       =   0.01







		def        lowercase       (    self				)      ->      Optional[Any]:


							'''simple docstring'''

							_snake_case       :					Optional[Any]				       =   ids_tensor([self.batch_size, self.seq_length] ,						self.vocab_size				)
							_snake_case       :					int				       =   ids_tensor([self.batch_size, self.seq_length] ,						self.vocab_size				)

							_snake_case       :					Tuple				       =   None
							if self.use_labels:
												_snake_case       :					List[str]				       =   ids_tensor([self.batch_size, self.seq_length] ,						self.vocab_size				)

							_snake_case       :					Dict				       =   TransfoXLConfig(
							    vocab_size=self.vocab_size ,						mem_len=self.mem_len ,						clamp_len=self.clamp_len ,						cutoffs=self.cutoffs ,						d_model=self.hidden_size ,						d_embed=self.d_embed ,						n_head=self.num_attention_heads ,						d_head=self.d_head ,						d_inner=self.d_inner ,						div_val=self.div_val ,						n_layer=self.num_hidden_layers ,						eos_token_id=self.eos_token_id ,						pad_token_id=self.vocab_size - 1 ,						init_range=self.init_range ,						num_labels=self.num_labels ,						)

							return (config, input_ids_a, input_ids_a, lm_labels)







		def        lowercase       (    self				)      ->      List[str]:


							'''simple docstring'''

							random.seed(self.seed				)
							tf.random.set_seed(self.seed				)







		def        lowercase       (    self ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case				)      ->      int:


							'''simple docstring'''

							_snake_case       :					Optional[int]				       =   TFTransfoXLModel(__snake_case				)

							_snake_case       , _snake_case       :					List[Any]				       =   model(__snake_case				).to_tuple()

							_snake_case       :					Dict				       =   {"input_ids": input_ids_a, "mems": mems_a}

							_snake_case       , _snake_case       :					Optional[Any]				       =   model(__snake_case				).to_tuple()

							self.parent.assertEqual(hidden_states_a.shape ,						(self.batch_size, self.seq_length, self.hidden_size)				)
							self.parent.assertEqual(hidden_states_a.shape ,						(self.batch_size, self.seq_length, self.hidden_size)				)
							self.parent.assertListEqual(
							    [mem.shape for mem in mems_a] ,						[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers ,						)
							self.parent.assertListEqual(
							    [mem.shape for mem in mems_a] ,						[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers ,						)







		def        lowercase       (    self ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case				)      ->      Any:


							'''simple docstring'''

							_snake_case       :					Optional[Any]				       =   TFTransfoXLLMHeadModel(__snake_case				)

							_snake_case       , _snake_case       :					Optional[int]				       =   model(__snake_case				).to_tuple()

							_snake_case       :					Tuple				       =   {"input_ids": input_ids_a, "labels": lm_labels}
							_snake_case       , _snake_case       :					Optional[int]				       =   model(__snake_case				).to_tuple()

							_snake_case       , _snake_case       :					Optional[Any]				       =   model([input_ids_a, mems_a]				).to_tuple()

							_snake_case       :					Any				       =   {"input_ids": input_ids_a, "mems": mems_a, "labels": lm_labels}

							_snake_case       , _snake_case       :					List[Any]				       =   model(__snake_case				).to_tuple()

							self.parent.assertEqual(lm_logits_a.shape ,						(self.batch_size, self.seq_length, self.vocab_size)				)
							self.parent.assertListEqual(
							    [mem.shape for mem in mems_a] ,						[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers ,						)

							self.parent.assertEqual(lm_logits_a.shape ,						(self.batch_size, self.seq_length, self.vocab_size)				)
							self.parent.assertListEqual(
							    [mem.shape for mem in mems_a] ,						[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers ,						)







		def        lowercase       (    self ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case				)      ->      str:


							'''simple docstring'''

							_snake_case       :					Optional[Any]				       =   TFTransfoXLForSequenceClassification(__snake_case				)
							_snake_case       :					Tuple				       =   model(__snake_case				)
							self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.num_labels)				)







		def        lowercase       (    self				)      ->      str:


							'''simple docstring'''

							_snake_case       :					str				       =   self.prepare_config_and_inputs()
							((_snake_case)       , (_snake_case)       , (_snake_case)       , (_snake_case))       :					Dict				       =   config_and_inputs
							_snake_case       :					Optional[int]				       =   {"input_ids": input_ids_a}
							return config, inputs_dict






@require_tf
class        _a(    __A	,   __A	,   unittest.TestCase    ):
		lowerCamelCase__     :str   				=		(
		    (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
		)
		lowerCamelCase__     :Optional[Any]   				=		() if is_tf_available() else ()
		lowerCamelCase__     :List[str]   				=		(
		    {
		        'feature-extraction': TFTransfoXLModel,
		        'text-classification': TFTransfoXLForSequenceClassification,
		        'text-generation': TFTransfoXLLMHeadModel,
		        'zero-shot': TFTransfoXLForSequenceClassification,
		    }
		    if is_tf_available()
		    else {}
		)
		# TODO: add this test when TFTransfoXLLMHead has a linear output layer implemented
		lowerCamelCase__     :List[str]   				=		False
		lowerCamelCase__     :List[Any]   				=		False
		lowerCamelCase__     :Any   				=		False
		lowerCamelCase__     :List[str]   				=		False







		def        lowercase       (    self ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case				)      ->      List[Any]:


							'''simple docstring'''

							if pipeline_test_casse_name == "TextGenerationPipelineTests":
												# Get `ValueError: AttributeError: 'NoneType' object has no attribute 'new_ones'` or `AssertionError`.
												# `TransfoXLConfig` was never used in pipeline tests: cannot create a simple
												# tokenizer.
												return True

							return False







		def        lowercase       (    self				)      ->      List[str]:


							'''simple docstring'''

							_snake_case       :					int				       =   TFTransfoXLModelTester(self				)
							_snake_case       :					Tuple				       =   ConfigTester(self ,						config_class=__snake_case ,						d_embed=3_7				)







		def        lowercase       (    self				)      ->      List[str]:


							'''simple docstring'''

							self.config_tester.run_common_tests()







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


							'''simple docstring'''

							self.model_tester.set_seed()
							_snake_case       :					Tuple				       =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_transfo_xl_model(*__snake_case				)







		def        lowercase       (    self				)      ->      Any:


							'''simple docstring'''

							self.model_tester.set_seed()
							_snake_case       :					Any				       =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_transfo_xl_lm_head(*__snake_case				)







		def        lowercase       (    self				)      ->      Any:


							'''simple docstring'''

							_snake_case       :					Optional[Any]				       =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*__snake_case				)







		def        lowercase       (    self				)      ->      int:


							'''simple docstring'''

							_snake_case       , _snake_case       :					Optional[Any]				       =   self.model_tester.prepare_config_and_inputs_for_common()
							_snake_case       :					Union[str, Any]				       =   [TFTransfoXLForSequenceClassification]

							for model_class in self.all_model_classes:
												_snake_case       :					Optional[Any]				       =   model_class(__snake_case				)
												assert isinstance(model.get_input_embeddings() ,						tf.keras.layers.Layer				)
												if model_class in list_other_models_with_output_ebd:
																	_snake_case       :					Union[str, Any]				       =   model.get_output_embeddings()
																	assert isinstance(__snake_case ,						tf.keras.layers.Layer				)
																	_snake_case       :					Union[str, Any]				       =   model.get_bias()
																	assert name is None
												else:
																	_snake_case       :					Union[str, Any]				       =   model.get_output_embeddings()
																	assert x is None
																	_snake_case       :					List[Any]				       =   model.get_bias()
																	assert name is None







		def        lowercase       (    self				)      ->      Tuple:


							'''simple docstring'''

							pass







		@slow
		def        lowercase       (    self				)      ->      Tuple:


							'''simple docstring'''

							for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												_snake_case       :					Union[str, Any]				       =   TFTransfoXLModel.from_pretrained(__snake_case				)
												self.assertIsNotNone(__snake_case				)







		@unittest.skip(reason="This model doesn't play well with fit() due to not returning a single loss."				)
		def        lowercase       (    self				)      ->      Dict:


							'''simple docstring'''

							pass






@require_tf
class        _a(    unittest.TestCase    ):







		@unittest.skip("Skip test until #12651 is resolved."				)
		@slow
		def        lowercase       (    self				)      ->      Optional[Any]:


							'''simple docstring'''

							_snake_case       :					Dict				       =   TFTransfoXLLMHeadModel.from_pretrained("transfo-xl-wt103"				)
							# fmt: off
							_snake_case       :					Union[str, Any]				       =   tf.convert_to_tensor([[3_3,1_2_9_7,2,1,1_0_0_9,4,1_1_0_9,1_1_7_3_9,4_7_6_2,3_5_8,5,2_5,2_4_5,2_2,1_7_0_6,1_7,2_0_0_9_8,5,3_2_1_5,2_1,3_7,1_1_1_0,3,1_3,1_0_4_1,4,2_4,6_0_3,4_9_0,2,7_1_4_7_7,2_0_0_9_8,1_0_4_4_4_7,2,2_0_9_6_1,1,2_6_0_4,4,1,3_2_9,3,6_2_2_4,8_3_1,1_6_0_0_2,2,8,6_0_3,7_8_9_6_7,2_9_5_4_6,2_3,8_0_3,2_0,2_5,4_1_6,5,8,2_3_2,4,2_7_7,6,1_8_5_5,4_6_0_1,3,2_9_5_4_6,5_4,8,3_6_0_9,5,5_7_2_1_1,4_9,4,1,2_7_7,1_8,8,1_7_5_5,1_5_6_9_1,3,3_4_1,2_5,4_1_6,6_9_3,4_2_5_7_3,7_1,1_7,4_0_1,9_4,3_1,1_7_9_1_9,2,2_9_5_4_6,7_8_7_3,1_8,1,4_3_5,2_3,1_1_0_1_1,7_5_5,5,5_1_6_7,3,7_9_8_3,9_8,8_4,2,2_9_5_4_6,3_2_6_7,8,3_6_0_9,4,1,4_8_6_5,1_0_7_5,2,6_0_8_7,7_1,6,3_4_6,8,5_8_5_4,3,2_9_5_4_6,8_2_4,1_4_0_0,1_8_6_8,2,1_9,1_6_0,2,3_1_1,8,5_4_9_6,2,2_0_9_2_0,1_7,2_5,1_5_0_9_7,3,2_4,2_4,0]] ,						dtype=tf.intaa				)  # noqa: E231
							# fmt: on
							#  In 1991 , the remains of Russian Tsar Nicholas II and his family
							#  ( except for Alexei and Maria ) are discovered .
							#  The voice of Nicholas's young son , Tsarevich Alexei Nikolaevich , narrates the
							#  remainder of the story . 1883 Western Siberia ,
							#  a young Grigori Rasputin is asked by his father and a group of men to perform magic .
							#  Rasputin has a vision and denounces one of the men as a horse thief . Although his
							#  father initially slaps him for making such an accusation , Rasputin watches as the
							#  man is chased outside and beaten . Twenty years later , Rasputin sees a vision of
							#  the Virgin Mary , prompting him to become a priest . Rasputin quickly becomes famous ,
							#  with people , even a bishop , begging for his blessing . <eod> </s> <eos>

							# fmt: off
							_snake_case       :					Tuple				       =   [3_3,1_2_9_7,2,1,1_0_0_9,4,1_1_0_9,1_1_7_3_9,4_7_6_2,3_5_8,5,2_5,2_4_5,2_2,1_7_0_6,1_7,2_0_0_9_8,5,3_2_1_5,2_1,3_7,1_1_1_0,3,1_3,1_0_4_1,4,2_4,6_0_3,4_9_0,2,7_1_4_7_7,2_0_0_9_8,1_0_4_4_4_7,2,2_0_9_6_1,1,2_6_0_4,4,1,3_2_9,3,6_2_2_4,8_3_1,1_6_0_0_2,2,8,6_0_3,7_8_9_6_7,2_9_5_4_6,2_3,8_0_3,2_0,2_5,4_1_6,5,8,2_3_2,4,2_7_7,6,1_8_5_5,4_6_0_1,3,2_9_5_4_6,5_4,8,3_6_0_9,5,5_7_2_1_1,4_9,4,1,2_7_7,1_8,8,1_7_5_5,1_5_6_9_1,3,3_4_1,2_5,4_1_6,6_9_3,4_2_5_7_3,7_1,1_7,4_0_1,9_4,3_1,1_7_9_1_9,2,2_9_5_4_6,7_8_7_3,1_8,1,4_3_5,2_3,1_1_0_1_1,7_5_5,5,5_1_6_7,3,7_9_8_3,9_8,8_4,2,2_9_5_4_6,3_2_6_7,8,3_6_0_9,4,1,4_8_6_5,1_0_7_5,2,6_0_8_7,7_1,6,3_4_6,8,5_8_5_4,3,2_9_5_4_6,8_2_4,1_4_0_0,1_8_6_8,2,1_9,1_6_0,2,3_1_1,8,5_4_9_6,2,2_0_9_2_0,1_7,2_5,1_5_0_9_7,3,2_4,2_4,0,3_3,1,1_8_5_7,2,1,1_0_0_9,4,1_1_0_9,1_1_7_3_9,4_7_6_2,3_5_8,5,2_5,2_4_5,2_8,1_1_1_0,3,1_3,1_0_4_1,4,2_4,6_0_3,4_9_0,2,7_1_4_7_7,2_0_0_9_8,1_0_4_4_4_7,2,2_0_9_6_1,1,2_6_0_4,4,1,3_2_9,3,0]  # noqa: E231
							# fmt: on
							#  In 1991, the remains of Russian Tsar Nicholas II and his family (
							#  except for Alexei and Maria ) are discovered. The voice of young son,
							#  Tsarevich Alexei Nikolaevich, narrates the remainder of the story.
							#  1883 Western Siberia, a young Grigori Rasputin is asked by his father
							#  and a group of men to perform magic. Rasputin has a vision and
							#  denounces one of the men as a horse thief. Although his father initially
							#  slaps him for making such an accusation, Rasputin watches as the man
							#  is chased outside and beaten. Twenty years later, Rasputin sees a vision
							#  of the Virgin Mary, prompting him to become a priest.
							#  Rasputin quickly becomes famous, with people, even a bishop, begging for
							#  his blessing. <unk> <unk> <eos> In the 1990s, the remains of Russian Tsar
							# Nicholas II and his family were discovered. The voice of <unk> young son,
							# Tsarevich Alexei Nikolaevich, narrates the remainder of the story.<eos>

							_snake_case       :					List[str]				       =   model.generate(__snake_case ,						max_length=2_0_0 ,						do_sample=__snake_case				)
							self.assertListEqual(output_ids[0].numpy().tolist() ,						__snake_case				)






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







def    A				(							UpperCAmelCase				):
					_snake_case       :					List[str]				       =   test_results.split(" "				)

					_snake_case       :					Optional[int]				       =   0
					_snake_case       :					int				       =   0

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

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

					return failed, success, time_spent







def    A				(							UpperCAmelCase				):
					_snake_case       :					Union[str, Any]				       =   {}
					_snake_case       :					Any				       =   None
					_snake_case       :					str				       =   False
					for line in failures_short_lines.split("\n"				):
										if re.search(R"_ \[doctest\]"  ,  UpperCAmelCase				):
															_snake_case       :					Union[str, Any]				       =   True
															_snake_case       :					Tuple				       =   line.split(" "				)[2]
										elif in_error and not line.split(" "				)[0].isdigit():
															_snake_case       :					Optional[Any]				       =   line
															_snake_case       :					Dict				       =   False

					return failures






class        _a:







		def __init__(    self ,						__snake_case ,						__snake_case				)      ->      Tuple:


							'''simple docstring'''

							_snake_case       :					Dict				       =   title

							_snake_case       :					Optional[Any]				       =   doc_test_results["time_spent"].split(","				)[0]
							_snake_case       :					Dict				       =   doc_test_results["success"]
							_snake_case       :					Optional[Any]				       =   doc_test_results["failures"]
							_snake_case       :					Tuple				       =   self.n_success + self.n_failures

							# Failures and success of the modeling tests
							_snake_case       :					Union[str, Any]				       =   doc_test_results







		@property
		def        lowercase       (    self				)      ->      str:


							'''simple docstring'''

							_snake_case       :					Dict				       =   [self._time_spent]
							_snake_case       :					Tuple				       =   0

							for time in time_spent:
												_snake_case       :					str				       =   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(__snake_case				) == 1:
																	_snake_case       :					List[Any]				       =   [0, 0, time_parts[0]]

												_snake_case       , _snake_case       , _snake_case       :					int				       =   int(time_parts[0]				), int(time_parts[1]				), float(time_parts[2]				)
												total_secs += hours * 3_6_0_0 + minutes * 6_0 + seconds

							_snake_case       , _snake_case       , _snake_case       :					List[str]				       =   total_secs // 3_6_0_0, (total_secs % 3_6_0_0) // 6_0, total_secs % 6_0
							return f"""{int(__snake_case				)}h{int(__snake_case				)}m{int(__snake_case				)}s"""







		@property
		def        lowercase       (    self				)      ->      Dict:


							'''simple docstring'''

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







		@property
		def        lowercase       (    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        lowercase       (    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        lowercase       (    self				)      ->      Dict:


							'''simple docstring'''

							_snake_case       :					List[str]				       =   4_0
							_snake_case       :					Any				       =   {k: v["failed"] for k, v in doc_test_results.items() if isinstance(__snake_case ,						__snake_case				)}

							_snake_case       :					int				       =   ""
							for category, failures in category_failures.items():
												if len(__snake_case				) == 0:
																	continue

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

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

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







		@property
		def        lowercase       (    self				)      ->      str:


							'''simple docstring'''

							_snake_case       :					Optional[Any]				       =   [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(__snake_case				)







		@staticmethod
		def        lowercase       (    )      ->      Dict:


							'''simple docstring'''

							_snake_case       :					Dict				       =   [
							    {
							        "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(__snake_case				)}				)				)

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







		def        lowercase       (    self				)      ->      Optional[Any]:


							'''simple docstring'''

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

							_snake_case       :					List[str]				       =   f"""{self.n_failures} failures out of {self.n_tests} tests,""" if self.n_failures else "All tests passed."

							_snake_case       :					Tuple				       =   client.chat_postMessage(
							    channel=os.environ["CI_SLACK_CHANNEL_ID_DAILY"] ,						blocks=self.payload ,						text=__snake_case ,						)







		def        lowercase       (    self ,						__snake_case ,						__snake_case ,						__snake_case ,						__snake_case				)      ->      Any:


							'''simple docstring'''

							_snake_case       :					str				       =   ""
							for key, value in failures.items():
												_snake_case       :					Any				       =   value[:2_0_0] + " [Truncated]" if len(__snake_case				) > 2_5_0 else value
												failures_text += f"""*{key}*\n_{value}_\n\n"""

							_snake_case       :					str				       =   job_name
							_snake_case       :					List[str]				       =   {"type": "section", "text": {"type": "mrkdwn", "text": text}}

							if job_link is not None:
												_snake_case       :					Union[str, Any]				       =   {
												    "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				)      ->      Optional[Any]:


							'''simple docstring'''

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

							_snake_case       :					Optional[int]				       =   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"				)

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

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

																	time.sleep(1				)







def    A				(							):
					_snake_case       :					Optional[Any]				       =   os.environ["GITHUB_RUN_ID"]
					_snake_case       :					Union[str, Any]				       =   F"""https://api.github.com/repos/huggingface/transformers/actions/runs/{run_id}/jobs?per_page=100"""
					_snake_case       :					List[Any]				       =   requests.get(UpperCAmelCase				).json()
					_snake_case       :					str				       =   {}

					try:
										jobs.update({job["name"]: job["html_url"] for job in result["jobs"]}				)
										_snake_case       :					Union[str, Any]				       =   math.ceil((result["total_count"] - 100) / 100				)

										for i in range(UpperCAmelCase				):
															_snake_case       :					Any				       =   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."  ,  UpperCAmelCase				)

					return {}







def    A				(							UpperCAmelCase				):
					_snake_case       :					Optional[int]				       =   {}

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

					return _artifact







def    A				(							):






					class        _a:







							def __init__(    self ,						__snake_case				)      ->      List[Any]:


												'''simple docstring'''

												_snake_case       :					Any				       =   name
												_snake_case       :					Any				       =   []







							def __str__(    self				)      ->      Tuple:


												'''simple docstring'''

												return self.name







							def        lowercase       (    self ,						__snake_case				)      ->      List[Any]:


												'''simple docstring'''

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






					_snake_case       :					Dict[str, Artifact]				       =   {}

					_snake_case       :					Any				       =   filter(os.path.isdir  ,  os.listdir()				)
					for directory in directories:
										_snake_case       :					Optional[int]				       =   directory
										if artifact_name not in _available_artifacts:
															_snake_case       :					Optional[Any]				       =   Artifact(UpperCAmelCase				)

															_available_artifacts[artifact_name].add_path(UpperCAmelCase				)

					return _available_artifacts


if __name__ == "__main__":
							__lowerCAmelCase :str     =    get_job_links()
							__lowerCAmelCase :Optional[int]     =    retrieve_available_artifacts()

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

							# Link to the GitHub Action job
							__lowerCAmelCase :str     =    github_actions_job_links.get('run_doctests')

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

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

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

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

																																										__lowerCAmelCase :Union[str, Any]     =    all_failures[test] if test in all_failures else 'N/A'
																																										__lowerCAmelCase :Optional[Any]     =    failure
																																										break

							__lowerCAmelCase :Optional[int]     =    Message('🤗 Results of the doc tests.', doc_test_results)
							message.post()
							message.post_reply()