





def    A				(							UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase				):
					if index == r:
										for j in range(UpperCAmelCase				):
															print(data[j]  ,  end=" "				)
										print(" "				)
										return
					#  When no more elements are there to put in data[]
					if i >= n:
										return
					# current is included, put next at next location
					_snake_case       :					Optional[Any]				       =   arr[i]
					combination_util(UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  index + 1  ,  UpperCAmelCase  ,  i + 1				)
					# current is excluded, replace it with
					# next (Note that i+1 is passed, but
					# index is not changed)
					combination_util(UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  i + 1				)
					# The main function that prints all combinations
					# of size r in arr[] of size n. This function
					# mainly uses combinationUtil()







def    A				(							UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase				):
					# A temporary array to store all combination one by one
					_snake_case       :					Any				       =   [0] * r
					# Print all combination using temporary array 'data[]'
					combination_util(UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  ,  0  ,  UpperCAmelCase  ,  0				)


if __name__ == "__main__":
							# Driver code to check the function above
							__lowerCAmelCase :Tuple     =    [10, 20, 30, 40, 50]
							print_combination(arr, len(arr), 3)
							# This code is contributed by Ambuj sahu






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()