





'''simple docstring'''







import unittest
from dataclasses import dataclass
from typing import Optional

from transformers.utils import ModelOutput


@dataclass
class        __a   (lowerCamelCase  ):
							__a       : float
							__a       : Optional[float]          =							None
							__a       : Optional[float]          =							None





class        __a   (unittest.TestCase  ):

							def      UpperCAmelCase__						(				self				:  Tuple )       ->							Optional[int]:







													"""simple docstring"""
													UpperCAmelCase_      :   Tuple      =	ModelOutputTest(a=30 )
													self.assertEqual(x.a							,  30 )
													self.assertIsNone(x.b )
													self.assertIsNone(x.c )
													with self.assertRaises(__magic_name__ ):
																			UpperCAmelCase_      :   List[Any]      =	x.d

							def      UpperCAmelCase__						(				self				:  Dict )       ->							List[str]:







													"""simple docstring"""
													UpperCAmelCase_      :   Union[str, Any]      =	ModelOutputTest(a=30							,  b=10 )
													self.assertEqual(x[0]							,  30 )
													self.assertEqual(x[1]							,  10 )
													self.assertEqual(x[:2]							,  (30, 10) )
													self.assertEqual(x[:]							,  (30, 10) )

													UpperCAmelCase_      :   Tuple      =	ModelOutputTest(a=30							,  c=10 )
													self.assertEqual(x[0]							,  30 )
													self.assertEqual(x[1]							,  10 )
													self.assertEqual(x[:2]							,  (30, 10) )
													self.assertEqual(x[:]							,  (30, 10) )

							def      UpperCAmelCase__						(				self				:  str )       ->							List[str]:







													"""simple docstring"""
													UpperCAmelCase_      :   str      =	ModelOutputTest(a=30							,  b=10 )
													self.assertEqual(x['''a''']							,  30 )
													self.assertEqual(x['''b''']							,  10 )
													with self.assertRaises(__magic_name__ ):
																			UpperCAmelCase_      :   Optional[Any]      =	x['''c''']

													UpperCAmelCase_      :   int      =	ModelOutputTest(a=30							,  c=10 )
													self.assertEqual(x['''a''']							,  30 )
													self.assertEqual(x['''c''']							,  10 )
													with self.assertRaises(__magic_name__ ):
																			UpperCAmelCase_      :   Union[str, Any]      =	x['''b''']

							def      UpperCAmelCase__						(				self				:  Optional[int] )       ->							Optional[Any]:







													"""simple docstring"""
													UpperCAmelCase_      :   Optional[int]      =	ModelOutputTest(a=30 )
													self.assertEqual(list(x.keys() )							,  ['''a'''] )
													self.assertEqual(list(x.values() )							,  [30] )
													self.assertEqual(list(x.items() )							,  [('''a''', 30)] )
													self.assertEqual(list(__magic_name__ )							,  ['''a'''] )

													UpperCAmelCase_      :   str      =	ModelOutputTest(a=30							,  b=10 )
													self.assertEqual(list(x.keys() )							,  ['''a''', '''b'''] )
													self.assertEqual(list(x.values() )							,  [30, 10] )
													self.assertEqual(list(x.items() )							,  [('''a''', 30), ('''b''', 10)] )
													self.assertEqual(list(__magic_name__ )							,  ['''a''', '''b'''] )

													UpperCAmelCase_      :   int      =	ModelOutputTest(a=30							,  c=10 )
													self.assertEqual(list(x.keys() )							,  ['''a''', '''c'''] )
													self.assertEqual(list(x.values() )							,  [30, 10] )
													self.assertEqual(list(x.items() )							,  [('''a''', 30), ('''c''', 10)] )
													self.assertEqual(list(__magic_name__ )							,  ['''a''', '''c'''] )

													with self.assertRaises(__magic_name__ ):
																			UpperCAmelCase_      :   Any      =	x.update({'''d''': 20} )
													with self.assertRaises(__magic_name__ ):
																			del x["a"]
													with self.assertRaises(__magic_name__ ):
																			UpperCAmelCase_      :   Tuple      =	x.pop('''a''' )
													with self.assertRaises(__magic_name__ ):
																			UpperCAmelCase_      :   List[Any]      =	x.setdefault('''d'''							,  32 )

							def      UpperCAmelCase__						(				self				:  Tuple )       ->							List[str]:







													"""simple docstring"""
													UpperCAmelCase_      :   Optional[int]      =	ModelOutputTest(a=30 )
													UpperCAmelCase_      :   Union[str, Any]      =	10
													self.assertEqual(x.a							,  10 )
													self.assertEqual(x['''a''']							,  10 )

							def      UpperCAmelCase__						(				self				:  Tuple )       ->							str:







													"""simple docstring"""
													UpperCAmelCase_      :   int      =	ModelOutputTest(a=30 )
													UpperCAmelCase_      :   Dict      =	10
													self.assertEqual(x.a							,  10 )
													self.assertEqual(x['''a''']							,  10 )

							def      UpperCAmelCase__						(				self				:  Optional[int] )       ->							Optional[int]:







													"""simple docstring"""
													UpperCAmelCase_      :   Dict      =	ModelOutputTest({'''a''': 30, '''b''': 10} )
													self.assertEqual(list(x.keys() )							,  ['''a''', '''b'''] )
													self.assertEqual(x.a							,  30 )
													self.assertEqual(x.b							,  10 )



							def      UpperCAmelCase__						(				self				:  Optional[int] )       ->							Tuple:







													"""simple docstring"""
													UpperCAmelCase_      :   Dict      =	ModelOutputTest([('''a''', 30), ('''b''', 10)] )
													self.assertEqual(list(x.keys() )							,  ['''a''', '''b'''] )
													self.assertEqual(x.a							,  30 )
													self.assertEqual(x.b							,  10 )

													with self.assertRaises(__magic_name__ ):
																			UpperCAmelCase_      :   str      =	ModelOutputTest([('''a''', 30), (10, 10)] )

													UpperCAmelCase_      :   str      =	ModelOutputTest(a=(30, 30) )
													self.assertEqual(list(x.keys() )							,  ['''a'''] )
													self.assertEqual(x.a							,  (30, 30) )







from __future__ import annotations

from queue import Queue


class 	UpperCamelCase__       :

						'''simple docstring'''



						def __init__(  self	)  ->None:
									UpperCAmelCase__		:dict[int, list[int]] 		=    {}


						def    A__       (  self	)  ->None:
									for i in self.vertices:
												print(A  , ' : '  , ' -> '.join([str(A	) for j in self.vertices[i]]	)	)


						def    A__       (  self  , A  , A	)  ->None:
									if from_vertex in self.vertices:
												self.vertices[from_vertex].append(A	)
									else:
												UpperCAmelCase__		:Union[str, Any] 		=    [to_vertex]


						def    A__       (  self  , A	)  ->set[int]:
									UpperCAmelCase__		:str 		=    set()

									# create a first in first out queue to store all the vertices for BFS
									UpperCAmelCase__		:Queue 		=    Queue()

									# mark the source node as visited and enqueue it
									visited.add(A	)
									queue.put(A	)

									while not queue.empty():
												UpperCAmelCase__		:List[str] 		=    queue.get()

												# loop through all adjacent vertex and enqueue it if not yet visited
												for adjacent_vertex in self.vertices[vertex]:
															if adjacent_vertex not in visited:
																		queue.put(A	)
																		visited.add(A	)
									return visited


if __name__ == "__main__":
						from doctest import testmod

						testmod(verbose=True)

						__snake_case					:							Any           =							Graph()
						g.add_edge(0, 1)
						g.add_edge(0, 2)
						g.add_edge(1, 2)
						g.add_edge(2, 0)
						g.add_edge(2, 3)
						g.add_edge(3, 3)

						g.print_graph()
						# 0  :  1 -> 2
						# 1  :  2
						# 2  :  0 -> 3
						# 3  :  3

						assert sorted(g.bfs(2)) == [0, 1, 2, 3]





