

'''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									=     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        A__   :



    def __init__(       self		,					UpperCamelCase__		,					UpperCamelCase__=16		,					UpperCamelCase__=13		,					UpperCamelCase__=7		,					UpperCamelCase__=14		,					UpperCamelCase__=10		,					UpperCamelCase__=19		,					UpperCamelCase__=5		,					UpperCamelCase__=4		,					UpperCamelCase__=True		,					UpperCamelCase__=16		,					UpperCamelCase__=2		,					UpperCamelCase__=4		,					UpperCamelCase__=4		,					UpperCamelCase__="gelu"		,					UpperCamelCase__=0.1		,					UpperCamelCase__=0.1		,					UpperCamelCase__=[1, 2, 3, 4, 5]		,					UpperCamelCase__=25		,					UpperCamelCase__=5		,					)    ->   List[Any]:





           '''simple docstring'''
           A_						       =   d_model
           A_						       =   parent
           A_						       =   batch_size
           A_						       =   prediction_length
           A_						       =   context_length
           A_						       =   cardinality
           A_						       =   num_time_features
           A_						       =   lags_sequence
           A_						       =   embedding_dimension
           A_						       =   is_training
           A_						       =   hidden_size
           A_						       =   num_hidden_layers
           A_						       =   num_attention_heads
           A_						       =   intermediate_size
           A_						       =   hidden_act
           A_						       =   hidden_dropout_prob
           A_						       =   attention_probs_dropout_prob

           A_						       =   context_length
           A_						       =   prediction_length + label_length
           A_						       =   label_length

           A_						       =   moving_average
           A_						       =   autocorrelation_factor



    def        snake_case_      (       self							)    ->   Dict:





           '''simple docstring'''
           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        snake_case_      (       self		,					UpperCamelCase__							)    ->   str:





           '''simple docstring'''
           A_						       =   config.context_length + max(config.lags_sequence							)

           A_						       =   ids_tensor([self.batch_size, 1]		,					config.cardinality[0]							)
           A_						       =   floats_tensor([self.batch_size, _past_length, config.num_time_features]							)
           A_						       =   floats_tensor([self.batch_size, _past_length]							)
           A_						       =   floats_tensor([self.batch_size, _past_length]							) > 0.5

           # decoder inputs
           A_						       =   floats_tensor([self.batch_size, config.prediction_length, config.num_time_features]							)
           A_						       =   floats_tensor([self.batch_size, config.prediction_length]							)

           A_						       =   {
               """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        snake_case_      (       self							)    ->   Dict:





           '''simple docstring'''
           A_						       =   self.get_config()
           A_						       =   self.prepare_autoformer_inputs_dict(UpperCamelCase__							)
           return config, inputs_dict



    def        snake_case_      (       self							)    ->   Dict:





           '''simple docstring'''
           A_       ,      A_						       =   self.prepare_config_and_inputs()
           return config, inputs_dict







    def        snake_case_      (       self		,					UpperCamelCase__		,					UpperCamelCase__							)    ->   Union[str, Any]:





           '''simple docstring'''
           A_						       =   AutoformerModel(config=UpperCamelCase__							).to(UpperCamelCase__							).eval()
           A_						       =   model(**UpperCamelCase__							)

           A_						       =   outputs.encoder_last_hidden_state
           A_						       =   outputs.last_hidden_state

           with tempfile.TemporaryDirectory() as tmpdirname:
                  A_						       =   model.get_encoder()
                  encoder.save_pretrained(UpperCamelCase__							)
                  A_						       =   AutoformerEncoder.from_pretrained(UpperCamelCase__							).to(UpperCamelCase__							)

           A_       ,      A_       ,      A_       ,      A_       ,      A_						       =   model.create_network_inputs(**UpperCamelCase__							)
           A_       ,      A_						       =   model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]							)

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

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

           A_						       =   torch.cat(
               (
                   torch.cat((seasonal_input[:, -config.label_length :, ...], zeros)		,					dim=1							),
                   feature[:, config.context_length - config.label_length :, ...],
               )		,					dim=-1		,					)
           A_						       =   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:
                  A_						       =   model.get_decoder()
                  decoder.save_pretrained(UpperCamelCase__							)
                  A_						       =   AutoformerDecoder.from_pretrained(UpperCamelCase__							).to(UpperCamelCase__							)

           A_						       =   decoder(
               trend=UpperCamelCase__		,					inputs_embeds=UpperCamelCase__		,					encoder_hidden_states=UpperCamelCase__		,					)[0]

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


@require_torch
class        A__   (   _snake_case    ,    _snake_case    ,    unittest.TestCase      ):
    lowercase						       =		(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
    lowercase						       =		(AutoformerForPrediction,) if is_torch_available() else ()
    lowercase						       =		{"feature-extraction": AutoformerModel} if is_torch_available() else {}
    lowercase						       =		False
    lowercase						       =		False
    lowercase						       =		False
    lowercase						       =		False
    lowercase						       =		False
    lowercase						       =		False



    def        snake_case_      (       self							)    ->   Optional[int]:





           '''simple docstring'''
           A_						       =   AutoformerModelTester(self							)
           A_						       =   ConfigTester(self		,					config_class=UpperCamelCase__		,					has_text_modality=UpperCamelCase__							)



    def        snake_case_      (       self							)    ->   List[Any]:





           '''simple docstring'''
           self.config_tester.run_common_tests()



    def        snake_case_      (       self							)    ->   str:





           '''simple docstring'''
           A_       ,      A_						       =   self.model_tester.prepare_config_and_inputs()
           for model_class in self.all_model_classes:
                  A_						       =   model_class(UpperCamelCase__							)

                  with tempfile.TemporaryDirectory() as tmpdirname:
                         model.save_pretrained(UpperCamelCase__							)
                         A_       ,      A_						       =   model_class.from_pretrained(UpperCamelCase__		,					output_loading_info=UpperCamelCase__							)
                  self.assertEqual(info["""missing_keys"""]		,					[]							)



    def        snake_case_      (       self							)    ->   int:





           '''simple docstring'''
           A_						       =   self.model_tester.prepare_config_and_inputs_for_common()
           self.model_tester.check_encoder_decoder_model_standalone(*UpperCamelCase__							)



    @unittest.skip(reason="""Model has no tokens embeddings"""							)
    def        snake_case_      (       self							)    ->   Dict:





           '''simple docstring'''
           pass



    def        snake_case_      (       self							)    ->   Dict:





           '''simple docstring'''
           A_						       =   inspect.signature(getattr(UpperCamelCase__		,					"""forward"""							)							)
           # The main input is the name of the argument after `self`
           A_						       =   list(model_signature.parameters.keys()							)[1]
           self.assertEqual(AutoformerModel.main_input_name		,					UpperCamelCase__							)



    def        snake_case_      (       self							)    ->   List[str]:





           '''simple docstring'''
           A_       ,      A_						       =   self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
                  A_						       =   model_class(UpperCamelCase__							)
                  A_						       =   inspect.signature(model.forward							)
                  # signature.parameters is an OrderedDict => so arg_names order is deterministic
                  A_						       =   [*signature.parameters.keys()]

                  A_						       =   [
                      """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(UpperCamelCase__							)]		,					UpperCamelCase__							)



    def        snake_case_      (       self							)    ->   Tuple:





           '''simple docstring'''
           A_       ,      A_						       =   self.model_tester.prepare_config_and_inputs_for_common()
           A_						       =   True

           A_						       =   getattr(self.model_tester		,					"""seq_length"""		,					UpperCamelCase__							)
           A_						       =   getattr(self.model_tester		,					"""decoder_seq_length"""		,					UpperCamelCase__							)
           A_						       =   getattr(self.model_tester		,					"""encoder_seq_length"""		,					UpperCamelCase__							)
           A_						       =   getattr(self.model_tester		,					"""d_model"""		,					UpperCamelCase__							)
           A_						       =   getattr(self.model_tester		,					"""num_attention_heads"""		,					UpperCamelCase__							)
           A_						       =   d_model // num_attention_heads

           for model_class in self.all_model_classes:
                  A_						       =   True
                  A_						       =   False
                  A_						       =   True
                  A_						       =   model_class(UpperCamelCase__							)
                  model.to(UpperCamelCase__							)
                  model.eval()
                  with torch.no_grad():
                         A_						       =   model(**self._prepare_for_class(UpperCamelCase__		,					UpperCamelCase__							)							)
                  A_						       =   outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
                  self.assertEqual(len(UpperCamelCase__							)		,					self.model_tester.num_hidden_layers							)

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

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

                  A_						       =   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(UpperCamelCase__		,					UpperCamelCase__							)

                  # decoder attentions
                  A_						       =   outputs.decoder_attentions
                  self.assertIsInstance(UpperCamelCase__		,					(list, tuple)							)
                  self.assertEqual(len(UpperCamelCase__							)		,					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
                  A_						       =   outputs.cross_attentions
                  self.assertIsInstance(UpperCamelCase__		,					(list, tuple)							)
                  self.assertEqual(len(UpperCamelCase__							)		,					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
           A_						       =   True
           A_						       =   True
           A_						       =   model_class(UpperCamelCase__							)
           model.to(UpperCamelCase__							)
           model.eval()
           with torch.no_grad():
                  A_						       =   model(**self._prepare_for_class(UpperCamelCase__		,					UpperCamelCase__							)							)

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

           A_						       =   outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions

           self.assertEqual(len(UpperCamelCase__							)		,					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        snake_case_      (       self							)    ->   List[str]:





           '''simple docstring'''
           super().test_retain_grad_hidden_states_attentions()

def    UpperCAmelCase__     (   UpperCAmelCase__="train-batch.pt"					)      ->      Any:
       A_						       =   hf_hub_download(repo_id="""hf-internal-testing/tourism-monthly-batch""",							filename=UpperCAmelCase__,							repo_type="""dataset"""					)
       A_						       =   torch.load(UpperCAmelCase__,							map_location=UpperCAmelCase__					)
       return batch







@require_torch
@slow
class        A__   (   unittest.TestCase      ):



    def        snake_case_      (       self							)    ->   str:





           '''simple docstring'''
           A_						       =   AutoformerModel.from_pretrained("""huggingface/autoformer-tourism-monthly"""							).to(UpperCamelCase__							)
           A_						       =   prepare_batch()

           with torch.no_grad():
                  A_						       =   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]

           A_						       =   torch.Size(
               (64, model.config.prediction_length + model.config.label_length, model.config.feature_size)							)
           self.assertEqual(output.shape		,					UpperCamelCase__							)

           A_						       =   torch.tensor(
               [[0.3593, -1.3398, 0.6330], [0.2279, 1.5396, -0.1792], [0.0450, 1.3225, -0.2335]]		,					device=UpperCamelCase__							)
           self.assertTrue(torch.allclose(output[0, :3, :3]		,					UpperCamelCase__		,					atol=UpperCamelCase__							)							)



    def        snake_case_      (       self							)    ->   Optional[Any]:





           '''simple docstring'''
           A_						       =   AutoformerForPrediction.from_pretrained("""huggingface/autoformer-tourism-monthly"""							).to(UpperCamelCase__							)
           A_						       =   prepare_batch("""val-batch.pt"""							)
           with torch.no_grad():
                  A_						       =   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
           A_						       =   torch.Size((64, model.config.context_length, model.config.d_model)							)
           self.assertEqual(output.shape		,					UpperCamelCase__							)

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







    def        snake_case_      (       self							)    ->   Optional[Any]:





           '''simple docstring'''
           A_						       =   AutoformerForPrediction.from_pretrained("""huggingface/autoformer-tourism-monthly"""							).to(UpperCamelCase__							)
           A_						       =   prepare_batch("""val-batch.pt"""							)
           with torch.no_grad():
                  A_						       =   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"""]		,					)
           A_						       =   torch.Size((64, model.config.num_parallel_samples, model.config.prediction_length)							)
           self.assertEqual(outputs.sequences.shape		,					UpperCamelCase__							)

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



'''simple docstring'''







import csv

import tweepy

# Twitter API credentials
__lowerCamelCase									=     ''''''
__lowerCamelCase									=     ''''''
__lowerCamelCase									=     ''''''
__lowerCamelCase									=     ''''''
def    UpperCAmelCase__     (   UpperCAmelCase__					)      ->      None:
       # authorize twitter, initialize tweepy
       A_						       =   tweepy.OAuthHandler(UpperCAmelCase__,							UpperCAmelCase__					)
       auth.set_access_token(UpperCAmelCase__,							UpperCAmelCase__					)
       A_						       =   tweepy.API(UpperCAmelCase__					)

       # initialize a list to hold all the tweepy Tweets
       A_						       =   []

       # make initial request for most recent tweets (200 is the maximum allowed count)
       A_						       =   api.user_timeline(screen_name=UpperCAmelCase__,							count=2_00					)

       # save most recent tweets
       alltweets.extend(UpperCAmelCase__					)

       # save the id of the oldest tweet less one
       A_						       =   alltweets[-1].id - 1

       # keep grabbing tweets until there are no tweets left to grab
       while len(UpperCAmelCase__					) > 0:
              print(F'''getting tweets before {oldest}'''					)

              # all subsequent requests use the max_id param to prevent duplicates
              A_						       =   api.user_timeline(
                  screen_name=UpperCAmelCase__,							count=2_00,							max_id=UpperCAmelCase__					)

              # save most recent tweets
              alltweets.extend(UpperCAmelCase__					)

              # update the id of the oldest tweet less one
              A_						       =   alltweets[-1].id - 1

              print(F'''...{len(UpperCAmelCase__					)} tweets downloaded so far'''					)

       # transform the tweepy tweets into a 2D array that will populate the csv
       A_						       =   [[tweet.id_str, tweet.created_at, tweet.text] for tweet in alltweets]

       # write the csv
       with open(F'''new_{screen_name}_tweets.csv''',							"""w"""					) as f:
              A_						       =   csv.writer(UpperCAmelCase__					)
              writer.writerow(["""id""", """created_at""", """text"""]					)
              writer.writerows(UpperCAmelCase__					)


if __name__ == "__main__":
      # pass in the username of the account you want to download
      get_all_tweets('''FirePing32''')
