






import csv

import tweepy

# Twitter API credentials
snake_case    				=		""""""
snake_case    				=		""""""
snake_case    				=		""""""
snake_case    				=		""""""


def   lowerCamelCase__			(     lowercase				):

  """simple docstring"""






  SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    tweepy.OAuthHandler(lowercase						,     lowercase				)
  auth.set_access_token(lowercase						,     lowercase				)
  SCREAMING_SNAKE_CASE       :      Dict							=    tweepy.API(lowercase				)

  # initialize a list to hold all the tweepy Tweets
  SCREAMING_SNAKE_CASE       :      List[Any]							=    []

  # make initial request for most recent tweets (200 is the maximum allowed count)
  SCREAMING_SNAKE_CASE       :      List[Any]							=    api.user_timeline(screen_name=lowercase						,     count=200				)

  # save most recent tweets
  alltweets.extend(lowercase				)

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

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

    # all subsequent requests use the max_id param to prevent duplicates
    SCREAMING_SNAKE_CASE       :      Dict							=    api.user_timeline(
        screen_name=lowercase						,     count=200						,     max_id=lowercase				)

    # save most recent tweets
    alltweets.extend(lowercase				)

    # update the id of the oldest tweet less one
    SCREAMING_SNAKE_CASE       :      List[Any]							=    alltweets[-1].id - 1

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

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


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














import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin


@skip_mps
class  SCREAMING_SNAKE_CASE			(			lowerCAmelCase      ,		lowerCAmelCase      ,		unittest.TestCase					):
     '''simple docstring'''


     UpperCamelCase_							:		Optional[Any]			=	IFImgaImgSuperResolutionPipeline
     UpperCamelCase_							:		Any			=	TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''width''', '''height'''}
     UpperCamelCase_							:		Optional[Any]			=	TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''original_image'''}					)
     UpperCamelCase_							:		str			=	PipelineTesterMixin.required_optional_params - {'''latents'''}


     def 				_A       (				self       :	List[Any]      ):
       return self._get_superresolution_dummy_components()


     def 				_A       (				self       :	Any					, UpperCAmelCase_       :	int					, UpperCAmelCase_       :	List[str]=0      ):
       if str(UpperCAmelCase_      ).startswith("mps"      ):
         SCREAMING_SNAKE_CASE       :      Any							=    torch.manual_seed(UpperCAmelCase_      )
       else:
         SCREAMING_SNAKE_CASE       :      List[str]							=    torch.Generator(device=UpperCAmelCase_      ).manual_seed(UpperCAmelCase_      )

       SCREAMING_SNAKE_CASE       :      Any							=    floats_tensor((1, 3, 32, 32)					, rng=random.Random(UpperCAmelCase_      )      ).to(UpperCAmelCase_      )
       SCREAMING_SNAKE_CASE       :      Any							=    floats_tensor((1, 3, 16, 16)					, rng=random.Random(UpperCAmelCase_      )      ).to(UpperCAmelCase_      )

       SCREAMING_SNAKE_CASE       :      int							=    {
           "prompt": "A painting of a squirrel eating a burger",
           "image": image,
           "original_image": original_image,
           "generator": generator,
           "num_inference_steps": 2,
           "output_type": "numpy",
       }

       return inputs


     @unittest.skipIf(
         torch_device != "cuda" or not is_xformers_available()					, reason="XFormers attention is only available with CUDA and `xformers` installed"					, )
     def 				_A       (				self       :	Tuple      ):
       self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3      )


     def 				_A       (				self       :	Optional[Any]      ):
       self._test_save_load_optional_components()


     @unittest.skipIf(torch_device != "cuda"					, reason="float16 requires CUDA"      )
     def 				_A       (				self       :	List[Any]      ):
       # Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
       super().test_save_load_floataa(expected_max_diff=1E-1      )


     def 				_A       (				self       :	Optional[int]      ):
       self._test_attention_slicing_forward_pass(expected_max_diff=1E-2      )


     def 				_A       (				self       :	Tuple      ):
       self._test_save_load_local()






     def 				_A       (				self       :	List[str]      ):
       self._test_inference_batch_single_identical(
           expected_max_diff=1E-2					, )






