

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


__lowerCamelCase		       =    WebClient(token=os.environ['''CI_SLACK_BOT_TOKEN'''])
def       UpperCAmelCase__    (      UpperCAmelCase__				)			->			List[Any]:
       A_						=      test_results.split(""" """				)

       A_						=      0
       A_						=      0

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

       return failures


class 					A__      :



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





           '''simple docstring'''
           A_						=      title

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

           # Failures and success of the modeling tests
           A_						=      doc_test_results



    @property
    def 					snake_case_			(					self       )						->      str:





           '''simple docstring'''
           A_						=      [self._time_spent]
           A_						=      0

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

                  A_					,			A_					,			A_						=      int(time_parts[0]       ), int(time_parts[1]       ), float(time_parts[2]       )
                  total_secs += hours * 3600 + minutes * 60 + seconds

           A_					,			A_					,			A_						=      total_secs // 3600, (total_secs % 3600) // 60, total_secs % 60
           return f'''{int(UpperCamelCase__       )}h{int(UpperCamelCase__       )}m{int(UpperCamelCase__       )}s'''



    @property
    def 					snake_case_			(					self       )						->      Dict:





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



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





           '''simple docstring'''
           A_						=      40
           A_						=      {k: v["""failed"""] for k, v in doc_test_results.items() if isinstance(UpperCamelCase__		,				UpperCamelCase__       )}

           A_						=      """"""
           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       )						->      str:





           '''simple docstring'''
           A_						=      [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_			(					)						->      Optional[int]:





           '''simple docstring'''
           A_						=      [
               {
                   """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       )						->      Optional[Any]:





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

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

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



    def 					snake_case_			(					self		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__		,				UpperCamelCase__       )						->      Any:





           '''simple docstring'''
           A_						=      """"""
           for key, value in failures.items():
                  A_						=      value[:200] + """ [Truncated]""" if len(UpperCamelCase__       ) > 250 else value
                  failures_text += f'''*{key}*\n_{value}_\n\n'''

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

           if job_link is not None:
                  A_						=      {
                      """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:





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

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

           A_						=      sorted(self.doc_test_results.items()		,				key=lambda UpperCamelCase__       : t[0]       )
           for job, job_result in sorted_dict:
                  if len(job_result["""failures"""]       ):
                         A_						=      f'''*Num failures* :{len(job_result["failed"]       )} \n'''
                         A_						=      job_result["""failures"""]
                         A_						=      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__    (      )			->			Optional[int]:
       A_						=      os.environ["""GITHUB_RUN_ID"""]
       A_						=      F'''https://api.github.com/repos/huggingface/transformers/actions/runs/{run_id}/jobs?per_page=100'''
       A_						=      requests.get(UpperCAmelCase__				).json()
       A_						=      {}

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

              for i in range(UpperCAmelCase__				):
                     A_						=      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       UpperCAmelCase__    (      UpperCAmelCase__				)			->			int:
       A_						=      {}

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

       return _artifact
def       UpperCAmelCase__    (      )			->			Optional[Any]:


       class 					A__      :



           def __init__(					self		,				UpperCamelCase__       )						->      int:





                  '''simple docstring'''
                  A_						=      name
                  A_						=      []



           def __str__(					self       )						->      Dict:





                  '''simple docstring'''
                  return self.name







           def 					snake_case_			(					self		,				UpperCamelCase__       )						->      Dict:





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

       A_						=      {}

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

                     _available_artifacts[artifact_name].add_path(UpperCAmelCase__				)

       return _available_artifacts


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

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

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

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

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

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

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

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

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



'''simple docstring'''







from __future__ import annotations

import math
def       UpperCAmelCase__    (      UpperCAmelCase__				)			->			bool:

       if 1 < number < 4:
              # 2 and 3 are primes
              return True
       elif number < 2 or number % 2 == 0 or number % 3 == 0:
              # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
              return False

       # All primes number are in format of 6k +/- 1
       for i in range(5,       int(math.sqrt(UpperCAmelCase__				) + 1				),       6				):
              if number % i == 0 or number % (i + 2) == 0:
                     return False
       return True


__lowerCamelCase		       =    [num for num in range(3, 10_0001, 2) if not is_prime(num)]
def       UpperCAmelCase__    (      UpperCAmelCase__				)			->			list[int]:
       if not isinstance(UpperCAmelCase__,       UpperCAmelCase__				):
              raise ValueError("""n must be an integer"""				)
       if n <= 0:
              raise ValueError("""n must be >= 0"""				)

       A_						=      []
       for num in range(len(UpperCAmelCase__				)				):
              A_						=      0
              while 2 * i * i <= odd_composites[num]:
                     A_						=      odd_composites[num] - 2 * i * i
                     if is_prime(UpperCAmelCase__				):
                            break
                     i += 1
              else:
                     list_nums.append(odd_composites[num]				)
                     if len(UpperCAmelCase__				) == n:
                            return list_nums

       return []
def       UpperCAmelCase__    (      )			->			int:
       return compute_nums(1				)[0]


if __name__ == "__main__":
      print(f"""{solution() = }""")
