





"""simple docstring"""




from __future__ import annotations







def       A__							(   SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__)       ->   Union[str, Any]:
  print(F'''Vertex\tShortest Distance from vertex {src}''')
  for i, d in enumerate(SCREAMING_SNAKE_CASE__):
    print(F'''{i}\t\t{d}''')







def       A__							(   SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__)       ->   Optional[int]:
  for j in range(SCREAMING_SNAKE_CASE__):
    __snake_case:						List[str]			  =						(graph[j][k] for k in ["""src""", """dst""", """weight"""])
    if distance[u] != float("""inf""") and distance[u] + w < distance[v]:
      return True
  return False







def       A__							(   SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__)       ->   list[float]:
  __snake_case:						Any			  =						[float("""inf""")] * vertex_count
  __snake_case:						Any			  =						0.0

  for _ in range(vertex_count - 1):
    for j in range(SCREAMING_SNAKE_CASE__):
      __snake_case:						int			  =						(graph[j][k] for k in ["""src""", """dst""", """weight"""])

      if distance[u] != float("""inf""") and distance[u] + w < distance[v]:
        __snake_case:						Union[str, Any]			  =						distance[u] + w

  __snake_case:						Optional[Any]			  =						check_negative_cycle(SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__ , SCREAMING_SNAKE_CASE__)
  if negative_cycle_exists:
    raise Exception("""Negative cycle found""")

  return distance


if __name__ == "__main__":
      import doctest

      doctest.testmod()

      __UpperCAmelCase	:       Tuple    	=							int(input("Enter number of vertices: ").strip())
      __UpperCAmelCase	:       Dict    	=							int(input("Enter number of edges: ").strip())

      __UpperCAmelCase	:       list[dict[str, int]]    	=							[{} for _ in range(E)]

      for i in range(E):
            print("Edge ", i + 1)
            __UpperCAmelCase	:       Union[str, Any]    	=							(
                int(x)
                for x in input("Enter source, destination, weight: ").strip().split(" ")
            )
            __UpperCAmelCase	:       Tuple    	=							{"src": src, "dst": dest, "weight": weight}

      __UpperCAmelCase	:       Union[str, Any]    	=							int(input("\nEnter shortest path source:").strip())
      __UpperCAmelCase	:       Optional[Any]    	=							bellman_ford(graph, V, E, source)
      print_distance(shortest_distance, 0)













import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartaaTokenizer, MBartaaTokenizerFast, is_torch_available
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
    slow,
)

from ...test_tokenization_common import TokenizerTesterMixin


__UpperCAmelCase	:       str    	=							get_tests_dir("fixtures/test_sentencepiece.model")

if is_torch_available():
      from transformers.models.mbart.modeling_mbart import shift_tokens_right

__UpperCAmelCase	:       Any    	=							250_004
__UpperCAmelCase	:       List[str]    	=							250_020







@require_sentencepiece
@require_tokenizers
class    __snake_case	(							__lowerCamelCase       ,      unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					MBartaaTokenizer
       lowerCAmelCase__						=					MBartaaTokenizerFast
       lowerCAmelCase__						=					True
       lowerCAmelCase__						=					True




       def 							UpperCAmelCase__			(  self			:   Tuple		):
         super().setUp()

         # We have a SentencePiece fixture for testing
         __snake_case:						Optional[int]			  =						MBartaaTokenizer(A							,    src_lang="""en_XX"""							,    tgt_lang="""ro_RO"""							,    keep_accents=A		)
         tokenizer.save_pretrained(self.tmpdirname		)




       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         __snake_case:						Any			  =						"""<s>"""
         __snake_case:						Tuple			  =						0

         self.assertEqual(self.get_tokenizer()._convert_token_to_id(A		)							,    A		)
         self.assertEqual(self.get_tokenizer()._convert_id_to_token(A		)							,    A		)




       def 							UpperCAmelCase__			(  self			:   Any		):
         __snake_case:						Dict			  =						list(self.get_tokenizer().get_vocab().keys()		)

         self.assertEqual(vocab_keys[0]							,    """<s>"""		)
         self.assertEqual(vocab_keys[1]							,    """<pad>"""		)
         self.assertEqual(vocab_keys[-1]							,    """<mask>"""		)
         self.assertEqual(len(A		)							,    1_054		)




       def 							UpperCAmelCase__			(  self			:   Any		):
         self.assertEqual(self.get_tokenizer().vocab_size							,    1_054		)




       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         __snake_case:						Dict			  =						MBartaaTokenizer(A							,    src_lang="""en_XX"""							,    tgt_lang="""ro_RO"""							,    keep_accents=A		)

         __snake_case:						int			  =						tokenizer.tokenize("""This is a test"""		)
         self.assertListEqual(A							,    ["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]		)

         self.assertListEqual(
             tokenizer.convert_tokens_to_ids(A		)							,    [value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]							,    )

         __snake_case:						Union[str, Any]			  =						tokenizer.tokenize("""I was born in 92000, and this is falsé."""		)
         self.assertListEqual(
             A							,    [SPIECE_UNDERLINE + """I""", SPIECE_UNDERLINE + """was""", SPIECE_UNDERLINE + """b""", """or""", """n""", SPIECE_UNDERLINE + """in""", SPIECE_UNDERLINE + """""", """9""", """2""", """0""", """0""", """0""", """,""", SPIECE_UNDERLINE + """and""", SPIECE_UNDERLINE + """this""", SPIECE_UNDERLINE + """is""", SPIECE_UNDERLINE + """f""", """al""", """s""", """é""", """."""]							,    )
         __snake_case:						List[Any]			  =						tokenizer.convert_tokens_to_ids(A		)
         self.assertListEqual(
             A							,    [
                 value + tokenizer.fairseq_offset
                 for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
             ]							,    )

         __snake_case:						int			  =						tokenizer.convert_ids_to_tokens(A		)
         self.assertListEqual(
             A							,    [SPIECE_UNDERLINE + """I""", SPIECE_UNDERLINE + """was""", SPIECE_UNDERLINE + """b""", """or""", """n""", SPIECE_UNDERLINE + """in""", SPIECE_UNDERLINE + """""", """<unk>""", """2""", """0""", """0""", """0""", """,""", SPIECE_UNDERLINE + """and""", SPIECE_UNDERLINE + """this""", SPIECE_UNDERLINE + """is""", SPIECE_UNDERLINE + """f""", """al""", """s""", """<unk>""", """."""]							,    )




       @slow
       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         # fmt: off
         __snake_case:						List[str]			  =						{"""input_ids""": [[250_004, 11_062, 82_772, 7, 15, 82_772, 538, 51_529, 237, 17_198, 1_290, 206, 9, 215_175, 1_314, 136, 17_198, 1_290, 206, 9, 56_359, 42, 122_009, 9, 16_466, 16, 87_344, 4_537, 9, 4_717, 78_381, 6, 159_958, 7, 15, 24_480, 618, 4, 527, 22_693, 5_428, 4, 2_777, 24_480, 9_874, 4, 43_523, 594, 4, 803, 18_392, 33_189, 18, 4, 43_523, 24_447, 12_399, 100, 24_955, 83_658, 9_626, 144_057, 15, 839, 22_335, 16, 136, 24_955, 83_658, 83_479, 15, 39_102, 724, 16, 678, 645, 2_789, 1_328, 4_589, 42, 122_009, 115_774, 23, 805, 1_328, 46_876, 7, 136, 53_894, 1_940, 42_227, 41_159, 17_721, 823, 425, 4, 27_512, 98_722, 206, 136, 5_531, 4_970, 919, 17_336, 5, 2], [250_004, 20_080, 618, 83, 82_775, 47, 479, 9, 1_517, 73, 53_894, 333, 80_581, 110_117, 18_811, 5_256, 1_295, 51, 152_526, 297, 7_986, 390, 124_416, 538, 35_431, 214, 98, 15_044, 25_737, 136, 7_108, 43_701, 23, 756, 135_355, 7, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [250_004, 581, 63_773, 119_455, 6, 147_797, 88_203, 7, 645, 70, 21, 3_285, 10_269, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], """attention_mask""": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
         # fmt: on

         self.tokenizer_integration_test_util(
             expected_encoding=A							,    model_name="""facebook/mbart-large-50"""							,    revision="""d3913889c59cd5c9e456b269c376325eabad57e2"""							,    )






       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         if not self.test_slow_tokenizer:
           # as we don't have a slow version, we can't compare the outputs between slow and fast versions
           return

         __snake_case:						Any			  =						(self.rust_tokenizer_class, """hf-internal-testing/tiny-random-mbart50""", {})
         for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
           with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''		):
             __snake_case:						Optional[int]			  =						self.rust_tokenizer_class.from_pretrained(A							,    **A		)
             __snake_case:						Union[str, Any]			  =						self.tokenizer_class.from_pretrained(A							,    **A		)

             __snake_case:						List[str]			  =						tempfile.mkdtemp()

             __snake_case:						Tuple			  =						tokenizer_r.save_pretrained(A		)
             __snake_case:						Optional[int]			  =						tokenizer_p.save_pretrained(A		)

             # Checks it save with the same files + the tokenizer.json file for the fast one
             self.assertTrue(any("""tokenizer.json""" in f for f in tokenizer_r_files		)		)
             __snake_case:						Dict			  =						tuple(f for f in tokenizer_r_files if """tokenizer.json""" not in f		)
             self.assertSequenceEqual(A							,    A		)

             # Checks everything loads correctly in the same way
             __snake_case:						Tuple			  =						tokenizer_r.from_pretrained(A		)
             __snake_case:						Optional[Any]			  =						tokenizer_p.from_pretrained(A		)

             # Check special tokens are set accordingly on Rust and Python
             for key in tokenizer_pp.special_tokens_map:
               self.assertTrue(hasattr(A							,    A		)		)
               # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key))
               # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id"))

             shutil.rmtree(A		)

             # Save tokenizer rust, legacy_format=True
             __snake_case:						Tuple			  =						tempfile.mkdtemp()

             __snake_case:						Any			  =						tokenizer_r.save_pretrained(A							,    legacy_format=A		)
             __snake_case:						List[str]			  =						tokenizer_p.save_pretrained(A		)

             # Checks it save with the same files
             self.assertSequenceEqual(A							,    A		)

             # Checks everything loads correctly in the same way
             __snake_case:						List[Any]			  =						tokenizer_r.from_pretrained(A		)
             __snake_case:						Dict			  =						tokenizer_p.from_pretrained(A		)

             # Check special tokens are set accordingly on Rust and Python
             for key in tokenizer_pp.special_tokens_map:
               self.assertTrue(hasattr(A							,    A		)		)

             shutil.rmtree(A		)

             # Save tokenizer rust, legacy_format=False
             __snake_case:						List[str]			  =						tempfile.mkdtemp()

             __snake_case:						Any			  =						tokenizer_r.save_pretrained(A							,    legacy_format=A		)
             __snake_case:						Dict			  =						tokenizer_p.save_pretrained(A		)

             # Checks it saved the tokenizer.json file
             self.assertTrue(any("""tokenizer.json""" in f for f in tokenizer_r_files		)		)

             # Checks everything loads correctly in the same way
             __snake_case:						Any			  =						tokenizer_r.from_pretrained(A		)
             __snake_case:						Any			  =						tokenizer_p.from_pretrained(A		)

             # Check special tokens are set accordingly on Rust and Python
             for key in tokenizer_pp.special_tokens_map:
               self.assertTrue(hasattr(A							,    A		)		)

             shutil.rmtree(A		)







@require_torch
@require_sentencepiece
@require_tokenizers
class    __snake_case	(							unittest.TestCase      ):





       '''simple docstring'''







       lowerCAmelCase__						=					"""facebook/mbart-large-50-one-to-many-mmt"""
       lowerCAmelCase__						=					[
           """ UN Chief Says There Is No Military Solution in Syria""",
           """ Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.""",
       ]
       lowerCAmelCase__						=					[
           """Şeful ONU declară că nu există o soluţie militară în Siria""",
           """Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei"""
           """ pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor"""
           """ face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.""",
       ]
       lowerCAmelCase__						=					[EN_CODE, 82_74, 12_78_73, 2_59_16, 7, 86_22, 20_71, 4_38, 6_74_85, 53, 18_78_95, 23, 5_17_12, 2]




       @classmethod
       def 							UpperCAmelCase__			(  cls			:   int		):
         __snake_case:						MBartaaTokenizer			  =						MBartaaTokenizer.from_pretrained(
             cls.checkpoint_name							,    src_lang="""en_XX"""							,    tgt_lang="""ro_RO"""		)
         __snake_case:						str			  =						1
         return cls




       def 							UpperCAmelCase__			(  self			:   Any		):
         self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ar_AR"""]							,    250_001		)
         self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""en_EN"""]							,    250_004		)
         self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ro_RO"""]							,    250_020		)
         self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""mr_IN"""]							,    250_038		)




       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         __snake_case:						List[str]			  =						self.tokenizer.batch_encode_plus(self.src_text		).input_ids[0]
         self.assertListEqual(self.expected_src_tokens							,    A		)




       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         self.assertIn(A							,    self.tokenizer.all_special_ids		)
         __snake_case:						Dict			  =						[RO_CODE, 884, 9_019, 96, 9, 916, 86_792, 36, 18_743, 15_596, 5, 2]
         __snake_case:						str			  =						self.tokenizer.decode(A							,    skip_special_tokens=A		)
         __snake_case:						Union[str, Any]			  =						self.tokenizer.decode(generated_ids[1:]							,    skip_special_tokens=A		)
         self.assertEqual(A							,    A		)
         self.assertNotIn(self.tokenizer.eos_token							,    A		)




       def 							UpperCAmelCase__			(  self			:   Dict		):
         __snake_case:						List[str]			  =						["""this is gunna be a long sentence """ * 20]
         assert isinstance(src_text[0]							,    A		)
         __snake_case:						Union[str, Any]			  =						10
         __snake_case:						List[Any]			  =						self.tokenizer(A							,    max_length=A							,    truncation=A		).input_ids[0]
         self.assertEqual(ids[0]							,    A		)
         self.assertEqual(ids[-1]							,    2		)
         self.assertEqual(len(A		)							,    A		)




       def 							UpperCAmelCase__			(  self			:   Tuple		):
         self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["""<mask>""", """ar_AR"""]		)							,    [250_053, 250_001]		)




       def 							UpperCAmelCase__			(  self			:   List[Any]		):
         __snake_case:						List[Any]			  =						tempfile.mkdtemp()
         __snake_case:						Any			  =						self.tokenizer.fairseq_tokens_to_ids
         self.tokenizer.save_pretrained(A		)
         __snake_case:						Union[str, Any]			  =						MBartaaTokenizer.from_pretrained(A		)
         self.assertDictEqual(new_tok.fairseq_tokens_to_ids							,    A		)




       @require_torch
       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         __snake_case:						List[str]			  =						self.tokenizer(self.src_text							,    text_target=self.tgt_text							,    padding=A							,    return_tensors="""pt"""		)
         __snake_case:						List[Any]			  =						shift_tokens_right(batch["""labels"""]							,    self.tokenizer.pad_token_id		)

         # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
         assert batch.input_ids[1][0] == EN_CODE
         assert batch.input_ids[1][-1] == 2
         assert batch.labels[1][0] == RO_CODE
         assert batch.labels[1][-1] == 2
         assert batch.decoder_input_ids[1][:2].tolist() == [2, RO_CODE]




       @require_torch
       def 							UpperCAmelCase__			(  self			:   Optional[int]		):
         __snake_case:						int			  =						self.tokenizer(
             self.src_text							,    text_target=self.tgt_text							,    padding=A							,    truncation=A							,    max_length=len(self.expected_src_tokens		)							,    return_tensors="""pt"""							,    )
         __snake_case:						Optional[Any]			  =						shift_tokens_right(batch["""labels"""]							,    self.tokenizer.pad_token_id		)

         self.assertIsInstance(A							,    A		)

         self.assertEqual((2, 14)							,    batch.input_ids.shape		)
         self.assertEqual((2, 14)							,    batch.attention_mask.shape		)
         __snake_case:						List[str]			  =						batch.input_ids.tolist()[0]
         self.assertListEqual(self.expected_src_tokens							,    A		)
         self.assertEqual(2							,    batch.decoder_input_ids[0, 0]		)  # decoder_start_token_id
         # Test that special tokens are reset
         self.assertEqual(self.tokenizer.prefix_tokens							,    [EN_CODE]		)
         self.assertEqual(self.tokenizer.suffix_tokens							,    [self.tokenizer.eos_token_id]		)




       def 							UpperCAmelCase__			(  self			:   str		):
         __snake_case:						List[Any]			  =						self.tokenizer(self.src_text							,    padding=A							,    truncation=A							,    max_length=3							,    return_tensors="""pt"""		)
         __snake_case:						Union[str, Any]			  =						self.tokenizer(
             text_target=self.tgt_text							,    padding=A							,    truncation=A							,    max_length=10							,    return_tensors="""pt"""		)
         __snake_case:						Dict			  =						targets["""input_ids"""]
         __snake_case:						Any			  =						shift_tokens_right(A							,    self.tokenizer.pad_token_id		)

         self.assertEqual(batch.input_ids.shape[1]							,    3		)
         self.assertEqual(batch.decoder_input_ids.shape[1]							,    10		)






       @require_torch
       def 							UpperCAmelCase__			(  self			:   Union[str, Any]		):
         __snake_case:						int			  =						self.tokenizer._build_translation_inputs(
             """A test"""							,    return_tensors="""pt"""							,    src_lang="""en_XX"""							,    tgt_lang="""ar_AR"""		)

         self.assertEqual(
             nested_simplify(A		)							,    {
                 # en_XX, A, test, EOS
                 """input_ids""": [[250_004, 62, 3_034, 2]],
                 """attention_mask""": [[1, 1, 1, 1]],
                 # ar_AR
                 """forced_bos_token_id""": 250_001,
             }							,    )






