
'''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   a_ (      unittest.TestCase					):




			def 					lowerCAmelCase__					(       self	):
				a_      				=						tf.convert_to_tensor(
				    [
				        [
				            8.2_22_09_91,  # 3rd highest value; idx. 0
				            -0.5_62_00_44,
				            5.23_22_97_52,
				            4.0_38_63_93,
				            -6.8_79_83_78,
				            -0.54_78_58_02,
				            -3.2_01_21_53,
				            2.92_77_71_76,
				            1.88_17_19_53,
				            7.35_34_12_76,  # 5th highest value; idx. 9
				            8.43_20_78_33,  # 2nd highest value; idx. 10
				            -9.85_71_18_36,
				            -5.96_20_92_36,
				            -1.13_03_91_61,
				            -7.1_11_52_94,
				            -0.8_36_96_33,
				            -5.3_18_64_08,
				            7.06_42_74_07,
				            0.81_36_93_44,
				            -0.82_02_38_17,
				            -5.9_17_97_96,
				            0.58_81_34_43,
				            -6.99_77_84_38,
				            4.71_55_11_89,
				            -0.18_77_16_37,
				            7.44_02_07_59,  # 4th highest value; idx. 25
				            9.38_45_09_87,  # 1st highest value; idx. 26
				            2.12_66_29_41,
				            -9.32_56_20_38,
				            2.35_65_25_22,
				        ],  # cummulative prob of 5 highest values <= 0.6
				        [
				            0.58_42_55_18,
				            4.53_13_92_38,
				            -5.57_51_04_64,
				            -6.28_03_06_99,
				            -7.19_52_95_03,
				            -4.02_12_25_51,
				            1.39_33_70_37,
				            -6.06_70_70_57,
				            1.59_48_05_17,
				            -9.64_31_19,
				            0.03_90_77_99,
				            0.67_23_17_62,
				            -8.88_20_67_26,
				            6.27_11_59_22,  # 4th highest value; idx. 13
				            2.28_52_07_23,
				            4.82_76_75_06,
				            4.30_42_13_68,
				            8.8_27_53_13,  # 2nd highest value; idx. 17
				            5.44_02_99_58,  # 5th highest value; idx. 18
				            -4.4_73_57_94,
				            7.38_57_95_36,  # 3rd highest value; idx. 20
				            -2.91_05_16_63,
				            2.61_94_60_77,
				            -2.5_67_47_62,
				            -9.48_95_93_02,
				            -4.02_92_26_45,
				            -1.35_41_69_18,
				            9.67_70_23_23,  # 1st highest value; idx. 27
				            -5.89_47_85_53,
				            1.85_37_04_67,
				        ],  # cummulative prob of 5 highest values <= 0.6
				    ]					,   dtype=tf.floataa					,   )

				a_      				=						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_      				=						tf.convert_to_tensor(
				    [8.22_20_99, 7.3_53_41_26, 8.43_20_78, 7.4_40_20_75, 9.3_84_51, 6.27_11_59, 8.82_75_31, 5.4_40_29_95, 7.3_85_79_56, 9.67_70_23]					,   dtype=tf.floataa					,   )  # expected non filtered values as noted above

				a_      				=						tf_top_k_top_p_filtering(snake_case__					,   top_k=10					,   top_p=0.6					,   min_tokens_to_keep=4	)

				a_      				=						output[output != -float("""inf"""	)]
				a_      				=						tf.cast(
				    tf.where(tf.not_equal(snake_case__					,   tf.constant(-float("""inf"""	)					,   dtype=tf.floataa	)	)	)					,   dtype=tf.intaa					,   )

				tf.debugging.assert_near(snake_case__					,   snake_case__					,   rtol=1e-12	)
				tf.debugging.assert_equal(snake_case__					,   snake_case__	)







@require_tf
class   a_ (      unittest.TestCase		,  lowerCamelCase__					):






			if is_tf_available():
						lowerCamelCase__	:			Optional[int]       =    {
						    """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 					lowerCAmelCase__					(       self	):
				a_      				=						TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""	)
				a_      				=						2
				a_      				=						2







				class   a_ (      tf.Module					):




							def __init__(       self					,   UpperCAmelCase	):
								super(snake_case__					,   self	).__init__()
								a_      				=						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=snake_case__					,   )
							def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   UpperCAmelCase	):
								a_      				=						self.model.generate(
								    input_ids=snake_case__					,   attention_mask=snake_case__					,   max_new_tokens=snake_case__					,   return_dict_in_generate=snake_case__					,   )
								return {"sequences": outputs["sequences"]}







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




			@slow
			def 					lowerCAmelCase__					(       self	):
				a_      				=						TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""	)
				a_      				=						1
				a_      				=						2







				class   a_ (      tf.Module					):




							def __init__(       self					,   UpperCAmelCase	):
								super(snake_case__					,   self	).__init__()
								a_      				=						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=snake_case__					,   )
							def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   UpperCAmelCase	):
								a_      				=						self.model.generate(
								    input_ids=snake_case__					,   attention_mask=snake_case__					,   max_new_tokens=snake_case__					,   return_dict_in_generate=snake_case__					,   )
								return {"sequences": outputs["sequences"]}







				a_      				=						[[2], [1_02, 1_03]]
				a_      				=						[[1], [1, 1]]
				a_      				=						DummyModel(model=snake_case__	)
				with tempfile.TemporaryDirectory() as tmp_dir:
					tf.saved_model.save(snake_case__					,   snake_case__					,   signatures={"""serving_default""": dummy_model.serving}	)
					a_      				=						tf.saved_model.load(snake_case__	).signatures["""serving_default"""]
					for input_row in range(len(snake_case__	)	):
						a_      				=						{
						    """input_ids""": tf.constant([dummy_input_ids[input_row]]	),
						    """attention_mask""": tf.constant([dummy_attention_masks[input_row]]	),
						}
						a_      				=						serving_func(**snake_case__	)["""sequences"""]
						a_      				=						test_model.generate(**snake_case__					,   max_new_tokens=snake_case__	)
						tf.debugging.assert_equal(snake_case__					,   snake_case__	)




			@slow
			@require_tensorflow_text
			def 					lowerCAmelCase__					(       self	):
				# 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=snake_case__	)







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




								def __init__(       self	):
									super().__init__()
									a_      				=						text.SentencepieceTokenizer(
									    model=tf.io.gfile.GFile(os.path.join(snake_case__					,   """spiece.model"""	)					,   """rb"""	).read()	)
									a_      				=						TFAutoModelForSeqaSeqLM.from_pretrained("""hf-internal-testing/tiny-random-t5"""	)






								def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   *UpperCAmelCase					,   **UpperCAmelCase	):
									a_      				=						self.tokenizer.tokenize(snake_case__	)
									a_      				=						text.pad_model_inputs(
									    snake_case__					,   max_seq_length=64					,   pad_value=self.model.config.pad_token_id	)
									a_      				=						self.model.generate(input_ids=snake_case__					,   attention_mask=snake_case__	)
									return self.tokenizer.detokenize(snake_case__	)







					a_      				=						CompleteSentenceTransformer()
					a_      				=						tf.keras.layers.Input(shape=(1,)					,   dtype=tf.string					,   name="""inputs"""	)
					a_      				=						complete_model(snake_case__	)
					a_      				=						tf.keras.Model(snake_case__					,   snake_case__	)
					keras_model.save(snake_case__	)




			def 					lowerCAmelCase__					(       self	):
				a_      				=						{
				    """do_sample""": True,
				    """num_beams""": 1,
				    """top_p""": 0.7,
				    """top_k""": 10,
				    """temperature""": 0.7,
				}
				a_      				=						14

				a_      				=						AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""	)
				a_      				=						"""Hello, my dog is cute and"""
				a_      				=						tokenizer(snake_case__					,   return_tensors="""tf"""	)
				a_      				=						TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""	)

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

				a_      				=						[6_38, 1_98]
				with tf.device(""":/CPU:0"""	):
					tf.random.set_seed(0	)
					a_      				=						model.generate(**snake_case__					,   eos_token_id=snake_case__					,   **snake_case__	)
				self.assertTrue(expectation == len(generated_tokens[0]	)	)






			def 					lowerCAmelCase__					(       self	):
				a_      				=						AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bart"""	)
				a_      				=						"""Hugging Face is a technology company based in New York and Paris."""
				a_      				=						bart_tokenizer(snake_case__					,   return_tensors="""tf"""	).input_ids
				a_      				=						TFBartForConditionalGeneration.from_pretrained("""hf-internal-testing/tiny-random-bart"""	)
				a_      				=						bart_model.generate(snake_case__	).numpy()







				class   a_ (      lowerCamelCase__					):




							def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   UpperCAmelCase=None					,   **UpperCAmelCase	):
								return super().call(snake_case__					,   **snake_case__	)







				a_      				=						FakeBart.from_pretrained("""hf-internal-testing/tiny-random-bart"""	)
				a_      				=						bart_model.generate(snake_case__					,   foo="""bar"""	).numpy()
				self.assertTrue(np.array_equal(snake_case__					,   snake_case__	)	)







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




							def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   **UpperCAmelCase	):
								return super().call(snake_case__					,   **snake_case__	)







				a_      				=						FakeEncoder(bart_model.config					,   bart_model.model.shared	)
				a_      				=						fake_encoder

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







import qiskit





def  __magic_name__  (				lowercase				,       lowercase				)				-> qiskit.result.counts.Counts:

							"""simple docstring"""



							lowercase_	:   Dict  				=     qiskit.Aer.get_backend("""aer_simulator"""				)

							# Create a Quantum Circuit acting on the q register
							lowercase_	:   str  				=     qiskit.QuantumCircuit(lowercase				,       lowercase				)

							# Map the quantum measurement to the classical bits
							circuit.measure([0]				,       [0]				)

							# Execute the circuit on the simulator
							lowercase_	:   List[Any]  				=     qiskit.execute(lowercase				,       lowercase				,       shots=1000				)

							# Return the histogram data of the results of the experiment.
							return job.result().get_counts(lowercase				)


if __name__ == "__main__":
							print(F'''Total count for various states are: {single_qubit_measure(1, 1)}''')