





from __future__ import annotations

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



@dataclass
class    _SCREAMING_SNAKE_CASE						:







 '''simple docstring'''
 lowercase_		=			42
 lowercase_		=			42



class    _SCREAMING_SNAKE_CASE						:







 '''simple docstring'''

 def __init__(self				:   List[Any]       , UpperCAmelCase_				:   int)       ->List[str]:



   '''simple docstring'''



   lowerCamelCase__:      list[list[Edge]]			  =[[] for _ in range(UpperCAmelCase_)]
   lowerCamelCase__:      List[Any]			  =size

 def __getitem__(self				:   List[str]       , UpperCAmelCase_				:   int)       ->Iterator[Edge]:



   '''simple docstring'''



   return iter(self._graph[vertex])

 @property
 def 							SCREAMING_SNAKE_CASE_					(self				:   str)       ->List[Any]:



   '''simple docstring'''



   return self._size

 def 							SCREAMING_SNAKE_CASE_					(self				:   Optional[int]       , UpperCAmelCase_				:   int       , UpperCAmelCase_				:   int       , UpperCAmelCase_				:   int)       ->Optional[int]:



   '''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(UpperCAmelCase_       , UpperCAmelCase_))







 def 							SCREAMING_SNAKE_CASE_					(self				:   Dict       , UpperCAmelCase_				:   int       , UpperCAmelCase_				:   int)       ->int | None:



   '''simple docstring'''



   lowerCamelCase__:      Any			  =deque([start_vertex])
   lowerCamelCase__:      list[int | None]			  =[None] * self.size
   lowerCamelCase__:      List[Any]			  =0

   while queue:
     lowerCamelCase__:      int			  =queue.popleft()
     lowerCamelCase__:      Dict			  =distances[current_vertex]
     if current_distance is None:
       continue

     for edge in self[current_vertex]:
       lowerCamelCase__:      Optional[Any]			  =current_distance + edge.weight
       lowerCamelCase__:      Tuple			  =distances[edge.destination_vertex]
       if (
           isinstance(UpperCAmelCase_       , UpperCAmelCase_)
           and new_distance >= dest_vertex_distance
       ):
         continue
       lowerCamelCase__:      str			  =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()








from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__A									=				{"configuration_ibert": ["IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "IBertConfig", "IBertOnnxConfig"]}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     __A									=				[
         "IBERT_PRETRAINED_MODEL_ARCHIVE_LIST",
         "IBertForMaskedLM",
         "IBertForMultipleChoice",
         "IBertForQuestionAnswering",
         "IBertForSequenceClassification",
         "IBertForTokenClassification",
         "IBertModel",
         "IBertPreTrainedModel",
     ]

if TYPE_CHECKING:
     from .configuration_ibert import IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, IBertConfig, IBertOnnxConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_ibert import (
              IBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
              IBertForMaskedLM,
              IBertForMultipleChoice,
              IBertForQuestionAnswering,
              IBertForSequenceClassification,
              IBertForTokenClassification,
              IBertModel,
              IBertPreTrainedModel,
          )

else:
     import sys

     __A									=				_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)

