
# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import sys
import warnings
from os.path import abspath, dirname, join


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
__lowerCamelCase							= abspath(join(dirname(dirname(dirname(__file__))), """src"""))
sys.path.insert(1, git_repo_path)


# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action="""ignore""", category=FutureWarning)


def     UpperCamelCase      (					__lowerCamelCase  :				Optional[Any]					):
       from diffusers.utils.testing_utils import pytest_addoption_shared

       pytest_addoption_shared(__lowerCamelCase					)




def     UpperCamelCase      (					__lowerCamelCase  :				Any					):
       from diffusers.utils.testing_utils import pytest_terminal_summary_main

       snake_case :     int           =   terminalreporter.config.getoption("--make-reports"					)
       if make_reports:
              pytest_terminal_summary_main(__lowerCamelCase       ,      id=__lowerCamelCase					)







from __future__ import annotations






class 						UpperCAmelCase	:



   def __init__(self	:      List[str]					,		snake_case__	:      int				)	->			None:


          '''simple docstring'''


          snake_case :     Any           =   vertices
          snake_case :     str           =   [[0] * vertices for _ in range(snake_case__				)]



   def        _SCREAMING_SNAKE_CASE     (self	:      str					,		snake_case__	:      list[int]				)	->			None:


          '''simple docstring'''


          print("Vertex \t Distance from Source"				)
          for vertex in range(self.vertices				):
                 print(snake_case__					,		"\t\t"					,		distances_from_source[vertex]				)



   def        _SCREAMING_SNAKE_CASE     (self	:      Optional[int]					,		snake_case__	:      list[int]					,		snake_case__	:      list[bool]				)	->			int:


          '''simple docstring'''


          snake_case :     Union[str, Any]           =   1e7
          snake_case :     Any           =   0

          # Search not nearest vertex not in the shortest path tree
          for vertex in range(self.vertices				):
                 if distances_from_source[vertex] < minimum and visited[vertex] is False:
                        snake_case :     Union[str, Any]           =   distances_from_source[vertex]
                        snake_case :     str           =   vertex
          return min_index



   def        _SCREAMING_SNAKE_CASE     (self	:      Optional[Any]					,		snake_case__	:      int				)	->			None:


          '''simple docstring'''


          snake_case :     Optional[int]           =   [int(1e7				)] * self.vertices  # distances from the source
          snake_case :     Dict           =   0
          snake_case :     Union[str, Any]           =   [False] * self.vertices

          for _ in range(self.vertices				):
                 snake_case :     Dict           =   self.minimum_distance(snake_case__					,		snake_case__				)
                 snake_case :     List[str]           =   True

                 # Update dist value of the adjacent vertices
                 # of the picked vertex only if the current
                 # distance is greater than new distance and
                 # the vertex in not in the shortest path tree
                 for v in range(self.vertices				):
                        if (
                            self.graph[u][v] > 0
                            and visited[v] is False
                            and distances[v] > distances[u] + self.graph[u][v]
                        ):
                               snake_case :     Union[str, Any]           =   distances[u] + self.graph[u][v]

          self.print_solution(snake_case__				)


if __name__ == "__main__":
   __lowerCamelCase							= Graph(9)
   __lowerCamelCase							= [
       [0, 4, 0, 0, 0, 0, 0, 8, 0],
       [4, 0, 8, 0, 0, 0, 0, 11, 0],
       [0, 8, 0, 7, 0, 4, 0, 0, 2],
       [0, 0, 7, 0, 9, 14, 0, 0, 0],
       [0, 0, 0, 9, 0, 10, 0, 0, 0],
       [0, 0, 4, 14, 10, 0, 2, 0, 0],
       [0, 0, 0, 0, 0, 2, 0, 1, 6],
       [8, 11, 0, 0, 0, 0, 1, 0, 7],
       [0, 0, 2, 0, 0, 0, 6, 7, 0],
   ]
   graph.dijkstra(0)





