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


__UpperCAmelCase					=WebClient(token=os.environ["CI_SLACK_BOT_TOKEN"])






def __lowerCAmelCase					(				UpperCamelCase__							)      ->       Union[str, Any]:
    __lowerCamelCase            =    test_results.split(''' '''							)

    __lowerCamelCase            =    0
    __lowerCamelCase            =    0

    # When the output is short enough, the output is surrounded by = signs: "== OUTPUT =="
    # When it is too long, those signs are not present.
    __lowerCamelCase            =    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 __lowerCAmelCase					(				UpperCamelCase__							)      ->       int:
    __lowerCamelCase            =    {}
    __lowerCamelCase            =    None
    __lowerCamelCase            =    False
    for line in failures_short_lines.split('''\n'''							):
        if re.search(r'''_ \[doctest\]'''							,    UpperCamelCase__							):
            __lowerCamelCase            =    True
            __lowerCamelCase            =    line.split(''' '''							)[2]
        elif in_error and not line.split(''' '''							)[0].isdigit():
            __lowerCamelCase            =    line
            __lowerCamelCase            =    False

    return failures




class        a__ :






     def __init__(					self						:						Any    ,							a						:						str    ,							a						:						Dict       ):





         """simple docstring"""



         __lowerCamelCase            =    title

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

         # Failures and success of the modeling tests
         __lowerCamelCase            =    doc_test_results






     @property
     def   SCREAMING_SNAKE_CASE__  (					self						:						Union[str, Any]       ):





         """simple docstring"""



         __lowerCamelCase            =    [self._time_spent]
         __lowerCamelCase            =    0

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

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

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






     @property
     def   SCREAMING_SNAKE_CASE__  (					self						:						str       ):





         """simple docstring"""



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






     @property
     def   SCREAMING_SNAKE_CASE__  (					self						:						str       ):





         """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   SCREAMING_SNAKE_CASE__  (					self						:						Tuple       ):





         """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   SCREAMING_SNAKE_CASE__  (					self						:						str       ):





         """simple docstring"""



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

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

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

             report += f"""*{category} failures*:""".ljust(line_length // 2       ).rjust(line_length // 2       ) + "\n"
             report += "`"
             report += "`\n`".join(a       )
             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						:						Optional[Any]       ):





         """simple docstring"""



         __lowerCamelCase            =    [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(a       )






     @staticmethod
     def   SCREAMING_SNAKE_CASE__  (					):





         """simple docstring"""



         __lowerCamelCase            =    [
             {
                 '''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(a       )}       )       )

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






     def   SCREAMING_SNAKE_CASE__  (					self						:						Dict       ):





         """simple docstring"""



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

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

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






     def   SCREAMING_SNAKE_CASE__  (					self						:						List[Any]    ,							a						:						Optional[Any]    ,							a						:						Dict    ,							a						:						Union[str, Any]    ,							a						:						Optional[Any]       ):





         """simple docstring"""



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

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

         if job_link is not None:
             __lowerCamelCase            =    {
                 '''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						:						str       ):





         """simple docstring"""



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

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

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

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

                 time.sleep(1       )






def __lowerCAmelCase					(				)      ->       Optional[Any]:
    __lowerCamelCase            =    os.environ['''GITHUB_RUN_ID''']
    __lowerCamelCase            =    f"""https://api.github.com/repos/huggingface/transformers/actions/runs/{run_id}/jobs?per_page=100"""
    __lowerCamelCase            =    requests.get(UpperCamelCase__							).json()
    __lowerCamelCase            =    {}

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

        for i in range(UpperCamelCase__							):
            __lowerCamelCase            =    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 __lowerCAmelCase					(				UpperCamelCase__							)      ->       str:
    __lowerCamelCase            =    {}

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

    return _artifact






def __lowerCAmelCase					(				)      ->       str:




    class        a__ :






         def __init__(					self						:						Dict    ,							a						:						str       ):





             """simple docstring"""



             __lowerCamelCase            =    name
             __lowerCamelCase            =    []






         def __str__(					self						:						Any       ):





             """simple docstring"""



             return self.name






         def   SCREAMING_SNAKE_CASE__  (					self						:						Optional[Any]    ,							a						:						str       ):





             """simple docstring"""



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

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

            _available_artifacts[artifact_name].add_path(UpperCamelCase__							)

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

'''simple docstring'''




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


__UpperCAmelCase					=logging.get_logger(__name__)

__UpperCAmelCase					={
    "Visual-Attention-Network/van-base": (
        "https://huggingface.co/Visual-Attention-Network/van-base/blob/main/config.json"
    ),
}




class        a__ (  UpperCAmelCase__					):
     lowerCamelCase    :	Optional[Any]				="van"






     def __init__(					self						:						Union[str, Any]    ,							a						:						List[Any]=2_24    ,							a						:						Optional[int]=3    ,							a						:						Optional[Any]=[7, 3, 3, 3]    ,							a						:						int=[4, 2, 2, 2]    ,							a						:						Optional[int]=[64, 1_28, 3_20, 5_12]    ,							a						:						str=[3, 3, 12, 3]    ,							a						:						str=[8, 8, 4, 4]    ,							a						:						int="gelu"    ,							a						:						int=0.02    ,							a						:						Optional[int]=1e-6    ,							a						:						List[str]=1e-2    ,							a						:						Union[str, Any]=0.0    ,							a						:						int=0.0    ,							**a						:						Optional[Any]    ,							):





         """simple docstring"""



         super().__init__(**a       )
         __lowerCamelCase            =    image_size
         __lowerCamelCase            =    num_channels
         __lowerCamelCase            =    patch_sizes
         __lowerCamelCase            =    strides
         __lowerCamelCase            =    hidden_sizes
         __lowerCamelCase            =    depths
         __lowerCamelCase            =    mlp_ratios
         __lowerCamelCase            =    hidden_act
         __lowerCamelCase            =    initializer_range
         __lowerCamelCase            =    layer_norm_eps
         __lowerCamelCase            =    layer_scale_init_value
         __lowerCamelCase            =    drop_path_rate
         __lowerCamelCase            =    dropout_rate
