



'''simple docstring'''







import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
      import torch

      from transformers import (
          RemBertConfig,
          RemBertForCausalLM,
          RemBertForMaskedLM,
          RemBertForMultipleChoice,
          RemBertForQuestionAnswering,
          RemBertForSequenceClassification,
          RemBertForTokenClassification,
          RemBertModel,
      )
      from transformers.models.rembert.modeling_rembert import REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST

class       lowerCamelCase_							:






   '''simple docstring'''

   def __init__(  self     ,						__UpperCamelCase     ,						__UpperCamelCase=13     ,						__UpperCamelCase=7     ,						__UpperCamelCase=True     ,						__UpperCamelCase=True     ,						__UpperCamelCase=True     ,						__UpperCamelCase=True     ,						__UpperCamelCase=99     ,						__UpperCamelCase=32     ,						__UpperCamelCase=18     ,						__UpperCamelCase=43     ,						__UpperCamelCase=5     ,						__UpperCamelCase=4     ,						__UpperCamelCase=37     ,						__UpperCamelCase="gelu"     ,						__UpperCamelCase=0.1     ,						__UpperCamelCase=0.1     ,						__UpperCamelCase=5_12     ,						__UpperCamelCase=16     ,						__UpperCamelCase=2     ,						__UpperCamelCase=0.02     ,						__UpperCamelCase=3     ,						__UpperCamelCase=4     ,						__UpperCamelCase=None     ,						):
       UpperCamelCase__      =			parent
       UpperCamelCase__      =			batch_size
       UpperCamelCase__      =			seq_length
       UpperCamelCase__      =			is_training
       UpperCamelCase__      =			use_input_mask
       UpperCamelCase__      =			use_token_type_ids
       UpperCamelCase__      =			use_labels
       UpperCamelCase__      =			vocab_size
       UpperCamelCase__      =			hidden_size
       UpperCamelCase__      =			input_embedding_size
       UpperCamelCase__      =			output_embedding_size
       UpperCamelCase__      =			num_hidden_layers
       UpperCamelCase__      =			num_attention_heads
       UpperCamelCase__      =			intermediate_size
       UpperCamelCase__      =			hidden_act
       UpperCamelCase__      =			hidden_dropout_prob
       UpperCamelCase__      =			attention_probs_dropout_prob
       UpperCamelCase__      =			max_position_embeddings
       UpperCamelCase__      =			type_vocab_size
       UpperCamelCase__      =			type_sequence_label_size
       UpperCamelCase__      =			initializer_range
       UpperCamelCase__      =			num_labels
       UpperCamelCase__      =			num_choices
       UpperCamelCase__      =			scope


   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			ids_tensor([self.batch_size, self.seq_length]     ,						self.vocab_size )

       UpperCamelCase__      =			None
       if self.use_input_mask:
           UpperCamelCase__      =			random_attention_mask([self.batch_size, self.seq_length] )

       UpperCamelCase__      =			None
       if self.use_token_type_ids:
           UpperCamelCase__      =			ids_tensor([self.batch_size, self.seq_length]     ,						self.type_vocab_size )

       UpperCamelCase__      =			None
       UpperCamelCase__      =			None
       UpperCamelCase__      =			None
       if self.use_labels:
           UpperCamelCase__      =			ids_tensor([self.batch_size]     ,						self.type_sequence_label_size )
           UpperCamelCase__      =			ids_tensor([self.batch_size, self.seq_length]     ,						self.num_labels )
           UpperCamelCase__      =			ids_tensor([self.batch_size]     ,						self.num_choices )

       UpperCamelCase__      =			RemBertConfig(
           vocab_size=self.vocab_size     ,						hidden_size=self.hidden_size     ,						input_embedding_size=self.input_embedding_size     ,						output_embedding_size=self.output_embedding_size     ,						num_hidden_layers=self.num_hidden_layers     ,						num_attention_heads=self.num_attention_heads     ,						intermediate_size=self.intermediate_size     ,						hidden_act=self.hidden_act     ,						hidden_dropout_prob=self.hidden_dropout_prob     ,						attention_probs_dropout_prob=self.attention_probs_dropout_prob     ,						max_position_embeddings=self.max_position_embeddings     ,						type_vocab_size=self.type_vocab_size     ,						is_decoder=__UpperCamelCase     ,						initializer_range=self.initializer_range     ,						)

       return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels


   def 	_UpperCamelCase       (  self ):
       (
           (
           UpperCamelCase__
       )    ,  (
           UpperCamelCase__
       )    ,  (
           UpperCamelCase__
       )    ,  (
           UpperCamelCase__
       )    ,  (
           UpperCamelCase__
       )    ,  (
           UpperCamelCase__
       )    ,  (
           UpperCamelCase__
       )    ,  
       )      =			self.prepare_config_and_inputs()

       UpperCamelCase__      =			True
       UpperCamelCase__      =			floats_tensor([self.batch_size, self.seq_length, self.hidden_size] )
       UpperCamelCase__      =			ids_tensor([self.batch_size, self.seq_length]     ,						vocab_size=2 )

       return (
           config,
           input_ids,
           token_type_ids,
           input_mask,
           sequence_labels,
           token_labels,
           choice_labels,
           encoder_hidden_states,
           encoder_attention_mask,
       )


   def 	_UpperCamelCase       (  self     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase ):
       UpperCamelCase__      =			RemBertModel(config=__UpperCamelCase )
       model.to(__UpperCamelCase )
       model.eval()
       UpperCamelCase__      =			model(__UpperCamelCase     ,						attention_mask=__UpperCamelCase     ,						token_type_ids=__UpperCamelCase )
       UpperCamelCase__      =			model(__UpperCamelCase     ,						token_type_ids=__UpperCamelCase )
       UpperCamelCase__      =			model(__UpperCamelCase )
       self.parent.assertEqual(result.last_hidden_state.shape     ,						(self.batch_size, self.seq_length, self.hidden_size) )


   def 	_UpperCamelCase       (  self     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						):
       UpperCamelCase__      =			True
       UpperCamelCase__      =			RemBertModel(__UpperCamelCase )
       model.to(__UpperCamelCase )
       model.eval()
       UpperCamelCase__      =			model(
           __UpperCamelCase     ,						attention_mask=__UpperCamelCase     ,						token_type_ids=__UpperCamelCase     ,						encoder_hidden_states=__UpperCamelCase     ,						encoder_attention_mask=__UpperCamelCase     ,						)
       UpperCamelCase__      =			model(
           __UpperCamelCase     ,						attention_mask=__UpperCamelCase     ,						token_type_ids=__UpperCamelCase     ,						encoder_hidden_states=__UpperCamelCase     ,						)
       UpperCamelCase__      =			model(__UpperCamelCase     ,						attention_mask=__UpperCamelCase     ,						token_type_ids=__UpperCamelCase )
       self.parent.assertEqual(result.last_hidden_state.shape     ,						(self.batch_size, self.seq_length, self.hidden_size) )


   def 	_UpperCamelCase       (  self     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						):
       UpperCamelCase__      =			RemBertForCausalLM(config=__UpperCamelCase )
       model.to(__UpperCamelCase )
       model.eval()
       UpperCamelCase__      =			model(__UpperCamelCase     ,						attention_mask=__UpperCamelCase     ,						token_type_ids=__UpperCamelCase     ,						labels=__UpperCamelCase )
       self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.seq_length, self.vocab_size) )


   def 	_UpperCamelCase       (  self     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase ):
       UpperCamelCase__      =			RemBertForMaskedLM(config=__UpperCamelCase )
       model.to(__UpperCamelCase )
       model.eval()
       UpperCamelCase__      =			model(__UpperCamelCase     ,						attention_mask=__UpperCamelCase     ,						token_type_ids=__UpperCamelCase     ,						labels=__UpperCamelCase )
       self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.seq_length, self.vocab_size) )


   def 	_UpperCamelCase       (  self     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						):
       UpperCamelCase__      =			True
       UpperCamelCase__      =			True
       UpperCamelCase__      =			RemBertForCausalLM(config=__UpperCamelCase )
       model.to(__UpperCamelCase )
       model.eval()

       # first forward pass
       UpperCamelCase__      =			model(
           __UpperCamelCase     ,						attention_mask=__UpperCamelCase     ,						encoder_hidden_states=__UpperCamelCase     ,						encoder_attention_mask=__UpperCamelCase     ,						use_cache=__UpperCamelCase     ,						)
       UpperCamelCase__      =			outputs.past_key_values

       # create hypothetical multiple next token and extent to next_input_ids
       UpperCamelCase__      =			ids_tensor((self.batch_size, 3)     ,						config.vocab_size )
       UpperCamelCase__      =			ids_tensor((self.batch_size, 3)     ,						vocab_size=2 )

       # append to next input_ids and
       UpperCamelCase__      =			torch.cat([input_ids, next_tokens]     ,						dim=-1 )
       UpperCamelCase__      =			torch.cat([input_mask, next_mask]     ,						dim=-1 )

       UpperCamelCase__      =			model(
           __UpperCamelCase     ,						attention_mask=__UpperCamelCase     ,						encoder_hidden_states=__UpperCamelCase     ,						encoder_attention_mask=__UpperCamelCase     ,						output_hidden_states=__UpperCamelCase     ,						)["hidden_states"][0]
       UpperCamelCase__      =			model(
           __UpperCamelCase     ,						attention_mask=__UpperCamelCase     ,						encoder_hidden_states=__UpperCamelCase     ,						encoder_attention_mask=__UpperCamelCase     ,						past_key_values=__UpperCamelCase     ,						output_hidden_states=__UpperCamelCase     ,						)["hidden_states"][0]

       # select random slice
       UpperCamelCase__      =			ids_tensor((1,)     ,						output_from_past.shape[-1] ).item()
       UpperCamelCase__      =			output_from_no_past[:, -3:, random_slice_idx].detach()
       UpperCamelCase__      =			output_from_past[:, :, random_slice_idx].detach()

       self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1] )

       # test that outputs are equal for slice
       self.parent.assertTrue(torch.allclose(__UpperCamelCase     ,						__UpperCamelCase     ,						atol=1e-3 ) )


   def 	_UpperCamelCase       (  self     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase ):
       UpperCamelCase__      =			RemBertForQuestionAnswering(config=__UpperCamelCase )
       model.to(__UpperCamelCase )
       model.eval()
       UpperCamelCase__      =			model(
           __UpperCamelCase     ,						attention_mask=__UpperCamelCase     ,						token_type_ids=__UpperCamelCase     ,						start_positions=__UpperCamelCase     ,						end_positions=__UpperCamelCase     ,						)
       self.parent.assertEqual(result.start_logits.shape     ,						(self.batch_size, self.seq_length) )
       self.parent.assertEqual(result.end_logits.shape     ,						(self.batch_size, self.seq_length) )


   def 	_UpperCamelCase       (  self     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase ):
       UpperCamelCase__      =			self.num_labels
       UpperCamelCase__      =			RemBertForSequenceClassification(__UpperCamelCase )
       model.to(__UpperCamelCase )
       model.eval()
       UpperCamelCase__      =			model(__UpperCamelCase     ,						attention_mask=__UpperCamelCase     ,						token_type_ids=__UpperCamelCase     ,						labels=__UpperCamelCase )
       self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.num_labels) )


   def 	_UpperCamelCase       (  self     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase ):
       UpperCamelCase__      =			self.num_labels
       UpperCamelCase__      =			RemBertForTokenClassification(config=__UpperCamelCase )
       model.to(__UpperCamelCase )
       model.eval()
       UpperCamelCase__      =			model(__UpperCamelCase     ,						attention_mask=__UpperCamelCase     ,						token_type_ids=__UpperCamelCase     ,						labels=__UpperCamelCase )
       self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.seq_length, self.num_labels) )


   def 	_UpperCamelCase       (  self     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase ):
       UpperCamelCase__      =			self.num_choices
       UpperCamelCase__      =			RemBertForMultipleChoice(config=__UpperCamelCase )
       model.to(__UpperCamelCase )
       model.eval()
       UpperCamelCase__      =			input_ids.unsqueeze(1 ).expand(-1     ,						self.num_choices     ,						-1 ).contiguous()
       UpperCamelCase__      =			token_type_ids.unsqueeze(1 ).expand(-1     ,						self.num_choices     ,						-1 ).contiguous()
       UpperCamelCase__      =			input_mask.unsqueeze(1 ).expand(-1     ,						self.num_choices     ,						-1 ).contiguous()
       UpperCamelCase__      =			model(
           __UpperCamelCase     ,						attention_mask=__UpperCamelCase     ,						token_type_ids=__UpperCamelCase     ,						labels=__UpperCamelCase     ,						)
       self.parent.assertEqual(result.logits.shape     ,						(self.batch_size, self.num_choices) )







   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			self.prepare_config_and_inputs()
       (
           (
           UpperCamelCase__
       )    ,  (
           UpperCamelCase__
       )    ,  (
           UpperCamelCase__
       )    ,  (
           UpperCamelCase__
       )    ,  (
           UpperCamelCase__
       )    ,  (
           UpperCamelCase__
       )    ,  (
           UpperCamelCase__
       )    ,  
       )      =			config_and_inputs
       UpperCamelCase__      =			{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
       return config, inputs_dict

@require_torch
class       lowerCamelCase_							(	lowerCAmelCase_					,    lowerCAmelCase_					,    unittest.TestCase  ):






   '''simple docstring'''

   A :     Optional[Any]				=	(
       (
           RemBertModel,
           RemBertForMaskedLM,
           RemBertForCausalLM,
           RemBertForMultipleChoice,
           RemBertForQuestionAnswering,
           RemBertForSequenceClassification,
           RemBertForTokenClassification,
       )
       if is_torch_available()
       else ()
   )
   A :     List[Any]				=	(RemBertForCausalLM,) if is_torch_available() else ()
   A :     Union[str, Any]				=	(
       {
           "feature-extraction": RemBertModel,
           "fill-mask": RemBertForMaskedLM,
           "question-answering": RemBertForQuestionAnswering,
           "text-classification": RemBertForSequenceClassification,
           "text-generation": RemBertForCausalLM,
           "token-classification": RemBertForTokenClassification,
           "zero-shot": RemBertForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )


   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			RemBertModelTester(self )
       UpperCamelCase__      =			ConfigTester(self     ,						config_class=__UpperCamelCase     ,						hidden_size=37 )


   def 	_UpperCamelCase       (  self ):
       self.config_tester.run_common_tests()


   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*__UpperCamelCase )


   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			self.model_tester.prepare_config_and_inputs()
       for type in ["absolute", "relative_key", "relative_key_query"]:
           UpperCamelCase__      =			type
           self.model_tester.create_and_check_model(*__UpperCamelCase )


   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_lm(*__UpperCamelCase )


   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_multiple_choice(*__UpperCamelCase )


   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			self.model_tester.prepare_config_and_inputs_for_decoder()
       self.model_tester.create_and_check_decoder_model_past_large_inputs(*__UpperCamelCase )


   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*__UpperCamelCase )


   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*__UpperCamelCase )


   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*__UpperCamelCase )


   def 	_UpperCamelCase       (  self ):
       UpperCamelCase__      =			self.model_tester.prepare_config_and_inputs_for_decoder()
       self.model_tester.create_and_check_model_as_decoder(*__UpperCamelCase )


   def 	_UpperCamelCase       (  self ):
       # This regression test was failing with PyTorch < 1.3
       (
           (
           UpperCamelCase__
       )    ,  (
           UpperCamelCase__
       )    ,  (
           UpperCamelCase__
       )    ,  (
           UpperCamelCase__
       )    ,  (
           UpperCamelCase__
       )    ,  (
           UpperCamelCase__
       )    ,  (
           UpperCamelCase__
       )    ,  (
           UpperCamelCase__
       )    ,  (
           UpperCamelCase__
       )    ,  
       )      =			self.model_tester.prepare_config_and_inputs_for_decoder()

       UpperCamelCase__      =			None

       self.model_tester.create_and_check_model_as_decoder(
           __UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						__UpperCamelCase     ,						)







   @slow
   def 	_UpperCamelCase       (  self ):
       for model_name in REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           UpperCamelCase__      =			RemBertModel.from_pretrained(__UpperCamelCase )
           self.assertIsNotNone(__UpperCamelCase )

@require_torch
class       lowerCamelCase_							(	unittest.TestCase  ):






   '''simple docstring'''

   @slow
   def 	_UpperCamelCase       (  self ):
       # Test exact values at the last hidden layer
       UpperCamelCase__      =			RemBertModel.from_pretrained("google/rembert" )
       UpperCamelCase__      =			torch.tensor([[3_12, 5_64_98, 3_13, 21_25, 3_13]] )
       UpperCamelCase__      =			torch.tensor([[0, 0, 0, 1, 1]] )
       with torch.no_grad():
           UpperCamelCase__      =			model(__UpperCamelCase     ,						token_type_ids=__UpperCamelCase     ,						output_hidden_states=__UpperCamelCase )

       UpperCamelCase__      =			11_52

       UpperCamelCase__      =			torch.Size((1, 5, hidden_size) )
       self.assertEqual(output["last_hidden_state"].shape     ,						__UpperCamelCase )

       UpperCamelCase__      =			torch.tensor(
           [
               [
                   [0.0_754, -0.2_022, 0.1_904],
                   [-0.3_354, -0.3_692, -0.4_791],
                   [-0.2_314, -0.6_729, -0.0_749],
                   [-0.0_396, -0.3_105, -0.4_234],
                   [-0.1_571, -0.0_525, 0.5_353],
               ]
           ] )

       # Running on the original tf implementation gives slightly different results here.
       # Not clear why this variations is present
       # TODO: Find reason for discrepancy
       # expected_original_implementation = [[
       #     [0.07630594074726105, -0.20146065950393677, 0.19107051193714142],
       #     [-0.3405614495277405, -0.36971670389175415, -0.4808273911476135],
       #     [-0.22587086260318756, -0.6656315922737122, -0.07844287157058716],
       #     [-0.04145475849509239, -0.3077218234539032, -0.42316967248916626],
       #     [-0.15887849032878876, -0.054529931396245956, 0.5356100797653198]
       # ]]

       self.assertTrue(torch.allclose(output["last_hidden_state"][:, :, :3]     ,						__UpperCamelCase     ,						atol=1e-4 ) )









'''simple docstring'''







import heapq





def 						snake_case__ (lowerCAmelCase_					,  lowerCAmelCase_					,  lowerCAmelCase_	):
    UpperCamelCase__      =			[(0, start)]  # cost from start node,end node
    UpperCamelCase__      =			set()
    while heap:
        ((UpperCamelCase__)    ,  (UpperCamelCase__))      =			heapq.heappop(lowerCAmelCase_	)
        if u in visited:
            continue
        visited.add(lowerCAmelCase_	)
        if u == end:
            return cost
        for v, c in graph[u]:
            if v in visited:
                continue
            UpperCamelCase__      =			cost + c
            heapq.heappush(lowerCAmelCase_					,  (next_item, v)	)
    return -1


lowercase__     :  Any    					=			{
    '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]],
}
lowercase__     :  Optional[int]    					=			{
    'B': [['C', 1]],
    'C': [['D', 1]],
    'D': [['F', 1]],
    'E': [['B', 1], ['F', 3]],
    'F': [],
}
lowercase__     :  Union[str, Any]    					=			{
    'B': [['C', 1]],
    'C': [['D', 1]],
    'D': [['F', 1]],
    'E': [['B', 1], ['G', 2]],
    'F': [],
    'G': [['F', 1]],
}

lowercase__     :  Union[str, Any]    					=			dijkstra(G, 'E', 'C')
print(short_distance)  # E -- 3 --> F -- 3 --> C == 6

lowercase__     :  Optional[int]    					=			dijkstra(Ga, 'E', 'F')
print(short_distance)  # E -- 3 --> F == 3

lowercase__     :  Any    					=			dijkstra(Ga, 'E', 'F')
print(short_distance)  # E -- 2 --> G -- 1 --> F == 3

if __name__ == "__main__":
      import doctest

      doctest.testmod()




