



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




    '''simple docstring'''






    def       _lowerCAmelCase (	self		):
        A			:	Tuple										=       tf.convert_to_tensor(
            [
                [
                    8.222_0991,  # 3rd highest value; idx. 0
                    -0.562_0044,
                    5.2322_9752,
                    4.038_6393,
                    -6.879_8378,
                    -0.5478_5802,
                    -3.201_2153,
                    2.9277_7176,
                    1.8817_1953,
                    7.3534_1276,  # 5th highest value; idx. 9
                    8.4320_7833,  # 2nd highest value; idx. 10
                    -9.8571_1836,
                    -5.9620_9236,
                    -1.1303_9161,
                    -7.111_5294,
                    -0.836_9633,
                    -5.318_6408,
                    7.0642_7407,
                    0.8136_9344,
                    -0.8202_3817,
                    -5.917_9796,
                    0.5881_3443,
                    -6.9977_8438,
                    4.7155_1189,
                    -0.1877_1637,
                    7.4402_0759,  # 4th highest value; idx. 25
                    9.3845_0987,  # 1st highest value; idx. 26
                    2.1266_2941,
                    -9.3256_2038,
                    2.3565_2522,
                ],  # cummulative prob of 5 highest values <= 0.6
                [
                    0.5842_5518,
                    4.5313_9238,
                    -5.5751_0464,
                    -6.2803_0699,
                    -7.1952_9503,
                    -4.0212_2551,
                    1.3933_7037,
                    -6.0670_7057,
                    1.5948_0517,
                    -9.64_3119,
                    0.0390_7799,
                    0.6723_1762,
                    -8.8820_6726,
                    6.2711_5922,  # 4th highest value; idx. 13
                    2.2852_0723,
                    4.8276_7506,
                    4.3042_1368,
                    8.827_5313,  # 2nd highest value; idx. 17
                    5.4402_9958,  # 5th highest value; idx. 18
                    -4.473_5794,
                    7.3857_9536,  # 3rd highest value; idx. 20
                    -2.9105_1663,
                    2.6194_6077,
                    -2.567_4762,
                    -9.4895_9302,
                    -4.0292_2645,
                    -1.3541_6918,
                    9.6770_2323,  # 1st highest value; idx. 27
                    -5.8947_8553,
                    1.8537_0467,
                ],  # cummulative prob of 5 highest values <= 0.6
            ],		dtype=tf.floataa,		)

        A			:	int										=       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			:	List[str]										=       tf.convert_to_tensor(
            [8.22_2099, 7.353_4126, 8.43_2078, 7.440_2075, 9.3_8451, 6.27_1159, 8.82_7531, 5.440_2995, 7.385_7956, 9.67_7023],		dtype=tf.floataa,		)  # expected non filtered values as noted above

        A			:	Tuple										=       tf_top_k_top_p_filtering(lowerCamelCase__,		top_k=10,		top_p=0.6,		min_tokens_to_keep=4		)

        A			:	Union[str, Any]										=       output[output != -float("""inf"""		)]
        A			:	Any										=       tf.cast(
            tf.where(tf.not_equal(lowerCamelCase__,		tf.constant(-float("""inf"""		),		dtype=tf.floataa		)		)		),		dtype=tf.intaa,		)

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






@require_tf
class SCREAMING_SNAKE_CASE__					(		unittest.TestCase			,						SCREAMING_SNAKE_CASE__   ):




    '''simple docstring'''






    if is_tf_available():
        __lowerCamelCase      :			Dict =				{
            "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		):
        # TF-only test: tf.saved_model export
        A			:	Optional[Any]										=       TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""		)
        A			:	Tuple										=       2
        A			:	str										=       2






        class SCREAMING_SNAKE_CASE__					(		tf.Module   ):




            '''simple docstring'''






            def __init__(	self,		lowerCamelCase__		):
                super(lowerCamelCase__,		self		).__init__()
                A			:	Dict										=       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=lowerCamelCase__,		)
            def       _lowerCAmelCase (	self,		lowerCamelCase__,		lowerCamelCase__		):
                A			:	str										=       self.model.generate(
                    input_ids=lowerCamelCase__,		attention_mask=lowerCamelCase__,		max_new_tokens=lowerCamelCase__,		return_dict_in_generate=lowerCamelCase__,		)
                return {"sequences": outputs["sequences"]}


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






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






        class SCREAMING_SNAKE_CASE__					(		tf.Module   ):




            '''simple docstring'''






            def __init__(	self,		lowerCamelCase__		):
                super(lowerCamelCase__,		self		).__init__()
                A			:	List[str]										=       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=lowerCamelCase__,		)
            def       _lowerCAmelCase (	self,		lowerCamelCase__,		lowerCamelCase__		):
                A			:	List[str]										=       self.model.generate(
                    input_ids=lowerCamelCase__,		attention_mask=lowerCamelCase__,		max_new_tokens=lowerCamelCase__,		return_dict_in_generate=lowerCamelCase__,		)
                return {"sequences": outputs["sequences"]}


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






    @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=lowerCamelCase__		)






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




                '''simple docstring'''






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






                def       _lowerCAmelCase (	self,		lowerCamelCase__,		*lowerCamelCase__,		**lowerCamelCase__		):
                    A			:	Dict										=       self.tokenizer.tokenize(lowerCamelCase__		)
                    A					,							A			:	List[Any]										=       text.pad_model_inputs(
                        lowerCamelCase__,		max_seq_length=64,		pad_value=self.model.config.pad_token_id		)
                    A			:	Tuple										=       self.model.generate(input_ids=lowerCamelCase__,		attention_mask=lowerCamelCase__		)
                    return self.tokenizer.detokenize(lowerCamelCase__		)


            A			:	int										=       CompleteSentenceTransformer()
            A			:	Tuple										=       tf.keras.layers.Input(shape=(1,),		dtype=tf.string,		name="""inputs"""		)
            A			:	List[str]										=       complete_model(lowerCamelCase__		)
            A			:	str										=       tf.keras.Model(lowerCamelCase__,		lowerCamelCase__		)
            keras_model.save(lowerCamelCase__		)






    def       _lowerCAmelCase (	self		):
        # Has PT equivalent: this test relies on random sampling
        A			:	List[Any]										=       {
            """do_sample""": True,
            """num_beams""": 1,
            """top_p""": 0.7,
            """top_k""": 10,
            """temperature""": 0.7,
        }
        A			:	Dict										=       14

        A			:	Dict										=       AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""		)
        A			:	Any										=       """Hello, my dog is cute and"""
        A			:	Optional[int]										=       tokenizer(lowerCamelCase__,		return_tensors="""tf"""		)
        A			:	List[Any]										=       TFAutoModelForCausalLM.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""		)

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

        A			:	Tuple										=       [638, 198]
        with tf.device(""":/CPU:0"""		):
            tf.random.set_seed(0		)
            A			:	Tuple										=       model.generate(**lowerCamelCase__,		eos_token_id=lowerCamelCase__,		**lowerCamelCase__		)
        self.assertTrue(expectation == len(generated_tokens[0]		)		)






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






        class SCREAMING_SNAKE_CASE__					(		SCREAMING_SNAKE_CASE__   ):




            '''simple docstring'''






            def       _lowerCAmelCase (	self,		lowerCamelCase__,		lowerCamelCase__=None,		**lowerCamelCase__		):
                return super().call(lowerCamelCase__,		**lowerCamelCase__		)


        A			:	Union[str, Any]										=       FakeBart.from_pretrained("""hf-internal-testing/tiny-random-bart"""		)
        A			:	Tuple										=       bart_model.generate(lowerCamelCase__,		foo="""bar"""		).numpy()
        self.assertTrue(np.array_equal(lowerCamelCase__,		lowerCamelCase__		)		)






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




            '''simple docstring'''






            def       _lowerCAmelCase (	self,		lowerCamelCase__,		**lowerCamelCase__		):
                return super().call(lowerCamelCase__,		**lowerCamelCase__		)


        A			:	Dict										=       FakeEncoder(bart_model.config,		bart_model.model.shared		)
        A			:	List[Any]										=       fake_encoder

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







import requests

SCREAMING_SNAKE_CASE_:List[str]					=						""""""  # <-- Put your OpenWeatherMap appid here!
SCREAMING_SNAKE_CASE_:Dict					=						"""https://api.openweathermap.org/data/2.5/"""




def      __UpperCamelCase     (  _lowerCAmelCase = "Chicago"				,					_lowerCAmelCase = APPID		)	->  dict:



    """simple docstring"""






    return requests.get(URL_BASE + """weather"""				,					params=locals()		).json()




def      __UpperCamelCase     (  _lowerCAmelCase = "Kolkata, India"				,					_lowerCAmelCase = APPID		)	->  dict:



    """simple docstring"""






    return requests.get(URL_BASE + """forecast"""				,					params=locals()		).json()




def      __UpperCamelCase     (  _lowerCAmelCase = 55.68				,					_lowerCAmelCase = 12.57				,					_lowerCAmelCase = APPID		)	->  dict:



    """simple docstring"""






    return requests.get(URL_BASE + """onecall"""				,					params=locals()		).json()


if __name__ == "__main__":
     from pprint import pprint

     while True:
          SCREAMING_SNAKE_CASE_:int					=						input("""Enter a location:""").strip()
          if location:
               pprint(current_weather(location))
          else:
               break


