
'''simple docstring'''
from ..utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_invisible_watermark_available,
    is_k_diffusion_available,
    is_librosa_available,
    is_note_seq_available,
    is_onnx_available,
    is_torch_available,
    is_transformers_available,
)


try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						from ..utils.dummy_pt_objects import *  # noqa F403
else:
						from .consistency_models import ConsistencyModelPipeline
						from .dance_diffusion import DanceDiffusionPipeline
						from .ddim import DDIMPipeline
						from .ddpm import DDPMPipeline
						from .dit import DiTPipeline
						from .latent_diffusion import LDMSuperResolutionPipeline
						from .latent_diffusion_uncond import LDMPipeline
						from .pipeline_utils import AudioPipelineOutput, DiffusionPipeline, ImagePipelineOutput
						from .pndm import PNDMPipeline
						from .repaint import RePaintPipeline
						from .score_sde_ve import ScoreSdeVePipeline
						from .stochastic_karras_ve import KarrasVePipeline

try:
						if not (is_torch_available() and is_librosa_available()):
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						from ..utils.dummy_torch_and_librosa_objects import *  # noqa F403
else:
						from .audio_diffusion import AudioDiffusionPipeline, Mel

try:
						if not (is_torch_available() and is_transformers_available()):
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						from ..utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
						from .alt_diffusion import AltDiffusionImgaImgPipeline, AltDiffusionPipeline
						from .audioldm import AudioLDMPipeline
						from .controlnet import (
						    StableDiffusionControlNetImgaImgPipeline,
						    StableDiffusionControlNetInpaintPipeline,
						    StableDiffusionControlNetPipeline,
						)
						from .deepfloyd_if import (
						    IFImgaImgPipeline,
						    IFImgaImgSuperResolutionPipeline,
						    IFInpaintingPipeline,
						    IFInpaintingSuperResolutionPipeline,
						    IFPipeline,
						    IFSuperResolutionPipeline,
						)
						from .kandinsky import (
						    KandinskyImgaImgPipeline,
						    KandinskyInpaintPipeline,
						    KandinskyPipeline,
						    KandinskyPriorPipeline,
						)
						from .kandinskya_a import (
						    KandinskyVaaControlnetImgaImgPipeline,
						    KandinskyVaaControlnetPipeline,
						    KandinskyVaaImgaImgPipeline,
						    KandinskyVaaInpaintPipeline,
						    KandinskyVaaPipeline,
						    KandinskyVaaPriorEmbaEmbPipeline,
						    KandinskyVaaPriorPipeline,
						)
						from .latent_diffusion import LDMTextToImagePipeline
						from .paint_by_example import PaintByExamplePipeline
						from .semantic_stable_diffusion import SemanticStableDiffusionPipeline
						from .shap_e import ShapEImgaImgPipeline, ShapEPipeline
						from .stable_diffusion import (
						    CycleDiffusionPipeline,
						    StableDiffusionAttendAndExcitePipeline,
						    StableDiffusionDepthaImgPipeline,
						    StableDiffusionDiffEditPipeline,
						    StableDiffusionImageVariationPipeline,
						    StableDiffusionImgaImgPipeline,
						    StableDiffusionInpaintPipeline,
						    StableDiffusionInpaintPipelineLegacy,
						    StableDiffusionInstructPixaPixPipeline,
						    StableDiffusionLatentUpscalePipeline,
						    StableDiffusionLDMaDPipeline,
						    StableDiffusionModelEditingPipeline,
						    StableDiffusionPanoramaPipeline,
						    StableDiffusionParadigmsPipeline,
						    StableDiffusionPipeline,
						    StableDiffusionPixaPixZeroPipeline,
						    StableDiffusionSAGPipeline,
						    StableDiffusionUpscalePipeline,
						    StableUnCLIPImgaImgPipeline,
						    StableUnCLIPPipeline,
						)
						from .stable_diffusion_safe import StableDiffusionPipelineSafe
						from .text_to_video_synthesis import TextToVideoSDPipeline, TextToVideoZeroPipeline, VideoToVideoSDPipeline
						from .unclip import UnCLIPImageVariationPipeline, UnCLIPPipeline
						from .unidiffuser import ImageTextPipelineOutput, UniDiffuserModel, UniDiffuserPipeline, UniDiffuserTextDecoder
						from .versatile_diffusion import (
						    VersatileDiffusionDualGuidedPipeline,
						    VersatileDiffusionImageVariationPipeline,
						    VersatileDiffusionPipeline,
						    VersatileDiffusionTextToImagePipeline,
						)
						from .vq_diffusion import VQDiffusionPipeline


try:
						if not (is_torch_available() and is_transformers_available() and is_invisible_watermark_available()):
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						from ..utils.dummy_torch_and_transformers_and_invisible_watermark_objects import *  # noqa F403
else:
						from .stable_diffusion_xl import StableDiffusionXLImgaImgPipeline, StableDiffusionXLPipeline

try:
						if not is_onnx_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						from ..utils.dummy_onnx_objects import *  # noqa F403
else:
						from .onnx_utils import OnnxRuntimeModel

try:
						if not (is_torch_available() and is_transformers_available() and is_onnx_available()):
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						from ..utils.dummy_torch_and_transformers_and_onnx_objects import *  # noqa F403
else:
						from .stable_diffusion import (
						    OnnxStableDiffusionImgaImgPipeline,
						    OnnxStableDiffusionInpaintPipeline,
						    OnnxStableDiffusionInpaintPipelineLegacy,
						    OnnxStableDiffusionPipeline,
						    OnnxStableDiffusionUpscalePipeline,
						    StableDiffusionOnnxPipeline,
						)

try:
						if not (is_torch_available() and is_transformers_available() and is_k_diffusion_available()):
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						from ..utils.dummy_torch_and_transformers_and_k_diffusion_objects import *  # noqa F403
else:
						from .stable_diffusion import StableDiffusionKDiffusionPipeline

try:
						if not is_flax_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						from ..utils.dummy_flax_objects import *  # noqa F403
else:
						from .pipeline_flax_utils import FlaxDiffusionPipeline


try:
						if not (is_flax_available() and is_transformers_available()):
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						from ..utils.dummy_flax_and_transformers_objects import *  # noqa F403
else:
						from .controlnet import FlaxStableDiffusionControlNetPipeline
						from .stable_diffusion import (
						    FlaxStableDiffusionImgaImgPipeline,
						    FlaxStableDiffusionInpaintPipeline,
						    FlaxStableDiffusionPipeline,
						)
try:
						if not (is_transformers_available() and is_torch_available() and is_note_seq_available()):
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						from ..utils.dummy_transformers_and_torch_and_note_seq_objects import *  # noqa F403
else:
						from .spectrogram_diffusion import MidiProcessor, SpectrogramDiffusionPipeline




'''simple docstring'''
#
# Sort large text files in a minimum amount of memory
#
import argparse
import os






class      snake_case__    :







		"""simple docstring"""

		lowerCamelCase							=		"""block_{0}.dat"""



		def __init__(	self							:       List[str]   ,     UpperCamelCase__							:       str	)		->       Union[str, Any]:






				"""simple docstring"""







				snake_case   :    Optional[int]			       =		filename
				snake_case   :    Any			       =		[]



		def 	lowerCAmelCase							(	self							:       Any   ,     UpperCamelCase__							:       int   ,     UpperCamelCase__							:       str	)		->       Dict:






				"""simple docstring"""







				snake_case   :    str			       =		self.BLOCK_FILENAME_FORMAT.format(UpperCamelCase__	)
				with open(UpperCamelCase__   ,     '''w'''	) as file:
						file.write(UpperCamelCase__	)
				self.block_filenames.append(UpperCamelCase__	)



		def 	lowerCAmelCase							(	self							:       Optional[Any]	)		->       Optional[int]:






				"""simple docstring"""







				return self.block_filenames



		def 	lowerCAmelCase							(	self							:       Optional[int]   ,     UpperCamelCase__							:       Union[str, Any]   ,     UpperCamelCase__							:       Optional[Any]=None	)		->       Dict:






				"""simple docstring"""







				snake_case   :    Optional[Any]			       =		0
				with open(self.filename	) as file:
						while True:
								snake_case   :    List[str]			       =		file.readlines(UpperCamelCase__	)

								if lines == []:
										break

								if sort_key is None:
										lines.sort()
								else:
										lines.sort(key=UpperCamelCase__	)

								self.write_block(''''''.join(UpperCamelCase__	)   ,     UpperCamelCase__	)
								i += 1



		def 	lowerCAmelCase							(	self							:       Dict	)		->       Optional[Any]:






				"""simple docstring"""







				map(os.remove   ,     self.block_filenames	)







class      snake_case__    :







		"""simple docstring"""

		def 	lowerCAmelCase							(	self							:       str   ,     UpperCamelCase__							:       Optional[int]	)		->       Dict:






				"""simple docstring"""







				snake_case   :    str			       =		-1
				snake_case   :    Optional[Any]			       =		None

				for i in range(len(UpperCamelCase__	)	):
						if min_str is None or choices[i] < min_str:
								snake_case   :    Union[str, Any]			       =		i

				return min_index







class      snake_case__    :







		"""simple docstring"""

		def __init__(	self							:       str   ,     UpperCamelCase__							:       Tuple	)		->       Dict:






				"""simple docstring"""







				snake_case   :    Dict			       =		files
				snake_case   :    Optional[Any]			       =		set()
				snake_case   :    Tuple			       =		len(UpperCamelCase__	)
				snake_case   :    List[Any]			       =		{i: None for i in range(self.num_buffers	)}



		def 	lowerCAmelCase							(	self							:       Tuple	)		->       int:






				"""simple docstring"""







				return {
				    i: self.buffers[i] for i in range(self.num_buffers	) if i not in self.empty
				}



		def 	lowerCAmelCase							(	self							:       List[str]	)		->       int:






				"""simple docstring"""







				for i in range(self.num_buffers	):
						if self.buffers[i] is None and i not in self.empty:
								snake_case   :    Optional[Any]			       =		self.files[i].readline()

								if self.buffers[i] == "":
										self.empty.add(UpperCamelCase__	)
										self.files[i].close()

				if len(self.empty	) == self.num_buffers:
						return False

				return True



		def 	lowerCAmelCase							(	self							:       Optional[Any]   ,     UpperCamelCase__							:       Any	)		->       str:






				"""simple docstring"""







				snake_case   :    List[Any]			       =		self.buffers[index]
				snake_case   :    Optional[int]			       =		None

				return value







class      snake_case__    :







		"""simple docstring"""

		def __init__(	self							:       List[Any]   ,     UpperCamelCase__							:       Optional[Any]	)		->       Optional[Any]:






				"""simple docstring"""







				snake_case   :    Optional[int]			       =		merge_strategy



		def 	lowerCAmelCase							(	self							:       str   ,     UpperCamelCase__							:       Optional[int]   ,     UpperCamelCase__							:       int   ,     UpperCamelCase__							:       Dict	)		->       Tuple:






				"""simple docstring"""







				snake_case   :    List[Any]			       =		FilesArray(self.get_file_handles(UpperCamelCase__   ,     UpperCamelCase__	)	)
				with open(UpperCamelCase__   ,     '''w'''   ,     UpperCamelCase__	) as outfile:
						while buffers.refresh():
								snake_case   :    List[Any]			       =		self.merge_strategy.select(buffers.get_dict()	)
								outfile.write(buffers.unshift(UpperCamelCase__	)	)



		def 	lowerCAmelCase							(	self							:       List[str]   ,     UpperCamelCase__							:       Tuple   ,     UpperCamelCase__							:       str	)		->       int:






				"""simple docstring"""







				snake_case   :    str			       =		{}

				for i in range(len(UpperCamelCase__	)	):
						snake_case   :    Any			       =		open(filenames[i]   ,     '''r'''   ,     UpperCamelCase__	)  # noqa: UP015

				return files







class      snake_case__    :







		"""simple docstring"""

		def __init__(	self							:       Any   ,     UpperCamelCase__							:       Any	)		->       Optional[Any]:






				"""simple docstring"""







				snake_case   :    Optional[Any]			       =		block_size



		def 	lowerCAmelCase							(	self							:       Dict   ,     UpperCamelCase__							:       int   ,     UpperCamelCase__							:       Tuple=None	)		->       Optional[Any]:






				"""simple docstring"""







				snake_case   :    List[str]			       =		self.get_number_blocks(UpperCamelCase__   ,     self.block_size	)
				snake_case   :    Optional[Any]			       =		FileSplitter(UpperCamelCase__	)
				splitter.split(self.block_size   ,     UpperCamelCase__	)

				snake_case   :    Optional[Any]			       =		FileMerger(NWayMerge()	)
				snake_case   :    Any			       =		self.block_size / (num_blocks + 1)
				merger.merge(splitter.get_block_filenames()   ,     filename + '''.out'''   ,     UpperCamelCase__	)

				splitter.cleanup()



		def 	lowerCAmelCase							(	self							:       Optional[Any]   ,     UpperCamelCase__							:       List[str]   ,     UpperCamelCase__							:       Dict	)		->       List[Any]:






				"""simple docstring"""







				return (os.stat(UpperCamelCase__	).st_size / block_size) + 1







def 					_UpperCamelCase		(    SCREAMING_SNAKE_CASE__       )   ->				List[Any]:


		'''simple docstring'''


		if string[-1].lower() == "k":
				return int(string[:-1]       ) * 1024
		elif string[-1].lower() == "m":
				return int(string[:-1]       ) * 1024 * 1024
		elif string[-1].lower() == "g":
				return int(string[:-1]       ) * 1024 * 1024 * 1024
		else:
				return int(SCREAMING_SNAKE_CASE__       )




def 					_UpperCamelCase		(    )   ->				Optional[int]:


		'''simple docstring'''


		snake_case   :    Tuple			       =		argparse.ArgumentParser()
		parser.add_argument(
		    '''-m'''      ,    '''--mem'''      ,    help='''amount of memory to use for sorting'''      ,    default='''100M'''       )
		parser.add_argument(
		    '''filename'''      ,    metavar='''<filename>'''      ,    nargs=1      ,    help='''name of file to sort'''       )
		snake_case   :    Any			       =		parser.parse_args()

		snake_case   :    int			       =		ExternalSort(parse_memory(args.mem       )       )
		sorter.sort(args.filename[0]       )


if __name__ == "__main__":
						main()


