



"""simple docstring"""
from __future__ import annotations
class     lowerCamelCase  :






					'''simple docstring'''





					def __init__(	self:							str						,					snake_case:							int						)       ->     None:
											snake_case_			:Optional[int]						=      vertices
											snake_case_			:List[str]						=      [[0] * vertices for _ in range(snake_case						)]






					def        lowerCAmelCase_    (	self:							Any						,					snake_case:							list[int]						)       ->     None:
											print("""Vertex \t Distance from Source"""						)
											for vertex in range(self.vertices						):
																	print(snake_case						,					"""\t\t"""						,					distances_from_source[vertex]						)






					def        lowerCAmelCase_    (	self:							List[str]						,					snake_case:							list[int]						,					snake_case:							list[bool]						)       ->     int:
											snake_case_			:Union[str, Any]						=      1E7
											snake_case_			:List[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_			:Tuple						=      distances_from_source[vertex]
																							snake_case_			:int						=      vertex
											return min_index






					def        lowerCAmelCase_    (	self:							List[str]						,					snake_case:							int						)       ->     None:
											snake_case_			:List[str]						=      [int(1E7						)] * self.vertices  # distances from the source
											snake_case_			:Union[str, Any]						=      0
											snake_case_			:Optional[int]						=      [False] * self.vertices

											for _ in range(self.vertices						):
																	snake_case_			:int						=      self.minimum_distance(snake_case						,					snake_case						)
																	snake_case_			:Any						=      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_			:List[Any]						=      distances[u] + self.graph[u][v]

											self.print_solution(snake_case						)


if __name__ == "__main__":
						__a     =    Graph(9)
						__a     =    [
						    [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)





"""simple docstring"""
import unittest
from pathlib import Path
from tempfile import TemporaryDirectory
from unittest.mock import Mock, patch

import diffusers.utils.hub_utils
class     lowerCamelCase  (      unittest.TestCase    ):






					'''simple docstring'''





					@patch("""diffusers.utils.hub_utils.get_full_repo_name"""						)
					def        lowerCAmelCase_    (	self:							int						,					snake_case:							Mock						)       ->     None:
											snake_case_			:str						=      """full_repo_name"""
											with TemporaryDirectory() as tmpdir:
																	# Dummy args values
																	snake_case_			:int						=      Mock()
																	snake_case_			:Any						=      tmpdir
																	snake_case_			:int						=      0
																	snake_case_			:Optional[int]						=      """hub_token"""
																	snake_case_			:str						=      """dataset_name"""
																	snake_case_			:List[str]						=      0.0_1
																	snake_case_			:Dict						=      100_000
																	snake_case_			:Optional[Any]						=      10_000
																	snake_case_			:Optional[Any]						=      0.0_1
																	snake_case_			:Dict						=      0.0_2
																	snake_case_			:Dict						=      0.0_3
																	snake_case_			:Union[str, Any]						=      0.0_0_0_5
																	snake_case_			:Optional[Any]						=      0.0_0_0_0_0_1
																	snake_case_			:List[Any]						=      1
																	snake_case_			:Optional[Any]						=      10
																	snake_case_			:Dict						=      0.0_0_1
																	snake_case_			:Any						=      0.1
																	snake_case_			:List[Any]						=      0.2
																	snake_case_			:Any						=      True

																	# Model card mush be rendered and saved
																	diffusers.utils.hub_utils.create_model_card(snake_case						,					model_name="""model_name"""						)
																	self.assertTrue((Path(snake_case						) / """README.md""").is_file()						)
