




import inspect
import re
from hashlib import shaaaa
from typing import Dict, List

from .arrow import arrow
from .audiofolder import audiofolder
from .csv import csv
from .imagefolder import imagefolder
from .json import json
from .pandas import pandas
from .parquet import parquet
from .sql import sql  # noqa F401
from .text import text


def 		lowerCamelCase__       (						_A				):







	'''simple docstring'''





	snake_case_						       =	[]
	for line in lines:
		snake_case_						       =	re.sub(R"#.*"	,      ""	,      _A				)  # remove comments
		if line:
			filtered_lines.append(_A				)
	snake_case_						       =	"\n".join(_A				)

	# Make a hash from all this code
	snake_case_						       =	full_str.encode("utf-8"				)
	return shaaaa(_A				).hexdigest()


# get importable module names and hash for caching
lowercase__							:	Dict											=		{
    "csv": (csv.__name__, _hash_python_lines(inspect.getsource(csv).splitlines())),
    "json": (json.__name__, _hash_python_lines(inspect.getsource(json).splitlines())),
    "pandas": (pandas.__name__, _hash_python_lines(inspect.getsource(pandas).splitlines())),
    "parquet": (parquet.__name__, _hash_python_lines(inspect.getsource(parquet).splitlines())),
    "arrow": (arrow.__name__, _hash_python_lines(inspect.getsource(arrow).splitlines())),
    "text": (text.__name__, _hash_python_lines(inspect.getsource(text).splitlines())),
    "imagefolder": (imagefolder.__name__, _hash_python_lines(inspect.getsource(imagefolder).splitlines())),
    "audiofolder": (audiofolder.__name__, _hash_python_lines(inspect.getsource(audiofolder).splitlines())),
}

# Used to infer the module to use based on the data files extensions
lowercase__							:	Any											=		{
    ".csv": ("csv", {}),
    ".tsv": ("csv", {"sep": "\t"}),
    ".json": ("json", {}),
    ".jsonl": ("json", {}),
    ".parquet": ("parquet", {}),
    ".arrow": ("arrow", {}),
    ".txt": ("text", {}),
}
_EXTENSION_TO_MODULE.update({ext: ("imagefolder", {}) for ext in imagefolder.ImageFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext.upper(): ("imagefolder", {}) for ext in imagefolder.ImageFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext: ("audiofolder", {}) for ext in audiofolder.AudioFolder.EXTENSIONS})
_EXTENSION_TO_MODULE.update({ext.upper(): ("audiofolder", {}) for ext in audiofolder.AudioFolder.EXTENSIONS})
lowercase__							:	Optional[Any]											=		{"imagefolder", "audiofolder"}

# Used to filter data files based on extensions given a module name
lowercase__							:	Dict[str, List[str]]											=		{}
for _ext, (_module, _) in _EXTENSION_TO_MODULE.items():
		_MODULE_TO_EXTENSIONS.setdefault(_module, []).append(_ext)

_MODULE_TO_EXTENSIONS["imagefolder"].append(".zip")






_MODULE_TO_EXTENSIONS["audiofolder"].append(".zip")






import tempfile

import torch

from diffusers import (
    DEISMultistepScheduler,
    DPMSolverMultistepScheduler,
    DPMSolverSinglestepScheduler,
    UniPCMultistepScheduler,
)

from .test_schedulers import SchedulerCommonTest
class 						UpperCAmelCase  (							UpperCAmelCase__     ):







						'''simple docstring'''





						lowerCAmelCase_							=  (DPMSolverSinglestepScheduler,)
						lowerCAmelCase_							=  (('''num_inference_steps''', 25),)






						def 			snake_case__		(		self				:	str			,      **__lowercase				:	Any		):






							"""simple docstring"""






							snake_case_						       =	{
							    "num_train_timesteps": 10_00,
							    "beta_start": 0.0001,
							    "beta_end": 0.02,
							    "beta_schedule": "linear",
							    "solver_order": 2,
							    "prediction_type": "epsilon",
							    "thresholding": False,
							    "sample_max_value": 1.0,
							    "algorithm_type": "dpmsolver++",
							    "solver_type": "midpoint",
							    "lambda_min_clipped": -float("inf"		),
							    "variance_type": None,
							}

							config.update(**__lowercase		)
							return config






						def 			snake_case__		(		self				:	str			,      __lowercase				:	int=0			,      **__lowercase				:	str		):






							"""simple docstring"""






							snake_case_						       =	dict(self.forward_default_kwargs		)
							snake_case_						       =	kwargs.pop("num_inference_steps"			,      __lowercase		)
							snake_case_						       =	self.dummy_sample
							snake_case_						       =	0.1 * sample
							snake_case_						       =	[residual + 0.2, residual + 0.15, residual + 0.10]

							for scheduler_class in self.scheduler_classes:
								snake_case_						       =	self.get_scheduler_config(**__lowercase		)
								snake_case_						       =	scheduler_class(**__lowercase		)
								scheduler.set_timesteps(__lowercase		)
								# copy over dummy past residuals
								snake_case_						       =	dummy_past_residuals[: scheduler.config.solver_order]

								with tempfile.TemporaryDirectory() as tmpdirname:
									scheduler.save_config(__lowercase		)
									snake_case_						       =	scheduler_class.from_pretrained(__lowercase		)
									new_scheduler.set_timesteps(__lowercase		)
									# copy over dummy past residuals
									snake_case_						       =	dummy_past_residuals[: new_scheduler.config.solver_order]

								snake_case_       , snake_case_						       =	sample, sample
								for t in range(__lowercase			,      time_step + scheduler.config.solver_order + 1		):
									snake_case_						       =	scheduler.step(__lowercase			,      __lowercase			,      __lowercase			,      **__lowercase		).prev_sample
									snake_case_						       =	new_scheduler.step(__lowercase			,      __lowercase			,      __lowercase			,      **__lowercase		).prev_sample

									assert torch.sum(torch.abs(output - new_output		)		) < 1E-5, "Scheduler outputs are not identical"






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






							"""simple docstring"""






							pass






						def 			snake_case__		(		self				:	List[Any]			,      __lowercase				:	Optional[int]=0			,      **__lowercase				:	int		):






							"""simple docstring"""






							snake_case_						       =	dict(self.forward_default_kwargs		)
							snake_case_						       =	kwargs.pop("num_inference_steps"			,      __lowercase		)
							snake_case_						       =	self.dummy_sample
							snake_case_						       =	0.1 * sample
							snake_case_						       =	[residual + 0.2, residual + 0.15, residual + 0.10]

							for scheduler_class in self.scheduler_classes:
								snake_case_						       =	self.get_scheduler_config()
								snake_case_						       =	scheduler_class(**__lowercase		)
								scheduler.set_timesteps(__lowercase		)

								# copy over dummy past residuals (must be after setting timesteps)
								snake_case_						       =	dummy_past_residuals[: scheduler.config.solver_order]

								with tempfile.TemporaryDirectory() as tmpdirname:
									scheduler.save_config(__lowercase		)
									snake_case_						       =	scheduler_class.from_pretrained(__lowercase		)
									# copy over dummy past residuals
									new_scheduler.set_timesteps(__lowercase		)

									# copy over dummy past residual (must be after setting timesteps)
									snake_case_						       =	dummy_past_residuals[: new_scheduler.config.solver_order]

								snake_case_						       =	scheduler.step(__lowercase			,      __lowercase			,      __lowercase			,      **__lowercase		).prev_sample
								snake_case_						       =	new_scheduler.step(__lowercase			,      __lowercase			,      __lowercase			,      **__lowercase		).prev_sample

								assert torch.sum(torch.abs(output - new_output		)		) < 1E-5, "Scheduler outputs are not identical"






						def 			snake_case__		(		self				:	List[str]			,      __lowercase				:	Any=None			,      **__lowercase				:	List[Any]		):






							"""simple docstring"""






							if scheduler is None:
								snake_case_						       =	self.scheduler_classes[0]
								snake_case_						       =	self.get_scheduler_config(**__lowercase		)
								snake_case_						       =	scheduler_class(**__lowercase		)

							snake_case_						       =	self.scheduler_classes[0]
							snake_case_						       =	self.get_scheduler_config(**__lowercase		)
							snake_case_						       =	scheduler_class(**__lowercase		)

							snake_case_						       =	10
							snake_case_						       =	self.dummy_model()
							snake_case_						       =	self.dummy_sample_deter
							scheduler.set_timesteps(__lowercase		)

							for i, t in enumerate(scheduler.timesteps		):
								snake_case_						       =	model(__lowercase			,      __lowercase		)
								snake_case_						       =	scheduler.step(__lowercase			,      __lowercase			,      __lowercase		).prev_sample

							return sample






						def 			snake_case__		(		self				:	Any		):






							"""simple docstring"""






							snake_case_						       =	DPMSolverSinglestepScheduler(**self.get_scheduler_config()		)
							snake_case_						       =	50
							snake_case_						       =	self.dummy_model()
							snake_case_						       =	self.dummy_sample_deter
							scheduler.set_timesteps(__lowercase		)

							# make sure that the first t is uneven
							for i, t in enumerate(scheduler.timesteps[3:]		):
								snake_case_						       =	model(__lowercase			,      __lowercase		)
								snake_case_						       =	scheduler.step(__lowercase			,      __lowercase			,      __lowercase		).prev_sample

							snake_case_						       =	torch.mean(torch.abs(__lowercase		)		)

							assert abs(result_mean.item() - 0.2574		) < 1E-3






						def 			snake_case__		(		self				:	Optional[int]		):






							"""simple docstring"""






							for timesteps in [25, 50, 1_00, 9_99, 10_00]:
								self.check_over_configs(num_train_timesteps=__lowercase		)






						def 			snake_case__		(		self				:	Dict		):






							"""simple docstring"""






							snake_case_						       =	DPMSolverSinglestepScheduler(**self.get_scheduler_config()		)
							snake_case_						       =	self.full_loop(scheduler=__lowercase		)
							snake_case_						       =	torch.mean(torch.abs(__lowercase		)		)

							assert abs(result_mean.item() - 0.2791		) < 1E-3

							snake_case_						       =	DEISMultistepScheduler.from_config(scheduler.config		)
							snake_case_						       =	DPMSolverMultistepScheduler.from_config(scheduler.config		)
							snake_case_						       =	UniPCMultistepScheduler.from_config(scheduler.config		)
							snake_case_						       =	DPMSolverSinglestepScheduler.from_config(scheduler.config		)

							snake_case_						       =	self.full_loop(scheduler=__lowercase		)
							snake_case_						       =	torch.mean(torch.abs(__lowercase		)		)

							assert abs(result_mean.item() - 0.2791		) < 1E-3






						def 			snake_case__		(		self				:	List[str]		):






							"""simple docstring"""






							self.check_over_configs(thresholding=__lowercase		)
							for order in [1, 2, 3]:
								for solver_type in ["midpoint", "heun"]:
									for threshold in [0.5, 1.0, 2.0]:
										for prediction_type in ["epsilon", "sample"]:
											self.check_over_configs(
											    thresholding=__lowercase			,      prediction_type=__lowercase			,      sample_max_value=__lowercase			,      algorithm_type="dpmsolver++"			,      solver_order=__lowercase			,      solver_type=__lowercase			,      )






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






							"""simple docstring"""






							for prediction_type in ["epsilon", "v_prediction"]:
								self.check_over_configs(prediction_type=__lowercase		)






						def 			snake_case__		(		self				:	Optional[Any]		):






							"""simple docstring"""






							for algorithm_type in ["dpmsolver", "dpmsolver++"]:
								for solver_type in ["midpoint", "heun"]:
									for order in [1, 2, 3]:
										for prediction_type in ["epsilon", "sample"]:
											self.check_over_configs(
											    solver_order=__lowercase			,      solver_type=__lowercase			,      prediction_type=__lowercase			,      algorithm_type=__lowercase			,      )
											snake_case_						       =	self.full_loop(
											    solver_order=__lowercase			,      solver_type=__lowercase			,      prediction_type=__lowercase			,      algorithm_type=__lowercase			,      )
											assert not torch.isnan(__lowercase		).any(), "Samples have nan numbers"






						def 			snake_case__		(		self				:	List[Any]		):






							"""simple docstring"""






							self.check_over_configs(lower_order_final=__lowercase		)
							self.check_over_configs(lower_order_final=__lowercase		)






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






							"""simple docstring"""






							self.check_over_configs(lambda_min_clipped=-float("inf"		)		)
							self.check_over_configs(lambda_min_clipped=-5.1		)






						def 			snake_case__		(		self				:	List[Any]		):






							"""simple docstring"""






							self.check_over_configs(variance_type=__lowercase		)
							self.check_over_configs(variance_type="learned_range"		)






						def 			snake_case__		(		self				:	List[Any]		):






							"""simple docstring"""






							for num_inference_steps in [1, 2, 3, 5, 10, 50, 1_00, 9_99, 10_00]:
								self.check_over_forward(num_inference_steps=__lowercase			,      time_step=0		)






						def 			snake_case__		(		self				:	int		):






							"""simple docstring"""






							snake_case_						       =	self.full_loop()
							snake_case_						       =	torch.mean(torch.abs(__lowercase		)		)

							assert abs(result_mean.item() - 0.2791		) < 1E-3






						def 			snake_case__		(		self				:	Any		):






							"""simple docstring"""






							snake_case_						       =	self.full_loop(use_karras_sigmas=__lowercase		)
							snake_case_						       =	torch.mean(torch.abs(__lowercase		)		)

							assert abs(result_mean.item() - 0.2248		) < 1E-3






						def 			snake_case__		(		self				:	str		):






							"""simple docstring"""






							snake_case_						       =	self.full_loop(prediction_type="v_prediction"		)
							snake_case_						       =	torch.mean(torch.abs(__lowercase		)		)

							assert abs(result_mean.item() - 0.1453		) < 1E-3






						def 			snake_case__		(		self				:	int		):






							"""simple docstring"""






							snake_case_						       =	self.full_loop(prediction_type="v_prediction"			,      use_karras_sigmas=__lowercase		)
							snake_case_						       =	torch.mean(torch.abs(__lowercase		)		)

							assert abs(result_mean.item() - 0.0649		) < 1E-3






						def 			snake_case__		(		self				:	Optional[Any]		):






							"""simple docstring"""






							snake_case_						       =	self.scheduler_classes[0]
							snake_case_						       =	self.get_scheduler_config(thresholding=__lowercase			,      dynamic_thresholding_ratio=0		)
							snake_case_						       =	scheduler_class(**__lowercase		)

							snake_case_						       =	10
							snake_case_						       =	self.dummy_model()
							snake_case_						       =	self.dummy_sample_deter.half()
							scheduler.set_timesteps(__lowercase		)

							for i, t in enumerate(scheduler.timesteps		):
								snake_case_						       =	model(__lowercase			,      __lowercase		)
								snake_case_						       =	scheduler.step(__lowercase			,      __lowercase			,      __lowercase		).prev_sample

							assert sample.dtype == torch.floataa
