





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__a      : Union[str, Any] 				=				{
    'configuration_timesformer': ['TIMESFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TimesformerConfig'],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__a      : Optional[Any] 				=				[
		    'TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'TimesformerModel',
		    'TimesformerForVideoClassification',
		    'TimesformerPreTrainedModel',
		]

if TYPE_CHECKING:
		from .configuration_timesformer import TIMESFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, TimesformerConfig

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_timesformer import (
				    TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TimesformerForVideoClassification,
				    TimesformerModel,
				    TimesformerPreTrainedModel,
				)

else:
		import sys

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












import heapq as hq
import math
from collections.abc import Iterator
class  _UpperCAmelCase   :

				"""simple docstring"""




				def __init__(	self		:       str,    lowerCamelCase		:       List[Any]    ):

								'''simple docstring'''
								lowercase__  					=     str(id_    )
								lowercase__  					=     None
								lowercase__  					=     None
								lowercase__  					=     []
								lowercase__  					=     {}  # {vertex:distance}




				def __lt__(	self		:       Dict,    lowerCamelCase		:       Tuple    ):

								'''simple docstring'''
								return self.key < other.key




				def __repr__(	self		:       Dict    ):

								'''simple docstring'''
								return self.id




				def 							lowercase__  (	self		:       str,    lowerCamelCase		:       List[str]    ):

								'''simple docstring'''
								self.neighbors.append(lowerCamelCase    )




				def 							lowercase__  (	self		:       Any,    lowerCamelCase		:       Dict,    lowerCamelCase		:       Optional[Any]    ):

								'''simple docstring'''
								lowercase__  					=     weight






def     a     (		lowerCamelCase_						,  lowerCamelCase_						,  lowerCamelCase_						,  lowerCamelCase_							):






				'''simple docstring'''
				# add the neighbors:
				graph[a - 1].add_neighbor(graph[b - 1]							)
				graph[b - 1].add_neighbor(graph[a - 1]							)
				# add the edges:
				graph[a - 1].add_edge(graph[b - 1]						,  lowerCamelCase_							)
				graph[b - 1].add_edge(graph[a - 1]						,  lowerCamelCase_							)






def     a     (		lowerCamelCase_						,  lowerCamelCase_							):






				'''simple docstring'''
				lowercase__  					=     []
				for u in graph:
								lowercase__  					=     math.inf
								lowercase__  					=     None
				lowercase__  					=     0
				lowercase__  					=     graph[:]
				while q:
								lowercase__  					=     min(lowerCamelCase_							)
								q.remove(lowerCamelCase_							)
								for v in u.neighbors:
												if (v in q) and (u.edges[v.id] < v.key):
																lowercase__  					=     u
																lowercase__  					=     u.edges[v.id]
				for i in range(1						,  len(lowerCamelCase_							)							):
								a.append((int(graph[i].id							) + 1, int(graph[i].pi.id							) + 1)							)
				return a






def     a     (		lowerCamelCase_						,  lowerCamelCase_							):






				'''simple docstring'''
				for u in graph:
								lowercase__  					=     math.inf
								lowercase__  					=     None
				lowercase__  					=     0

				lowercase__  					=     list(lowerCamelCase_							)
				hq.heapify(lowerCamelCase_							)

				while h:
								lowercase__  					=     hq.heappop(lowerCamelCase_							)
								for v in u.neighbors:
												if (v in h) and (u.edges[v.id] < v.key):
																lowercase__  					=     u
																lowercase__  					=     u.edges[v.id]
																hq.heapify(lowerCamelCase_							)

				for i in range(1						,  len(lowerCamelCase_							)							):
								yield (int(graph[i].id							) + 1, int(graph[i].pi.id							) + 1)






def     a     (		):






				'''simple docstring'''


if __name__ == "__main__":
							import doctest

							doctest.testmod()




