




import csv

import tweepy

# Twitter API credentials
__magic_name__  :  str					=       """"""
__magic_name__  :  Union[str, Any]					=       """"""
__magic_name__  :  List[Any]					=       """"""
__magic_name__  :  Dict					=       """"""
def 		a_							( __lowerCAmelCase				):
  # authorize twitter, initialize tweepy
  lowerCAmelCase__										=      tweepy.OAuthHandler(__lowerCAmelCase   , __lowerCAmelCase				)
  auth.set_access_token(__lowerCAmelCase   , __lowerCAmelCase				)
  lowerCAmelCase__										=      tweepy.API(__lowerCAmelCase				)

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

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

  # save most recent tweets
  alltweets.extend(__lowerCAmelCase				)

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

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

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

    # save most recent tweets
    alltweets.extend(__lowerCAmelCase				)

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

    print(F"""...{len(__lowerCAmelCase				)} tweets downloaded so far"""				)

  # transform the tweepy tweets into a 2D array that will populate the csv
  lowerCAmelCase__										=      [[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:
    lowerCAmelCase__										=      csv.writer(__lowerCAmelCase				)
    writer.writerow(['''id''', '''created_at''', '''text''']				)
    writer.writerows(__lowerCAmelCase				)


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







import argparse
import os
import pickle
import sys

import torch

from transformers import TransfoXLConfig, TransfoXLLMHeadModel, load_tf_weights_in_transfo_xl
from transformers.models.transfo_xl import tokenization_transfo_xl as data_utils
from transformers.models.transfo_xl.tokenization_transfo_xl import CORPUS_NAME, VOCAB_FILES_NAMES
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()

# We do this to be able to load python 2 datasets pickles
# See e.g. https://stackoverflow.com/questions/2121874/python-pickling-after-changing-a-modules-directory/2121918#2121918
__magic_name__  :  Tuple					=       data_utils.TransfoXLTokenizer
__magic_name__  :  int					=       data_utils.TransfoXLCorpus
__magic_name__  :  List[str]					=       data_utils
__magic_name__  :  str					=       data_utils
def 		a_							( __lowerCAmelCase   , __lowerCAmelCase   , __lowerCAmelCase   , __lowerCAmelCase				):
  if transfo_xl_dataset_file:
    # Convert a pre-processed corpus (see original TensorFlow repo)
    with open(__lowerCAmelCase   , '''rb'''				) as fp:
      lowerCAmelCase__										=      pickle.load(__lowerCAmelCase   , encoding='''latin1'''				)
    # Save vocabulary and dataset cache as Dictionaries (should be better than pickles for the long-term)
    lowerCAmelCase__										=      pytorch_dump_folder_path + '''/''' + VOCAB_FILES_NAMES['''pretrained_vocab_file''']
    print(F"""Save vocabulary to {pytorch_vocab_dump_path}"""				)
    lowerCAmelCase__										=      corpus.vocab.__dict__
    torch.save(__lowerCAmelCase   , __lowerCAmelCase				)

    lowerCAmelCase__										=      corpus.__dict__
    corpus_dict_no_vocab.pop('''vocab'''   , __lowerCAmelCase				)
    lowerCAmelCase__										=      pytorch_dump_folder_path + '''/''' + CORPUS_NAME
    print(F"""Save dataset to {pytorch_dataset_dump_path}"""				)
    torch.save(__lowerCAmelCase   , __lowerCAmelCase				)

  if tf_checkpoint_path:
    # Convert a pre-trained TensorFlow model
    lowerCAmelCase__										=      os.path.abspath(__lowerCAmelCase				)
    lowerCAmelCase__										=      os.path.abspath(__lowerCAmelCase				)

    print(F"""Converting Transformer XL checkpoint from {tf_path} with config at {config_path}."""				)
    # Initialise PyTorch model
    if transfo_xl_config_file == "":
      lowerCAmelCase__										=      TransfoXLConfig()
    else:
      lowerCAmelCase__										=      TransfoXLConfig.from_json_file(__lowerCAmelCase				)
    print(F"""Building PyTorch model from configuration: {config}"""				)
    lowerCAmelCase__										=      TransfoXLLMHeadModel(__lowerCAmelCase				)

    lowerCAmelCase__										=      load_tf_weights_in_transfo_xl(__lowerCAmelCase   , __lowerCAmelCase   , __lowerCAmelCase				)
    # Save pytorch-model
    lowerCAmelCase__										=      os.path.join(__lowerCAmelCase   , __lowerCAmelCase				)
    lowerCAmelCase__										=      os.path.join(__lowerCAmelCase   , __lowerCAmelCase				)
    print(F"""Save PyTorch model to {os.path.abspath(__lowerCAmelCase				)}"""				)
    torch.save(model.state_dict()   , __lowerCAmelCase				)
    print(F"""Save configuration file to {os.path.abspath(__lowerCAmelCase				)}"""				)
    with open(__lowerCAmelCase   , '''w'''   , encoding='''utf-8'''				) as f:
      f.write(config.to_json_string()				)


if __name__ == "__main__":
      __magic_name__  :  int					=       argparse.ArgumentParser()
      parser.add_argument(
          """--pytorch_dump_folder_path""",
          default=None,
          type=str,
          required=True,
          help="""Path to the folder to store the PyTorch model or dataset/vocab.""",
      )
      parser.add_argument(
          """--tf_checkpoint_path""",
          default="""""",
          type=str,
          help="""An optional path to a TensorFlow checkpoint path to be converted.""",
      )
      parser.add_argument(
          """--transfo_xl_config_file""",
          default="""""",
          type=str,
          help=(
              """An optional config json file corresponding to the pre-trained BERT model. \n"""
              """This specifies the model architecture."""
          ),
      )
      parser.add_argument(
          """--transfo_xl_dataset_file""",
          default="""""",
          type=str,
          help="""An optional dataset file to be converted in a vocabulary.""",
      )
      __magic_name__  :  Optional[Any]					=       parser.parse_args()
      convert_transfo_xl_checkpoint_to_pytorch(
          args.tf_checkpoint_path,
          args.transfo_xl_config_file,
          args.pytorch_dump_folder_path,
          args.transfo_xl_dataset_file,
      )

