





import gc
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionAttendAndExcitePipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_numpy, skip_mps, slow
from diffusers.utils.testing_utils import require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


lowerCAmelCase_						   =    False



@skip_mps
class        _lowerCAmelCase    (			UpperCAmelCase_							,    UpperCAmelCase_							,    UpperCAmelCase_							,    unittest.TestCase							):


  '''simple docstring'''
  a_							:       Optional[int]      					=StableDiffusionAttendAndExcitePipeline
  a_							:       Optional[Any]      					=False
  a_							:       Union[str, Any]      					=TEXT_TO_IMAGE_PARAMS
  a_							:       Dict      					=TEXT_TO_IMAGE_BATCH_PARAMS.union({"""token_indices"""}							)
  a_							:       Tuple      					=TEXT_TO_IMAGE_IMAGE_PARAMS
  a_							:       List[Any]      					=TEXT_TO_IMAGE_IMAGE_PARAMS







  @classmethod
  def UpperCamelCase_ (      cls      :					List[str]							):


    '''simple docstring'''





    super().setUpClass()
    torch.use_deterministic_algorithms(UpperCamelCase							)







  @classmethod
  def UpperCamelCase_ (      cls      :					List[str]							):


    '''simple docstring'''





    super().tearDownClass()
    torch.use_deterministic_algorithms(UpperCamelCase							)







  def UpperCamelCase_ (      self      :					List[Any]							):


    '''simple docstring'''





    torch.manual_seed(0							)
    _snake_case   :				List[str]														=	UNetaDConditionModel(
        block_out_channels=(32, 64)      ,				layers_per_block=1      ,				sample_size=32      ,				in_channels=4      ,				out_channels=4      ,				down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')      ,				up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')      ,				cross_attention_dim=32      ,				attention_head_dim=(2, 4)      ,				use_linear_projection=UpperCamelCase      ,				)
    _snake_case   :				str														=	DDIMScheduler(
        beta_start=0.0_00_85      ,				beta_end=0.0_12      ,				beta_schedule='scaled_linear'      ,				clip_sample=UpperCamelCase      ,				set_alpha_to_one=UpperCamelCase      ,				)
    torch.manual_seed(0							)
    _snake_case   :				Any														=	AutoencoderKL(
        block_out_channels=[32, 64]      ,				in_channels=3      ,				out_channels=3      ,				down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']      ,				up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']      ,				latent_channels=4      ,				sample_size=1_28      ,				)
    torch.manual_seed(0							)
    _snake_case   :				Any														=	CLIPTextConfig(
        bos_token_id=0      ,				eos_token_id=2      ,				hidden_size=32      ,				intermediate_size=37      ,				layer_norm_eps=1e-0_5      ,				num_attention_heads=4      ,				num_hidden_layers=5      ,				pad_token_id=1      ,				vocab_size=10_00      ,				hidden_act='gelu'      ,				projection_dim=5_12      ,				)
    _snake_case   :				Any														=	CLIPTextModel(UpperCamelCase							)
    _snake_case   :				List[str]														=	CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'							)

    _snake_case   :				int														=	{
        'unet': unet,
        'scheduler': scheduler,
        'vae': vae,
        'text_encoder': text_encoder,
        'tokenizer': tokenizer,
        'safety_checker': None,
        'feature_extractor': None,
    }

    return components







  def UpperCamelCase_ (      self      :					List[str]      ,				UpperCamelCase      :					Dict      ,				UpperCamelCase      :					List[Any]=0							):


    '''simple docstring'''





    if str(UpperCamelCase							).startswith('mps'							):
      _snake_case   :				Any														=	torch.manual_seed(UpperCamelCase							)
    else:
      _snake_case   :				List[str]														=	torch.Generator(device=UpperCamelCase							).manual_seed(UpperCamelCase							)
    _snake_case   :				Union[str, Any]														=	{
        'prompt': 'a cat and a frog',
        'token_indices': [2, 5],
        'generator': generator,
        'num_inference_steps': 1,
        'guidance_scale': 6.0,
        'output_type': 'numpy',
        'max_iter_to_alter': 2,
        'thresholds': {0: 0.7},
    }
    return inputs







  def UpperCamelCase_ (      self      :					Dict							):


    '''simple docstring'''





    _snake_case   :				List[Any]														=	'cpu'

    _snake_case   :				List[Any]														=	self.get_dummy_components()
    _snake_case   :				Any														=	self.pipeline_class(**UpperCamelCase							)
    pipe.to(UpperCamelCase							)
    pipe.set_progress_bar_config(disable=UpperCamelCase							)

    _snake_case   :				Tuple														=	self.get_dummy_inputs(UpperCamelCase							)
    _snake_case   :				Optional[Any]														=	pipe(**UpperCamelCase							).images
    _snake_case   :				Optional[Any]														=	image[0, -3:, -3:, -1]

    self.assertEqual(image.shape      ,				(1, 64, 64, 3)							)
    _snake_case   :				List[str]														=	np.array(
        [0.63_90_53_64, 0.62_89_73_07, 0.48_59_90_17, 0.5_13_36_24, 0.5_55_00_48, 0.45_76_95_16, 0.50_32_69_73, 0.5_02_31_39, 0.45_38_44_96]							)
    _snake_case   :				List[Any]														=	np.abs(image_slice.flatten() - expected_slice							).max()
    self.assertLessEqual(UpperCamelCase      ,				1e-3							)







  def UpperCamelCase_ (      self      :					int							):


    '''simple docstring'''





    super().test_cpu_offload_forward_pass(expected_max_diff=5e-4							)







  def UpperCamelCase_ (      self      :					Optional[int]							):


    '''simple docstring'''





    self._test_inference_batch_consistent(batch_sizes=[1, 2]							)







  def UpperCamelCase_ (      self      :					Dict							):


    '''simple docstring'''





    self._test_inference_batch_single_identical(batch_size=2      ,				expected_max_diff=7e-4							)







  def UpperCamelCase_ (      self      :					List[str]							):


    '''simple docstring'''





    super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3							)







  def UpperCamelCase_ (      self      :					Union[str, Any]							):


    '''simple docstring'''





    super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4							)







  def UpperCamelCase_ (      self      :					Optional[int]							):


    '''simple docstring'''





    super().test_save_load_local(expected_max_difference=5e-4							)







  def UpperCamelCase_ (      self      :					Optional[Any]							):


    '''simple docstring'''





    super().test_save_load_optional_components(expected_max_difference=4e-4							)




@require_torch_gpu
@slow
class        _lowerCAmelCase    (			unittest.TestCase							):


  '''simple docstring'''







  @classmethod
  def UpperCamelCase_ (      cls      :					Optional[Any]							):


    '''simple docstring'''





    super().setUpClass()
    torch.use_deterministic_algorithms(UpperCamelCase							)







  @classmethod
  def UpperCamelCase_ (      cls      :					List[str]							):


    '''simple docstring'''





    super().tearDownClass()
    torch.use_deterministic_algorithms(UpperCamelCase							)







  def UpperCamelCase_ (      self      :					Any							):


    '''simple docstring'''





    super().tearDown()
    gc.collect()
    torch.cuda.empty_cache()







  def UpperCamelCase_ (      self      :					int							):


    '''simple docstring'''





    _snake_case   :				List[str]														=	torch.manual_seed(51							)

    _snake_case   :				Optional[Any]														=	StableDiffusionAttendAndExcitePipeline.from_pretrained(
        'CompVis/stable-diffusion-v1-4'      ,				safety_checker=UpperCamelCase      ,				torch_dtype=torch.floataa							)
    pipe.to('cuda'							)

    _snake_case   :				List[Any]														=	'a painting of an elephant with glasses'
    _snake_case   :				Tuple														=	[5, 7]

    _snake_case   :				int														=	pipe(
        prompt=UpperCamelCase      ,				token_indices=UpperCamelCase      ,				guidance_scale=7.5      ,				generator=UpperCamelCase      ,				num_inference_steps=5      ,				max_iter_to_alter=5      ,				output_type='numpy'      ,				).images[0]

    _snake_case   :				Union[str, Any]														=	load_numpy(
        'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/attend-and-excite/elephant_glasses.npy'							)
    assert np.abs((expected_image - image).max()							) < 5e-1











import csv

import tweepy

# Twitter API credentials
lowerCAmelCase_						   =    """"""
lowerCAmelCase_						   =    """"""
lowerCAmelCase_						   =    """"""
lowerCAmelCase_						   =    """"""


def     lowerCamelCase_	(      lowerCAmelCase:	str				)->		None:
  # authorize twitter, initialize tweepy
  _snake_case   :				Optional[Any]														=	tweepy.OAuthHandler(lowerCAmelCase    ,							lowerCAmelCase				)
  auth.set_access_token(lowerCAmelCase    ,							lowerCAmelCase				)
  _snake_case   :				List[Any]														=	tweepy.API(lowerCAmelCase				)

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

  # make initial request for most recent tweets (200 is the maximum allowed count)
  _snake_case   :				List[str]														=	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
  _snake_case   :				List[Any]														=	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
    _snake_case   :				Tuple														=	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
    _snake_case   :				List[str]														=	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
  _snake_case   :				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:
    _snake_case   :				Any														=	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""")




