



'''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        UpperCAmelCase_ (    self     )     ->			int:
      __lowerCAmelCase												=  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			,				)

      __lowerCAmelCase												=  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

      __lowerCAmelCase												=  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

      __lowerCAmelCase												=  tf_top_k_top_p_filtering(UpperCamelCase			,				top_k=10			,				top_p=0.6			,				min_tokens_to_keep=4     )

      __lowerCAmelCase												=  output[output != -float("inf"     )]
      __lowerCAmelCase												=  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():
          a      :     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        UpperCAmelCase_ (    self     )     ->			Any:
      # TF-only test: tf.saved_model export
      __lowerCAmelCase												=  TFAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2"     )
      __lowerCAmelCase												=  2
      __lowerCAmelCase												=  2






      class 					UpperCAmelCase__	(		tf.Module ):



           def __init__(    self			,				UpperCamelCase     )     ->			Tuple:
            super(UpperCamelCase			,				self     ).__init__()
            __lowerCAmelCase												=  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        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase     )     ->			Optional[Any]:
            __lowerCAmelCase												=  self.model.generate(
                input_ids=UpperCamelCase			,				attention_mask=UpperCamelCase			,				max_new_tokens=UpperCamelCase			,				return_dict_in_generate=UpperCamelCase			,				)
            return {"sequences": outputs["sequences"]}


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



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






      class 					UpperCAmelCase__	(		tf.Module ):



           def __init__(    self			,				UpperCamelCase     )     ->			Optional[int]:
            super(UpperCamelCase			,				self     ).__init__()
            __lowerCAmelCase												=  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        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase     )     ->			str:
            __lowerCAmelCase												=  self.model.generate(
                input_ids=UpperCamelCase			,				attention_mask=UpperCamelCase			,				max_new_tokens=UpperCamelCase			,				return_dict_in_generate=UpperCamelCase			,				)
            return {"sequences": outputs["sequences"]}


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



     @slow
     @require_tensorflow_text
     def        UpperCAmelCase_ (    self     )     ->			Union[str, 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     )     ->			List[Any]:
             super().__init__()
             __lowerCAmelCase												=  text.SentencepieceTokenizer(
                 model=tf.io.gfile.GFile(os.path.join(UpperCamelCase			,				"spiece.model"     )			,				"rb"     ).read()     )
             __lowerCAmelCase												=  TFAutoModelForSeqaSeqLM.from_pretrained("hf-internal-testing/tiny-random-t5"     )



            def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				*UpperCamelCase			,				**UpperCamelCase     )     ->			Union[str, Any]:
             __lowerCAmelCase												=  self.tokenizer.tokenize(UpperCamelCase     )
             __lowerCAmelCase							,       __lowerCAmelCase												=  text.pad_model_inputs(
                 UpperCamelCase			,				max_seq_length=64			,				pad_value=self.model.config.pad_token_id     )
             __lowerCAmelCase												=  self.model.generate(input_ids=UpperCamelCase			,				attention_mask=UpperCamelCase     )
             return self.tokenizer.detokenize(UpperCamelCase     )


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



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

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

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

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



     def        UpperCAmelCase_ (    self     )     ->			Any:
      # Has PT equivalent: ample use of framework-specific code
      __lowerCAmelCase												=  AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-bart"     )
      __lowerCAmelCase												=  "Hugging Face is a technology company based in New York and Paris."
      __lowerCAmelCase												=  bart_tokenizer(UpperCamelCase			,				return_tensors="tf"     ).input_ids
      __lowerCAmelCase												=  TFBartForConditionalGeneration.from_pretrained("hf-internal-testing/tiny-random-bart"     )
      __lowerCAmelCase												=  bart_model.generate(UpperCamelCase     ).numpy()






      class 					UpperCAmelCase__	(		UpperCamelCase__ ):



           def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase=None			,				**UpperCamelCase     )     ->			Any:
            return super().call(UpperCamelCase			,				**UpperCamelCase     )


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






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



           def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				**UpperCamelCase     )     ->			List[str]:
            return super().call(UpperCamelCase			,				**UpperCamelCase     )


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

      # Normal generation still works (the output will be different because the encoder weights are different)
      __lowerCAmelCase												=  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'''



import requests
from bsa import BeautifulSoup



def   __lowerCAmelCase					(							lowerCamelCase   :						str = "https://www.worldometers.info/coronavirus"					):






	'''simple docstring'''




	__lowerCAmelCase												=  BeautifulSoup(requests.get(lowerCamelCase					).text				,		"html.parser"					)
	__lowerCAmelCase												=  soup.findAll("h1"					)
	__lowerCAmelCase												=  soup.findAll("div"				,		{"class": "maincounter-number"}					)
	keys += soup.findAll("span"				,		{"class": "panel-title"}					)
	values += soup.findAll("div"				,		{"class": "number-table-main"}					)
	return {key.text.strip(): value.text.strip() for key, value in zip(lowerCamelCase				,		lowerCamelCase					)}


if __name__ == "__main__":
	print('''\033[1m''' + '''COVID-19 Status of the World''' + '''\033[0m\n''')
	for key, value in world_covidaa_stats().items():
		print(f'{key}\n{value}\n')