code: 
  
  
  import heapq
  
  
  
  
  
  
  
  def 							UpperCAmelCase				(     UpperCAmelCase				,UpperCAmelCase				,UpperCAmelCase      )->		Optional[int]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					SCREAMING_SNAKE_CASE_	      =       [(0, start)]  # cost from start node,end node
  					SCREAMING_SNAKE_CASE_	      =       set()
  					while heap:
  										((SCREAMING_SNAKE_CASE_)      ,(SCREAMING_SNAKE_CASE_))	      =       heapq.heappop(UpperCAmelCase      )
  										if u in visited:
  															continue
  										visited.add(UpperCAmelCase      )
  										if u == end:
  															return cost
  										for v, c in graph[u]:
  															if v in visited:
  																				continue
  															SCREAMING_SNAKE_CASE_	      =       cost + c
  															heapq.heappush(UpperCAmelCase				,(next_item, v)      )
  					return -1
  
  
  A_														=      {
      "A": [["B", 2], ["C", 5]],
      "B": [["A", 2], ["D", 3], ["E", 1], ["F", 1]],
      "C": [["A", 5], ["F", 3]],
      "D": [["B", 3]],
      "E": [["B", 4], ["F", 3]],
      "F": [["C", 3], ["E", 3]],
  }
  A_														=      {
      "B": [["C", 1]],
      "C": [["D", 1]],
      "D": [["F", 1]],
      "E": [["B", 1], ["F", 3]],
      "F": [],
  }
  A_														=      {
      "B": [["C", 1]],
      "C": [["D", 1]],
      "D": [["F", 1]],
      "E": [["B", 1], ["G", 2]],
      "F": [],
      "G": [["F", 1]],
  }
  
  A_														=      dijkstra(G, "E", "C")
  print(short_distance)  # E -- 3 --> F -- 3 --> C == 6
  
  A_														=      dijkstra(Ga, "E", "F")
  print(short_distance)  # E -- 3 --> F == 3
  
  A_														=      dijkstra(Ga, "E", "F")
  print(short_distance)  # E -- 2 --> G -- 1 --> F == 3
  
  if __name__ == "__main__":
  		import doctest
  
  		doctest.testmod()
  
  
  
style_context: 
  
  
  import unittest
  
  from transformers import load_tool
  from transformers.tools.agent_types import AGENT_TYPE_MAPPING
  
  from .test_tools_common import ToolTesterMixin, output_types
  
  class 						snake_case			(       unittest.TestCase	, lowerCAmelCase__	):
  			'''simple docstring'''
  
  			def _lowercase (	self     :     List[Any]					)					->					Optional[Any]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       load_tool('''translation'''					)
  								self.tool.setup()
  								SCREAMING_SNAKE_CASE_	      =       load_tool('''translation'''							,							remote=lowerCAmelCase_					)
  
  			def _lowercase (	self     :     Tuple					)					->					str:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       self.tool('''Hey, what\'s up?'''							,							src_lang='''English'''							,							tgt_lang='''French'''					)
  								self.assertEqual(lowerCAmelCase_							,							'''- Hé, comment ça va?'''					)
  
  			def _lowercase (	self     :     Optional[Any]					)					->					int:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       self.remote_tool('''Hey, what\'s up?'''							,							src_lang='''English'''							,							tgt_lang='''French'''					)
  								self.assertEqual(lowerCAmelCase_							,							'''- Hé, comment ça va?'''					)
  
  			def _lowercase (	self     :     Optional[int]					)					->					str:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       self.tool(text='''Hey, what\'s up?'''							,							src_lang='''English'''							,							tgt_lang='''French'''					)
  								self.assertEqual(lowerCAmelCase_							,							'''- Hé, comment ça va?'''					)
  
  			def _lowercase (	self     :     str					)					->					List[str]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       self.remote_tool(text='''Hey, what\'s up?'''							,							src_lang='''English'''							,							tgt_lang='''French'''					)
  								self.assertEqual(lowerCAmelCase_							,							'''- Hé, comment ça va?'''					)
  
  			def _lowercase (	self     :     Optional[int]					)					->					Dict:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       ['''Hey, what\'s up?''', '''English''', '''Spanish''']
  								SCREAMING_SNAKE_CASE_	      =       self.tool(*lowerCAmelCase_					)
  
  								# There is a single output
  								if len(self.tool.outputs					) == 1:
  													SCREAMING_SNAKE_CASE_	      =       [outputs]
  
  								self.assertListEqual(output_types(lowerCAmelCase_					)							,							self.tool.outputs					)
  
  			def _lowercase (	self     :     Optional[int]					)					->					List[str]:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       ['''Hey, what\'s up?''', '''English''', '''Spanish''']
  								SCREAMING_SNAKE_CASE_	      =       self.tool(*lowerCAmelCase_					)
  
  								if not isinstance(lowerCAmelCase_							,							lowerCAmelCase_					):
  													SCREAMING_SNAKE_CASE_	      =       [outputs]
  
  								self.assertEqual(len(lowerCAmelCase_					)							,							len(self.tool.outputs					)					)
  
  								for output, output_type in zip(lowerCAmelCase_							,							self.tool.outputs					):
  													SCREAMING_SNAKE_CASE_	      =       AGENT_TYPE_MAPPING[output_type]
  													self.assertTrue(isinstance(lowerCAmelCase_							,							lowerCAmelCase_					)					)
  
  
  
  
  			def _lowercase (	self     :     Tuple					)					->					int:
  
  
  
  
  								"""simple docstring"""
  
  
  
  
  
  
  								SCREAMING_SNAKE_CASE_	      =       ['''Hey, what\'s up?''', '''English''', '''Spanish''']
  
  								SCREAMING_SNAKE_CASE_	      =       []
  
  								for _input, input_type in zip(lowerCAmelCase_							,							self.tool.inputs					):
  													if isinstance(lowerCAmelCase_							,							lowerCAmelCase_					):
  																		_inputs.append([AGENT_TYPE_MAPPING[_input_type](_input					) for _input_type in input_type]					)
  													else:
  																		_inputs.append(AGENT_TYPE_MAPPING[input_type](_input					)					)
  
          # Should not raise an error
  								SCREAMING_SNAKE_CASE_	      =       self.tool(*lowerCAmelCase_					)
  
  								if not isinstance(lowerCAmelCase_							,							lowerCAmelCase_					):
  													SCREAMING_SNAKE_CASE_	      =       [outputs]
  
  								self.assertEqual(len(lowerCAmelCase_					)							,							len(self.tool.outputs					)					)
  
  
  