


"""simple docstring"""


from dataclasses import dataclass
from typing import List, Optional, Union

import numpy as np
import PIL
from PIL import Image

from ...utils import (
    BaseOutput,
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_k_diffusion_available,
    is_k_diffusion_version,
    is_onnx_available,
    is_torch_available,
    is_transformers_available,
    is_transformers_version,
)
@dataclass
class   _UpperCamelCase  (   lowerCAmelCase__		):
							'''simple docstring'''







							__UpperCAmelCase						:    Union[List[PIL.Image.Image], np.ndarray]
							__UpperCAmelCase						:    Optional[List[bool]]


try:
	if not (is_transformers_available() and is_torch_available()):
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
	from .pipeline_cycle_diffusion import CycleDiffusionPipeline
	from .pipeline_stable_diffusion import StableDiffusionPipeline
	from .pipeline_stable_diffusion_attend_and_excite import StableDiffusionAttendAndExcitePipeline
	from .pipeline_stable_diffusion_imgaimg import StableDiffusionImgaImgPipeline
	from .pipeline_stable_diffusion_inpaint import StableDiffusionInpaintPipeline
	from .pipeline_stable_diffusion_inpaint_legacy import StableDiffusionInpaintPipelineLegacy
	from .pipeline_stable_diffusion_instruct_pixapix import StableDiffusionInstructPixaPixPipeline
	from .pipeline_stable_diffusion_latent_upscale import StableDiffusionLatentUpscalePipeline
	from .pipeline_stable_diffusion_ldmad import StableDiffusionLDMaDPipeline
	from .pipeline_stable_diffusion_model_editing import StableDiffusionModelEditingPipeline
	from .pipeline_stable_diffusion_panorama import StableDiffusionPanoramaPipeline
	from .pipeline_stable_diffusion_paradigms import StableDiffusionParadigmsPipeline
	from .pipeline_stable_diffusion_sag import StableDiffusionSAGPipeline
	from .pipeline_stable_diffusion_upscale import StableDiffusionUpscalePipeline
	from .pipeline_stable_unclip import StableUnCLIPPipeline
	from .pipeline_stable_unclip_imgaimg import StableUnCLIPImgaImgPipeline
	from .safety_checker import StableDiffusionSafetyChecker
	from .stable_unclip_image_normalizer import StableUnCLIPImageNormalizer

try:
	if not (is_transformers_available() and is_torch_available() and is_transformers_version(">=", "4.25.0")):
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	from ...utils.dummy_torch_and_transformers_objects import StableDiffusionImageVariationPipeline
else:
	from .pipeline_stable_diffusion_image_variation import StableDiffusionImageVariationPipeline


try:
	if not (is_transformers_available() and is_torch_available() and is_transformers_version(">=", "4.26.0")):
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	from ...utils.dummy_torch_and_transformers_objects import (
	    StableDiffusionDepthaImgPipeline,
	    StableDiffusionDiffEditPipeline,
	    StableDiffusionPixaPixZeroPipeline,
	)
else:
	from .pipeline_stable_diffusion_depthaimg import StableDiffusionDepthaImgPipeline
	from .pipeline_stable_diffusion_diffedit import StableDiffusionDiffEditPipeline
	from .pipeline_stable_diffusion_pixapix_zero import StableDiffusionPixaPixZeroPipeline


try:
	if not (
	    is_torch_available()
	    and is_transformers_available()
	    and is_k_diffusion_available()
	    and is_k_diffusion_version(">=", "0.0.12")
	):
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	from ...utils.dummy_torch_and_transformers_and_k_diffusion_objects import *  # noqa F403
else:
	from .pipeline_stable_diffusion_k_diffusion import StableDiffusionKDiffusionPipeline

try:
	if not (is_transformers_available() and is_onnx_available()):
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	from ...utils.dummy_onnx_objects import *  # noqa F403
else:
	from .pipeline_onnx_stable_diffusion import OnnxStableDiffusionPipeline, StableDiffusionOnnxPipeline
	from .pipeline_onnx_stable_diffusion_imgaimg import OnnxStableDiffusionImgaImgPipeline
	from .pipeline_onnx_stable_diffusion_inpaint import OnnxStableDiffusionInpaintPipeline
	from .pipeline_onnx_stable_diffusion_inpaint_legacy import OnnxStableDiffusionInpaintPipelineLegacy
	from .pipeline_onnx_stable_diffusion_upscale import OnnxStableDiffusionUpscalePipeline

if is_transformers_available() and is_flax_available():
	import flax
	@flax.struct.dataclass
	class   _UpperCamelCase  (   lowerCAmelCase__		):
								'''simple docstring'''







								__UpperCAmelCase						:    np.ndarray
								__UpperCAmelCase						:    List[bool]
	from ...schedulers.scheduling_pndm_flax import PNDMSchedulerState
	from .pipeline_flax_stable_diffusion import FlaxStableDiffusionPipeline
	from .pipeline_flax_stable_diffusion_imgaimg import FlaxStableDiffusionImgaImgPipeline
	from .pipeline_flax_stable_diffusion_inpaint import FlaxStableDiffusionInpaintPipeline
	from .safety_checker_flax import FlaxStableDiffusionSafetyChecker







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
lowercase_									=   data_utils.TransfoXLTokenizer
lowercase_									=   data_utils.TransfoXLCorpus
lowercase_									=   data_utils
lowercase_									=   data_utils
def      a      (			A__	:   int      ,   A__	:   Dict      ,   A__	:   Union[str, Any]      ,   A__	:   Union[str, Any]     )    ->      List[str]:





      """simple docstring"""



      if transfo_xl_dataset_file:
            # Convert a pre-processed corpus (see original TensorFlow repo)
            with open(A__      ,   'rb'     ) as fp:
                  _lowercase	       =pickle.load(A__      ,   encoding='latin1'     )
            # Save vocabulary and dataset cache as Dictionaries (should be better than pickles for the long-term)
            _lowercase	       =pytorch_dump_folder_path + '/' + VOCAB_FILES_NAMES['pretrained_vocab_file']
            print(F'''Save vocabulary to {pytorch_vocab_dump_path}'''     )
            _lowercase	       =corpus.vocab.__dict__
            torch.save(A__      ,   A__     )

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

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

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

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


if __name__ == "__main__":
  lowercase_									=   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.',
  )
  lowercase_									=   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,
  )


