





from __future__ import annotations

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

@dataclass
class      lowerCAmelCase							:
 UpperCAmelCase__									=	42
 UpperCAmelCase__									=	42


class      lowerCAmelCase							:
 def __init__(   self						:   Any    ,  UpperCAmelCase						:   int			)    ->			Tuple:
     lowerCamelCase__					:   list[list[Edge]]      				=	[[] for _ in range(UpperCAmelCase			)]
     lowerCamelCase__					:   Tuple      				=	size
 def __getitem__(   self						:   Optional[Any]    ,  UpperCAmelCase						:   int			)    ->			Iterator[Edge]:
     return iter(self._graph[vertex]			)
 @property
 def   A_			(   self						:   int			)    ->			str:
     return self._size
 def   A_			(   self						:   Optional[Any]    ,  UpperCAmelCase						:   int    ,  UpperCAmelCase						:   int    ,  UpperCAmelCase						:   int			)    ->			Optional[int]:
     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   A_			(   self						:   str    ,  UpperCAmelCase						:   int    ,  UpperCAmelCase						:   int			)    ->			int | None:
     lowerCamelCase__					:   int      				=	deque([start_vertex]			)
     lowerCamelCase__					:   list[int | None]      				=	[None] * self.size
     lowerCamelCase__					:   Tuple      				=	0

     while queue:
         lowerCamelCase__					:   str      				=	queue.popleft()
         lowerCamelCase__					:   List[Any]      				=	distances[current_vertex]
         if current_distance is None:
             continue

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

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_UpperCAmelCase       : List[str]			     =       {
    """configuration_autoformer""": [
        """AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """AutoformerConfig""",
    ],
}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _UpperCAmelCase       : List[Any]			     =       [
        """AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """AutoformerForPrediction""",
        """AutoformerModel""",
        """AutoformerPreTrainedModel""",
    ]


if TYPE_CHECKING:
    from .configuration_autoformer import (
        AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
        AutoformerConfig,
    )

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_autoformer import (
            AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
            AutoformerForPrediction,
            AutoformerModel,
            AutoformerPreTrainedModel,
        )

else:
    import sys

    _UpperCAmelCase       : Dict			     =       _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





