






'''simple docstring'''





import inspect
import tempfile
import unittest

from huggingface_hub import hf_hub_download

from transformers import is_torch_available
from transformers.testing_utils import is_flaky, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


__lowerCamelCase	:		Optional[int]										=   1e-4

if is_torch_available():
       import torch

       from transformers import AutoformerConfig, AutoformerForPrediction, AutoformerModel
       from transformers.models.autoformer.modeling_autoformer import AutoformerDecoder, AutoformerEncoder







@require_torch
class  _lowercase   :
      def __init__(     self				,			a				,			a=1_6				,			a=1_3				,			a=7				,			a=1_4				,			a=1_0				,			a=1_9				,			a=5				,			a=4				,			a=True				,			a=1_6				,			a=2				,			a=4				,			a=4				,			a="gelu"				,			a=0.1				,			a=0.1				,			a=[1, 2, 3, 4, 5]				,			a=2_5				,			a=5				,			):
       snake_case__  :    int							       =d_model
       snake_case__  :    Dict							       =parent
       snake_case__  :    Tuple							       =batch_size
       snake_case__  :    str							       =prediction_length
       snake_case__  :    Optional[int]							       =context_length
       snake_case__  :    Tuple							       =cardinality
       snake_case__  :    Any							       =num_time_features
       snake_case__  :    Union[str, Any]							       =lags_sequence
       snake_case__  :    str							       =embedding_dimension
       snake_case__  :    Union[str, Any]							       =is_training
       snake_case__  :    Optional[Any]							       =hidden_size
       snake_case__  :    List[Any]							       =num_hidden_layers
       snake_case__  :    Dict							       =num_attention_heads
       snake_case__  :    Union[str, Any]							       =intermediate_size
       snake_case__  :    Any							       =hidden_act
       snake_case__  :    Any							       =hidden_dropout_prob
       snake_case__  :    Dict							       =attention_probs_dropout_prob

       snake_case__  :    Any							       =context_length
       snake_case__  :    int							       =prediction_length + label_length
       snake_case__  :    Tuple							       =label_length

       snake_case__  :    str							       =moving_average
       snake_case__  :    Optional[int]							       =autocorrelation_factor
      def 						lowercase__					(     self   ):
       return AutoformerConfig(
           d_model=self.d_model				,			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				,			prediction_length=self.prediction_length				,			context_length=self.context_length				,			label_length=self.label_length				,			lags_sequence=self.lags_sequence				,			num_time_features=self.num_time_features				,			num_static_categorical_features=1				,			cardinality=[self.cardinality]				,			embedding_dimension=[self.embedding_dimension]				,			moving_average=self.moving_average				,			)
      def 						lowercase__					(     self				,			a   ):
       snake_case__  :    Optional[int]							       =config.context_length + max(config.lags_sequence   )

       snake_case__  :    Union[str, Any]							       =ids_tensor([self.batch_size, 1]				,			config.cardinality[0]   )
       snake_case__  :    List[Any]							       =floats_tensor([self.batch_size, _past_length, config.num_time_features]   )
       snake_case__  :    Any							       =floats_tensor([self.batch_size, _past_length]   )
       snake_case__  :    List[str]							       =floats_tensor([self.batch_size, _past_length]   ) > 0.5

       # decoder inputs
       snake_case__  :    Union[str, Any]							       =floats_tensor([self.batch_size, config.prediction_length, config.num_time_features]   )
       snake_case__  :    str							       =floats_tensor([self.batch_size, config.prediction_length]   )

       snake_case__  :    Dict							       ={
           """past_values""": past_values,
           """static_categorical_features""": static_categorical_features,
           """past_time_features""": past_time_features,
           """past_observed_mask""": past_observed_mask,
           """future_time_features""": future_time_features,
           """future_values""": future_values,
       }
       return inputs_dict
      def 						lowercase__					(     self   ):
       snake_case__  :    int							       =self.get_config()
       snake_case__  :    List[Any]							       =self.prepare_autoformer_inputs_dict(_lowercase   )
       return config, inputs_dict
      def 						lowercase__					(     self   ):
       snake_case__  :    Dict							       =self.prepare_config_and_inputs()
       return config, inputs_dict



      def 						lowercase__					(     self				,			a				,			a   ):
       snake_case__  :    Tuple							       =AutoformerModel(config=_lowercase   ).to(_lowercase   ).eval()
       snake_case__  :    Tuple							       =model(**_lowercase   )

       snake_case__  :    str							       =outputs.encoder_last_hidden_state
       snake_case__  :    Union[str, Any]							       =outputs.last_hidden_state

       with tempfile.TemporaryDirectory() as tmpdirname:
        snake_case__  :    List[str]							       =model.get_encoder()
        encoder.save_pretrained(_lowercase   )
        snake_case__  :    Union[str, Any]							       =AutoformerEncoder.from_pretrained(_lowercase   ).to(_lowercase   )

       snake_case__  :    Optional[Any]							       =model.create_network_inputs(**_lowercase   )
       snake_case__  :    int							       =model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]   )

       snake_case__  :    Dict							       =torch.cat(
           (transformer_inputs[:, : config.context_length, ...], feature[:, : config.context_length, ...])				,			dim=-1				,			)
       snake_case__  :    List[str]							       =encoder(inputs_embeds=_lowercase   )[0]
       self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1e-3   )

       snake_case__  :    Dict							       =(
           torch.mean(transformer_inputs[:, : config.context_length, ...]				,			dim=1   )
           .unsqueeze(1   )
           .repeat(1				,			config.prediction_length				,			1   )
       )
       snake_case__  :    int							       =torch.zeros(
           [transformer_inputs.shape[0], config.prediction_length, transformer_inputs.shape[2]]				,			device=enc_input.device				,			)

       snake_case__  :    Any							       =torch.cat(
           (
               torch.cat((seasonal_input[:, -config.label_length :, ...], zeros)				,			dim=1   ),
               feature[:, config.context_length - config.label_length :, ...],
           )				,			dim=-1				,			)
       snake_case__  :    List[str]							       =torch.cat(
           (
               torch.cat((trend_input[:, -config.label_length :, ...], mean)				,			dim=1   ),
               feature[:, config.context_length - config.label_length :, ...],
           )				,			dim=-1				,			)

       with tempfile.TemporaryDirectory() as tmpdirname:
        snake_case__  :    List[Any]							       =model.get_decoder()
        decoder.save_pretrained(_lowercase   )
        snake_case__  :    int							       =AutoformerDecoder.from_pretrained(_lowercase   ).to(_lowercase   )

       snake_case__  :    int							       =decoder(
           trend=_lowercase				,			inputs_embeds=_lowercase				,			encoder_hidden_states=_lowercase				,			)[0]

       self.parent.assertTrue((last_hidden_state_a - last_hidden_state).abs().max().item() < 1e-3   )







@require_torch
class  _lowercase   (   __snake_case						,				__snake_case						,				unittest.TestCase						):
      _a							:						Any										=							(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
      _a							:						List[Any]										=							(AutoformerForPrediction,) if is_torch_available() else ()
      _a							:						Union[str, Any]										=							{'feature-extraction': AutoformerModel} if is_torch_available() else {}
      _a							:						Tuple										=							False
      _a							:						Any										=							False
      _a							:						int										=							False
      _a							:						Dict										=							False
      _a							:						List[Any]										=							False
      _a							:						int										=							False
      def 						lowercase__					(     self   ):
       snake_case__  :    Dict							       =AutoformerModelTester(self   )
       snake_case__  :    Dict							       =ConfigTester(self				,			config_class=_lowercase				,			has_text_modality=_lowercase   )
      def 						lowercase__					(     self   ):
       self.config_tester.run_common_tests()
      def 						lowercase__					(     self   ):
       snake_case__  :    List[str]							       =self.model_tester.prepare_config_and_inputs()
       for model_class in self.all_model_classes:
        snake_case__  :    Optional[Any]							       =model_class(_lowercase   )

        with tempfile.TemporaryDirectory() as tmpdirname:
         model.save_pretrained(_lowercase   )
         snake_case__  :    str							       =model_class.from_pretrained(_lowercase				,			output_loading_info=_lowercase   )
        self.assertEqual(info["""missing_keys"""]				,			[]   )
      def 						lowercase__					(     self   ):
       snake_case__  :    Dict							       =self.model_tester.prepare_config_and_inputs_for_common()
       self.model_tester.check_encoder_decoder_model_standalone(*_lowercase   )
      @unittest.skip(reason="""Model has no tokens embeddings"""   )
      def 						lowercase__					(     self   ):
       pass
      def 						lowercase__					(     self   ):
       snake_case__  :    Tuple							       =inspect.signature(getattr(_lowercase				,			"""forward"""   )   )
       # The main input is the name of the argument after `self`
       snake_case__  :    str							       =list(model_signature.parameters.keys()   )[1]
       self.assertEqual(AutoformerModel.main_input_name				,			_lowercase   )
      def 						lowercase__					(     self   ):
       snake_case__  :    Optional[int]							       =self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
        snake_case__  :    Tuple							       =model_class(_lowercase   )
        snake_case__  :    List[str]							       =inspect.signature(model.forward   )
        # signature.parameters is an OrderedDict => so arg_names order is deterministic
        snake_case__  :    List[Any]							       =[*signature.parameters.keys()]

        snake_case__  :    Dict							       =[
            """past_values""",
            """past_time_features""",
            """past_observed_mask""",
            """static_categorical_features""",
            """static_real_features""",
            """future_values""",
            """future_time_features""",
        ]

        if model.__class__.__name__ in ["AutoformerForPrediction"]:
         expected_arg_names.append("""future_observed_mask"""   )

        expected_arg_names.extend(
            [
                """decoder_attention_mask""",
                """head_mask""",
                """decoder_head_mask""",
                """cross_attn_head_mask""",
                """encoder_outputs""",
                """past_key_values""",
                """output_hidden_states""",
                """output_attentions""",
                """use_cache""",
                """return_dict""",
            ]   )

        self.assertListEqual(arg_names[: len(_lowercase   )]				,			_lowercase   )
      def 						lowercase__					(     self   ):
       snake_case__  :    Dict							       =self.model_tester.prepare_config_and_inputs_for_common()
       snake_case__  :    Optional[Any]							       =True

       snake_case__  :    Optional[int]							       =getattr(self.model_tester				,			"""seq_length"""				,			_lowercase   )
       snake_case__  :    Optional[int]							       =getattr(self.model_tester				,			"""decoder_seq_length"""				,			_lowercase   )
       snake_case__  :    Optional[int]							       =getattr(self.model_tester				,			"""encoder_seq_length"""				,			_lowercase   )
       snake_case__  :    List[str]							       =getattr(self.model_tester				,			"""d_model"""				,			_lowercase   )
       snake_case__  :    Union[str, Any]							       =getattr(self.model_tester				,			"""num_attention_heads"""				,			_lowercase   )
       snake_case__  :    List[Any]							       =d_model // num_attention_heads

       for model_class in self.all_model_classes:
        snake_case__  :    int							       =True
        snake_case__  :    Union[str, Any]							       =False
        snake_case__  :    List[Any]							       =True
        snake_case__  :    int							       =model_class(_lowercase   )
        model.to(_lowercase   )
        model.eval()
        with torch.no_grad():
         snake_case__  :    int							       =model(**self._prepare_for_class(_lowercase				,			_lowercase   )   )
        snake_case__  :    Optional[Any]							       =outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
        self.assertEqual(len(_lowercase   )				,			self.model_tester.num_hidden_layers   )

        # check that output_attentions also work using config
        del inputs_dict["output_attentions"]
        snake_case__  :    Optional[int]							       =True
        snake_case__  :    Optional[int]							       =model_class(_lowercase   )
        model.to(_lowercase   )
        model.eval()
        with torch.no_grad():
         snake_case__  :    List[str]							       =model(**self._prepare_for_class(_lowercase				,			_lowercase   )   )
        snake_case__  :    int							       =outputs.encoder_attentions
        self.assertEqual(len(_lowercase   )				,			self.model_tester.num_hidden_layers   )

        self.assertListEqual(
            list(attentions[0].shape[-3:]   )				,			[self.model_tester.num_attention_heads, encoder_seq_length, dim]				,			)
        snake_case__  :    Dict							       =len(_lowercase   )

        snake_case__  :    int							       =7

        if "last_hidden_state" in outputs:
         correct_outlen += 1

        if "trend" in outputs:
         correct_outlen += 1

        if "past_key_values" in outputs:
         correct_outlen += 1  # past_key_values have been returned

        if "loss" in outputs:
         correct_outlen += 1

        if "params" in outputs:
         correct_outlen += 1

        self.assertEqual(_lowercase				,			_lowercase   )

        # decoder attentions
        snake_case__  :    Dict							       =outputs.decoder_attentions
        self.assertIsInstance(_lowercase				,			(list, tuple)   )
        self.assertEqual(len(_lowercase   )				,			self.model_tester.num_hidden_layers   )
        self.assertListEqual(
            list(decoder_attentions[0].shape[-3:]   )				,			[self.model_tester.num_attention_heads, decoder_seq_length, dim]				,			)

        # cross attentions
        snake_case__  :    Optional[Any]							       =outputs.cross_attentions
        self.assertIsInstance(_lowercase				,			(list, tuple)   )
        self.assertEqual(len(_lowercase   )				,			self.model_tester.num_hidden_layers   )
        self.assertListEqual(
            list(cross_attentions[0].shape[-3:]   )				,			[self.model_tester.num_attention_heads, decoder_seq_length, dim]				,			)

       # Check attention is always last and order is fine
       snake_case__  :    Any							       =True
       snake_case__  :    Any							       =True
       snake_case__  :    List[Any]							       =model_class(_lowercase   )
       model.to(_lowercase   )
       model.eval()
       with torch.no_grad():
        snake_case__  :    List[str]							       =model(**self._prepare_for_class(_lowercase				,			_lowercase   )   )

       self.assertEqual(out_len + 2				,			len(_lowercase   )   )

       snake_case__  :    Optional[int]							       =outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions

       self.assertEqual(len(_lowercase   )				,			self.model_tester.num_hidden_layers   )
       self.assertListEqual(
           list(self_attentions[0].shape[-3:]   )				,			[self.model_tester.num_attention_heads, encoder_seq_length, dim]				,			)



      @is_flaky()
      def 						lowercase__					(     self   ):
       super().test_retain_grad_hidden_states_attentions()







def 			A__							(      _a  :					Tuple="train-batch.pt"	):





 '''simple docstring'''







 snake_case__  :    Any							       =hf_hub_download(repo_id="""hf-internal-testing/tourism-monthly-batch"""		,  filename=_lowerCamelCase		,  repo_type="""dataset"""	)
 snake_case__  :    int							       =torch.load(_lowerCamelCase		,  map_location=_lowerCamelCase	)
 return batch







@require_torch
@slow
class  _lowercase   (   unittest.TestCase						):
      def 						lowercase__					(     self   ):
       snake_case__  :    Dict							       =AutoformerModel.from_pretrained("""huggingface/autoformer-tourism-monthly"""   ).to(_lowercase   )
       snake_case__  :    int							       =prepare_batch()

       with torch.no_grad():
        snake_case__  :    List[Any]							       =model(
            past_values=batch["""past_values"""]				,			past_time_features=batch["""past_time_features"""]				,			past_observed_mask=batch["""past_observed_mask"""]				,			static_categorical_features=batch["""static_categorical_features"""]				,			future_values=batch["""future_values"""]				,			future_time_features=batch["""future_time_features"""]				,			)[0]

       snake_case__  :    Optional[int]							       =torch.Size(
           (6_4, model.config.prediction_length + model.config.label_length, model.config.feature_size)   )
       self.assertEqual(output.shape				,			_lowercase   )

       snake_case__  :    Any							       =torch.tensor(
           [[0.3593, -1.3398, 0.6330], [0.2279, 1.5396, -0.1792], [0.0450, 1.3225, -0.2335]]				,			device=_lowercase   )
       self.assertTrue(torch.allclose(output[0, :3, :3]				,			_lowercase				,			atol=_lowercase   )   )
      def 						lowercase__					(     self   ):
       snake_case__  :    Optional[int]							       =AutoformerForPrediction.from_pretrained("""huggingface/autoformer-tourism-monthly"""   ).to(_lowercase   )
       snake_case__  :    List[str]							       =prepare_batch("""val-batch.pt"""   )
       with torch.no_grad():
        snake_case__  :    str							       =model(
            past_values=batch["""past_values"""]				,			past_time_features=batch["""past_time_features"""]				,			past_observed_mask=batch["""past_observed_mask"""]				,			static_categorical_features=batch["""static_categorical_features"""]				,			).encoder_last_hidden_state
       snake_case__  :    Optional[int]							       =torch.Size((6_4, model.config.context_length, model.config.d_model)   )
       self.assertEqual(output.shape				,			_lowercase   )

       snake_case__  :    str							       =torch.tensor(
           [[-0.0734, -0.9036, 0.8358], [4.7186, 2.4113, 1.9581], [1.7953, 2.3558, 1.2970]]				,			device=_lowercase   )
       self.assertTrue(torch.allclose(output[0, :3, :3]				,			_lowercase				,			atol=_lowercase   )   )



      def 						lowercase__					(     self   ):
       snake_case__  :    Tuple							       =AutoformerForPrediction.from_pretrained("""huggingface/autoformer-tourism-monthly"""   ).to(_lowercase   )
       snake_case__  :    Optional[Any]							       =prepare_batch("""val-batch.pt"""   )
       with torch.no_grad():
        snake_case__  :    Tuple							       =model.generate(
            static_categorical_features=batch["""static_categorical_features"""]				,			past_time_features=batch["""past_time_features"""]				,			past_values=batch["""past_values"""]				,			future_time_features=batch["""future_time_features"""]				,			past_observed_mask=batch["""past_observed_mask"""]				,			)
       snake_case__  :    str							       =torch.Size((6_4, model.config.num_parallel_samples, model.config.prediction_length)   )
       self.assertEqual(outputs.sequences.shape				,			_lowercase   )

       snake_case__  :    List[Any]							       =torch.tensor([3130.6763, 4056.5293, 7053.0786]				,			device=_lowercase   )
       snake_case__  :    List[Any]							       =outputs.sequences.mean(dim=1   )
       self.assertTrue(torch.allclose(mean_prediction[0, -3:]				,			_lowercase				,			rtol=1e-1   )   )













from collections import namedtuple

import requests
from lxml import html  # type: ignore

__lowerCamelCase	:		Any										=   namedtuple("""covid_data""", """cases deaths recovered""")







def 			A__							(      _a  :					str = "https://www.worldometers.info/coronavirus/"	):





 '''simple docstring'''







 snake_case__  :    Any							       ="""//div[@class = \"maincounter-number\"]/span/text()"""
 return covid_data(*html.fromstring(requests.get(_a	).content	).xpath(_a	)	)


__lowerCamelCase	:		str										=   """Total COVID-19 cases in the world: {}
Total deaths due to COVID-19 in the world: {}
Total COVID-19 patients recovered in the world: {}"""

print(fmt.format(*covid_stats()))





