
"""simple docstring"""
from __future__ import annotations

import unittest

from transformers import LEDConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

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


if is_tf_available():
    import tensorflow as tf

    from transformers import TFLEDForConditionalGeneration, TFLEDModel
@require_tf
class 			UpperCamelCase      :
     A__      =			LEDConfig
     A__      =			{}
     A__      =			"""gelu"""
     def __init__(     self  ,     snake_case__  ,     snake_case__=13  ,     snake_case__=7  ,     snake_case__=True  ,     snake_case__=False  ,     snake_case__=99  ,     snake_case__=32  ,     snake_case__=2  ,     snake_case__=4  ,     snake_case__=37  ,     snake_case__=0.1  ,     snake_case__=0.1  ,     snake_case__=20  ,     snake_case__=2  ,     snake_case__=1  ,     snake_case__=0  ,     snake_case__=4  ,     ):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				str							    = parent
       _SCREAMING_SNAKE_CASE   :				Any							    = batch_size
       _SCREAMING_SNAKE_CASE   :				List[str]							    = seq_length
       _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = is_training
       _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = use_labels
       _SCREAMING_SNAKE_CASE   :				List[str]							    = vocab_size
       _SCREAMING_SNAKE_CASE   :				Optional[int]							    = hidden_size
       _SCREAMING_SNAKE_CASE   :				List[Any]							    = num_hidden_layers
       _SCREAMING_SNAKE_CASE   :				Optional[int]							    = num_attention_heads
       _SCREAMING_SNAKE_CASE   :				Optional[int]							    = intermediate_size

       _SCREAMING_SNAKE_CASE   :				List[str]							    = hidden_dropout_prob
       _SCREAMING_SNAKE_CASE   :				Any							    = attention_probs_dropout_prob
       _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = max_position_embeddings
       _SCREAMING_SNAKE_CASE   :				int							    = eos_token_id
       _SCREAMING_SNAKE_CASE   :				Dict							    = pad_token_id
       _SCREAMING_SNAKE_CASE   :				List[Any]							    = bos_token_id
       _SCREAMING_SNAKE_CASE   :				str							    = attention_window

       # `ModelTesterMixin.test_attention_outputs` is expecting attention tensors to be of size
       # [num_attention_heads, encoder_seq_length, encoder_key_length], but TFLongformerSelfAttention
       # returns attention of shape [num_attention_heads, encoder_seq_length, self.attention_window + 1]
       # because its local attention only attends to `self.attention_window` and one before and one after
       _SCREAMING_SNAKE_CASE   :				str							    = self.attention_window + 2

       # because of padding `encoder_seq_length`, is different from `seq_length`. Relevant for
       # the `test_attention_outputs` and `test_hidden_states_output` tests
       _SCREAMING_SNAKE_CASE   :				Dict							    = (
           self.seq_length + (self.attention_window - self.seq_length % self.attention_window) % self.attention_window
       )
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				List[str]							    = ids_tensor([self.batch_size, self.seq_length - 1]  ,     self.vocab_size				)
       _SCREAMING_SNAKE_CASE   :				Optional[int]							    = tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size				)  ,     1				)
       _SCREAMING_SNAKE_CASE   :				Any							    = tf.concat([input_ids, eos_tensor]  ,     axis=1				)

       _SCREAMING_SNAKE_CASE   :				List[Any]							    = ids_tensor([self.batch_size, self.seq_length]  ,     self.vocab_size				)

       _SCREAMING_SNAKE_CASE   :				Optional[int]							    = self.config_cls(
           vocab_size=self.vocab_size  ,     d_model=self.hidden_size  ,     encoder_layers=self.num_hidden_layers  ,     decoder_layers=self.num_hidden_layers  ,     encoder_attention_heads=self.num_attention_heads  ,     decoder_attention_heads=self.num_attention_heads  ,     encoder_ffn_dim=self.intermediate_size  ,     decoder_ffn_dim=self.intermediate_size  ,     dropout=self.hidden_dropout_prob  ,     attention_dropout=self.attention_probs_dropout_prob  ,     max_position_embeddings=self.max_position_embeddings  ,     eos_token_ids=[2]  ,     bos_token_id=self.bos_token_id  ,     pad_token_id=self.pad_token_id  ,     decoder_start_token_id=self.pad_token_id  ,     attention_window=self.attention_window  ,     **self.config_updates  ,     )
       _SCREAMING_SNAKE_CASE   :				List[Any]							    = prepare_led_inputs_dict(snake_case__  ,     snake_case__  ,     snake_case__				)
       _SCREAMING_SNAKE_CASE   :				Any							    = tf.concat(
           [tf.zeros_like(snake_case__				)[:, :-1], tf.ones_like(snake_case__				)[:, -1:]]  ,     axis=-1  ,     )
       _SCREAMING_SNAKE_CASE   :				str							    = global_attention_mask
       return config, inputs_dict




     def 				__SCREAMING_SNAKE_CASE							(     self  ,     snake_case__  ,     snake_case__				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = TFLEDModel(config=snake_case__				).get_decoder()
       _SCREAMING_SNAKE_CASE   :				List[Any]							    = inputs_dict["input_ids"]

       _SCREAMING_SNAKE_CASE   :				List[Any]							    = input_ids[:1, :]
       _SCREAMING_SNAKE_CASE   :				Optional[int]							    = inputs_dict["attention_mask"][:1, :]
       _SCREAMING_SNAKE_CASE   :				Dict							    = 1

       # first forward pass
       _SCREAMING_SNAKE_CASE   :				Dict							    = model(snake_case__  ,     attention_mask=snake_case__  ,     use_cache=snake_case__				)

       _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = outputs.to_tuple()

       # create hypothetical next token and extent to next_input_ids
       _SCREAMING_SNAKE_CASE   :				Dict							    = ids_tensor((self.batch_size, 3)  ,     config.vocab_size				)
       _SCREAMING_SNAKE_CASE   :				Tuple							    = tf.cast(ids_tensor((self.batch_size, 3)  ,     2				)  ,     tf.inta				)

       # append to next input_ids and
       _SCREAMING_SNAKE_CASE   :				Dict							    = tf.concat([input_ids, next_tokens]  ,     axis=-1				)
       _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = tf.concat([attention_mask, next_attn_mask]  ,     axis=-1				)

       _SCREAMING_SNAKE_CASE   :				Dict							    = model(snake_case__  ,     attention_mask=snake_case__				)[0]
       _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = model(snake_case__  ,     attention_mask=snake_case__  ,     past_key_values=snake_case__				)[0]

       self.parent.assertEqual(next_tokens.shape[1]  ,     output_from_past.shape[1]				)

       # select random slice
       _SCREAMING_SNAKE_CASE   :				str							    = int(ids_tensor((1,)  ,     output_from_past.shape[-1]				)				)
       _SCREAMING_SNAKE_CASE   :				List[Any]							    = output_from_no_past[:, -3:, random_slice_idx]
       _SCREAMING_SNAKE_CASE   :				Optional[int]							    = output_from_past[:, :, random_slice_idx]

       # test that outputs are equal for slice
       tf.debugging.assert_near(snake_case__  ,     snake_case__  ,     rtol=1E-3				)





def    _lowerCAmelCase    (     lowerCamelCase__							:							Tuple,						lowerCamelCase__							:							Optional[Any],						lowerCamelCase__							:							Any,						lowerCamelCase__							:							Optional[Any]=None,						lowerCamelCase__							:							int=None,						lowerCamelCase__							:							Dict=None,						lowerCamelCase__							:							str=None,						)  ->    List[str]:
  if attention_mask is None:
    _SCREAMING_SNAKE_CASE   :				int							    = tf.cast(tf.math.not_equal(lowerCamelCase__,						config.pad_token_id				),						tf.inta				)
  if decoder_attention_mask is None:
    _SCREAMING_SNAKE_CASE   :				int							    = tf.concat(
        [
            tf.ones(decoder_input_ids[:, :1].shape,						dtype=tf.inta				),
            tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:],						config.pad_token_id				),						tf.inta				),
        ],						axis=-1,						)
  if head_mask is None:
    _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = tf.ones((config.encoder_layers, config.encoder_attention_heads)				)
  if decoder_head_mask is None:
    _SCREAMING_SNAKE_CASE   :				Optional[int]							    = tf.ones((config.decoder_layers, config.decoder_attention_heads)				)
  return {
      "input_ids": input_ids,
      "attention_mask": attention_mask,
      "decoder_input_ids": decoder_input_ids,
      "decoder_attention_mask": decoder_attention_mask,
      "head_mask": head_mask,
      "decoder_head_mask": decoder_head_mask,
  }
@require_tf
class 			UpperCamelCase      (							__SCREAMING_SNAKE_CASE      ,       __SCREAMING_SNAKE_CASE      ,       unittest.TestCase  ):
     A__      =			(TFLEDForConditionalGeneration, TFLEDModel) if is_tf_available() else ()
     A__      =			(TFLEDForConditionalGeneration,) if is_tf_available() else ()
     A__      =			(
         {
             """conversational""": TFLEDForConditionalGeneration,
             """feature-extraction""": TFLEDModel,
             """summarization""": TFLEDForConditionalGeneration,
             """text2text-generation""": TFLEDForConditionalGeneration,
             """translation""": TFLEDForConditionalGeneration,
         }
         if is_tf_available()
         else {}
     )
     A__      =			True
     A__      =			False
     A__      =			False
     A__      =			False
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = TFLEDModelTester(self				)
       _SCREAMING_SNAKE_CASE   :				Tuple							    = ConfigTester(self  ,     config_class=snake_case__				)
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       self.config_tester.run_common_tests()
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				str							    = self.model_tester.prepare_config_and_inputs_for_common()
       self.model_tester.check_decoder_model_past_large_inputs(*snake_case__				)
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Optional[int]							    = self.model_tester.prepare_config_and_inputs_for_common()
       _SCREAMING_SNAKE_CASE   :				int							    = tf.zeros_like(inputs_dict["attention_mask"]				)
       _SCREAMING_SNAKE_CASE   :				str							    = 2
       _SCREAMING_SNAKE_CASE   :				Tuple							    = tf.where(
           tf.range(self.model_tester.seq_length				)[None, :] < num_global_attn_indices  ,     1  ,     inputs_dict["global_attention_mask"]  ,     )

       _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = True
       _SCREAMING_SNAKE_CASE   :				List[str]							    = self.model_tester.seq_length
       _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = self.model_tester.encoder_seq_length

       def check_decoder_attentions_output(snake_case__				):
         _SCREAMING_SNAKE_CASE   :				Dict							    = outputs.decoder_attentions
         self.assertEqual(len(snake_case__				)  ,     self.model_tester.num_hidden_layers				)
         self.assertListEqual(
             list(decoder_attentions[0].shape[-3:]				)  ,     [self.model_tester.num_attention_heads, seq_length, seq_length]  ,     )

       def check_encoder_attentions_output(snake_case__				):
         _SCREAMING_SNAKE_CASE   :				str							    = [t.numpy() for t in outputs.encoder_attentions]
         _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = [t.numpy() for t in outputs.encoder_global_attentions]
         self.assertEqual(len(snake_case__				)  ,     self.model_tester.num_hidden_layers				)
         self.assertEqual(len(snake_case__				)  ,     self.model_tester.num_hidden_layers				)
         self.assertListEqual(
             list(attentions[0].shape[-3:]				)  ,     [self.model_tester.num_attention_heads, seq_length, seq_length]  ,     )
         self.assertListEqual(
             list(global_attentions[0].shape[-3:]				)  ,     [self.model_tester.num_attention_heads, encoder_seq_length, num_global_attn_indices]  ,     )

       for model_class in self.all_model_classes:
         _SCREAMING_SNAKE_CASE   :				Dict							    = True
         _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = False
         _SCREAMING_SNAKE_CASE   :				Optional[int]							    = False
         _SCREAMING_SNAKE_CASE   :				List[Any]							    = model_class(snake_case__				)
         _SCREAMING_SNAKE_CASE   :				List[str]							    = model(self._prepare_for_class(snake_case__  ,     snake_case__				)				)
         _SCREAMING_SNAKE_CASE   :				int							    = len(snake_case__				)
         self.assertEqual(config.output_hidden_states  ,     snake_case__				)
         check_encoder_attentions_output(snake_case__				)

         if self.is_encoder_decoder:
           _SCREAMING_SNAKE_CASE   :				List[str]							    = model_class(snake_case__				)
           _SCREAMING_SNAKE_CASE   :				str							    = model(self._prepare_for_class(snake_case__  ,     snake_case__				)				)
           self.assertEqual(config.output_hidden_states  ,     snake_case__				)
           check_decoder_attentions_output(snake_case__				)

         # Check that output attentions can also be changed via the config
         del inputs_dict["output_attentions"]
         _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = True
         _SCREAMING_SNAKE_CASE   :				Tuple							    = model_class(snake_case__				)
         _SCREAMING_SNAKE_CASE   :				Any							    = model(self._prepare_for_class(snake_case__  ,     snake_case__				)				)
         self.assertEqual(config.output_hidden_states  ,     snake_case__				)
         check_encoder_attentions_output(snake_case__				)

         # Check attention is always last and order is fine
         _SCREAMING_SNAKE_CASE   :				Tuple							    = True
         _SCREAMING_SNAKE_CASE   :				str							    = True
         _SCREAMING_SNAKE_CASE   :				int							    = model_class(snake_case__				)
         _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = model(self._prepare_for_class(snake_case__  ,     snake_case__				)				)

         self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1)  ,     len(snake_case__				)				)
         self.assertEqual(model.config.output_hidden_states  ,     snake_case__				)
         check_encoder_attentions_output(snake_case__				)
     @unittest.skip("LED keeps using potentially symbolic tensors in conditionals and breaks tracing."				)
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       pass




     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       pass





def    _lowerCAmelCase    (     lowerCamelCase__							:							str				)  ->    Union[str, Any]:
  return tf.constant(lowerCamelCase__,						dtype=tf.intaa				)


lowercase_       :						int     					=	1e-4





@slow
@require_tf
class 			UpperCamelCase      (							unittest.TestCase  ):
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Tuple							    = TFLEDForConditionalGeneration.from_pretrained("allenai/led-base-16384"				).led

       # change to intended input here
       _SCREAMING_SNAKE_CASE   :				Optional[int]							    = _long_tensor([512 * [0, 31414, 232, 328, 740, 1140, 12695, 69]]				)
       _SCREAMING_SNAKE_CASE   :				Tuple							    = _long_tensor([128 * [0, 31414, 232, 328, 740, 1140, 12695, 69]]				)
       _SCREAMING_SNAKE_CASE   :				List[str]							    = prepare_led_inputs_dict(model.config  ,     snake_case__  ,     snake_case__				)
       _SCREAMING_SNAKE_CASE   :				Dict							    = model(**snake_case__				)[0]
       _SCREAMING_SNAKE_CASE   :				int							    = (1, 1024, 768)
       self.assertEqual(output.shape  ,     snake_case__				)
       # change to expected output here
       _SCREAMING_SNAKE_CASE   :				Dict							    = tf.convert_to_tensor(
           [[2.3_050, 2.8_279, 0.6_531], [-1.8_457, -0.1_455, -3.5_661], [-1.0_186, 0.4_586, -2.2_043]]  ,     )
       tf.debugging.assert_near(output[:, :3, :3]  ,     snake_case__  ,     atol=1E-3				)




     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				List[str]							    = TFLEDForConditionalGeneration.from_pretrained("allenai/led-base-16384"				)

       # change to intended input here
       _SCREAMING_SNAKE_CASE   :				List[str]							    = _long_tensor([512 * [0, 31414, 232, 328, 740, 1140, 12695, 69]]				)
       _SCREAMING_SNAKE_CASE   :				str							    = _long_tensor([128 * [0, 31414, 232, 328, 740, 1140, 12695, 69]]				)
       _SCREAMING_SNAKE_CASE   :				str							    = prepare_led_inputs_dict(model.config  ,     snake_case__  ,     snake_case__				)
       _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = model(**snake_case__				)[0]
       _SCREAMING_SNAKE_CASE   :				str							    = (1, 1024, model.config.vocab_size)
       self.assertEqual(output.shape  ,     snake_case__				)
       # change to expected output here
       _SCREAMING_SNAKE_CASE   :				int							    = tf.convert_to_tensor(
           [[33.6_507, 6.4_572, 16.8_089], [5.8_739, -2.4_238, 11.2_902], [-3.2_139, -4.3_149, 4.2_783]]  ,     )
       tf.debugging.assert_near(output[:, :3, :3]  ,     snake_case__  ,     atol=1E-3  ,     rtol=1E-3				)





"""simple docstring"""
def    _lowerCAmelCase    (     lowerCamelCase__							:							str,						lowerCamelCase__							:							str				)  ->    Union[str, 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    _lowerCAmelCase    (     lowerCamelCase__							:							Dict,						lowerCamelCase__							:							Any				)  ->    List[str]:
  _SCREAMING_SNAKE_CASE   :				List[Any]							    = [[float("inf"				) for _ in range(lowerCamelCase__				)] for _ in range(lowerCamelCase__				)]

  for i in range(lowerCamelCase__				):
    for j in range(lowerCamelCase__				):
      _SCREAMING_SNAKE_CASE   :				List[Any]							    = 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]
        ):
          _SCREAMING_SNAKE_CASE   :				List[Any]							    = dist[i][k] + dist[k][j]

  _print_dist(lowerCamelCase__,						lowerCamelCase__				)
  return dist, v


if __name__ == "__main__":
      lowercase_       :						Tuple     					=	int(input('''Enter number of vertices: '''))
      lowercase_       :						List[Any]     					=	int(input('''Enter number of edges: '''))

      lowercase_       :						Optional[Any]     					=	[[float('''inf''') for i in range(v)] for j in range(v)]

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



