
'''simple docstring'''





import random
import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
 import torch

if is_vision_available():
 import PIL

 from transformers import FlavaImageProcessor
 from transformers.image_utils import PILImageResampling
 from transformers.models.flava.image_processing_flava import (
     FLAVA_CODEBOOK_MEAN,
     FLAVA_CODEBOOK_STD,
     FLAVA_IMAGE_MEAN,
     FLAVA_IMAGE_STD,
 )
else:
 a__						:				List[str]           =    None


class 	UpperCamelCase__					(      unittest.TestCase):






 def __init__(     self					:Tuple		,			_A					:Optional[Any]		,			_A					:List[Any]=7		,			_A					:List[str]=3		,			_A					:Optional[Any]=30		,			_A					:List[str]=400		,			_A					:Union[str, Any]=True		,			_A					:Union[str, Any]=None		,			_A					:Dict=True		,			_A					:Union[str, Any]=None		,			_A					:Optional[Any]=None		,			_A					:Any=True		,			_A					:int=1 / 255		,			_A					:int=True		,			_A					:Dict=FLAVA_IMAGE_MEAN		,			_A					:Optional[Any]=FLAVA_IMAGE_STD		,			_A					:int=14		,			_A					:str=75		,			_A					:Union[str, Any]=None		,			_A					:int=16		,			_A					:Optional[Any]=0.3		,			_A					:Optional[Any]=None		,			_A					:Tuple=True		,			_A					:Tuple=None		,			_A					:Dict=None		,			_A					:Tuple=True		,			_A					:Union[str, Any]=None		,			_A					:Optional[Any]=True		,			_A					:Optional[Any]=True		,			_A					:List[Any]=FLAVA_CODEBOOK_MEAN		,			_A					:Tuple=FLAVA_CODEBOOK_STD		,			)			->     List[Any]:







       '''simple docstring'''



       __A    		=     size if size is not None else {'height': 224, 'width': 224}
       __A    		=     crop_size if crop_size is not None else {'height': 224, 'width': 224}
       __A    		=     codebook_size if codebook_size is not None else {'height': 112, 'width': 112}
       __A    		=     codebook_crop_size if codebook_crop_size is not None else {'height': 112, 'width': 112}

       __A    		=     parent
       __A    		=     batch_size
       __A    		=     num_channels
       __A    		=     do_resize
       __A    		=     do_rescale
       __A    		=     rescale_factor
       __A    		=     min_resolution
       __A    		=     max_resolution
       __A    		=     size
       __A    		=     resample if resample is not None else PILImageResampling.BICUBIC
       __A    		=     do_normalize
       __A    		=     image_mean
       __A    		=     image_std
       __A    		=     do_center_crop
       __A    		=     crop_size

       __A    		=     input_size_patches
       __A    		=     total_mask_patches
       __A    		=     mask_group_max_patches
       __A    		=     mask_group_min_patches
       __A    		=     mask_group_min_aspect_ratio
       __A    		=     mask_group_max_aspect_ratio

       __A    		=     codebook_do_resize
       __A    		=     codebook_size
       __A    		=     codebook_resample if codebook_resample is not None else PILImageResampling.LANCZOS
       __A    		=     codebook_do_center_crop
       __A    		=     codebook_crop_size
       __A    		=     codebook_do_map_pixels
       __A    		=     codebook_do_normalize
       __A    		=     codebook_image_mean
       __A    		=     codebook_image_std






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







       '''simple docstring'''



       return {
           "image_mean": self.image_mean,
           "image_std": self.image_std,
           "do_normalize": self.do_normalize,
           "do_resize": self.do_resize,
           "size": self.size,
           "resample": self.resample,
           "do_rescale": self.do_rescale,
           "rescale_factor": self.rescale_factor,
           "do_center_crop": self.do_center_crop,
           "crop_size": self.crop_size,
           "input_size_patches": self.input_size_patches,
           "total_mask_patches": self.total_mask_patches,
           "mask_group_max_patches": self.mask_group_max_patches,
           "mask_group_min_patches": self.mask_group_min_patches,
           "mask_group_min_aspect_ratio": self.mask_group_min_aspect_ratio,
           "mask_group_max_aspect_ratio": self.mask_group_min_aspect_ratio,
           "codebook_do_resize": self.codebook_do_resize,
           "codebook_size": self.codebook_size,
           "codebook_resample": self.codebook_resample,
           "codebook_do_center_crop": self.codebook_do_center_crop,
           "codebook_crop_size": self.codebook_crop_size,
           "codebook_do_map_pixels": self.codebook_do_map_pixels,
           "codebook_do_normalize": self.codebook_do_normalize,
           "codebook_image_mean": self.codebook_image_mean,
           "codebook_image_std": self.codebook_image_std,
       }






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







       '''simple docstring'''



       return (self.size["height"], self.size["width"])






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







       '''simple docstring'''



       return (
           (self.input_size_patches, self.input_size_patches)
           if not isinstance(self.input_size_patches		,			_A     )
           else self.input_size_patches
       )






 def 		lowercase_  (     self					:int     )			->     str:







       '''simple docstring'''



       return (self.codebook_size["height"], self.codebook_size["width"])


@require_torch
@require_vision
class 	UpperCamelCase__					(      SCREAMING_SNAKE_CASE ,       unittest.TestCase):
 UpperCAmelCase__      :      Tuple  			=   FlavaImageProcessor if is_vision_available() else None
 UpperCAmelCase__      :      int  			=   None






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







       '''simple docstring'''



       __A    		=     FlavaImageProcessingTester(self     )






 @property
 def 		lowercase_  (     self					:List[Any]     )			->     Dict:







       '''simple docstring'''



       return self.image_processor_tester.prepare_image_processor_dict()






 def 		lowercase_  (     self					:Optional[int]     )			->     List[str]:







       '''simple docstring'''



       __A    		=     self.image_processing_class(**self.image_processor_dict     )
       self.assertTrue(hasattr(_A		,			'image_mean'     )     )
       self.assertTrue(hasattr(_A		,			'image_std'     )     )
       self.assertTrue(hasattr(_A		,			'do_normalize'     )     )
       self.assertTrue(hasattr(_A		,			'do_resize'     )     )
       self.assertTrue(hasattr(_A		,			'resample'     )     )
       self.assertTrue(hasattr(_A		,			'crop_size'     )     )
       self.assertTrue(hasattr(_A		,			'do_center_crop'     )     )
       self.assertTrue(hasattr(_A		,			'do_rescale'     )     )
       self.assertTrue(hasattr(_A		,			'rescale_factor'     )     )
       self.assertTrue(hasattr(_A		,			'masking_generator'     )     )
       self.assertTrue(hasattr(_A		,			'codebook_do_resize'     )     )
       self.assertTrue(hasattr(_A		,			'codebook_size'     )     )
       self.assertTrue(hasattr(_A		,			'codebook_resample'     )     )
       self.assertTrue(hasattr(_A		,			'codebook_do_center_crop'     )     )
       self.assertTrue(hasattr(_A		,			'codebook_crop_size'     )     )
       self.assertTrue(hasattr(_A		,			'codebook_do_map_pixels'     )     )
       self.assertTrue(hasattr(_A		,			'codebook_do_normalize'     )     )
       self.assertTrue(hasattr(_A		,			'codebook_image_mean'     )     )
       self.assertTrue(hasattr(_A		,			'codebook_image_std'     )     )






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







       '''simple docstring'''



       __A    		=     self.image_processing_class.from_dict(self.image_processor_dict     )
       self.assertEqual(image_processor.size		,			{'height': 224, 'width': 224}     )
       self.assertEqual(image_processor.crop_size		,			{'height': 224, 'width': 224}     )
       self.assertEqual(image_processor.codebook_size		,			{'height': 112, 'width': 112}     )
       self.assertEqual(image_processor.codebook_crop_size		,			{'height': 112, 'width': 112}     )

       __A    		=     self.image_processing_class.from_dict(
           self.image_processor_dict		,			size=42		,			crop_size=84		,			codebook_size=33		,			codebook_crop_size=66     )
       self.assertEqual(image_processor.size		,			{'height': 42, 'width': 42}     )
       self.assertEqual(image_processor.crop_size		,			{'height': 84, 'width': 84}     )
       self.assertEqual(image_processor.codebook_size		,			{'height': 33, 'width': 33}     )
       self.assertEqual(image_processor.codebook_crop_size		,			{'height': 66, 'width': 66}     )






 def 		lowercase_  (     self					:List[str]     )			->     int:







       '''simple docstring'''



       pass






 def 		lowercase_  (     self					:str     )			->     int:







       '''simple docstring'''



       __A    		=     self.image_processing_class(**self.image_processor_dict     )
       # create random PIL images
       __A    		=     prepare_image_inputs(self.image_processor_tester		,			equal_resolution=_A     )
       for image in image_inputs:
             self.assertIsInstance(_A		,			PIL.Image.Image     )

       # Test not batched input
       __A    		=     image_processing(image_inputs[0]		,			return_tensors='pt'     )

       # Test no bool masked pos
       self.assertFalse('bool_masked_pos' in encoded_images     )

       __A		, __A    		=     self.image_processor_tester.get_expected_image_size()

       self.assertEqual(
           encoded_images.pixel_values.shape		,			(1, self.image_processor_tester.num_channels, expected_height, expected_width)		,			)

       # Test batched
       __A    		=     image_processing(_A		,			return_tensors='pt'     )
       __A		, __A    		=     self.image_processor_tester.get_expected_image_size()

       # Test no bool masked pos
       self.assertFalse('bool_masked_pos' in encoded_images     )

       self.assertEqual(
           encoded_images.pixel_values.shape		,			(
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               expected_height,
               expected_width,
           )		,			)






 def 		lowercase_  (     self					:Optional[Any]		,			_A					:Optional[Any]		,			_A					:Dict     )			->     Union[str, Any]:







       '''simple docstring'''



       __A    		=     self.image_processing_class(**self.image_processor_dict     )
       # create random tensors
       __A    		=     prepare_image_inputs(self.image_processor_tester		,			equal_resolution=_A		,			**_A     )
       for image in image_inputs:
             self.assertIsInstance(_A		,			_A     )

       # Test not batched input
       __A    		=     image_processing(image_inputs[0]		,			return_tensors='pt'     )

       __A		, __A    		=     self.image_processor_tester.get_expected_image_size()
       self.assertEqual(
           encoded_images.pixel_values.shape		,			(1, self.image_processor_tester.num_channels, expected_height, expected_width)		,			)

       __A    		=     image_processing(_A		,			return_image_mask=_A		,			return_tensors='pt'     )

       __A		, __A    		=     self.image_processor_tester.get_expected_image_size()
       self.assertEqual(
           encoded_images.pixel_values.shape		,			(
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               expected_height,
               expected_width,
           )		,			)

       __A		, __A    		=     self.image_processor_tester.get_expected_mask_size()
       self.assertEqual(
           encoded_images.bool_masked_pos.shape		,			(
               self.image_processor_tester.batch_size,
               expected_height,
               expected_width,
           )		,			)

       # Test batched
       __A    		=     image_processing(_A		,			return_tensors='pt'     ).pixel_values

       __A		, __A    		=     self.image_processor_tester.get_expected_image_size()
       self.assertEqual(
           encoded_images.shape		,			(
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               expected_height,
               expected_width,
           )		,			)

       # Test masking
       __A    		=     image_processing(_A		,			return_image_mask=_A		,			return_tensors='pt'     )

       __A		, __A    		=     self.image_processor_tester.get_expected_image_size()
       self.assertEqual(
           encoded_images.pixel_values.shape		,			(
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               expected_height,
               expected_width,
           )		,			)

       __A		, __A    		=     self.image_processor_tester.get_expected_mask_size()
       self.assertEqual(
           encoded_images.bool_masked_pos.shape		,			(
               self.image_processor_tester.batch_size,
               expected_height,
               expected_width,
           )		,			)






 def 		lowercase_  (     self					:Tuple     )			->     str:







       '''simple docstring'''



       self._test_call_framework(np.ndarray		,			prepare_kwargs={'numpify': True}     )






 def 		lowercase_  (     self					:Any     )			->     str:







       '''simple docstring'''



       self._test_call_framework(torch.Tensor		,			prepare_kwargs={'torchify': True}     )






 def 		lowercase_  (     self					:Dict     )			->     List[Any]:







       '''simple docstring'''



       random.seed(1_234     )
       __A    		=     self.image_processing_class(**self.image_processor_dict     )
       __A    		=     prepare_image_inputs(self.image_processor_tester		,			equal_resolution=_A		,			torchify=_A     )

       # Test not batched input
       __A    		=     image_processing(image_inputs[0]		,			return_image_mask=_A		,			return_tensors='pt'     )
       self.assertEqual(encoded_images.bool_masked_pos.sum().item()		,			75     )






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







       '''simple docstring'''



       __A    		=     self.image_processing_class(**self.image_processor_dict     )
       # create random PIL images
       __A    		=     prepare_image_inputs(self.image_processor_tester		,			equal_resolution=_A     )
       for image in image_inputs:
             self.assertIsInstance(_A		,			PIL.Image.Image     )

       # Test not batched input
       __A    		=     image_processing(image_inputs[0]		,			return_codebook_pixels=_A		,			return_tensors='pt'     )
       __A		, __A    		=     self.image_processor_tester.get_expected_codebook_image_size()
       self.assertEqual(
           encoded_images.codebook_pixel_values.shape		,			(1, self.image_processor_tester.num_channels, expected_height, expected_width)		,			)

       # Test batched
       __A    		=     image_processing(_A		,			return_codebook_pixels=_A		,			return_tensors='pt'     )
       __A		, __A    		=     self.image_processor_tester.get_expected_codebook_image_size()
       self.assertEqual(
           encoded_images.codebook_pixel_values.shape		,			(
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_channels,
               expected_height,
               expected_width,
           )		,			)








'''simple docstring'''





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







      """simple docstring"""
      print('\nVertex Distance'		)
      for i in range(UpperCAmelCase		):
            if dist[i] != float('inf'		):
                  print(UpperCAmelCase ,					'\t' ,					int(dist[i]		) ,					end='\t'		)
            else:
                  print(UpperCAmelCase ,					'\t' ,					'INF' ,					end='\t'		)
            print()





def     snake_case							(						UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase		)->     List[Any]:







      """simple docstring"""
      __A    		=     float('inf'		)
      __A    		=     -1
      for i in range(UpperCAmelCase		):
            if (not vset[i]) and mdist[i] < min_val:
                  __A    		=     i
                  __A    		=     mdist[i]
      return min_ind





def     snake_case							(						UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase		)->     Dict:







      """simple docstring"""
      __A    		=     [float('inf'		) for _ in range(UpperCAmelCase		)]
      __A    		=     [False for _ in range(UpperCAmelCase		)]
      __A    		=     0.0

      for _ in range(v - 1		):
            __A    		=     min_dist(UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase		)
            __A    		=     True

            for i in range(UpperCAmelCase		):
                  if (
                      (not vset[i])
                      and graph[u][i] != float('inf'		)
                      and mdist[u] + graph[u][i] < mdist[i]
                  ):
                        __A    		=     mdist[u] + graph[u][i]

      print_dist(UpperCAmelCase ,					UpperCAmelCase		)


if __name__ == "__main__":
 a__						:				Tuple           =    int(input("Enter number of vertices: ").strip())
 a__						:				List[str]           =    int(input("Enter number of edges: ").strip())

 a__						:				int           =    [[float("inf") for i in range(V)] for j in range(V)]

 for i in range(V):
  a__						:				Optional[int]           =    0.0

 for i in range(E):
  print("\nEdge ", i + 1)
  a__						:				Union[str, Any]           =    int(input("Enter source:").strip())
  a__						:				Tuple           =    int(input("Enter destination:").strip())
  a__						:				int           =    float(input("Enter weight:").strip())
  a__						:				Dict           =    weight

 a__						:				int           =    int(input("\nEnter shortest path source:").strip())
 dijkstra(graph, V, gsrc)






