



"""simple docstring"""







import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
							from PIL import Image

							from transformers import CLIPSegProcessor, ViTImageProcessor
@require_vision
class        __A       (	unittest.TestCase    ):







		'''simple docstring'''





		def 					UpperCAmelCase    (	self						:  Dict						)					->		Dict:






				"""simple docstring"""



				lowercase__   :    str				=			tempfile.mkdtemp()

				# fmt: off
				lowercase__   :    str				=			['''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
				lowercase__   :    str				=			dict(zip(_snake_case			,range(len(_snake_case						)						)						)						)
				lowercase__   :    List[str]				=			['''#version: 0.2''', '''l o''', '''lo w</w>''', '''e r</w>''', '''''']
				lowercase__   :    Tuple				=			{'''unk_token''': '''<unk>'''}

				lowercase__   :    Union[str, Any]				=			os.path.join(self.tmpdirname			,VOCAB_FILES_NAMES['''vocab_file''']						)
				lowercase__   :    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(_snake_case						) + '''\n'''						)
				with open(self.merges_file			,'''w'''			,encoding='''utf-8'''						) as fp:
						fp.write('''\n'''.join(_snake_case						)						)

				lowercase__   :    str				=			{
				    '''do_resize''': True,
				    '''size''': 20,
				    '''do_center_crop''': True,
				    '''crop_size''': 18,
				    '''do_normalize''': True,
				    '''image_mean''': [0.4814_5466, 0.457_8275, 0.4082_1073],
				    '''image_std''': [0.2686_2954, 0.2613_0258, 0.2757_7711],
				}
				lowercase__   :    Optional[Any]				=			os.path.join(self.tmpdirname			,_snake_case						)
				with open(self.image_processor_file			,'''w'''			,encoding='''utf-8'''						) as fp:
						json.dump(_snake_case			,_snake_case						)







		def 					UpperCAmelCase    (	self						:  Any			,**_snake_case						:  Optional[int]						)					->		List[str]:






				"""simple docstring"""



				return CLIPTokenizer.from_pretrained(self.tmpdirname			,**_snake_case						)







		def 					UpperCAmelCase    (	self						:  Union[str, Any]			,**_snake_case						:  Union[str, Any]						)					->		Union[str, Any]:






				"""simple docstring"""



				return CLIPTokenizerFast.from_pretrained(self.tmpdirname			,**_snake_case						)







		def 					UpperCAmelCase    (	self						:  Any			,**_snake_case						:  List[Any]						)					->		Any:






				"""simple docstring"""



				return ViTImageProcessor.from_pretrained(self.tmpdirname			,**_snake_case						)







		def 					UpperCAmelCase    (	self						:  str						)					->		List[Any]:






				"""simple docstring"""



				shutil.rmtree(self.tmpdirname						)







		def 					UpperCAmelCase    (	self						:  int						)					->		Union[str, Any]:






				"""simple docstring"""



				lowercase__   :    Any				=			[np.random.randint(255			,size=(3, 30, 400)			,dtype=np.uinta						)]

				lowercase__   :    str				=			[Image.fromarray(np.moveaxis(_snake_case			,0			,-1						)						) for x in image_inputs]

				return image_inputs







		def 					UpperCAmelCase    (	self						:  str						)					->		Union[str, Any]:






				"""simple docstring"""



				lowercase__   :    List[Any]				=			self.get_tokenizer()
				lowercase__   :    Optional[int]				=			self.get_rust_tokenizer()
				lowercase__   :    int				=			self.get_image_processor()

				lowercase__   :    int				=			CLIPSegProcessor(tokenizer=_snake_case			,image_processor=_snake_case						)
				processor_slow.save_pretrained(self.tmpdirname						)
				lowercase__   :    Any				=			CLIPSegProcessor.from_pretrained(self.tmpdirname			,use_fast=_snake_case						)

				lowercase__   :    Union[str, Any]				=			CLIPSegProcessor(tokenizer=_snake_case			,image_processor=_snake_case						)
				processor_fast.save_pretrained(self.tmpdirname						)
				lowercase__   :    Any				=			CLIPSegProcessor.from_pretrained(self.tmpdirname						)

				self.assertEqual(processor_slow.tokenizer.get_vocab()			,tokenizer_slow.get_vocab()						)
				self.assertEqual(processor_fast.tokenizer.get_vocab()			,tokenizer_fast.get_vocab()						)
				self.assertEqual(tokenizer_slow.get_vocab()			,tokenizer_fast.get_vocab()						)
				self.assertIsInstance(processor_slow.tokenizer			,_snake_case						)
				self.assertIsInstance(processor_fast.tokenizer			,_snake_case						)

				self.assertEqual(processor_slow.image_processor.to_json_string()			,image_processor.to_json_string()						)
				self.assertEqual(processor_fast.image_processor.to_json_string()			,image_processor.to_json_string()						)
				self.assertIsInstance(processor_slow.image_processor			,_snake_case						)
				self.assertIsInstance(processor_fast.image_processor			,_snake_case						)







		def 					UpperCAmelCase    (	self						:  Union[str, Any]						)					->		Any:






				"""simple docstring"""



				lowercase__   :    int				=			CLIPSegProcessor(tokenizer=self.get_tokenizer()			,image_processor=self.get_image_processor()						)
				processor.save_pretrained(self.tmpdirname						)

				lowercase__   :    List[Any]				=			self.get_tokenizer(bos_token='''(BOS)'''			,eos_token='''(EOS)'''						)
				lowercase__   :    Any				=			self.get_image_processor(do_normalize=_snake_case			,padding_value=1.0						)

				lowercase__   :    Any				=			CLIPSegProcessor.from_pretrained(
				    self.tmpdirname			,bos_token='''(BOS)'''			,eos_token='''(EOS)'''			,do_normalize=_snake_case			,padding_value=1.0						)

				self.assertEqual(processor.tokenizer.get_vocab()			,tokenizer_add_kwargs.get_vocab()						)
				self.assertIsInstance(processor.tokenizer			,_snake_case						)

				self.assertEqual(processor.image_processor.to_json_string()			,image_processor_add_kwargs.to_json_string()						)
				self.assertIsInstance(processor.image_processor			,_snake_case						)







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






				"""simple docstring"""



				lowercase__   :    int				=			self.get_image_processor()
				lowercase__   :    List[str]				=			self.get_tokenizer()

				lowercase__   :    Any				=			CLIPSegProcessor(tokenizer=_snake_case			,image_processor=_snake_case						)

				lowercase__   :    Union[str, Any]				=			self.prepare_image_inputs()

				lowercase__   :    List[Any]				=			image_processor(_snake_case			,return_tensors='''np'''						)
				lowercase__   :    Union[str, Any]				=			processor(images=_snake_case			,return_tensors='''np'''						)

				for key in input_feat_extract.keys():
						self.assertAlmostEqual(input_feat_extract[key].sum()			,input_processor[key].sum()			,delta=1e-2						)







		def 					UpperCAmelCase    (	self						:  Union[str, Any]						)					->		Optional[Any]:






				"""simple docstring"""



				lowercase__   :    Tuple				=			self.get_image_processor()
				lowercase__   :    Any				=			self.get_tokenizer()

				lowercase__   :    List[str]				=			CLIPSegProcessor(tokenizer=_snake_case			,image_processor=_snake_case						)

				lowercase__   :    int				=			'''lower newer'''

				lowercase__   :    Optional[int]				=			processor(text=_snake_case						)

				lowercase__   :    Tuple				=			tokenizer(_snake_case						)

				for key in encoded_tok.keys():
						self.assertListEqual(encoded_tok[key]			,encoded_processor[key]						)







		def 					UpperCAmelCase    (	self						:  Any						)					->		Any:






				"""simple docstring"""



				lowercase__   :    Tuple				=			self.get_image_processor()
				lowercase__   :    Optional[Any]				=			self.get_tokenizer()

				lowercase__   :    Tuple				=			CLIPSegProcessor(tokenizer=_snake_case			,image_processor=_snake_case						)

				lowercase__   :    Any				=			'''lower newer'''
				lowercase__   :    List[str]				=			self.prepare_image_inputs()

				lowercase__   :    List[Any]				=			processor(text=_snake_case			,images=_snake_case						)

				self.assertListEqual(list(inputs.keys()						)			,['''input_ids''', '''attention_mask''', '''pixel_values''']						)

				# test if it raises when no input is passed
				with pytest.raises(_snake_case						):
						processor()







		def 					UpperCAmelCase    (	self						:  Optional[Any]						)					->		str:






				"""simple docstring"""



				lowercase__   :    Union[str, Any]				=			self.get_image_processor()
				lowercase__   :    List[str]				=			self.get_tokenizer()

				lowercase__   :    Union[str, Any]				=			CLIPSegProcessor(tokenizer=_snake_case			,image_processor=_snake_case						)

				lowercase__   :    Dict				=			self.prepare_image_inputs()
				lowercase__   :    str				=			self.prepare_image_inputs()

				lowercase__   :    List[str]				=			processor(images=_snake_case			,visual_prompt=_snake_case						)

				self.assertListEqual(list(inputs.keys()						)			,['''pixel_values''', '''conditional_pixel_values''']						)

				# test if it raises when no input is passed
				with pytest.raises(_snake_case						):
						processor()







		def 					UpperCAmelCase    (	self						:  Any						)					->		Any:






				"""simple docstring"""



				lowercase__   :    Any				=			self.get_image_processor()
				lowercase__   :    str				=			self.get_tokenizer()

				lowercase__   :    Optional[Any]				=			CLIPSegProcessor(tokenizer=_snake_case			,image_processor=_snake_case						)

				lowercase__   :    List[str]				=			[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

				lowercase__   :    str				=			processor.batch_decode(_snake_case						)
				lowercase__   :    Optional[int]				=			tokenizer.batch_decode(_snake_case						)

				self.assertListEqual(_snake_case			,_snake_case						)





"""simple docstring"""







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



def      __UpperCAmelCase      (    __lowerCamelCase						,     __lowerCamelCase	)							->      Optional[Any]:
		lowercase__   :    str				=			[[float('''inf'''	) for _ in range(__lowerCamelCase	)] for _ in range(__lowerCamelCase	)]

		for i in range(__lowerCamelCase	):
				for j in range(__lowerCamelCase	):
						lowercase__   :    List[str]				=			graph[i][j]

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

		_print_dist(__lowerCamelCase						,     __lowerCamelCase	)
		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
