code: 
  
  
  '''simple docstring'''
  
  import heapq
  
  def _SCREAMING_SNAKE_CASE   (A						,				A						,				A ) -> Union[str, Any]:
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         lowercase__       =				[(0, start)]  # cost from start node,end node
         lowercase__       =				set()
         while heap:
                ((lowercase__)    ,(lowercase__))       =				heapq.heappop(A )
                if u in visited:
                       continue
                visited.add(A )
                if u == end:
                       return cost
                for v, c in graph[u]:
                       if v in visited:
                              continue
                       lowercase__       =				cost + c
                       heapq.heappush(A						,				(next_item, v) )
         return -1
  
  
  lowerCamelCase							:     str								=			{
      '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]],
  }
  lowerCamelCase							:     Optional[Any]								=			{
      'B': [['C', 1]],
      'C': [['D', 1]],
      'D': [['F', 1]],
      'E': [['B', 1], ['F', 3]],
      'F': [],
  }
  lowerCamelCase							:     str								=			{
      'B': [['C', 1]],
      'C': [['D', 1]],
      'D': [['F', 1]],
      'E': [['B', 1], ['G', 2]],
      'F': [],
      'G': [['F', 1]],
  }
  
  lowerCamelCase							:     str								=			dijkstra(G, 'E', 'C')
  print(short_distance)  # E -- 3 --> F -- 3 --> C == 6
  
  lowerCamelCase							:     int								=			dijkstra(Ga, 'E', 'F')
  print(short_distance)  # E -- 3 --> F == 3
  
  lowerCamelCase							:     Optional[int]								=			dijkstra(Ga, 'E', 'F')
  print(short_distance)  # E -- 2 --> G -- 1 --> F == 3
  
  if __name__ == "__main__":
   import doctest
  
   doctest.testmod()
  
  
  
  
  
style_context: 
  
  
  '''simple docstring'''
  
  import argparse
  
  import torch
  
  from transformers import ElectraConfig, ElectraForMaskedLM, ElectraForPreTraining, load_tf_weights_in_electra
  from transformers.utils import logging
  
  
  logging.set_verbosity_info()
  
  def _SCREAMING_SNAKE_CASE   (A						,				A						,				A						,				A ) -> Dict:
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         lowercase__       =				ElectraConfig.from_json_file(A )
         print(f"Building PyTorch model from configuration: {config}" )
  
         if discriminator_or_generator == "discriminator":
                lowercase__       =				ElectraForPreTraining(A )
         elif discriminator_or_generator == "generator":
                lowercase__       =				ElectraForMaskedLM(A )
         else:
                raise ValueError('''The discriminator_or_generator argument should be either \'discriminator\' or \'generator\'''' )
  
         # Load weights from tf checkpoint
         load_tf_weights_in_electra(
             A						,				A						,				A						,				discriminator_or_generator=A )
  
         # Save pytorch-model
         print(f"Save PyTorch model to {pytorch_dump_path}" )
         torch.save(model.state_dict()						,				A )
  
  
  if __name__ == "__main__":
   lowerCamelCase							:     Tuple								=			argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       '--tf_checkpoint_path', default=None, type=str, required=True, help='Path to the TensorFlow checkpoint path.'
   )
   parser.add_argument(
       '--config_file',
       default=None,
       type=str,
       required=True,
       help='The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.',
   )
   parser.add_argument(
       '--pytorch_dump_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
   )
   parser.add_argument(
       '--discriminator_or_generator',
       default=None,
       type=str,
       required=True,
       help=(
           'Whether to export the generator or the discriminator. Should be a string, either \'discriminator\' or '
           '\'generator\'.'
       ),
   )
   lowerCamelCase							:     Optional[int]								=			parser.parse_args()
   convert_tf_checkpoint_to_pytorch(
       args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.discriminator_or_generator
   )
  
  
  
  
  