




"""simple docstring"""


from __future__ import annotations

from collections import deque
from collections.abc import Iterator
from dataclasses import dataclass






@dataclass
class       lowercase:
 lowercase__				      =      42
 lowercase__				      =      42







class       lowercase:


 def __init__(       self:	str,   a_:	Optional[int]	):




   '''simple docstring'''



   _snake_case							:	str			=						[[] for _ in range(_a	)]
   _snake_case							:	Dict			=						size


 def __getitem__(       self:	str,   a_:	Tuple	):




   '''simple docstring'''



   return iter(self._graph[vertex]	)


 @property
 def 				UpperCamelCase_     (       self:	Optional[Any]	):




   '''simple docstring'''



   return self._size


 def 				UpperCamelCase_     (       self:	Optional[Any],   a_:	Dict,   a_:	Dict,   a_:	List[Any]	):




   '''simple docstring'''



   if weight not in (0, 1):
     raise ValueError("""Edge weight must be either 0 or 1."""	)

   if to_vertex < 0 or to_vertex >= self.size:
     raise ValueError("""Vertex indexes must be in [0; size)."""	)

   self._graph[from_vertex].append(Edge(_a,   _a	)	)


 def 				UpperCamelCase_     (       self:	str,   a_:	Optional[int],   a_:	Dict	):




   '''simple docstring'''



   _snake_case							:	List[str]			=						deque([start_vertex]	)
   _snake_case							:	int			=						[None] * self.size
   _snake_case							:	Optional[int]			=						0

   while queue:
     _snake_case							:	Union[str, Any]			=						queue.popleft()
     _snake_case							:	Optional[Any]			=						distances[current_vertex]
     if current_distance is None:
       continue

     for edge in self[current_vertex]:
       _snake_case							:	str			=						current_distance + edge.weight
       _snake_case							:	List[Any]			=						distances[edge.destination_vertex]
       if (
           isinstance(_a,   _a	)
           and new_distance >= dest_vertex_distance
       ):
         continue
       _snake_case							:	Union[str, Any]			=						new_distance
       if edge.weight == 0:
         queue.appendleft(edge.destination_vertex	)
       else:
         queue.append(edge.destination_vertex	)

   if distances[finish_vertex] is None:
     raise ValueError("""No path from start_vertex to finish_vertex."""	)

   return distances[finish_vertex]


if __name__ == "__main__":
     import doctest

     doctest.testmod()








"""simple docstring"""


from abc import ABC, abstractmethod
from argparse import ArgumentParser






class       lowercase(  __a				):







 '''simple docstring'''





 @staticmethod
 @abstractmethod
 def 				UpperCamelCase_     (       a_:	ArgumentParser	):




   '''simple docstring'''



   raise NotImplementedError()


 @abstractmethod
 def 				UpperCamelCase_     (       self:	List[str]	):




   '''simple docstring'''



   raise NotImplementedError()


