
"""simple docstring"""



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


a					:	str							=		logging.get_logger(__name__)

a					:	Optional[int]							=		{
    '''google/vivit-b-16x2-kinetics400''': (
        '''https://huggingface.co/google/vivit-b-16x2-kinetics400/resolve/main/config.json'''
    ),
    # See all Vivit models at https://huggingface.co/models?filter=vivit
}




class 		a_						( _UpperCAmelCase	):
    a      :				Dict     =				'vivit'







    def __init__(			self			:       Tuple     ,					__UpperCamelCase			:       Tuple=2_24     ,					__UpperCamelCase			:       Optional[Any]=32     ,					__UpperCamelCase			:       Tuple=[2, 16, 16]     ,					__UpperCamelCase			:       Dict=3     ,					__UpperCamelCase			:       Tuple=7_68     ,					__UpperCamelCase			:       Optional[Any]=12     ,					__UpperCamelCase			:       Optional[Any]=12     ,					__UpperCamelCase			:       Dict=30_72     ,					__UpperCamelCase			:       Any="gelu_fast"     ,					__UpperCamelCase			:       int=0.0     ,					__UpperCamelCase			:       Dict=0.0     ,					__UpperCamelCase			:       Optional[int]=0.0_2     ,					__UpperCamelCase			:       Optional[int]=1e-06     ,					__UpperCamelCase			:       Optional[int]=True     ,					**__UpperCamelCase			:       Dict     ,					)		->Union[str, Any]:






        '''simple docstring'''






        _UpperCAmelCase          =   hidden_size
        _UpperCAmelCase          =   num_hidden_layers
        _UpperCAmelCase          =   num_attention_heads
        _UpperCAmelCase          =   intermediate_size
        _UpperCAmelCase          =   hidden_act
        _UpperCAmelCase          =   hidden_dropout_prob
        _UpperCAmelCase          =   attention_probs_dropout_prob
        _UpperCAmelCase          =   initializer_range
        _UpperCAmelCase          =   layer_norm_eps

        _UpperCAmelCase          =   image_size
        _UpperCAmelCase          =   num_frames
        _UpperCAmelCase          =   tubelet_size
        _UpperCAmelCase          =   num_channels
        _UpperCAmelCase          =   qkv_bias

        super().__init__(**__UpperCamelCase     )

"""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


a					:	int							=		WebClient(token=os.environ['''CI_SLACK_BOT_TOKEN'''])


def  _UpperCamelCase	(						_A      )    ->  List[str]:





    """simple docstring"""

    _UpperCAmelCase          =   test_results.split(""" """      )

    _UpperCAmelCase          =   0
    _UpperCAmelCase          =   0

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





    """simple docstring"""

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

    return failures




class 		a_						:







    def __init__(			self			:       Union[str, Any]     ,					__UpperCamelCase			:       str     ,					__UpperCamelCase			:       Dict     )		->Union[str, Any]:






        '''simple docstring'''






        _UpperCAmelCase          =   title

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

        # Failures and success of the modeling tests
        _UpperCAmelCase          =   doc_test_results







    @property
    def      _snake_case					(			self			:       int     )		->str:






        '''simple docstring'''






        _UpperCAmelCase          =   [self._time_spent]
        _UpperCAmelCase          =   0

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

            _UpperCAmelCase    ,_UpperCAmelCase    ,_UpperCAmelCase          =   int(time_parts[0]     ), int(time_parts[1]     ), float(time_parts[2]     )
            total_secs += hours * 36_00 + minutes * 60 + seconds

        _UpperCAmelCase    ,_UpperCAmelCase    ,_UpperCAmelCase          =   total_secs // 36_00, (total_secs % 36_00) // 60, total_secs % 60
        return f"""{int(__UpperCamelCase     )}h{int(__UpperCamelCase     )}m{int(__UpperCamelCase     )}s"""







    @property
    def      _snake_case					(			self			:       List[Any]     )		->Dict:






        '''simple docstring'''






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







    @property
    def      _snake_case					(			self			:       Optional[Any]     )		->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      _snake_case					(			self			:       Union[str, Any]     )		->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      _snake_case					(			self			:       List[str]     )		->Dict:






        '''simple docstring'''






        _UpperCAmelCase          =   40
        _UpperCAmelCase          =   {k: v["""failed"""] for k, v in doc_test_results.items() if isinstance(__UpperCamelCase     ,					__UpperCamelCase     )}

        _UpperCAmelCase          =   """"""
        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      _snake_case					(			self			:       Union[str, Any]     )		->str:






        '''simple docstring'''






        _UpperCAmelCase          =   [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      _snake_case					(			)		->Any:






        '''simple docstring'''






        _UpperCAmelCase          =   [
            {
                """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      _snake_case					(			self			:       Tuple     )		->Optional[Any]:






        '''simple docstring'''






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

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

        _UpperCAmelCase          =   client.chat_postMessage(
            channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""]     ,					blocks=self.payload     ,					text=__UpperCamelCase     ,					)







    def      _snake_case					(			self			:       List[Any]     ,					__UpperCamelCase			:       Optional[int]     ,					__UpperCamelCase			:       Any     ,					__UpperCamelCase			:       Any     ,					__UpperCamelCase			:       List[str]     )		->str:






        '''simple docstring'''






        _UpperCAmelCase          =   """"""
        for key, value in failures.items():
            _UpperCAmelCase          =   value[:2_00] + """ [Truncated]""" if len(__UpperCamelCase     ) > 2_50 else value
            failures_text += f"""*{key}*\n_{value}_\n\n"""

        _UpperCAmelCase          =   job_name
        _UpperCAmelCase          =   {"""type""": """section""", """text""": {"""type""": """mrkdwn""", """text""": text}}

        if job_link is not None:
            _UpperCAmelCase          =   {
                """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      _snake_case					(			self			:       int     )		->Optional[Any]:






        '''simple docstring'''






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

        _UpperCAmelCase          =   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"""     )

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





    """simple docstring"""

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

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

        for i in range(_A      ):
            _UpperCAmelCase          =   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      )    ->  Optional[int]:





    """simple docstring"""

    _UpperCAmelCase          =   {}

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

    return _artifact


def  _UpperCamelCase	(						)    ->  int:





    """simple docstring"""

    class 		a_						:







        def __init__(			self			:       List[Any]     ,					__UpperCamelCase			:       str     )		->Tuple:






            '''simple docstring'''






            _UpperCAmelCase          =   name
            _UpperCAmelCase          =   []







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






            '''simple docstring'''






            return self.name







        def      _snake_case					(			self			:       Dict     ,					__UpperCamelCase			:       str     )		->int:






            '''simple docstring'''






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







    _UpperCAmelCase          =   {}

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

            _available_artifacts[artifact_name].add_path(_A      )

    return _available_artifacts


if __name__ == "__main__":
 a					:	Dict							=		get_job_links()
 a					:	Dict							=		retrieve_available_artifacts()

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

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

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

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

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

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

      a					:	Optional[Any]							=		all_failures[test] if test in all_failures else '''N/A'''
      a					:	List[str]							=		failure
      break

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