code: 
  
  
  
  
  
  from typing import Optional, Union
  
  from ...file_utils import TensorType
  from ...processing_utils import ProcessorMixin
  from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, TruncationStrategy
  
  class 				A    (__UpperCAmelCase				):
        _SCREAMING_SNAKE_CASE					=							"""MarkupLMFeatureExtractor"""
        _SCREAMING_SNAKE_CASE					=							("""MarkupLMTokenizer""", """MarkupLMTokenizerFast""")
        _SCREAMING_SNAKE_CASE					=							True
  
  
  
        def __call__(					self     ,  lowercase_=None     ,  lowercase_=None     ,  lowercase_=None     ,  lowercase_=None     ,  lowercase_=None     ,  lowercase_ = True     ,  lowercase_ = False     ,  lowercase_ = None     ,  lowercase_ = None     ,  lowercase_ = 0     ,  lowercase_ = None     ,  lowercase_ = None     ,  lowercase_ = None     ,  lowercase_ = False     ,  lowercase_ = False     ,  lowercase_ = False     ,  lowercase_ = False     ,  lowercase_ = True     ,  lowercase_ = None     ,  **lowercase_     ,  )      ->   BatchEncoding:
  
  
  
               '''simple docstring'''
  
               if self.parse_html:
                      if html_strings is None:
                             raise ValueError('''Make sure to pass HTML strings in case `parse_html` is set to `True`'''					)
  
                      if nodes is not None or xpaths is not None or node_labels is not None:
                             raise ValueError(
                                 '''Please don\'t pass nodes, xpaths nor node labels in case `parse_html` is set to `True`'''					)
  
                      _snake_case      :							int     				=						self.feature_extractor(lowercase_					)
                      _snake_case      :							Union[str, Any]     				=						features['''nodes''']
                      _snake_case      :							Dict     				=						features['''xpaths''']
               else:
                      if html_strings is not None:
                             raise ValueError('''You have passed HTML strings but `parse_html` is set to `False`.'''					)
                      if nodes is None or xpaths is None:
                             raise ValueError('''Make sure to pass nodes and xpaths in case `parse_html` is set to `False`'''					)
  
          # # second, apply the tokenizer
               if questions is not None and self.parse_html:
                      if isinstance(lowercase_     ,  lowercase_					):
                             _snake_case      :							Dict     				=						[questions]  # add batch dimension (as the feature extractor always adds a batch dimension)
  
               _snake_case      :							Union[str, Any]     				=						self.tokenizer(
                   text=questions if questions is not None else nodes     ,  text_pair=nodes if questions is not None else None     ,  xpaths=lowercase_     ,  node_labels=lowercase_     ,  add_special_tokens=lowercase_     ,  padding=lowercase_     ,  truncation=lowercase_     ,  max_length=lowercase_     ,  stride=lowercase_     ,  pad_to_multiple_of=lowercase_     ,  return_token_type_ids=lowercase_     ,  return_attention_mask=lowercase_     ,  return_overflowing_tokens=lowercase_     ,  return_special_tokens_mask=lowercase_     ,  return_offsets_mapping=lowercase_     ,  return_length=lowercase_     ,  verbose=lowercase_     ,  return_tensors=lowercase_     ,  **lowercase_     ,  )
  
               return encoded_inputs
  
  
  
        def    __a (					self     ,  *lowercase_     ,  **lowercase_					)      ->   Optional[int]:
  
  
  
               '''simple docstring'''
  
               return self.tokenizer.batch_decode(*lowercase_     ,  **lowercase_					)
  
  
  
        def    __a (					self     ,  *lowercase_     ,  **lowercase_					)      ->   Union[str, Any]:
  
  
  
               '''simple docstring'''
  
               return self.tokenizer.decode(*lowercase_     ,  **lowercase_					)
  
  
  
        @property
        def    __a (					self					)      ->   str:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Optional[int]     				=						self.tokenizer.model_input_names
               return tokenizer_input_names
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  from __future__ import annotations
  
  class 				A    :
  
  
  
        def __init__(					self     ,  lowercase_					)      ->   None:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							Optional[Any]     				=						vertices
               _snake_case      :							int     				=						[[0] * vertices for _ in range(lowercase_					)]
  
  
  
        def    __a (					self     ,  lowercase_					)      ->   None:
  
  
  
               '''simple docstring'''
  
               print('''Vertex \t Distance from Source'''					)
               for vertex in range(self.vertices					):
                      print(lowercase_     ,  '''\t\t'''     ,  distances_from_source[vertex]					)
  
  
  
        def    __a (					self     ,  lowercase_     ,  lowercase_					)      ->   int:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							List[Any]     				=						1E7
               _snake_case      :							Tuple     				=						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      :							Dict     				=						distances_from_source[vertex]
                             _snake_case      :							int     				=						vertex
               return min_index
  
  
  
        def    __a (					self     ,  lowercase_					)      ->   None:
  
  
  
               '''simple docstring'''
  
               _snake_case      :							List[Any]     				=						[int(1E7					)] * self.vertices  # distances from the source
               _snake_case      :							List[Any]     				=						0
               _snake_case      :							List[str]     				=						[False] * self.vertices
  
               for _ in range(self.vertices					):
                      _snake_case      :							List[Any]     				=						self.minimum_distance(lowercase_     ,  lowercase_					)
                      _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      :							Any     				=						distances[u] + self.graph[u][v]
  
               self.print_solution(lowercase_					)
  
  
  if __name__ == "__main__":
     lowerCAmelCase_   =   Graph(9)
     lowerCAmelCase_   =   [
         [0, 4, 0, 0, 0, 0, 0, 8, 0],
         [4, 0, 8, 0, 0, 0, 0, 1_1, 0],
         [0, 8, 0, 7, 0, 4, 0, 0, 2],
         [0, 0, 7, 0, 9, 1_4, 0, 0, 0],
         [0, 0, 0, 9, 0, 1_0, 0, 0, 0],
         [0, 0, 4, 1_4, 1_0, 0, 2, 0, 0],
         [0, 0, 0, 0, 0, 2, 0, 1, 6],
         [8, 1_1, 0, 0, 0, 0, 1, 0, 7],
         [0, 0, 2, 0, 0, 0, 6, 7, 0],
     ]
     graph.dijkstra(0)
  
  
  
  
  
  
  