
from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase	      = logging.get_logger(__name__)

UpperCAmelCase	      = {'''ctrl''': '''https://huggingface.co/ctrl/resolve/main/config.json'''}







class        A_   (			__lowerCamelCase   ):




	'''simple docstring'''


	_UpperCamelCase     :     str							 =       """ctrl"""
	_UpperCamelCase     :     str							 =       ["""past_key_values"""]
	_UpperCamelCase     :     Optional[int]							 =       {
	    """max_position_embeddings""": """n_positions""",
	    """hidden_size""": """n_embd""",
	    """num_attention_heads""": """n_head""",
	    """num_hidden_layers""": """n_layer""",
	}





	def __init__(       self		,    snake_case=24_6534		,    snake_case=256		,    snake_case=1280		,    snake_case=8192		,    snake_case=48		,    snake_case=16		,    snake_case=0.1		,    snake_case=0.1		,    snake_case=1E-6		,    snake_case=0.02		,    snake_case=True		,    **snake_case		,    ):
		lowercase       =    vocab_size
		lowercase       =    n_positions
		lowercase       =    n_embd
		lowercase       =    n_layer
		lowercase       =    n_head
		lowercase       =    dff
		lowercase       =    resid_pdrop
		lowercase       =    embd_pdrop
		lowercase       =    layer_norm_epsilon
		lowercase       =    initializer_range

		lowercase       =    use_cache

		super().__init__(**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


UpperCAmelCase	      = WebClient(token=os.environ['''CI_SLACK_BOT_TOKEN'''])






def 							UpperCAmelCase_		(							__SCREAMING_SNAKE_CASE							):
	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(__SCREAMING_SNAKE_CASE							):
		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_		(							__SCREAMING_SNAKE_CASE							):
	lowercase       =    {}
	lowercase       =    None
	lowercase       =    False
	for line in failures_short_lines.split('\n'							):
		if re.search(r'_ \[doctest\]' ,							__SCREAMING_SNAKE_CASE							):
			lowercase       =    True
			lowercase       =    line.split(' '							)[2]
		elif in_error and not line.split(' '							)[0].isdigit():
			lowercase       =    line
			lowercase       =    False

	return failures







class        A_   :




	'''simple docstring'''


	def __init__(       self		,    snake_case		,    snake_case       ):
		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 	SCREAMING_SNAKE_CASE__						(       self       ):
		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(snake_case       ) == 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(snake_case       )}h{int(snake_case       )}m{int(snake_case       )}s'''





	@property
	def 	SCREAMING_SNAKE_CASE__						(       self       ):
		return {"type": "header", "text": {"type": "plain_text", "text": self.title}}





	@property
	def 	SCREAMING_SNAKE_CASE__						(       self       ):
		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 	SCREAMING_SNAKE_CASE__						(       self       ):
		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 	SCREAMING_SNAKE_CASE__						(       self       ):
		lowercase       =    40
		lowercase       =    {k: v['failed'] for k, v in doc_test_results.items() if isinstance(snake_case		,    snake_case       )}

		lowercase       =    ''
		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 	SCREAMING_SNAKE_CASE__						(       self       ):
		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(snake_case       )





	@staticmethod
	def 	SCREAMING_SNAKE_CASE__						(       ):
		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(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 	SCREAMING_SNAKE_CASE__						(       self       ):
		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=snake_case		,    )





	def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case		,    snake_case		,    snake_case		,    snake_case       ):
		lowercase       =    ''
		for key, value in failures.items():
			lowercase       =    value[:200] + ' [Truncated]' if len(snake_case       ) > 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 	SCREAMING_SNAKE_CASE__						(       self       ):
		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 snake_case       : 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(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 							UpperCAmelCase_		(							):
	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(__SCREAMING_SNAKE_CASE							).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(__SCREAMING_SNAKE_CASE							):
			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.' ,							__SCREAMING_SNAKE_CASE							)

	return {}






def 							UpperCAmelCase_		(							__SCREAMING_SNAKE_CASE							):
	lowercase       =    {}

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

	return _artifact






def 							UpperCAmelCase_		(							):







	class        A_   :




		'''simple docstring'''


		def __init__(       self		,    snake_case       ):
			lowercase       =    name
			lowercase       =    []





		def __str__(       self       ):
			return self.name





		def 	SCREAMING_SNAKE_CASE__						(       self		,    snake_case       ):
			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(__SCREAMING_SNAKE_CASE							)

			_available_artifacts[artifact_name].add_path(__SCREAMING_SNAKE_CASE							)

	return _available_artifacts


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

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

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

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

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

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

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

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

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

