





"""simple docstring"""





def  __A   (_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE			)					->Any:





  """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  __A   (_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE			)					->List[Any]:





  """simple docstring"""


  lowerCAmelCase__			:int											=							[[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			):
      lowerCAmelCase__			:List[Any]											=							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]
        ):
          lowerCAmelCase__			:Any											=							dist[i][k] + dist[k][j]

  _print_dist(_SCREAMING_SNAKE_CASE     ,   _SCREAMING_SNAKE_CASE			)
  return dist, v


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

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

  for i in range(v):
    __A											=		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											=		int(input("""Enter source:"""))
    __A											=		int(input("""Enter destination:"""))
    __A											=		float(input("""Enter weight:"""))
    __A											=		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







"""simple docstring"""





import tempfile
import unittest

from transformers import AutoModelForSeqaSeqLM, AutoTokenizer
from transformers.testing_utils import (
    is_torch_available,
    require_optimum,
    require_torch,
    slow,
)


if is_torch_available():
  import torch






@require_torch
@require_optimum
@slow
class 					_lowerCAmelCase   (     unittest.TestCase       ):
       """simple docstring"""




       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:Optional[Any]											=							'hf-internal-testing/tiny-random-t5'
         lowerCAmelCase__			:List[Any]											=							AutoTokenizer.from_pretrained(__UpperCAmelCase      )
         lowerCAmelCase__			:str											=							AutoModelForSeqaSeqLM.from_pretrained(__UpperCAmelCase      )

         lowerCAmelCase__			:Any											=							tokenizer('This is me'    , return_tensors='pt'      )

         lowerCAmelCase__			:Dict											=							model.to_bettertransformer()

         self.assertTrue(any('BetterTransformer' in mod.__class__.__name__ for _, mod in model.named_modules()      )      )

         lowerCAmelCase__			:Optional[Any]											=							model.generate(**__UpperCAmelCase      )

         lowerCAmelCase__			:List[Any]											=							model.reverse_bettertransformer()

         self.assertFalse(any('BetterTransformer' in mod.__class__.__name__ for _, mod in model.named_modules()      )      )

         with tempfile.TemporaryDirectory() as tmpdirname:
           model.save_pretrained(__UpperCAmelCase      )

           lowerCAmelCase__			:Any											=							AutoModelForSeqaSeqLM.from_pretrained(__UpperCAmelCase      )

           self.assertFalse(
               any('BetterTransformer' in mod.__class__.__name__ for _, mod in model_reloaded.named_modules()      )      )

           lowerCAmelCase__			:Union[str, Any]											=							model_reloaded.generate(**__UpperCAmelCase      )
           self.assertTrue(torch.allclose(__UpperCAmelCase    , __UpperCAmelCase      )      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:int											=							'hf-internal-testing/tiny-random-t5'
         lowerCAmelCase__			:Union[str, Any]											=							AutoModelForSeqaSeqLM.from_pretrained(__UpperCAmelCase      )

         lowerCAmelCase__			:str											=							model.to_bettertransformer()

         with tempfile.TemporaryDirectory() as tmpdirname:
           with self.assertRaises(__UpperCAmelCase      ):
             model.save_pretrained(__UpperCAmelCase      )

           lowerCAmelCase__			:Optional[int]											=							model.reverse_bettertransformer()
           model.save_pretrained(__UpperCAmelCase      )
