


'''simple docstring'''



from argparse import ArgumentParser

from datasets.commands.convert import ConvertCommand
from datasets.commands.dummy_data import DummyDataCommand
from datasets.commands.env import EnvironmentCommand
from datasets.commands.run_beam import RunBeamCommand
from datasets.commands.test import TestCommand
from datasets.utils.logging import set_verbosity_info






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Optional[Any]   ):
					return {key.lstrip('-'   ): value for key, value in zip(unknown_args[::2]						,      unknown_args[1::2]   )}






def   lowerCamelCase							():
					__a			:       Optional[int]					    =  ArgumentParser(
					    'HuggingFace Datasets CLI tool'						,      usage='datasets-cli <command> [<args>]'						,      allow_abbrev=_SCREAMING_SNAKE_CASE   )
					__a			:       Any					    =  parser.add_subparsers(help='datasets-cli command helpers'   )
					set_verbosity_info()

					# Register commands
					ConvertCommand.register_subcommand(_SCREAMING_SNAKE_CASE   )
					EnvironmentCommand.register_subcommand(_SCREAMING_SNAKE_CASE   )
					TestCommand.register_subcommand(_SCREAMING_SNAKE_CASE   )
					RunBeamCommand.register_subcommand(_SCREAMING_SNAKE_CASE   )
					DummyDataCommand.register_subcommand(_SCREAMING_SNAKE_CASE   )

					# Parse args
					__a    ,				__a			:       Dict					    =  parser.parse_known_args()
					if not hasattr(_SCREAMING_SNAKE_CASE						,      'func'   ):
										parser.print_help()
										exit(1   )
					__a			:       List[str]					    =  parse_unknown_args(_SCREAMING_SNAKE_CASE   )

					# Run
					__a			:       Optional[Any]					    =  args.func(_SCREAMING_SNAKE_CASE						,      **_SCREAMING_SNAKE_CASE   )
					service.run()


if __name__ == "__main__":
	main()







import math







class 		_snake_case  :




 def __init__(		self					,  _lowerCamelCase=0    ):  # a graph with Node 0,1,...,N-1
       a						:Optional[int] 							=       n
       a						:Union[str, Any] 							=       [
           [math.inf for j in range(0					,  _lowerCamelCase    )] for i in range(0					,  _lowerCamelCase    )
       ]  # adjacency matrix for weight
       a						:List[Any] 							=       [
           [math.inf for j in range(0					,  _lowerCamelCase    )] for i in range(0					,  _lowerCamelCase    )
       ]  # dp[i][j] stores minimum distance from i to j




 def        SCREAMING_SNAKE_CASE__				(		self					,  _lowerCamelCase					,  _lowerCamelCase					,  _lowerCamelCase    ):
       a						:Tuple 							=       w




 def        SCREAMING_SNAKE_CASE__				(		self    ):
       for k in range(0					,  self.n    ):
             for i in range(0					,  self.n    ):
                   for j in range(0					,  self.n    ):
                         a						:Union[str, Any] 							=       min(self.dp[i][j]					,  self.dp[i][k] + self.dp[k][j]    )




 def        SCREAMING_SNAKE_CASE__				(		self					,  _lowerCamelCase					,  _lowerCamelCase    ):
       return self.dp[u][v]


if __name__ == "__main__":
     snake_case				:    str       				=     Graph(5)
     graph.add_edge(0, 2, 9)
     graph.add_edge(0, 4, 10)
     graph.add_edge(1, 3, 5)
     graph.add_edge(2, 3, 7)
     graph.add_edge(3, 0, 10)
     graph.add_edge(3, 1, 2)
     graph.add_edge(3, 2, 1)
     graph.add_edge(3, 4, 6)
     graph.add_edge(4, 1, 3)
     graph.add_edge(4, 2, 4)
     graph.add_edge(4, 3, 9)
     graph.floyd_warshall()
     graph.show_min(1, 4)
     graph.show_min(0, 3)





