





'''simple docstring'''

from __future__ import annotations

import copy
import inspect
import json
import math
import os
import tempfile
import unittest
from importlib import import_module

import numpy as np

from transformers import ViTMAEConfig
from transformers.file_utils import cached_property, is_tf_available, is_vision_available
from transformers.testing_utils import require_tf, require_vision, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
   import tensorflow as tf

   from transformers import TFViTMAEForPreTraining, TFViTMAEModel


if is_vision_available():
   from PIL import Image

   from transformers import ViTImageProcessor
class 							__lowerCAmelCase	:






       """simple docstring"""





       def __init__(				self  :						List[str]			,					lowerCAmelCase__  :						Dict			,					lowerCAmelCase__  :						Union[str, Any]=13			,					lowerCAmelCase__  :						List[str]=30			,					lowerCAmelCase__  :						Dict=2			,					lowerCAmelCase__  :						Optional[Any]=3			,					lowerCAmelCase__  :						Dict=True			,					lowerCAmelCase__  :						str=True			,					lowerCAmelCase__  :						Tuple=32			,					lowerCAmelCase__  :						str=2			,					lowerCAmelCase__  :						int=4			,					lowerCAmelCase__  :						List[str]=37			,					lowerCAmelCase__  :						Optional[Any]="gelu"			,					lowerCAmelCase__  :						Tuple=0.1			,					lowerCAmelCase__  :						List[Any]=0.1			,					lowerCAmelCase__  :						str=10			,					lowerCAmelCase__  :						Dict=0.02			,					lowerCAmelCase__  :						int=3			,					lowerCAmelCase__  :						Any=0.6			,					lowerCAmelCase__  :						Optional[Any]=None			,					)       ->	str:

            '''simple docstring'''




            _UpperCamelCase							       =			parent
            _UpperCamelCase							       =			batch_size
            _UpperCamelCase							       =			image_size
            _UpperCamelCase							       =			patch_size
            _UpperCamelCase							       =			num_channels
            _UpperCamelCase							       =			is_training
            _UpperCamelCase							       =			use_labels
            _UpperCamelCase							       =			hidden_size
            _UpperCamelCase							       =			num_hidden_layers
            _UpperCamelCase							       =			num_attention_heads
            _UpperCamelCase							       =			intermediate_size
            _UpperCamelCase							       =			hidden_act
            _UpperCamelCase							       =			hidden_dropout_prob
            _UpperCamelCase							       =			attention_probs_dropout_prob
            _UpperCamelCase							       =			type_sequence_label_size
            _UpperCamelCase							       =			initializer_range
            _UpperCamelCase							       =			mask_ratio
            _UpperCamelCase							       =			scope

            # in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above
            # (we add 1 for the [CLS] token)
            _UpperCamelCase							       =			(image_size // patch_size) ** 2
            _UpperCamelCase							       =			int(math.ceil((1 - mask_ratio) * (num_patches + 1)	)	)





       def snake_case__		(				self  :						Dict	)       ->	int:

            '''simple docstring'''




            _UpperCamelCase							       =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

            _UpperCamelCase							       =			None
            if self.use_labels:
                 _UpperCamelCase							       =			ids_tensor([self.batch_size]			,					self.type_sequence_label_size	)

            _UpperCamelCase							       =			self.get_config()

            return config, pixel_values, labels





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

            '''simple docstring'''




            return ViTMAEConfig(
                image_size=self.image_size			,					patch_size=self.patch_size			,					num_channels=self.num_channels			,					hidden_size=self.hidden_size			,					num_hidden_layers=self.num_hidden_layers			,					num_attention_heads=self.num_attention_heads			,					intermediate_size=self.intermediate_size			,					decoder_hidden_size=self.hidden_size			,					decoder_num_hidden_layers=self.num_hidden_layers			,					decoder_num_attention_heads=self.num_attention_heads			,					decoder_intermediate_size=self.intermediate_size			,					hidden_act=self.hidden_act			,					hidden_dropout_prob=self.hidden_dropout_prob			,					attention_probs_dropout_prob=self.attention_probs_dropout_prob			,					is_decoder=lowerCAmelCase__			,					initializer_range=self.initializer_range			,					mask_ratio=self.mask_ratio			,					)





       def snake_case__		(				self  :						Tuple			,					lowerCAmelCase__  :						List[Any]			,					lowerCAmelCase__  :						List[str]			,					lowerCAmelCase__  :						Optional[int]	)       ->	List[Any]:

            '''simple docstring'''




            _UpperCamelCase							       =			TFViTMAEModel(config=lowerCAmelCase__	)
            _UpperCamelCase							       =			model(lowerCAmelCase__			,					training=lowerCAmelCase__	)
            self.parent.assertEqual(result.last_hidden_state.shape			,					(self.batch_size, self.seq_length, self.hidden_size)	)





       def snake_case__		(				self  :						Union[str, Any]			,					lowerCAmelCase__  :						Union[str, Any]			,					lowerCAmelCase__  :						Any			,					lowerCAmelCase__  :						Dict	)       ->	Optional[Any]:

            '''simple docstring'''




            _UpperCamelCase							       =			TFViTMAEForPreTraining(lowerCAmelCase__	)
            _UpperCamelCase							       =			model(lowerCAmelCase__			,					training=lowerCAmelCase__	)
            # expected sequence length = num_patches
            _UpperCamelCase							       =			(self.image_size // self.patch_size) ** 2
            _UpperCamelCase							       =			self.patch_size**2 * self.num_channels
            self.parent.assertEqual(result.logits.shape			,					(self.batch_size, num_patches, expected_num_channels)	)

            # test greyscale images
            _UpperCamelCase							       =			1
            _UpperCamelCase							       =			TFViTMAEForPreTraining(lowerCAmelCase__	)

            _UpperCamelCase							       =			floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
            _UpperCamelCase							       =			model(lowerCAmelCase__			,					training=lowerCAmelCase__	)
            _UpperCamelCase							       =			self.patch_size**2
            self.parent.assertEqual(result.logits.shape			,					(self.batch_size, num_patches, expected_num_channels)	)







       def snake_case__		(				self  :						str	)       ->	int:

            '''simple docstring'''




            _UpperCamelCase							       =			self.prepare_config_and_inputs()
            ((_UpperCamelCase)       ,							(_UpperCamelCase)       ,							(_UpperCamelCase))							       =			config_and_inputs
            _UpperCamelCase							       =			{'''pixel_values''': pixel_values}
            return config, inputs_dict

@require_tf
class 							__lowerCAmelCase	(       __magic_name__		,		__magic_name__		,		unittest.TestCase					):






       """simple docstring"""
       _snake_case      :	List[Any]									=       (TFViTMAEModel, TFViTMAEForPreTraining) if is_tf_available() else ()
       _snake_case      :	int									=       {'feature-extraction': TFViTMAEModel} if is_tf_available() else {}

       _snake_case      :	Any									=       False
       _snake_case      :	Dict									=       False
       _snake_case      :	Any									=       False
       _snake_case      :	List[Any]									=       False





       def snake_case__		(				self  :						Tuple	)       ->	Tuple:

            '''simple docstring'''




            _UpperCamelCase							       =			TFViTMAEModelTester(self	)
            _UpperCamelCase							       =			ConfigTester(self			,					config_class=lowerCAmelCase__			,					has_text_modality=lowerCAmelCase__			,					hidden_size=37	)





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

            '''simple docstring'''




            self.config_tester.run_common_tests()





       @unittest.skip(reason='''ViTMAE does not use inputs_embeds'''	)
       def snake_case__		(				self  :						Any	)       ->	Tuple:

            '''simple docstring'''




            pass





       def snake_case__		(				self  :						Dict	)       ->	Dict:

            '''simple docstring'''




            _UpperCamelCase       ,							_UpperCamelCase							       =			self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                 _UpperCamelCase							       =			model_class(lowerCAmelCase__	)
                 self.assertIsInstance(model.get_input_embeddings()			,					(tf.keras.layers.Layer)	)
                 _UpperCamelCase							       =			model.get_output_embeddings()
                 self.assertTrue(x is None or isinstance(lowerCAmelCase__			,					tf.keras.layers.Layer	)	)





       def snake_case__		(				self  :						Dict	)       ->	Optional[Any]:

            '''simple docstring'''




            _UpperCamelCase       ,							_UpperCamelCase							       =			self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                 _UpperCamelCase							       =			model_class(lowerCAmelCase__	)
                 _UpperCamelCase							       =			inspect.signature(model.call	)
                 # signature.parameters is an OrderedDict => so arg_names order is deterministic
                 _UpperCamelCase							       =			[*signature.parameters.keys()]

                 _UpperCamelCase							       =			['''pixel_values''']
                 self.assertListEqual(arg_names[:1]			,					lowerCAmelCase__	)





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

            '''simple docstring'''




            _UpperCamelCase							       =			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*lowerCAmelCase__	)





       def snake_case__		(				self  :						List[Any]	)       ->	int:

            '''simple docstring'''




            _UpperCamelCase							       =			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_pretraining(*lowerCAmelCase__	)





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

            '''simple docstring'''




            np.random.seed(2	)

            _UpperCamelCase       ,							_UpperCamelCase							       =			self.model_tester.prepare_config_and_inputs_for_common()

            _UpperCamelCase							       =			int((config.image_size // config.patch_size) ** 2	)
            _UpperCamelCase							       =			np.random.uniform(size=(self.model_tester.batch_size, num_patches)	)

            for model_class in self.all_model_classes:
                 _UpperCamelCase							       =			model_class(lowerCAmelCase__	)
                 _UpperCamelCase							       =			self._prepare_for_class(lowerCAmelCase__			,					lowerCAmelCase__	)

                 _UpperCamelCase							       =			model(lowerCAmelCase__			,					noise=lowerCAmelCase__	)

                 _UpperCamelCase							       =			copy.deepcopy(self._prepare_for_class(lowerCAmelCase__			,					lowerCAmelCase__	)	)
                 _UpperCamelCase							       =			model(**lowerCAmelCase__			,					noise=lowerCAmelCase__	)
                 _UpperCamelCase							       =			outputs_dict[0].numpy()
                 _UpperCamelCase							       =			outputs_keywords[0].numpy()

                 self.assertLess(np.sum(np.abs(output_dict - output_keywords	)	)			,					1e-6	)





       def snake_case__		(				self  :						Dict	)       ->	int:

            '''simple docstring'''




            np.random.seed(2	)

            _UpperCamelCase       ,							_UpperCamelCase							       =			self.model_tester.prepare_config_and_inputs_for_common()

            _UpperCamelCase							       =			int((config.image_size // config.patch_size) ** 2	)
            _UpperCamelCase							       =			np.random.uniform(size=(self.model_tester.batch_size, num_patches)	)

            def prepare_numpy_arrays(lowerCAmelCase__  :						Optional[Any]	):
                 _UpperCamelCase							       =			{}
                 for k, v in inputs_dict.items():
                      if tf.is_tensor(lowerCAmelCase__	):
                           _UpperCamelCase							       =			v.numpy()
                      else:
                           _UpperCamelCase							       =			np.array(lowerCAmelCase__	)

                 return inputs_np_dict

            for model_class in self.all_model_classes:
                 _UpperCamelCase							       =			model_class(lowerCAmelCase__	)

                 _UpperCamelCase							       =			self._prepare_for_class(lowerCAmelCase__			,					lowerCAmelCase__	)
                 _UpperCamelCase							       =			prepare_numpy_arrays(lowerCAmelCase__	)

                 _UpperCamelCase							       =			model(lowerCAmelCase__			,					noise=lowerCAmelCase__	)
                 _UpperCamelCase							       =			model(**lowerCAmelCase__			,					noise=lowerCAmelCase__	)
                 self.assert_outputs_same(lowerCAmelCase__			,					lowerCAmelCase__	)





       def snake_case__		(				self  :						Tuple			,					lowerCAmelCase__  :						Any			,					lowerCAmelCase__  :						str			,					lowerCAmelCase__  :						Dict	)       ->	Optional[Any]:

            '''simple docstring'''




            np.random.seed(2	)

            _UpperCamelCase							       =			int((tf_model.config.image_size // tf_model.config.patch_size) ** 2	)
            _UpperCamelCase							       =			np.random.uniform(size=(self.model_tester.batch_size, num_patches)	)
            _UpperCamelCase							       =			tf.constant(lowerCAmelCase__	)

            # Add `noise` argument.
            # PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument
            _UpperCamelCase							       =			tf_noise

            super().check_pt_tf_models(lowerCAmelCase__			,					lowerCAmelCase__			,					lowerCAmelCase__	)





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

            '''simple docstring'''




            np.random.seed(2	)

            _UpperCamelCase       ,							_UpperCamelCase							       =			self.model_tester.prepare_config_and_inputs_for_common()

            _UpperCamelCase							       =			{
                module_member
                for model_class in self.all_model_classes
                for module in (import_module(model_class.__module__	),)
                for module_member_name in dir(lowerCAmelCase__	)
                if module_member_name.endswith('''MainLayer'''	)
                # This condition is required, since `modeling_tf_clip.py` has 3 classes whose names end with `MainLayer`.
                and module_member_name[: -len('''MainLayer'''	)] == model_class.__name__[: -len('''Model'''	)]
                for module_member in (getattr(lowerCAmelCase__			,					lowerCAmelCase__	),)
                if isinstance(lowerCAmelCase__			,					lowerCAmelCase__	)
                and tf.keras.layers.Layer in module_member.__bases__
                and getattr(lowerCAmelCase__			,					'''_keras_serializable'''			,					lowerCAmelCase__	)
            }

            _UpperCamelCase							       =			int((config.image_size // config.patch_size) ** 2	)
            _UpperCamelCase							       =			np.random.uniform(size=(self.model_tester.batch_size, num_patches)	)
            _UpperCamelCase							       =			tf.convert_to_tensor(lowerCAmelCase__	)
            inputs_dict.update({'''noise''': noise}	)

            for main_layer_class in tf_main_layer_classes:
                 _UpperCamelCase							       =			main_layer_class(lowerCAmelCase__	)

                 _UpperCamelCase							       =			{
                     name: tf.keras.Input(tensor.shape[1:]			,					dtype=tensor.dtype	) for name, tensor in inputs_dict.items()
                 }

                 _UpperCamelCase							       =			tf.keras.Model(lowerCAmelCase__			,					outputs=main_layer(lowerCAmelCase__	)	)
                 _UpperCamelCase							       =			model(lowerCAmelCase__	)

                 with tempfile.TemporaryDirectory() as tmpdirname:
                      _UpperCamelCase							       =			os.path.join(lowerCAmelCase__			,					'''keras_model.h5'''	)
                      model.save(lowerCAmelCase__	)
                      _UpperCamelCase							       =			tf.keras.models.load_model(
                          lowerCAmelCase__			,					custom_objects={main_layer_class.__name__: main_layer_class}	)
                      assert isinstance(lowerCAmelCase__			,					tf.keras.Model	)
                      _UpperCamelCase							       =			model(lowerCAmelCase__	)
                      self.assert_outputs_same(lowerCAmelCase__			,					lowerCAmelCase__	)





       @slow
       def snake_case__		(				self  :						Union[str, Any]	)       ->	int:

            '''simple docstring'''




            np.random.seed(2	)

            _UpperCamelCase       ,							_UpperCamelCase							       =			self.model_tester.prepare_config_and_inputs_for_common()

            _UpperCamelCase							       =			int((config.image_size // config.patch_size) ** 2	)
            _UpperCamelCase							       =			np.random.uniform(size=(self.model_tester.batch_size, num_patches)	)

            for model_class in self.all_model_classes:
                 _UpperCamelCase							       =			model_class(lowerCAmelCase__	)
                 _UpperCamelCase							       =			self._prepare_for_class(lowerCAmelCase__			,					lowerCAmelCase__	)
                 _UpperCamelCase							       =			model(lowerCAmelCase__			,					noise=lowerCAmelCase__	)

                 if model_class.__name__ == "TFViTMAEModel":
                      _UpperCamelCase							       =			outputs.last_hidden_state.numpy()
                      _UpperCamelCase							       =			0
                 else:
                      _UpperCamelCase							       =			outputs.logits.numpy()
                      _UpperCamelCase							       =			0

                 with tempfile.TemporaryDirectory() as tmpdirname:
                      model.save_pretrained(lowerCAmelCase__			,					saved_model=lowerCAmelCase__	)
                      _UpperCamelCase							       =			model_class.from_pretrained(lowerCAmelCase__	)
                      _UpperCamelCase							       =			model(lowerCAmelCase__			,					noise=lowerCAmelCase__	)

                      if model_class.__name__ == "TFViTMAEModel":
                           _UpperCamelCase							       =			after_outputs['''last_hidden_state'''].numpy()
                           _UpperCamelCase							       =			0
                      else:
                           _UpperCamelCase							       =			after_outputs['''logits'''].numpy()
                           _UpperCamelCase							       =			0

                      _UpperCamelCase							       =			np.amax(np.abs(out_a - out_a	)	)
                      self.assertLessEqual(lowerCAmelCase__			,					1e-5	)





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

            '''simple docstring'''




            np.random.seed(2	)

            _UpperCamelCase       ,							_UpperCamelCase							       =			self.model_tester.prepare_config_and_inputs_for_common()

            _UpperCamelCase							       =			int((config.image_size // config.patch_size) ** 2	)
            _UpperCamelCase							       =			np.random.uniform(size=(self.model_tester.batch_size, num_patches)	)

            for model_class in self.all_model_classes:
                 _UpperCamelCase							       =			model_class(lowerCAmelCase__	)
                 _UpperCamelCase							       =			self._prepare_for_class(lowerCAmelCase__			,					lowerCAmelCase__	)

                 _UpperCamelCase							       =			model(lowerCAmelCase__			,					noise=lowerCAmelCase__	)
                 _UpperCamelCase							       =			model.get_config()
                 # make sure that returned config is jsonifiable, which is required by keras
                 json.dumps(lowerCAmelCase__	)
                 _UpperCamelCase							       =			model_class.from_config(model.get_config()	)
                 # make sure it also accepts a normal config
                 _UpperCamelCase							       =			model_class.from_config(model.config	)
                 _UpperCamelCase							       =			new_model(lowerCAmelCase__	)  # Build model
                 new_model.set_weights(model.get_weights()	)
                 _UpperCamelCase							       =			new_model(lowerCAmelCase__			,					noise=lowerCAmelCase__	)

                 self.assert_outputs_same(lowerCAmelCase__			,					lowerCAmelCase__	)





       @unittest.skip(
           reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load
    to get deterministic results.'''	)
       def snake_case__		(				self  :						List[Any]	)       ->	Dict:

            '''simple docstring'''




            pass





       @unittest.skip(reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load'''	)
       def snake_case__		(				self  :						List[Any]	)       ->	Optional[Any]:

            '''simple docstring'''




            pass







       @slow
       def snake_case__		(				self  :						List[str]	)       ->	Tuple:

            '''simple docstring'''




            _UpperCamelCase							       =			TFViTMAEModel.from_pretrained('''google/vit-base-patch16-224'''	)
            self.assertIsNotNone(lowerCAmelCase__	)







def    a__							(							)						->						List[str]:





     """simple docstring"""

     _UpperCamelCase							       =			Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' )
     return image




@require_tf
@require_vision
class 							__lowerCAmelCase	(       unittest.TestCase					):






       """simple docstring"""





       @cached_property
       def snake_case__		(				self  :						int	)       ->	Any:

            '''simple docstring'''




            return ViTImageProcessor.from_pretrained('''facebook/vit-mae-base'''	) if is_vision_available() else None







       @slow
       def snake_case__		(				self  :						Optional[Any]	)       ->	str:

            '''simple docstring'''




            np.random.seed(2	)

            _UpperCamelCase							       =			TFViTMAEForPreTraining.from_pretrained('''facebook/vit-mae-base'''	)

            _UpperCamelCase							       =			self.default_image_processor
            _UpperCamelCase							       =			prepare_img()
            _UpperCamelCase							       =			image_processor(images=lowerCAmelCase__			,					return_tensors='''tf'''	)

            # prepare a noise vector that will be also used for testing the TF model
            # (this way we can ensure that the PT and TF models operate on the same inputs)
            _UpperCamelCase							       =			ViTMAEConfig()
            _UpperCamelCase							       =			int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2	)
            _UpperCamelCase							       =			np.random.uniform(size=(1, num_patches)	)

            # forward pass
            _UpperCamelCase							       =			model(**lowerCAmelCase__			,					noise=lowerCAmelCase__	)

            # verify the logits
            _UpperCamelCase							       =			tf.convert_to_tensor([1, 196, 768]	)
            self.assertEqual(outputs.logits.shape			,					lowerCAmelCase__	)

            _UpperCamelCase							       =			tf.convert_to_tensor(
                [[-0.0548, -1.7023, -0.9325], [0.3721, -0.5670, -0.2233], [0.8235, -1.3878, -0.3524]]	)

            tf.debugging.assert_near(outputs.logits[0, :3, :3]			,					lowerCAmelCase__			,					atol=1e-4	)










def 				__lowerCAmelCase(       _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE				)							-> int:




    """simple docstring"""




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





def 				__lowerCAmelCase(       _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE				)							-> str:




    """simple docstring"""




    _A     =							[[float('inf'				) for _ in range(_SCREAMING_SNAKE_CASE				)] for _ in range(_SCREAMING_SNAKE_CASE				)]

    for i in range(_SCREAMING_SNAKE_CASE				):
        for j in range(_SCREAMING_SNAKE_CASE				):
            _A     =							graph[i][j]

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

    _print_dist(_SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE				)
    return dist, v


if __name__ == "__main__":
 __A							:			Dict         =			int(input("Enter number of vertices: "))
 __A							:			Union[str, Any]         =			int(input("Enter number of edges: "))

 __A							:			List[str]         =			[[float("inf") for i in range(v)] for j in range(v)]

 for i in range(v):
  __A							:			List[Any]         =			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)
  __A							:			Union[str, Any]         =			int(input("Enter source:"))
  __A							:			List[str]         =			int(input("Enter destination:"))
  __A							:			Union[str, Any]         =			float(input("Enter weight:"))
  __A							:			Any         =			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





