






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


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

def 			lowerCAmelCase__     (     UpperCamelCase__				):



  '''simple docstring'''
  _a  :       Optional[Any]             =	test_results.split(""" """				)

  _a  :       Optional[Any]             =	0
  _a  :       List[Any]             =	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  :       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 			lowerCAmelCase__     (     UpperCamelCase__				):



  '''simple docstring'''
  _a  :       Any             =	{}
  _a  :       Optional[Any]             =	None
  _a  :       List[str]             =	False
  for line in failures_short_lines.split("""\n"""				):
    if re.search(R"""_ \[doctest\]"""     ,   UpperCamelCase__				):
      _a  :       int             =	True
      _a  :       List[str]             =	line.split(""" """				)[2]
    elif in_error and not line.split(""" """				)[0].isdigit():
      _a  :       Dict             =	line
      _a  :       Optional[int]             =	False

  return failures






class        UpperCamelCase			:


 def __init__(     self		:						Optional[Any]							,						UpperCAmelCase__		:						str							,						UpperCAmelCase__		:						Dict							)					->       str:
   _a  :       Any             =	title

   _a  :       Dict             =	doc_test_results["""time_spent"""].split(""","""							)[0]
   _a  :       List[Any]             =	doc_test_results["""success"""]
   _a  :       List[Any]             =	doc_test_results["""failures"""]
   _a  :       Optional[int]             =	self.n_success + self.n_failures

   # Failures and success of the modeling tests
   _a  :       Optional[Any]             =	doc_test_results


 @property
 def _lowercase	(     self		:						Dict							)					->       str:
   _a  :       str             =	[self._time_spent]
   _a  :       Union[str, Any]             =	0

   for time in time_spent:
     _a  :       Optional[Any]             =	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  :       int             =	[0, 0, time_parts[0]]

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

   _a      ,  _a      ,  _a  :       Dict             =	total_secs // 3600, (total_secs % 3600) // 60, total_secs % 60
   return f"""{int(UpperCAmelCase__							)}h{int(UpperCAmelCase__							)}m{int(UpperCAmelCase__							)}s"""


 @property
 def _lowercase	(     self		:						Dict							)					->       Dict:
   return {"type": "header", "text": {"type": "plain_text", "text": self.title}}


 @property
 def _lowercase	(     self		:						Tuple							)					->       Dict:
   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		:						Optional[int]							)					->       Dict:
   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		:						Tuple							)					->       Dict:
   _a  :       Tuple             =	40
   _a  :       Any             =	{k: v["""failed"""] for k, v in doc_test_results.items() if isinstance(UpperCAmelCase__							,						UpperCAmelCase__							)}

   _a  :       Optional[Any]             =	""""""
   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 _lowercase	(     self		:						List[Any]							)					->       str:
   _a  :       str             =	[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 _lowercase	(     )					->       List[str]:
   _a  :       str             =	[
       {
           """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 _lowercase	(     self		:						Union[str, Any]							)					->       int:
   print("""Sending the following payload"""							)
   print(json.dumps({"""blocks""": json.loads(self.payload							)}							)							)

   _a  :       Optional[Any]             =	f"""{self.n_failures} failures out of {self.n_tests} tests,""" if self.n_failures else """All tests passed."""

   _a  :       Optional[Any]             =	client.chat_postMessage(
       channel=os.environ["""CI_SLACK_CHANNEL_ID_DAILY"""]							,						blocks=self.payload							,						text=UpperCAmelCase__							,						)


 def _lowercase	(     self		:						Union[str, Any]							,						UpperCAmelCase__		:						Union[str, Any]							,						UpperCAmelCase__		:						int							,						UpperCAmelCase__		:						Tuple							,						UpperCAmelCase__		:						List[str]							)					->       Union[str, Any]:
   _a  :       Optional[Any]             =	""""""
   for key, value in failures.items():
     _a  :       Dict             =	value[:200] + """ [Truncated]""" if len(UpperCAmelCase__							) > 250 else value
     failures_text += f"""*{key}*\n_{value}_\n\n"""

   _a  :       Optional[Any]             =	job_name
   _a  :       Any             =	{"""type""": """section""", """text""": {"""type""": """mrkdwn""", """text""": text}}

   if job_link is not None:
     _a  :       str             =	{
         """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		:						List[Any]							)					->       Tuple:
   if self.thread_ts is None:
     raise ValueError("""Can only post reply if a post has been made."""							)

   _a  :       str             =	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  :       Optional[Any]             =	sorted(self.doc_test_results.items()							,						key=lambda UpperCAmelCase__							: t[0]							)
   for job, job_result in sorted_dict:
     if len(job_result["""failures"""]							):
       _a  :       Union[str, Any]             =	f"""*Num failures* :{len(job_result['failed']							)} \n"""
       _a  :       Optional[Any]             =	job_result["""failures"""]
       _a  :       Optional[int]             =	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 			lowerCAmelCase__     (     ):



  '''simple docstring'''
  _a  :       Any             =	os.environ["""GITHUB_RUN_ID"""]
  _a  :       str             =	F"""https://api.github.com/repos/huggingface/transformers/actions/runs/{run_id}/jobs?per_page=100"""
  _a  :       List[str]             =	requests.get(UpperCamelCase__				).json()
  _a  :       Dict             =	{}

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

    for i in range(UpperCamelCase__				):
      _a  :       Union[str, 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 			lowerCAmelCase__     (     UpperCamelCase__				):



  '''simple docstring'''
  _a  :       Any             =	{}

  if os.path.exists(UpperCamelCase__				):
    _a  :       Union[str, Any]             =	os.listdir(UpperCamelCase__				)
    for file in files:
      try:
        with open(os.path.join(UpperCamelCase__     ,   UpperCamelCase__				)     ,   encoding="""utf-8"""				) as f:
          _a  :       Optional[int]             =	f.read()
      except UnicodeDecodeError as e:
        raise ValueError(F"""Could not open {os.path.join(UpperCamelCase__     ,   UpperCamelCase__				)}."""				) from e

  return _artifact

def 			lowerCAmelCase__     (     ):



  '''simple docstring'''






  class        UpperCamelCase			:


   def __init__(     self		:						int							,						UpperCAmelCase__		:						str							)					->       int:
     _a  :       Dict             =	name
     _a  :       Optional[Any]             =	[]


   def __str__(     self		:						List[str]							)					->       Optional[Any]:
     return self.name







   def _lowercase	(     self		:						Optional[int]							,						UpperCAmelCase__		:						str							)					->       str:
     self.paths.append({"""name""": self.name, """path""": path}							)







  _a  :       Dict[str, Artifact]             =	{}

  _a  :       Any             =	filter(os.path.isdir     ,   os.listdir()				)
  for directory in directories:
    _a  :       Optional[int]             =	directory
    if artifact_name not in _available_artifacts:
      _a  :       Optional[int]             =	Artifact(UpperCamelCase__				)

      _available_artifacts[artifact_name].add_path(UpperCamelCase__				)

  return _available_artifacts


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

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

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

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

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

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

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

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

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









"""simple docstring"""




from __future__ import annotations

def 			lowerCAmelCase__     (     UpperCamelCase__     ,   UpperCamelCase__				):



  '''simple docstring'''
  print(F"""Vertex\tShortest Distance from vertex {src}"""				)
  for i, d in enumerate(UpperCamelCase__				):
    print(F"""{i}\t\t{d}"""				)

def 			lowerCAmelCase__     (     UpperCamelCase__     ,   UpperCamelCase__     ,   UpperCamelCase__				):



  '''simple docstring'''
  for j in range(UpperCamelCase__				):
    _a      ,  _a      ,  _a  :       List[str]             =	(graph[j][k] for k in ["""src""", """dst""", """weight"""])
    if distance[u] != float("""inf"""				) and distance[u] + w < distance[v]:
      return True
  return False

def 			lowerCAmelCase__     (     UpperCamelCase__     ,   UpperCamelCase__     ,   UpperCamelCase__     ,   UpperCamelCase__				):



  '''simple docstring'''
  _a  :       Dict             =	[float("""inf"""				)] * vertex_count
  _a  :       Any             =	0.0

  for _ in range(vertex_count - 1				):
    for j in range(UpperCamelCase__				):
      _a      ,  _a      ,  _a  :       List[Any]             =	(graph[j][k] for k in ["""src""", """dst""", """weight"""])

      if distance[u] != float("""inf"""				) and distance[u] + w < distance[v]:
        _a  :       Any             =	distance[u] + w

  _a  :       Union[str, Any]             =	check_negative_cycle(UpperCamelCase__     ,   UpperCamelCase__     ,   UpperCamelCase__				)
  if negative_cycle_exists:
    raise Exception("""Negative cycle found"""				)

  return distance


if __name__ == "__main__":
 import doctest

 doctest.testmod()

 _snake_case          =   int(input('Enter number of vertices: ').strip())
 _snake_case          =   int(input('Enter number of edges: ').strip())

 _snake_case          =   [{} for _ in range(E)]

 for i in range(E):
  print('Edge ', i + 1)
  _snake_case      , _snake_case      , _snake_case          =   (
      int(x)
      for x in input('Enter source, destination, weight: ').strip().split(' ')
  )
  _snake_case          =   {'src': src, 'dst': dest, 'weight': weight}

 _snake_case          =   int(input('\nEnter shortest path source:').strip())
 _snake_case          =   bellman_ford(graph, V, E, source)
 print_distance(shortest_distance, 0)

