





import json
import os
import unittest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_ftfy, require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin



@require_tokenizers
class 					__lowerCAmelCase       (			_a,     unittest.TestCase     ):
			lowerCamelCase_     :     Tuple       			=      CLIPTokenizer
			lowerCamelCase_     :     Tuple       			=      CLIPTokenizerFast
			lowerCamelCase_     :     List[str]       			=      True
			lowerCamelCase_     :     Tuple       			=      {}
			lowerCamelCase_     :     Any       			=      False






			def 			lowerCamelCase  (self    )     ->   int:


							'''simple docstring'''



							super().setUp()

							# fmt: off
							snake_case_						:    Optional[int]				=  ['''l''', '''o''', '''w''', '''e''', '''r''', '''s''', '''t''', '''i''', '''d''', '''n''', '''lo''', '''l</w>''', '''w</w>''', '''r</w>''', '''t</w>''', '''low</w>''', '''er</w>''', '''lowest</w>''', '''newer</w>''', '''wider''', '''<unk>''', '''<|startoftext|>''', '''<|endoftext|>''']
							# fmt: on
							snake_case_						:    str				=  dict(zip(__magic_name__					,							range(len(__magic_name__    )    )    )    )
							snake_case_						:    Optional[int]				=  ['''#version: 0.2''', '''l o''', '''lo w</w>''', '''e r</w>''']
							snake_case_						:    Dict				=  {'''unk_token''': '''<unk>'''}

							snake_case_						:    int				=  os.path.join(self.tmpdirname					,							VOCAB_FILES_NAMES['''vocab_file''']    )
							snake_case_						:    List[Any]				=  os.path.join(self.tmpdirname					,							VOCAB_FILES_NAMES['''merges_file''']    )
							with open(self.vocab_file					,							'''w'''					,							encoding='''utf-8'''    ) as fp:
											fp.write(json.dumps(__magic_name__    ) + '''\n'''    )
							with open(self.merges_file					,							'''w'''					,							encoding='''utf-8'''    ) as fp:
											fp.write('''\n'''.join(__magic_name__    )    )






			def 			lowerCamelCase  (self					,							**__magic_name__    )     ->   Union[str, Any]:


							'''simple docstring'''



							kwargs.update(self.special_tokens_map    )
							return CLIPTokenizer.from_pretrained(self.tmpdirname					,							**__magic_name__    )






			def 			lowerCamelCase  (self					,							**__magic_name__    )     ->   Any:


							'''simple docstring'''



							kwargs.update(self.special_tokens_map    )
							return CLIPTokenizerFast.from_pretrained(self.tmpdirname					,							**__magic_name__    )






			def 			lowerCamelCase  (self					,							__magic_name__    )     ->   Any:


							'''simple docstring'''



							snake_case_						:    Dict				=  '''lower newer'''
							snake_case_						:    Union[str, Any]				=  '''lower newer'''
							return input_text, output_text






			def 			lowerCamelCase  (self    )     ->   str:


							'''simple docstring'''



							snake_case_						:    Dict				=  CLIPTokenizer(self.vocab_file					,							self.merges_file					,							**self.special_tokens_map    )
							snake_case_						:    Union[str, Any]				=  '''lower newer'''
							snake_case_						:    Union[str, Any]				=  ['''lo''', '''w''', '''er</w>''', '''n''', '''e''', '''w''', '''er</w>''']
							snake_case_						:    Union[str, Any]				=  tokenizer.tokenize(__magic_name__    )
							self.assertListEqual(__magic_name__					,							__magic_name__    )

							snake_case_						:    int				=  tokens + [tokenizer.unk_token]
							snake_case_						:    Any				=  [10, 2, 16, 9, 3, 2, 16, 20]
							self.assertListEqual(tokenizer.convert_tokens_to_ids(__magic_name__    )					,							__magic_name__    )






			@require_ftfy
			def 			lowerCamelCase  (self    )     ->   Union[str, Any]:


							'''simple docstring'''



							for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
											with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''    ):
															snake_case_						:    List[str]				=  self.tokenizer_class.from_pretrained(__magic_name__					,							**__magic_name__    )
															snake_case_						:    int				=  self.rust_tokenizer_class.from_pretrained(__magic_name__					,							**__magic_name__    )

															snake_case_						:    Union[str, Any]				=  '''A\n\'ll 11p223RF☆ho!!to?\'d\'d\'\'d of a cat to-$\'\'d.'''
															snake_case_						:    Any				=  tokenizer_s.tokenize(__magic_name__    )
															snake_case_						:    List[Any]				=  tokenizer_r.tokenize(__magic_name__    )

															self.assertListEqual(__magic_name__					,							__magic_name__    )

															# Test that the tokenization is identical on an example containing a character (Latin Small Letter A
															# with Tilde) encoded in 2 different ways
															snake_case_						:    Optional[Any]				=  '''xa\u0303y''' + ''' ''' + '''x\xe3y'''
															snake_case_						:    int				=  tokenizer_s.tokenize(__magic_name__    )
															snake_case_						:    Any				=  tokenizer_r.tokenize(__magic_name__    )

															self.assertListEqual(__magic_name__					,							__magic_name__    )

															# Test that the tokenization is identical on unicode of space type
															snake_case_						:    int				=  [
															    '''\u0009''',  # (horizontal tab, '\t')
															    '''\u000B''',  # (vertical tab)
															    '''\u000C''',  # (form feed)
															    '''\u0020''',  # (space, ' ')
															    '''\u200E''',  # (left-to-right mark):w
															    '''\u200F''',  # (right-to-left mark)
															]
															for unicode_seq in spaces_unicodes:
																			snake_case_						:    List[str]				=  tokenizer_s.tokenize(__magic_name__    )
																			snake_case_						:    Optional[int]				=  tokenizer_r.tokenize(__magic_name__    )

																			self.assertListEqual(__magic_name__					,							__magic_name__    )

															# Test that the tokenization is identical on unicode of line break type
															snake_case_						:    int				=  [
															    '''\u000A''',  # (line feed, '\n')
															    '''\r\n''',  # (carriage return and line feed, '\r\n')
															    '''\u000D''',  # (carriage return, '\r')
															    '''\r''',  # (carriage return, '\r')
															    '''\u000D''',  # (carriage return, '\r')
															    '''\u2028''',  # (line separator)
															    '''\u2029''',  # (paragraph separator)
															    # "\u0085", # (next line)
															]

															# The tokenization is not identical for the character "\u0085" (next line). The slow version using ftfy transforms
															# it into the Horizontal Ellipsis character "…" ("\u2026") while the fast version transforms it into a
															# space (and thus into an empty list).

															for unicode_seq in line_break_unicodes:
																			snake_case_						:    str				=  tokenizer_s.tokenize(__magic_name__    )
																			snake_case_						:    Tuple				=  tokenizer_r.tokenize(__magic_name__    )

																			self.assertListEqual(__magic_name__					,							__magic_name__    )






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


							'''simple docstring'''



							for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
											with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''    ):
															snake_case_						:    Optional[Any]				=  '''hello'''  # `hello` is a token in the vocabulary of `pretrained_name`
															snake_case_						:    str				=  F'''{text_of_1_token} {text_of_1_token}'''

															snake_case_						:    Dict				=  self.rust_tokenizer_class.from_pretrained(
															    __magic_name__					,							use_fast=__magic_name__					,							)
															snake_case_						:    Any				=  tokenizer_r(__magic_name__					,							return_offsets_mapping=__magic_name__					,							add_special_tokens=__magic_name__    )
															self.assertEqual(encoding.offset_mapping[0]					,							(0, len(__magic_name__    ))    )
															self.assertEqual(
															    encoding.offset_mapping[1]					,							(len(__magic_name__    ) + 1, len(__magic_name__    ) + 1 + len(__magic_name__    ))					,							)

															snake_case_						:    Any				=  F''' {text}'''

															snake_case_						:    str				=  self.rust_tokenizer_class.from_pretrained(
															    __magic_name__					,							use_fast=__magic_name__					,							)
															snake_case_						:    Optional[Any]				=  tokenizer_r(__magic_name__					,							return_offsets_mapping=__magic_name__					,							add_special_tokens=__magic_name__    )
															self.assertEqual(encoding.offset_mapping[0]					,							(1, 1 + len(__magic_name__    ))    )
															self.assertEqual(
															    encoding.offset_mapping[1]					,							(1 + len(__magic_name__    ) + 1, 1 + len(__magic_name__    ) + 1 + len(__magic_name__    ))					,							)






			def 			lowerCamelCase  (self    )     ->   str:


							'''simple docstring'''



							with self.assertRaises(__magic_name__    ) as context:
											self.rust_tokenizer_class.from_pretrained('''robot-test/old-clip-tokenizer'''    )

							self.assertTrue(
							    context.exception.args[0].startswith(
							        '''The `backend_tokenizer` provided does not match the expected format.'''    )    )






			@require_ftfy
			def 			lowerCamelCase  (self    )     ->   Any:


							'''simple docstring'''



							super().test_tokenization_python_rust_equals()






			def 			lowerCamelCase  (self    )     ->   Dict:


							'''simple docstring'''



							pass







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
