





'''simple docstring'''




from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


__UpperCAmelCase			    =    logging.get_logger(__name__)

__UpperCAmelCase			    =    {
    """camembert-base""": """https://huggingface.co/camembert-base/resolve/main/config.json""",
    """umberto-commoncrawl-cased-v1""": (
        """https://huggingface.co/Musixmatch/umberto-commoncrawl-cased-v1/resolve/main/config.json"""
    ),
    """umberto-wikipedia-uncased-v1""": (
        """https://huggingface.co/Musixmatch/umberto-wikipedia-uncased-v1/resolve/main/config.json"""
    ),
}




class 			UpperCamelCase__ ( _a       ):




					"""simple docstring"""
					SCREAMING_SNAKE_CASE__            =     '''camembert'''


					def __init__(		self							:       Tuple	,		lowerCamelCase_							:       Union[str, Any]=3_05_22	,		lowerCamelCase_							:       Optional[Any]=7_68	,		lowerCamelCase_							:       Union[str, Any]=12	,		lowerCamelCase_							:       Any=12	,		lowerCamelCase_							:       Union[str, Any]=30_72	,		lowerCamelCase_							:       Optional[Any]="gelu"	,		lowerCamelCase_							:       Optional[int]=0.1	,		lowerCamelCase_							:       List[Any]=0.1	,		lowerCamelCase_							:       Dict=5_12	,		lowerCamelCase_							:       List[str]=2	,		lowerCamelCase_							:       Optional[int]=0.02	,		lowerCamelCase_							:       Union[str, Any]=1e-12	,		lowerCamelCase_							:       Optional[Any]=1	,		lowerCamelCase_							:       Optional[int]=0	,		lowerCamelCase_							:       List[str]=2	,		lowerCamelCase_							:       Optional[Any]="absolute"	,		lowerCamelCase_							:       Dict=True	,		lowerCamelCase_							:       int=None	,		**lowerCamelCase_							:       Union[str, Any]	,		):

							'''simple docstring'''



							super().__init__(pad_token_id=lowerCamelCase_	,		bos_token_id=lowerCamelCase_	,		eos_token_id=lowerCamelCase_	,		**lowerCamelCase_		)

							SCREAMING_SNAKE_CASE      :							Any						=       vocab_size
							SCREAMING_SNAKE_CASE      :							int						=       hidden_size
							SCREAMING_SNAKE_CASE      :							Tuple						=       num_hidden_layers
							SCREAMING_SNAKE_CASE      :							Tuple						=       num_attention_heads
							SCREAMING_SNAKE_CASE      :							Any						=       hidden_act
							SCREAMING_SNAKE_CASE      :							str						=       intermediate_size
							SCREAMING_SNAKE_CASE      :							Tuple						=       hidden_dropout_prob
							SCREAMING_SNAKE_CASE      :							Tuple						=       attention_probs_dropout_prob
							SCREAMING_SNAKE_CASE      :							List[Any]						=       max_position_embeddings
							SCREAMING_SNAKE_CASE      :							List[str]						=       type_vocab_size
							SCREAMING_SNAKE_CASE      :							Tuple						=       initializer_range
							SCREAMING_SNAKE_CASE      :							Dict						=       layer_norm_eps
							SCREAMING_SNAKE_CASE      :							int						=       position_embedding_type
							SCREAMING_SNAKE_CASE      :							int						=       use_cache
							SCREAMING_SNAKE_CASE      :							Optional[Any]						=       classifier_dropout







class 			UpperCamelCase__ ( _a       ):




					"""simple docstring"""


					@property
					def lowerCamelCase_       (		self							:       Optional[int]		):

							'''simple docstring'''



							if self.task == "multiple-choice":
									SCREAMING_SNAKE_CASE      :							Any						=       {0: '''batch''', 1: '''choice''', 2: '''sequence'''}
							else:
									SCREAMING_SNAKE_CASE      :							List[str]						=       {0: '''batch''', 1: '''sequence'''}
							return OrderedDict(
							    [
							        ("""input_ids""", dynamic_axis),
							        ("""attention_mask""", dynamic_axis),
							    ]		)










def      lowerCamelCase_						(				_UpperCamelCase ,				_UpperCamelCase )		->						List[str]:






				"""simple docstring"""


				print('''\nThe shortest path matrix using Floyd Warshall algorithm\n''' )
				for i in range(_UpperCamelCase ):
								for j in range(_UpperCamelCase ):
												if dist[i][j] != float('''inf''' ):
																print(int(dist[i][j] ) ,				end='''\t''' )
												else:
																print('''INF''' ,				end='''\t''' )
								print()






def      lowerCamelCase_						(				_UpperCamelCase ,				_UpperCamelCase )		->						Union[str, Any]:






				"""simple docstring"""


				snake_case_						:    int				=  [[float('''inf''' ) for _ in range(_UpperCamelCase )] for _ in range(_UpperCamelCase )]

				for i in range(_UpperCamelCase ):
								for j in range(_UpperCamelCase ):
												snake_case_						:    Dict				=  graph[i][j]

												# check vertex k against all other vertices (i, j)
				for k in range(_UpperCamelCase ):
								# looping through rows of graph array
								for i in range(_UpperCamelCase ):
												# looping through columns of graph array
												for j in range(_UpperCamelCase ):
																if (
																    dist[i][k] != float('''inf''' )
																    and dist[k][j] != float('''inf''' )
																    and dist[i][k] + dist[k][j] < dist[i][j]
																):
																				snake_case_						:    List[Any]				=  dist[i][k] + dist[k][j]

				_print_dist(_UpperCamelCase ,				_UpperCamelCase )
				return dist, v


if __name__ == "__main__":
	lowerCAmelCase_    =				int(input('''Enter number of vertices: '''))
	lowerCAmelCase_    =				int(input('''Enter number of edges: '''))

	lowerCAmelCase_    =				[[float('''inf''') for i in range(v)] for j in range(v)]

	for i in range(v):
		lowerCAmelCase_    =				0.0

		# src and dst are indices that must be within the array size graph[e][v]
		# failure to follow this will result in an error
	for i in range(e):
		print('''\nEdge ''', i + 1)
		lowerCAmelCase_    =				int(input('''Enter source:'''))
		lowerCAmelCase_    =				int(input('''Enter destination:'''))
		lowerCAmelCase_    =				float(input('''Enter weight:'''))
		lowerCAmelCase_    =				weight

	floyd_warshall(graph, v)

	# Example Input
	# Enter number of vertices: 3
	# Enter number of edges: 2

	# # generated graph from vertex and edge inputs
	# [[inf, inf, inf], [inf, inf, inf], [inf, inf, inf]]
	# [[0.0, inf, inf], [inf, 0.0, inf], [inf, inf, 0.0]]

	# specify source, destination and weight for edge #1
	# Edge  1
	# Enter source:1
	# Enter destination:2
	# Enter weight:2

	# specify source, destination and weight for edge #2
	# Edge  2
	# Enter source:2
	# Enter destination:1
	# Enter weight:1

	# # Expected Output from the vertice, edge and src, dst, weight inputs!!
	# 0		INF	INF
	# INF	0	2
	# INF	1	0
