


import argparse
import os
import shutil
from pathlib import Path

import onnx
import torch
from packaging import version
from torch.onnx import export

from diffusers import OnnxRuntimeModel, OnnxStableDiffusionPipeline, StableDiffusionPipeline


A      = version.parse(version.parse(torch.__version__).base_version) < version.parse("1.11")





def __UpperCAmelCase       (		__A ,						__A ,						__A ,						__A ,						__A ,						__A ,						__A ,						__A=False ,						)						->					Any:



  '''simple docstring'''





  output_path.parent.mkdir(parents=__A ,						exist_ok=__A			)
  # PyTorch deprecated the `enable_onnx_checker` and `use_external_data_format` arguments in v1.11,
  # so we check the torch version for backwards compatibility
  if is_torch_less_than_1_11:
    export(
        __A ,						__A ,						f=output_path.as_posix() ,						input_names=__A ,						output_names=__A ,						dynamic_axes=__A ,						do_constant_folding=__A ,						use_external_data_format=__A ,						enable_onnx_checker=__A ,						opset_version=__A ,						)
  else:
    export(
        __A ,						__A ,						f=output_path.as_posix() ,						input_names=__A ,						output_names=__A ,						dynamic_axes=__A ,						do_constant_folding=__A ,						opset_version=__A ,						)





@torch.no_grad()
def __UpperCAmelCase       (		__A ,						__A ,						__A ,						__A = False			)						->					str:



  '''simple docstring'''





  UpperCAmelCase__										=     torch.floataa if fpaa else torch.floataa
  if fpaa and torch.cuda.is_available():
    UpperCAmelCase__										=     "cuda"
  elif fpaa and not torch.cuda.is_available():
    raise ValueError("`float16` model export is only supported on GPUs with CUDA"			)
  else:
    UpperCAmelCase__										=     "cpu"
  UpperCAmelCase__										=     StableDiffusionPipeline.from_pretrained(__A ,						torch_dtype=__A			).to(__A			)
  UpperCAmelCase__										=     Path(__A			)

  # TEXT ENCODER
  UpperCAmelCase__										=     pipeline.text_encoder.config.max_position_embeddings
  UpperCAmelCase__										=     pipeline.text_encoder.config.hidden_size
  UpperCAmelCase__										=     pipeline.tokenizer(
      "A sample prompt" ,						padding="max_length" ,						max_length=pipeline.tokenizer.model_max_length ,						truncation=__A ,						return_tensors="pt" ,						)
  onnx_export(
      pipeline.text_encoder ,						model_args=(text_input.input_ids.to(device=__A ,						dtype=torch.intaa			)) ,						output_path=output_path / "text_encoder" / "model.onnx" ,						ordered_input_names=["input_ids"] ,						output_names=["last_hidden_state", "pooler_output"] ,						dynamic_axes={
          "input_ids": {0: "batch", 1: "sequence"},
      } ,						opset=__A ,						)
  del pipeline.text_encoder

  # UNET
  UpperCAmelCase__										=     pipeline.unet.config.in_channels
  UpperCAmelCase__										=     pipeline.unet.config.sample_size
  UpperCAmelCase__										=     output_path / "unet" / "model.onnx"
  onnx_export(
      pipeline.unet ,						model_args=(
          torch.randn(2 ,						__A ,						__A ,						__A			).to(device=__A ,						dtype=__A			),
          torch.randn(2			).to(device=__A ,						dtype=__A			),
          torch.randn(2 ,						__A ,						__A			).to(device=__A ,						dtype=__A			),
          False,
      ) ,						output_path=__A ,						ordered_input_names=["sample", "timestep", "encoder_hidden_states", "return_dict"] ,						output_names=["out_sample"] ,						dynamic_axes={
          "sample": {0: "batch", 1: "channels", 2: "height", 3: "width"},
          "timestep": {0: "batch"},
          "encoder_hidden_states": {0: "batch", 1: "sequence"},
      } ,						opset=__A ,						use_external_data_format=__A ,						)
  UpperCAmelCase__										=     str(unet_path.absolute().as_posix()			)
  UpperCAmelCase__										=     os.path.dirname(__A			)
  UpperCAmelCase__										=     onnx.load(__A			)
  # clean up existing tensor files
  shutil.rmtree(__A			)
  os.mkdir(__A			)
  # collate external tensor files into one
  onnx.save_model(
      __A ,						__A ,						save_as_external_data=__A ,						all_tensors_to_one_file=__A ,						location="weights.pb" ,						convert_attribute=__A ,						)
  del pipeline.unet

  # VAE ENCODER
  UpperCAmelCase__										=     pipeline.vae
  UpperCAmelCase__										=     vae_encoder.config.in_channels
  UpperCAmelCase__										=     vae_encoder.config.sample_size
  # need to get the raw tensor output (sample) from the encoder
  UpperCAmelCase__										=     lambda __A ,						__A			: vae_encoder.encode(__A ,						__A			)[0].sample()
  onnx_export(
      __A ,						model_args=(
          torch.randn(1 ,						__A ,						__A ,						__A			).to(device=__A ,						dtype=__A			),
          False,
      ) ,						output_path=output_path / "vae_encoder" / "model.onnx" ,						ordered_input_names=["sample", "return_dict"] ,						output_names=["latent_sample"] ,						dynamic_axes={
          "sample": {0: "batch", 1: "channels", 2: "height", 3: "width"},
      } ,						opset=__A ,						)

  # VAE DECODER
  UpperCAmelCase__										=     pipeline.vae
  UpperCAmelCase__										=     vae_decoder.config.latent_channels
  UpperCAmelCase__										=     vae_decoder.config.out_channels
  # forward only through the decoder part
  UpperCAmelCase__										=     vae_encoder.decode
  onnx_export(
      __A ,						model_args=(
          torch.randn(1 ,						__A ,						__A ,						__A			).to(device=__A ,						dtype=__A			),
          False,
      ) ,						output_path=output_path / "vae_decoder" / "model.onnx" ,						ordered_input_names=["latent_sample", "return_dict"] ,						output_names=["sample"] ,						dynamic_axes={
          "latent_sample": {0: "batch", 1: "channels", 2: "height", 3: "width"},
      } ,						opset=__A ,						)
  del pipeline.vae

  # SAFETY CHECKER
  if pipeline.safety_checker is not None:
    UpperCAmelCase__										=     pipeline.safety_checker
    UpperCAmelCase__										=     safety_checker.config.vision_config.num_channels
    UpperCAmelCase__										=     safety_checker.config.vision_config.image_size
    UpperCAmelCase__										=     safety_checker.forward_onnx
    onnx_export(
        pipeline.safety_checker ,						model_args=(
            torch.randn(
                1 ,						__A ,						__A ,						__A ,						).to(device=__A ,						dtype=__A			),
            torch.randn(1 ,						__A ,						__A ,						__A			).to(device=__A ,						dtype=__A			),
        ) ,						output_path=output_path / "safety_checker" / "model.onnx" ,						ordered_input_names=["clip_input", "images"] ,						output_names=["out_images", "has_nsfw_concepts"] ,						dynamic_axes={
            "clip_input": {0: "batch", 1: "channels", 2: "height", 3: "width"},
            "images": {0: "batch", 1: "height", 2: "width", 3: "channels"},
        } ,						opset=__A ,						)
    del pipeline.safety_checker
    UpperCAmelCase__										=     OnnxRuntimeModel.from_pretrained(output_path / "safety_checker"			)
    UpperCAmelCase__										=     pipeline.feature_extractor
  else:
    UpperCAmelCase__										=     None
    UpperCAmelCase__										=     None

  UpperCAmelCase__										=     OnnxStableDiffusionPipeline(
      vae_encoder=OnnxRuntimeModel.from_pretrained(output_path / "vae_encoder"			) ,						vae_decoder=OnnxRuntimeModel.from_pretrained(output_path / "vae_decoder"			) ,						text_encoder=OnnxRuntimeModel.from_pretrained(output_path / "text_encoder"			) ,						tokenizer=pipeline.tokenizer ,						unet=OnnxRuntimeModel.from_pretrained(output_path / "unet"			) ,						scheduler=pipeline.scheduler ,						safety_checker=__A ,						feature_extractor=__A ,						requires_safety_checker=safety_checker is not None ,						)

  onnx_pipeline.save_pretrained(__A			)
  print("ONNX pipeline saved to" ,						__A			)

  del pipeline
  del onnx_pipeline
  UpperCAmelCase__										=     OnnxStableDiffusionPipeline.from_pretrained(__A ,						provider="CPUExecutionProvider"			)
  print("ONNX pipeline is loadable"			)


if __name__ == "__main__":
    A      = argparse.ArgumentParser()

    parser.add_argument(
        "--model_path",
        type=str,
        required=True,
        help="Path to the `diffusers` checkpoint to convert (either a local directory or on the Hub).",
    )

    parser.add_argument("--output_path", type=str, required=True, help="Path to the output model.")

    parser.add_argument(
        "--opset",
        default=14,
        type=int,
        help="The version of the ONNX operator set to use.",
    )
    parser.add_argument("--fp16", action="store_true", default=False, help="Export the models in `float16` mode")

    A      = parser.parse_args()

    convert_models(args.model_path, args.output_path, args.opset, args.fpaa)









import csv

import tweepy

# Twitter API credentials
A      = ""
A      = ""
A      = ""
A      = ""





def __UpperCAmelCase       (		__A			)						->					None:



       '''simple docstring'''





       UpperCAmelCase__										=     tweepy.OAuthHandler(__A ,						__A			)
       auth.set_access_token(__A ,						__A			)
       UpperCAmelCase__										=     tweepy.API(__A			)

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

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

       # save most recent tweets
       alltweets.extend(__A			)

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

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

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

              # save most recent tweets
              alltweets.extend(__A			)

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

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

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


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





