code: 
  
  
  """simple docstring"""
  
  
  
  
  from __future__ import annotations
  
  
  
  
  
  class __snake_case		:
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
  
     def __init__(		self							:Tuple				,  UpperCamelCase__							:int       ):
            _a          =				vertices
            _a          =				[[0] * vertices for _ in range(UpperCamelCase__       )]
  
  
  
  
     def SCREAMING_SNAKE_CASE_      (		self							:List[str]				,  UpperCamelCase__							:list[int]       ):
            print("Vertex \t Distance from Source"       )
            for vertex in range(self.vertices       ):
                   print(UpperCamelCase__				,  "\t\t"				,  distances_from_source[vertex]       )
  
  
  
  
     def SCREAMING_SNAKE_CASE_      (		self							:Optional[Any]				,  UpperCamelCase__							:list[int]				,  UpperCamelCase__							:list[bool]       ):
            _a          =				1E7
            _a          =				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:
                          _a          =				distances_from_source[vertex]
                          _a          =				vertex
            return min_index
  
  
  
  
     def SCREAMING_SNAKE_CASE_      (		self							:List[Any]				,  UpperCamelCase__							:int       ):
            _a          =				[int(1E7       )] * self.vertices  # distances from the source
            _a          =				0
            _a          =				[False] * self.vertices
  
            for _ in range(self.vertices       ):
                   _a          =				self.minimum_distance(UpperCamelCase__				,  UpperCamelCase__       )
                   _a          =				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]
                          ):
                                 _a          =				distances[u] + self.graph[u][v]
  
            self.print_solution(UpperCamelCase__       )
  
  
  if __name__ == "__main__":
     __SCREAMING_SNAKE_CASE					=						Graph(9)
     __SCREAMING_SNAKE_CASE					=						[
         [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)
  
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  import warnings
  from contextlib import contextmanager
  
  from ...processing_utils import ProcessorMixin
  
  
  
  
  
  class __snake_case		(					_SCREAMING_SNAKE_CASE      ):
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
  
     lowerCAmelCase_				:   str     	=			'AutoFeatureExtractor'
     lowerCAmelCase_				:   List[Any]     	=			'Speech2Text2Tokenizer'
  
  
  
  
     def __init__(		self							:int				,  UpperCamelCase__							:List[str]				,  UpperCamelCase__							:Union[str, Any]       ):
            super().__init__(UpperCamelCase__				,  UpperCamelCase__       )
            _a          =				self.feature_extractor
            _a          =				False
  
  
  
  
     def __call__(		self							:List[str]				,  *UpperCamelCase__							:List[str]				,  **UpperCamelCase__							:Dict       ):
            # For backward compatibility
            if self._in_target_context_manager:
                   return self.current_processor(*UpperCamelCase__				,  **UpperCamelCase__       )
  
            if "raw_speech" in kwargs:
                   warnings.warn("Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead."       )
                   _a          =				kwargs.pop("raw_speech"       )
            else:
                   _a          =				kwargs.pop("audio"				,  UpperCamelCase__       )
            _a          =				kwargs.pop("sampling_rate"				,  UpperCamelCase__       )
            _a          =				kwargs.pop("text"				,  UpperCamelCase__       )
            if len(UpperCamelCase__       ) > 0:
                   _a          =				args[0]
                   _a          =				args[1:]
  
            if audio is None and text is None:
                   raise ValueError("You need to specify either an `audio` or `text` input to process."       )
  
            if audio is not None:
                   _a          =				self.feature_extractor(UpperCamelCase__				,  *UpperCamelCase__				,  sampling_rate=UpperCamelCase__				,  **UpperCamelCase__       )
            if text is not None:
                   _a          =				self.tokenizer(UpperCamelCase__				,  **UpperCamelCase__       )
  
            if text is None:
                   return inputs
            elif audio is None:
                   return encodings
            else:
                   _a          =				encodings["input_ids"]
                   return inputs
  
  
  
  
     def SCREAMING_SNAKE_CASE_      (		self							:Union[str, Any]				,  *UpperCamelCase__							:int				,  **UpperCamelCase__							:Optional[Any]       ):
            return self.tokenizer.batch_decode(*UpperCamelCase__				,  **UpperCamelCase__       )
  
  
  
  
     def SCREAMING_SNAKE_CASE_      (		self							:Optional[Any]				,  *UpperCamelCase__							:List[Any]				,  **UpperCamelCase__							:List[Any]       ):
            return self.tokenizer.decode(*UpperCamelCase__				,  **UpperCamelCase__       )
  
  
  
  
     @contextmanager
     def SCREAMING_SNAKE_CASE_      (		self							:Dict       ):
            warnings.warn(
                "`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your "
                "labels by using the argument `text` of the regular `__call__` method (either in the same call as "
                "your audio inputs, or in a separate call."       )
            _a          =				True
            _a          =				self.tokenizer
            yield
            _a          =				self.feature_extractor
            _a          =				False
  