






"""simple docstring"""




from __future__ import annotations

import os
import tempfile
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import is_tensorflow_text_available, is_tf_available
from transformers.testing_utils import require_tensorflow_text, require_tf, slow

from ..test_modeling_tf_common import floats_tensor
from .test_framework_agnostic import GenerationIntegrationTestsMixin


if is_tf_available():
 import tensorflow as tf

 from transformers import (
     AutoTokenizer,
     TFAutoModelForCausalLM,
     TFAutoModelForSeqaSeqLM,
     TFAutoModelForSpeechSeqaSeq,
     TFAutoModelForVisionaSeq,
     TFBartForConditionalGeneration,
     TFLogitsProcessorList,
     TFMinLengthLogitsProcessor,
     tf_top_k_top_p_filtering,
 )

if is_tensorflow_text_available():
 import tensorflow_text as text






@require_tf
class        UpperCamelCase			(	unittest.TestCase      ):


 def _lowercase	(     self		:						Optional[Any]							)					->       Dict:
   _a  :       List[str]             =	tf.convert_to_tensor(
       [
           [
               8.2_2_2_0_9_9_1,  # 3rd highest value; idx. 0
               -0.5_6_2_0_0_4_4,
               5.2_3_2_2_9_7_5_2,
               4.0_3_8_6_3_9_3,
               -6.8_7_9_8_3_7_8,
               -0.5_4_7_8_5_8_0_2,
               -3.2_0_1_2_1_5_3,
               2.9_2_7_7_7_1_7_6,
               1.8_8_1_7_1_9_5_3,
               7.3_5_3_4_1_2_7_6,  # 5th highest value; idx. 9
               8.4_3_2_0_7_8_3_3,  # 2nd highest value; idx. 10
               -9.8_5_7_1_1_8_3_6,
               -5.9_6_2_0_9_2_3_6,
               -1.1_3_0_3_9_1_6_1,
               -7.1_1_1_5_2_9_4,
               -0.8_3_6_9_6_3_3,
               -5.3_1_8_6_4_0_8,
               7.0_6_4_2_7_4_0_7,
               0.8_1_3_6_9_3_4_4,
               -0.8_2_0_2_3_8_1_7,
               -5.9_1_7_9_7_9_6,
               0.5_8_8_1_3_4_4_3,
               -6.9_9_7_7_8_4_3_8,
               4.7_1_5_5_1_1_8_9,
               -0.1_8_7_7_1_6_3_7,
               7.4_4_0_2_0_7_5_9,  # 4th highest value; idx. 25
               9.3_8_4_5_0_9_8_7,  # 1st highest value; idx. 26
               2.1_2_6_6_2_9_4_1,
               -9.3_2_5_6_2_0_3_8,
               2.3_5_6_5_2_5_2_2,
           ],  # cummulative prob of 5 highest values <= 0.6
           [
               0.5_8_4_2_5_5_1_8,
               4.5_3_1_3_9_2_3_8,
               -5.5_7_5_1_0_4_6_4,
               -6.2_8_0_3_0_6_9_9,
               -7.1_9_5_2_9_5_0_3,
               -4.0_2_1_2_2_5_5_1,
               1.3_9_3_3_7_0_3_7,
               -6.0_6_7_0_7_0_5_7,
               1.5_9_4_8_0_5_1_7,
               -9.6_4_3_1_1_9,
               0.0_3_9_0_7_7_9_9,
               0.6_7_2_3_1_7_6_2,
               -8.8_8_2_0_6_7_2_6,
               6.2_7_1_1_5_9_2_2,  # 4th highest value; idx. 13
               2.2_8_5_2_0_7_2_3,
               4.8_2_7_6_7_5_0_6,
               4.3_0_4_2_1_3_6_8,
               8.8_2_7_5_3_1_3,  # 2nd highest value; idx. 17
               5.4_4_0_2_9_9_5_8,  # 5th highest value; idx. 18
               -4.4_7_3_5_7_9_4,
               7.3_8_5_7_9_5_3_6,  # 3rd highest value; idx. 20
               -2.9_1_0_5_1_6_6_3,
               2.6_1_9_4_6_0_7_7,
               -2.5_6_7_4_7_6_2,
               -9.4_8_9_5_9_3_0_2,
               -4.0_2_9_2_2_6_4_5,
               -1.3_5_4_1_6_9_1_8,
               9.6_7_7_0_2_3_2_3,  # 1st highest value; idx. 27
               -5.8_9_4_7_8_5_5_3,
               1.8_5_3_7_0_4_6_7,
           ],  # cummulative prob of 5 highest values <= 0.6
       ]							,						dtype=tf.floataa							,						)

   _a  :       str             =	tf.convert_to_tensor(
       [[0, 0], [0, 9], [0, 10], [0, 25], [0, 26], [1, 13], [1, 17], [1, 18], [1, 20], [1, 27]]							,						dtype=tf.intaa							,						)  # expected non filtered idx as noted above

   _a  :       Optional[int]             =	tf.convert_to_tensor(
       [8.2_2_2_0_9_9, 7.3_5_3_4_1_2_6, 8.4_3_2_0_7_8, 7.4_4_0_2_0_7_5, 9.3_8_4_5_1, 6.2_7_1_1_5_9, 8.8_2_7_5_3_1, 5.4_4_0_2_9_9_5, 7.3_8_5_7_9_5_6, 9.6_7_7_0_2_3]							,						dtype=tf.floataa							,						)  # expected non filtered values as noted above

   _a  :       int             =	tf_top_k_top_p_filtering(UpperCAmelCase__							,						top_k=10							,						top_p=0.6							,						min_tokens_to_keep=4							)

   _a  :       int             =	output[output != -float("""inf"""							)]
   _a  :       Any             =	tf.cast(
       tf.where(tf.not_equal(UpperCAmelCase__							,						tf.constant(-float("""inf"""							)							,						dtype=tf.floataa							)							)							)							,						dtype=tf.intaa							,						)

   tf.debugging.assert_near(UpperCAmelCase__							,						UpperCAmelCase__							,						rtol=1E-12							)
   tf.debugging.assert_equal(UpperCAmelCase__							,						UpperCAmelCase__							)







@require_tf
class        UpperCamelCase			(	unittest.TestCase		,     __UpperCAmelCase      ):
 # setting framework_dependent_parameters needs to be gated, just like its contents' imports
 if is_tf_available():
  UpperCamelCase					:       Optional[Any]			=					{
      'AutoModelForCausalLM': TFAutoModelForCausalLM,
      'AutoModelForSpeechSeq2Seq': TFAutoModelForSpeechSeqaSeq,
      'AutoModelForSeq2SeqLM': TFAutoModelForSeqaSeqLM,
      'AutoModelForVision2Seq': TFAutoModelForVisionaSeq,
      'LogitsProcessorList': TFLogitsProcessorList,
      'MinLengthLogitsProcessor': TFMinLengthLogitsProcessor,
      'create_tensor_fn': tf.convert_to_tensor,
      'floats_tensor': floats_tensor,
      'return_tensors': 'tf',
  }


 @slow
 def _lowercase	(     self		:						Optional[Any]							)					->       Optional[Any]:
   # TF-only test: tf.saved_model export
   _a  :       Any             =	TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""							)
   _a  :       List[Any]             =	2
   _a  :       Optional[Any]             =	2






   class        UpperCamelCase			(	tf.Module      ):


    def __init__(     self		:						Optional[int]							,						UpperCAmelCase__		:						Tuple							)					->       Any:
      super(UpperCAmelCase__							,						self							).__init__()
      _a  :       List[str]             =	model







    @tf.function(
        input_signature=(
            tf.TensorSpec((None, input_length)							,						tf.intaa							,						name="""input_ids"""							),
            tf.TensorSpec((None, input_length)							,						tf.intaa							,						name="""attention_mask"""							),
        )							,						jit_compile=UpperCAmelCase__							,						)
    def _lowercase	(     self		:						str							,						UpperCAmelCase__		:						Union[str, Any]							,						UpperCAmelCase__		:						Dict							)					->       List[str]:
      _a  :       Union[str, Any]             =	self.model.generate(
          input_ids=UpperCAmelCase__							,						attention_mask=UpperCAmelCase__							,						max_new_tokens=UpperCAmelCase__							,						return_dict_in_generate=UpperCAmelCase__							,						)
      return {"sequences": outputs["sequences"]}







   _a  :       str             =	[[2, 0], [102, 103]]
   _a  :       Tuple             =	[[1, 0], [1, 1]]
   _a  :       List[str]             =	DummyModel(model=UpperCAmelCase__							)
   with tempfile.TemporaryDirectory() as tmp_dir:
     tf.saved_model.save(UpperCAmelCase__							,						UpperCAmelCase__							,						signatures={"""serving_default""": dummy_model.serving}							)
     _a  :       str             =	tf.saved_model.load(UpperCAmelCase__							).signatures["""serving_default"""]
     for batch_size in range(1							,						len(UpperCAmelCase__							) + 1							):
       _a  :       List[Any]             =	{
           """input_ids""": tf.constant(dummy_input_ids[:batch_size]							),
           """attention_mask""": tf.constant(dummy_attention_masks[:batch_size]							),
       }
       _a  :       Tuple             =	serving_func(**UpperCAmelCase__							)["""sequences"""]
       _a  :       Any             =	test_model.generate(**UpperCAmelCase__							,						max_new_tokens=UpperCAmelCase__							)
       tf.debugging.assert_equal(UpperCAmelCase__							,						UpperCAmelCase__							)


 @slow
 def _lowercase	(     self		:						Dict							)					->       List[str]:
   # TF-only test: tf.saved_model export
   _a  :       List[str]             =	TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""							)
   _a  :       Union[str, Any]             =	1
   _a  :       Optional[int]             =	2






   class        UpperCamelCase			(	tf.Module      ):


    def __init__(     self		:						List[Any]							,						UpperCAmelCase__		:						List[str]							)					->       List[str]:
      super(UpperCAmelCase__							,						self							).__init__()
      _a  :       Tuple             =	model







    @tf.function(
        input_signature=(
            tf.TensorSpec((batch_size, None)							,						tf.intaa							,						name="""input_ids"""							),
            tf.TensorSpec((batch_size, None)							,						tf.intaa							,						name="""attention_mask"""							),
        )							,						jit_compile=UpperCAmelCase__							,						)
    def _lowercase	(     self		:						int							,						UpperCAmelCase__		:						int							,						UpperCAmelCase__		:						str							)					->       List[str]:
      _a  :       Dict             =	self.model.generate(
          input_ids=UpperCAmelCase__							,						attention_mask=UpperCAmelCase__							,						max_new_tokens=UpperCAmelCase__							,						return_dict_in_generate=UpperCAmelCase__							,						)
      return {"sequences": outputs["sequences"]}







   _a  :       int             =	[[2], [102, 103]]
   _a  :       Dict             =	[[1], [1, 1]]
   _a  :       Tuple             =	DummyModel(model=UpperCAmelCase__							)
   with tempfile.TemporaryDirectory() as tmp_dir:
     tf.saved_model.save(UpperCAmelCase__							,						UpperCAmelCase__							,						signatures={"""serving_default""": dummy_model.serving}							)
     _a  :       Union[str, Any]             =	tf.saved_model.load(UpperCAmelCase__							).signatures["""serving_default"""]
     for input_row in range(len(UpperCAmelCase__							)							):
       _a  :       Union[str, Any]             =	{
           """input_ids""": tf.constant([dummy_input_ids[input_row]]							),
           """attention_mask""": tf.constant([dummy_attention_masks[input_row]]							),
       }
       _a  :       Optional[Any]             =	serving_func(**UpperCAmelCase__							)["""sequences"""]
       _a  :       int             =	test_model.generate(**UpperCAmelCase__							,						max_new_tokens=UpperCAmelCase__							)
       tf.debugging.assert_equal(UpperCAmelCase__							,						UpperCAmelCase__							)


 @slow
 @require_tensorflow_text
 def _lowercase	(     self		:						Union[str, Any]							)					->       List[Any]:
   # TF-only test: tf.saved_model export
   with tempfile.TemporaryDirectory() as tmp_dir:
     # file needed to load the TF tokenizer
     hf_hub_download(repo_id="""google/flan-t5-small"""							,						filename="""spiece.model"""							,						local_dir=UpperCAmelCase__							)






     class        UpperCamelCase			(	tf.keras.layers.Layer      ):


      def __init__(     self		:						Union[str, Any]							)					->       int:
        super().__init__()
        _a  :       Any             =	text.SentencepieceTokenizer(
            model=tf.io.gfile.GFile(os.path.join(UpperCAmelCase__							,						"""spiece.model"""							)							,						"""rb"""							).read()							)
        _a  :       List[Any]             =	TFAutoModelForSeqaSeqLM.from_pretrained("""hf-internal-testing/tiny-random-t5"""							)







      def _lowercase	(     self		:						str							,						UpperCAmelCase__		:						Union[str, Any]							,						*UpperCAmelCase__		:						Optional[Any]							,						**UpperCAmelCase__		:						Any							)					->       Tuple:
        _a  :       Optional[Any]             =	self.tokenizer.tokenize(UpperCAmelCase__							)
        _a  :       int             =	text.pad_model_inputs(
            UpperCAmelCase__							,						max_seq_length=64							,						pad_value=self.model.config.pad_token_id							)
        _a  :       Dict             =	self.model.generate(input_ids=UpperCAmelCase__							,						attention_mask=UpperCAmelCase__							)
        return self.tokenizer.detokenize(UpperCAmelCase__							)







     _a  :       Optional[Any]             =	CompleteSentenceTransformer()
     _a  :       Union[str, Any]             =	tf.keras.layers.Input(shape=(1,)							,						dtype=tf.string							,						name="""inputs"""							)
     _a  :       Optional[int]             =	complete_model(UpperCAmelCase__							)
     _a  :       Union[str, Any]             =	tf.keras.Model(UpperCAmelCase__							,						UpperCAmelCase__							)
     keras_model.save(UpperCAmelCase__							)


 def _lowercase	(     self		:						Optional[Any]							)					->       Tuple:
   # Has PT equivalent: this test relies on random sampling
   _a  :       int             =	{
       """do_sample""": True,
       """num_beams""": 1,
       """top_p""": 0.7,
       """top_k""": 10,
       """temperature""": 0.7,
   }
   _a  :       List[str]             =	14

   _a  :       List[Any]             =	AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""							)
   _a  :       Tuple             =	"""Hello, my dog is cute and"""
   _a  :       str             =	tokenizer(UpperCAmelCase__							,						return_tensors="""tf"""							)
   _a  :       Any             =	TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""							)

   _a  :       Tuple             =	638
   # forces the generation to happen on CPU, to avoid GPU-related quirks
   with tf.device(""":/CPU:0"""							):
     tf.random.set_seed(0							)
     _a  :       Dict             =	model.generate(**UpperCAmelCase__							,						eos_token_id=UpperCAmelCase__							,						**UpperCAmelCase__							)
   self.assertTrue(expectation == len(generated_tokens[0]							)							)

   _a  :       Union[str, Any]             =	[638, 198]
   with tf.device(""":/CPU:0"""							):
     tf.random.set_seed(0							)
     _a  :       str             =	model.generate(**UpperCAmelCase__							,						eos_token_id=UpperCAmelCase__							,						**UpperCAmelCase__							)
   self.assertTrue(expectation == len(generated_tokens[0]							)							)







 def _lowercase	(     self		:						Optional[int]							)					->       List[str]:
   # Has PT equivalent: ample use of framework-specific code
   _a  :       List[Any]             =	AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bart"""							)
   _a  :       Tuple             =	"""Hugging Face is a technology company based in New York and Paris."""
   _a  :       List[Any]             =	bart_tokenizer(UpperCAmelCase__							,						return_tensors="""tf"""							).input_ids
   _a  :       Tuple             =	TFBartForConditionalGeneration.from_pretrained("""hf-internal-testing/tiny-random-bart"""							)
   _a  :       Union[str, Any]             =	bart_model.generate(UpperCAmelCase__							).numpy()






   class        UpperCamelCase			(	__UpperCAmelCase      ):


    def _lowercase	(     self		:						List[str]							,						UpperCAmelCase__		:						Any							,						UpperCAmelCase__		:						List[Any]=None							,						**UpperCAmelCase__		:						List[str]							)					->       Optional[int]:
      return super().call(UpperCAmelCase__							,						**UpperCAmelCase__							)







   _a  :       int             =	FakeBart.from_pretrained("""hf-internal-testing/tiny-random-bart"""							)
   _a  :       Any             =	bart_model.generate(UpperCAmelCase__							,						foo="""bar"""							).numpy()
   self.assertTrue(np.array_equal(UpperCAmelCase__							,						UpperCAmelCase__							)							)






   class        UpperCamelCase			(	bart_model.model.encoder.__class__      ):


    def _lowercase	(     self		:						Optional[int]							,						UpperCAmelCase__		:						str							,						**UpperCAmelCase__		:						Union[str, Any]							)					->       List[str]:
      return super().call(UpperCAmelCase__							,						**UpperCAmelCase__							)







   _a  :       str             =	FakeEncoder(bart_model.config							,						bart_model.model.shared							)
   _a  :       Dict             =	fake_encoder

   # Normal generation still works (the output will be different because the encoder weights are different)
   _a  :       Optional[Any]             =	bart_model.generate(UpperCAmelCase__							).numpy()
   with self.assertRaises(UpperCAmelCase__							):
     # FakeEncoder.call() accepts **kwargs -> no filtering -> value error due to unexpected input "foo"
     bart_model.generate(UpperCAmelCase__							,						foo="""bar"""							)






'''simple docstring'''




# Author: OMKAR PATHAK, Nwachukwu Chidiebere

# Use a Python dictionary to construct the graph.
from __future__ import annotations

from pprint import pformat
from typing import Generic, TypeVar

lowerCamelCase							:str				    =					TypeVar('''T''')







class 	_lowerCAmelCase							(			Generic[T] ):


	def __init__(self       ,      lowercase = True							):
				A_	:						dict[T, list[T]]	=     {}  # dictionary of lists
				A_	:						Any	=     directed


	def     _a	(self       ,      lowercase       ,      lowercase							):

				if not self.directed:  # For undirected graphs
							# if both source vertex and destination vertex are both present in the
							# adjacency list, add destination vertex to source vertex list of adjacent
							# vertices and add source vertex to destination vertex list of adjacent
							# vertices.
							if source_vertex in self.adj_list and destination_vertex in self.adj_list:
										self.adj_list[source_vertex].append(lowercase							)
										self.adj_list[destination_vertex].append(lowercase							)
							# if only source vertex is present in adjacency list, add destination vertex
							# to source vertex list of adjacent vertices, then create a new vertex with
							# destination vertex as key and assign a list containing the source vertex
							# as it's first adjacent vertex.
							elif source_vertex in self.adj_list:
										self.adj_list[source_vertex].append(lowercase							)
										A_	:						Dict	=     [source_vertex]
							# if only destination vertex is present in adjacency list, add source vertex
							# to destination vertex list of adjacent vertices, then create a new vertex
							# with source vertex as key and assign a list containing the source vertex
							# as it's first adjacent vertex.
							elif destination_vertex in self.adj_list:
										self.adj_list[destination_vertex].append(lowercase							)
										A_	:						int	=     [destination_vertex]
							# if both source vertex and destination vertex are not present in adjacency
							# list, create a new vertex with source vertex as key and assign a list
							# containing the destination vertex as it's first adjacent vertex also
							# create a new vertex with destination vertex as key and assign a list
							# containing the source vertex as it's first adjacent vertex.
							else:
										A_	:						Optional[Any]	=     [destination_vertex]
										A_	:						Tuple	=     [source_vertex]
				else:  # For directed graphs
							# if both source vertex and destination vertex are present in adjacency
							# list, add destination vertex to source vertex list of adjacent vertices.
							if source_vertex in self.adj_list and destination_vertex in self.adj_list:
										self.adj_list[source_vertex].append(lowercase							)
							# if only source vertex is present in adjacency list, add destination
							# vertex to source vertex list of adjacent vertices and create a new vertex
							# with destination vertex as key, which has no adjacent vertex
							elif source_vertex in self.adj_list:
										self.adj_list[source_vertex].append(lowercase							)
										A_	:						Tuple	=     []
							# if only destination vertex is present in adjacency list, create a new
							# vertex with source vertex as key and assign a list containing destination
							# vertex as first adjacent vertex
							elif destination_vertex in self.adj_list:
										A_	:						Tuple	=     [destination_vertex]
							# if both source vertex and destination vertex are not present in adjacency
							# list, create a new vertex with source vertex as key and a list containing
							# destination vertex as it's first adjacent vertex. Then create a new vertex
							# with destination vertex as key, which has no adjacent vertex
							else:
										A_	:						int	=     [destination_vertex]
										A_	:						List[str]	=     []

				return self


	def __repr__(self							):
				return pformat(self.adj_list							)