

import copy
import os
import tempfile
from unittest import TestCase
from unittest.mock import patch

import numpy as np
import pyarrow as pa
import pyarrow.parquet as pq
import pytest

from datasets.arrow_writer import ArrowWriter, OptimizedTypedSequence, ParquetWriter, TypedSequence
from datasets.features import ArrayaD, ClassLabel, Features, Image, Value
from datasets.features.features import ArrayaDExtensionType, cast_to_python_objects
from datasets.keyhash import DuplicatedKeysError, InvalidKeyError

from .utils import require_pil

class 						__UpperCamelCase    (					lowercase						):




	def       __A					(		self	:						List[str]							):


		'''simple docstring'''







		UpperCAmelCase_       				=			pa.array(TypedSequence([1, 2, 3]							)							)
		self.assertEqual(arr.type		,	pa.intaa()							)




	def       __A					(		self	:						List[str]							):


		'''simple docstring'''







		with self.assertRaises(lowerCAmelCase							):
			UpperCAmelCase_       				=			pa.array(TypedSequence([1, 2, 3]							)		,	type=pa.intaa()							)




	def       __A					(		self	:						int							):


		'''simple docstring'''







		with self.assertRaises(lowerCAmelCase							):
			UpperCAmelCase_       				=			pa.array(TypedSequence([1, 2, 3]		,	try_type=Value("bool"							)		,	type=Value("int64"							)							)							)




	def       __A					(		self	:						Dict							):


		'''simple docstring'''







		UpperCAmelCase_       				=			pa.array(TypedSequence([1, 2, 3]		,	type=Value("int32"							)							)							)
		self.assertEqual(arr.type		,	pa.intaa()							)




	def       __A					(		self	:						List[Any]							):


		'''simple docstring'''







		with self.assertRaises((TypeError, pa.lib.ArrowInvalid)							):
			UpperCAmelCase_       				=			pa.array(TypedSequence(["foo", "bar"]		,	type=Value("int64"							)							)							)




	def       __A					(		self	:						Tuple							):


		'''simple docstring'''







		UpperCAmelCase_       				=			pa.array(TypedSequence([1, 2, 3]		,	try_type=Value("int32"							)							)							)
		self.assertEqual(arr.type		,	pa.intaa()							)




	def       __A					(		self	:						int							):


		'''simple docstring'''







		UpperCAmelCase_       				=			pa.array(TypedSequence(["foo", "bar"]		,	try_type=Value("int64"							)							)							)
		self.assertEqual(arr.type		,	pa.string()							)




	def       __A					(		self	:						int							):


		'''simple docstring'''







		UpperCAmelCase_       				=			pa.array(TypedSequence([[[1, 2, 3]]]		,	type=ArrayaD((1, 3)		,	"int64"							)							)							)
		self.assertEqual(arr.type		,	ArrayaDExtensionType((1, 3)		,	"int64"							)							)




	def       __A					(		self	:						Optional[int]							):


		'''simple docstring'''







		with self.assertRaises((TypeError, pa.lib.ArrowInvalid)							):
			UpperCAmelCase_       				=			pa.array(TypedSequence(["foo", "bar"]		,	type=ArrayaD((1, 3)		,	"int64"							)							)							)




	def       __A					(		self	:						Tuple							):


		'''simple docstring'''







		UpperCAmelCase_       				=			pa.array(TypedSequence([[[1, 2, 3]]]		,	try_type=ArrayaD((1, 3)		,	"int64"							)							)							)
		self.assertEqual(arr.type		,	ArrayaDExtensionType((1, 3)		,	"int64"							)							)




	def       __A					(		self	:						Optional[int]							):


		'''simple docstring'''







		UpperCAmelCase_       				=			pa.array(TypedSequence(["foo", "bar"]		,	try_type=ArrayaD((1, 3)		,	"int64"							)							)							)
		self.assertEqual(arr.type		,	pa.string()							)




	@require_pil
	def       __A					(		self	:						List[str]							):


		'''simple docstring'''







		import PIL.Image

		UpperCAmelCase_       				=			PIL.Image.fromarray(np.arange(10		,	dtype=np.uinta							).reshape(2		,	5							)							)
		with patch(
		    "datasets.arrow_writer.cast_to_python_objects"		,	side_effect=lowerCAmelCase							) as mock_cast_to_python_objects:
			UpperCAmelCase_       				=			pa.array(TypedSequence([{"path": None, "bytes": b"image_bytes"}, pil_image]		,	type=Image()							)							)
			UpperCAmelCase_				,   UpperCAmelCase_       				=			mock_cast_to_python_objects.call_args_list[-1]
			self.assertIn("optimize_list_casting"		,	lowerCAmelCase							)
			self.assertFalse(kwargs["optimize_list_casting"]							)



def       __lowerCAmelCase      (						A       ,     A    ):
	UpperCAmelCase_       				=			pa.BufferReader(A    ) if isinstance(A       ,     pa.Buffer    ) else pa.memory_map(A    )
	UpperCAmelCase_       				=			pa.ipc.open_stream(A    )
	UpperCAmelCase_       				=			f.read_all()
	assert len(pa_table.to_batches()    ) == expected_num_chunks
	assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]}
	del pa_table



@pytest.mark.parametrize("writer_batch_size"       ,     [None, 1, 10]    )
@pytest.mark.parametrize(
    "fields"       ,     [None, {"col_1": pa.string(), "col_2": pa.intaa()}, {"col_1": pa.string(), "col_2": pa.intaa()}]    )
def       __lowerCAmelCase      (						A       ,     A    ):
	UpperCAmelCase_       				=			pa.BufferOutputStream()
	UpperCAmelCase_       				=			pa.schema(A    ) if fields else None
	with ArrowWriter(stream=A       ,     schema=A       ,     writer_batch_size=A    ) as writer:
		writer.write({"col_1": "foo", "col_2": 1}    )
		writer.write({"col_1": "bar", "col_2": 2}    )
		UpperCAmelCase_				,   UpperCAmelCase_       				=			writer.finalize()
	assert num_examples == 2
	assert num_bytes > 0
	if not fields:
		UpperCAmelCase_       				=			{"col_1": pa.string(), "col_2": pa.intaa()}
	assert writer._schema == pa.schema(A       ,     metadata=writer._schema.metadata    )
	_check_output(output.getvalue()       ,     expected_num_chunks=num_examples if writer_batch_size == 1 else 1    )



def       __lowerCAmelCase      (						):
	UpperCAmelCase_       				=			pa.BufferOutputStream()
	UpperCAmelCase_       				=			Features({"labels": ClassLabel(names=["neg", "pos"]    )}    )
	with ArrowWriter(stream=A       ,     features=A    ) as writer:
		writer.write({"labels": 0}    )
		writer.write({"labels": 1}    )
		UpperCAmelCase_				,   UpperCAmelCase_       				=			writer.finalize()
	assert num_examples == 2
	assert num_bytes > 0
	assert writer._schema == features.arrow_schema
	assert writer._schema.metadata == features.arrow_schema.metadata
	UpperCAmelCase_       				=			pa.BufferReader(output.getvalue()    )
	UpperCAmelCase_       				=			pa.ipc.open_stream(A    )
	UpperCAmelCase_       				=			f.read_all()
	UpperCAmelCase_       				=			pa_table.schema
	assert pa_table.num_rows == 2
	assert schema == features.arrow_schema
	assert schema.metadata == features.arrow_schema.metadata
	assert features == Features.from_arrow_schema(A    )



@pytest.mark.parametrize("writer_batch_size"       ,     [None, 1, 10]    )
def       __lowerCAmelCase      (						A    ):
	UpperCAmelCase_       				=			pa.BufferOutputStream()
	with ArrowWriter(
	    stream=A       ,     writer_batch_size=A       ,     hash_salt="split_name"       ,     check_duplicates=A       ,     ) as writer:
		with pytest.raises(A    ):
			writer.write({"col_1": "foo", "col_2": 1}       ,     key=[1, 2]    )
			UpperCAmelCase_				,   UpperCAmelCase_       				=			writer.finalize()



@pytest.mark.parametrize("writer_batch_size"       ,     [None, 2, 10]    )
def       __lowerCAmelCase      (						A    ):
	UpperCAmelCase_       				=			pa.BufferOutputStream()
	with ArrowWriter(
	    stream=A       ,     writer_batch_size=A       ,     hash_salt="split_name"       ,     check_duplicates=A       ,     ) as writer:
		with pytest.raises(A    ):
			writer.write({"col_1": "foo", "col_2": 1}       ,     key=10    )
			writer.write({"col_1": "bar", "col_2": 2}       ,     key=10    )
			UpperCAmelCase_				,   UpperCAmelCase_       				=			writer.finalize()



@pytest.mark.parametrize("writer_batch_size"       ,     [None, 2, 10]    )
def       __lowerCAmelCase      (						A    ):
	UpperCAmelCase_       				=			pa.BufferOutputStream()
	with ArrowWriter(
	    stream=A       ,     writer_batch_size=A       ,     hash_salt="split_name"       ,     check_duplicates=A       ,     ) as writer:
		writer.write({"col_1": "foo", "col_2": 1}       ,     key=1    )
		writer.write({"col_1": "bar", "col_2": 2}       ,     key=2    )
		UpperCAmelCase_				,   UpperCAmelCase_       				=			writer.finalize()
	assert num_examples == 2
	assert num_bytes > 0
	_check_output(output.getvalue()       ,     expected_num_chunks=num_examples if writer_batch_size == 1 else 1    )



@pytest.mark.parametrize("writer_batch_size"       ,     [None, 1, 10]    )
@pytest.mark.parametrize(
    "fields"       ,     [None, {"col_1": pa.string(), "col_2": pa.intaa()}, {"col_1": pa.string(), "col_2": pa.intaa()}]    )
def       __lowerCAmelCase      (						A       ,     A    ):
	UpperCAmelCase_       				=			pa.BufferOutputStream()
	UpperCAmelCase_       				=			pa.schema(A    ) if fields else None
	with ArrowWriter(stream=A       ,     schema=A       ,     writer_batch_size=A    ) as writer:
		writer.write_batch({"col_1": ["foo", "bar"], "col_2": [1, 2]}    )
		writer.write_batch({"col_1": [], "col_2": []}    )
		UpperCAmelCase_				,   UpperCAmelCase_       				=			writer.finalize()
	assert num_examples == 2
	assert num_bytes > 0
	if not fields:
		UpperCAmelCase_       				=			{"col_1": pa.string(), "col_2": pa.intaa()}
	assert writer._schema == pa.schema(A       ,     metadata=writer._schema.metadata    )
	_check_output(output.getvalue()       ,     expected_num_chunks=num_examples if writer_batch_size == 1 else 1    )



@pytest.mark.parametrize("writer_batch_size"       ,     [None, 1, 10]    )
@pytest.mark.parametrize(
    "fields"       ,     [None, {"col_1": pa.string(), "col_2": pa.intaa()}, {"col_1": pa.string(), "col_2": pa.intaa()}]    )
def       __lowerCAmelCase      (						A       ,     A    ):
	UpperCAmelCase_       				=			pa.BufferOutputStream()
	UpperCAmelCase_       				=			pa.schema(A    ) if fields else None
	with ArrowWriter(stream=A       ,     schema=A       ,     writer_batch_size=A    ) as writer:
		writer.write_table(pa.Table.from_pydict({"col_1": ["foo", "bar"], "col_2": [1, 2]}    )    )
		UpperCAmelCase_				,   UpperCAmelCase_       				=			writer.finalize()
	assert num_examples == 2
	assert num_bytes > 0
	if not fields:
		UpperCAmelCase_       				=			{"col_1": pa.string(), "col_2": pa.intaa()}
	assert writer._schema == pa.schema(A       ,     metadata=writer._schema.metadata    )
	_check_output(output.getvalue()       ,     expected_num_chunks=num_examples if writer_batch_size == 1 else 1    )



@pytest.mark.parametrize("writer_batch_size"       ,     [None, 1, 10]    )
@pytest.mark.parametrize(
    "fields"       ,     [None, {"col_1": pa.string(), "col_2": pa.intaa()}, {"col_1": pa.string(), "col_2": pa.intaa()}]    )
def       __lowerCAmelCase      (						A       ,     A    ):
	UpperCAmelCase_       				=			pa.BufferOutputStream()
	UpperCAmelCase_       				=			pa.schema(A    ) if fields else None
	with ArrowWriter(stream=A       ,     schema=A       ,     writer_batch_size=A    ) as writer:
		writer.write_row(pa.Table.from_pydict({"col_1": ["foo"], "col_2": [1]}    )    )
		writer.write_row(pa.Table.from_pydict({"col_1": ["bar"], "col_2": [2]}    )    )
		UpperCAmelCase_				,   UpperCAmelCase_       				=			writer.finalize()
	assert num_examples == 2
	assert num_bytes > 0
	if not fields:
		UpperCAmelCase_       				=			{"col_1": pa.string(), "col_2": pa.intaa()}
	assert writer._schema == pa.schema(A       ,     metadata=writer._schema.metadata    )
	_check_output(output.getvalue()       ,     expected_num_chunks=num_examples if writer_batch_size == 1 else 1    )



def       __lowerCAmelCase      (						):
	with tempfile.TemporaryDirectory() as tmp_dir:
		UpperCAmelCase_       				=			{"col_1": pa.string(), "col_2": pa.intaa()}
		UpperCAmelCase_       				=			os.path.join(A       ,     "test.arrow"    )
		with ArrowWriter(path=A       ,     schema=pa.schema(A    )    ) as writer:
			writer.write_batch({"col_1": ["foo", "bar"], "col_2": [1, 2]}    )
			UpperCAmelCase_				,   UpperCAmelCase_       				=			writer.finalize()
		assert num_examples == 2
		assert num_bytes > 0
		assert writer._schema == pa.schema(A       ,     metadata=writer._schema.metadata    )
		_check_output(A       ,     1    )



def       __lowerCAmelCase      (						A    ):
	if pa.types.is_list(A    ):
		return get_base_dtype(arr_type.value_type    )
	else:
		return arr_type



def       __lowerCAmelCase      (						A       ,     A    ):
	if isinstance(lst[0]       ,     A    ):
		change_first_primitive_element_in_list(lst[0]       ,     A    )
	else:
		UpperCAmelCase_       				=			value



@pytest.mark.parametrize("optimized_int_type, expected_dtype"       ,     [(None, pa.intaa()), (Value("int32"    ), pa.intaa())]    )
@pytest.mark.parametrize("sequence"       ,     [[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]]    )
def       __lowerCAmelCase      (						A       ,     A       ,     A    ):
	UpperCAmelCase_       				=			pa.array(TypedSequence(A       ,     optimized_int_type=A    )    )
	assert get_base_dtype(arr.type    ) == expected_dtype



@pytest.mark.parametrize(
    "col, expected_dtype"       ,     [
        ("attention_mask", pa.inta()),
        ("special_tokens_mask", pa.inta()),
        ("token_type_ids", pa.inta()),
        ("input_ids", pa.intaa()),
        ("other", pa.intaa()),
    ]       ,     )
@pytest.mark.parametrize("sequence"       ,     [[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]]    )
def       __lowerCAmelCase      (						A       ,     A       ,     A    ):
	# in range
	UpperCAmelCase_       				=			pa.array(OptimizedTypedSequence(A       ,     col=A    )    )
	assert get_base_dtype(arr.type    ) == expected_dtype

	# not in range
	if col != "other":
		# avoids errors due to in-place modifications
		UpperCAmelCase_       				=			copy.deepcopy(A    )
		UpperCAmelCase_       				=			np.iinfo(expected_dtype.to_pandas_dtype()    ).max + 1
		change_first_primitive_element_in_list(A       ,     A    )
		UpperCAmelCase_       				=			pa.array(OptimizedTypedSequence(A       ,     col=A    )    )
		assert get_base_dtype(arr.type    ) == pa.intaa()



@pytest.mark.parametrize("raise_exception"       ,     [False, True]    )
def       __lowerCAmelCase      (						A       ,     A    ):
	UpperCAmelCase_       				=			str(tmp_path / "dataset-train.arrow"    )
	try:
		with ArrowWriter(path=A    ) as writer:
			if raise_exception:
				raise pa.lib.ArrowInvalid()
			else:
				writer.stream.close()
	except pa.lib.ArrowInvalid:
		pass
	finally:
		assert writer.stream.closed



def       __lowerCAmelCase      (						A    ):
	UpperCAmelCase_       				=			"mock://dataset-train.arrow"
	with ArrowWriter(path=A       ,     storage_options=mockfs.storage_options    ) as writer:
		assert isinstance(writer._fs       ,     type(A    )    )
		assert writer._fs.storage_options == mockfs.storage_options
		writer.write({"col_1": "foo", "col_2": 1}    )
		writer.write({"col_1": "bar", "col_2": 2}    )
		UpperCAmelCase_				,   UpperCAmelCase_       				=			writer.finalize()
	assert num_examples == 2
	assert num_bytes > 0
	assert mockfs.exists(A    )



def       __lowerCAmelCase      (						):
	UpperCAmelCase_       				=			pa.BufferOutputStream()
	with ParquetWriter(stream=A    ) as writer:
		writer.write({"col_1": "foo", "col_2": 1}    )
		writer.write({"col_1": "bar", "col_2": 2}    )
		UpperCAmelCase_				,   UpperCAmelCase_       				=			writer.finalize()
	assert num_examples == 2
	assert num_bytes > 0
	UpperCAmelCase_       				=			pa.BufferReader(output.getvalue()    )
	UpperCAmelCase_       				=			pq.read_table(A    )
	assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]}



@require_pil
@pytest.mark.parametrize("embed_local_files"       ,     [False, True]    )
def       __lowerCAmelCase      (						A       ,     A    ):
	import PIL.Image

	UpperCAmelCase_       				=			str(tmp_path / "test_image_rgb.jpg"    )
	PIL.Image.fromarray(np.zeros((5, 5)       ,     dtype=np.uinta    )    ).save(A       ,     format="png"    )
	UpperCAmelCase_       				=			pa.BufferOutputStream()
	with ParquetWriter(
	    stream=A       ,     features=Features({"image": Image()}    )       ,     embed_local_files=A    ) as writer:
		writer.write({"image": image_path}    )
		writer.finalize()
	UpperCAmelCase_       				=			pa.BufferReader(output.getvalue()    )
	UpperCAmelCase_       				=			pq.read_table(A    )
	UpperCAmelCase_       				=			pa_table.to_pydict()
	if embed_local_files:
		assert isinstance(out["image"][0]["path"]       ,     A    )
		with open(A       ,     "rb"    ) as f:
			assert out["image"][0]["bytes"] == f.read()
	else:
		assert out["image"][0]["path"] == image_path
		assert out["image"][0]["bytes"] is None




def       __lowerCAmelCase      (						):
	UpperCAmelCase_       				=			pa.schema([pa.field("col_1"       ,     pa.string()       ,     nullable=A    )]    )
	UpperCAmelCase_       				=			pa.BufferOutputStream()
	with ArrowWriter(stream=A    ) as writer:
		writer._build_writer(inferred_schema=A    )
		assert writer._schema == pa.schema([pa.field("col_1"       ,     pa.string()    )]    )


import torch

from diffusers import KDPMaDiscreteScheduler
from diffusers.utils import torch_device

from .test_schedulers import SchedulerCommonTest

class 						__UpperCamelCase    (					lowercase						):
	SCREAMING_SNAKE_CASE__    				=     (KDPMaDiscreteScheduler,)
	SCREAMING_SNAKE_CASE__    				=     10




	def       __A					(		self	:						Union[str, Any]		,	**lowerCAmelCase	:						Optional[Any]							):


		'''simple docstring'''







		UpperCAmelCase_       				=			{
		    "num_train_timesteps": 1_100,
		    "beta_start": 0.0_001,
		    "beta_end": 0.02,
		    "beta_schedule": "linear",
		}

		config.update(**lowerCAmelCase							)
		return config




	def       __A					(		self	:						List[Any]							):


		'''simple docstring'''







		for timesteps in [10, 50, 100, 1_000]:
			self.check_over_configs(num_train_timesteps=lowerCAmelCase							)




	def       __A					(		self	:						Optional[Any]							):


		'''simple docstring'''







		for beta_start, beta_end in zip([0.00_001, 0.0_001, 0.001]		,	[0.0_002, 0.002, 0.02]							):
			self.check_over_configs(beta_start=lowerCAmelCase		,	beta_end=lowerCAmelCase							)




	def       __A					(		self	:						List[str]							):


		'''simple docstring'''







		for schedule in ["linear", "scaled_linear"]:
			self.check_over_configs(beta_schedule=lowerCAmelCase							)




	def       __A					(		self	:						List[str]							):


		'''simple docstring'''







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




	def       __A					(		self	:						List[Any]							):


		'''simple docstring'''







		UpperCAmelCase_       				=			self.scheduler_classes[0]
		UpperCAmelCase_       				=			self.get_scheduler_config(prediction_type="v_prediction"							)
		UpperCAmelCase_       				=			scheduler_class(**lowerCAmelCase							)

		scheduler.set_timesteps(self.num_inference_steps							)

		UpperCAmelCase_       				=			self.dummy_model()
		UpperCAmelCase_       				=			self.dummy_sample_deter * scheduler.init_noise_sigma
		UpperCAmelCase_       				=			sample.to(lowerCAmelCase							)

		for i, t in enumerate(scheduler.timesteps							):
			UpperCAmelCase_       				=			scheduler.scale_model_input(lowerCAmelCase		,	lowerCAmelCase							)

			UpperCAmelCase_       				=			model(lowerCAmelCase		,	lowerCAmelCase							)

			UpperCAmelCase_       				=			scheduler.step(lowerCAmelCase		,	lowerCAmelCase		,	lowerCAmelCase							)
			UpperCAmelCase_       				=			output.prev_sample

		UpperCAmelCase_       				=			torch.sum(torch.abs(lowerCAmelCase							)							)
		UpperCAmelCase_       				=			torch.mean(torch.abs(lowerCAmelCase							)							)

		if torch_device in ["cpu", "mps"]:
			assert abs(result_sum.item() - 4.6_934e-07							) < 1e-2
			assert abs(result_mean.item() - 6.1_112e-10							) < 1e-3
		else:
			# CUDA
			assert abs(result_sum.item() - 4.693_428_650_170_972e-07							) < 1e-2
			assert abs(result_mean.item() - 0.0_002							) < 1e-3




	def       __A					(		self	:						int							):


		'''simple docstring'''







		if torch_device == "mps":
			return
		UpperCAmelCase_       				=			self.scheduler_classes[0]
		UpperCAmelCase_       				=			self.get_scheduler_config()
		UpperCAmelCase_       				=			scheduler_class(**lowerCAmelCase							)

		scheduler.set_timesteps(self.num_inference_steps							)

		UpperCAmelCase_       				=			self.dummy_model()
		UpperCAmelCase_       				=			self.dummy_sample_deter * scheduler.init_noise_sigma
		UpperCAmelCase_       				=			sample.to(lowerCAmelCase							)

		for i, t in enumerate(scheduler.timesteps							):
			UpperCAmelCase_       				=			scheduler.scale_model_input(lowerCAmelCase		,	lowerCAmelCase							)

			UpperCAmelCase_       				=			model(lowerCAmelCase		,	lowerCAmelCase							)

			UpperCAmelCase_       				=			scheduler.step(lowerCAmelCase		,	lowerCAmelCase		,	lowerCAmelCase							)
			UpperCAmelCase_       				=			output.prev_sample

		UpperCAmelCase_       				=			torch.sum(torch.abs(lowerCAmelCase							)							)
		UpperCAmelCase_       				=			torch.mean(torch.abs(lowerCAmelCase							)							)

		if torch_device in ["cpu", "mps"]:
			assert abs(result_sum.item() - 20.4_125							) < 1e-2
			assert abs(result_mean.item() - 0.0_266							) < 1e-3
		else:
			# CUDA
			assert abs(result_sum.item() - 20.4_125							) < 1e-2
			assert abs(result_mean.item() - 0.0_266							) < 1e-3




	def       __A					(		self	:						Dict							):


		'''simple docstring'''







		if torch_device == "mps":
			return
		UpperCAmelCase_       				=			self.scheduler_classes[0]
		UpperCAmelCase_       				=			self.get_scheduler_config()
		UpperCAmelCase_       				=			scheduler_class(**lowerCAmelCase							)

		scheduler.set_timesteps(self.num_inference_steps		,	device=lowerCAmelCase							)

		UpperCAmelCase_       				=			self.dummy_model()
		UpperCAmelCase_       				=			self.dummy_sample_deter.to(lowerCAmelCase							) * scheduler.init_noise_sigma

		for t in scheduler.timesteps:
			UpperCAmelCase_       				=			scheduler.scale_model_input(lowerCAmelCase		,	lowerCAmelCase							)

			UpperCAmelCase_       				=			model(lowerCAmelCase		,	lowerCAmelCase							)

			UpperCAmelCase_       				=			scheduler.step(lowerCAmelCase		,	lowerCAmelCase		,	lowerCAmelCase							)
			UpperCAmelCase_       				=			output.prev_sample

		UpperCAmelCase_       				=			torch.sum(torch.abs(lowerCAmelCase							)							)
		UpperCAmelCase_       				=			torch.mean(torch.abs(lowerCAmelCase							)							)

		if str(lowerCAmelCase							).startswith("cpu"							):
			# The following sum varies between 148 and 156 on mps. Why?
			assert abs(result_sum.item() - 20.4_125							) < 1e-2
			assert abs(result_mean.item() - 0.0_266							) < 1e-3
		else:
			# CUDA
			assert abs(result_sum.item() - 20.4_125							) < 1e-2
			assert abs(result_mean.item() - 0.0_266							) < 1e-3