




import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModelWithProjection

from diffusers import (
    AutoencoderKL,
    DPMSolverMultistepScheduler,
    PNDMScheduler,
    StableDiffusionImageVariationPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, nightly, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()

class 	__lowerCAmelCase			(			UpperCamelCase__   , UpperCamelCase__   , UpperCamelCase__   , unittest.TestCase				):
							UpperCamelCase__        =						StableDiffusionImageVariationPipeline
							UpperCamelCase__        =						IMAGE_VARIATION_PARAMS
							UpperCamelCase__        =						IMAGE_VARIATION_BATCH_PARAMS
							UpperCamelCase__        =						frozenset([]				)
							# TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
							UpperCamelCase__        =						frozenset([]				)
							def    lowerCamelCase__							(		self		:str       ):







								'''simple docstring'''







								torch.manual_seed(0       )
								a		       =							UNetaDConditionModel(
								    block_out_channels=(32, 64)	,   layers_per_block=2	,   sample_size=32	,   in_channels=4	,   out_channels=4	,   down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")	,   up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")	,   cross_attention_dim=32	,   )
								a		       =							PNDMScheduler(skip_prk_steps=lowerCAmelCase__       )
								torch.manual_seed(0       )
								a		       =							AutoencoderKL(
								    block_out_channels=[32, 64]	,   in_channels=3	,   out_channels=3	,   down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]	,   up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]	,   latent_channels=4	,   )
								torch.manual_seed(0       )
								a		       =							CLIPVisionConfig(
								    hidden_size=32	,   projection_dim=32	,   intermediate_size=37	,   layer_norm_eps=1E-0_5	,   num_attention_heads=4	,   num_hidden_layers=5	,   image_size=32	,   patch_size=4	,   )
								a		       =							CLIPVisionModelWithProjection(lowerCAmelCase__       )
								a		       =							CLIPImageProcessor(crop_size=32	,   size=32       )

								a		       =							{
								    "unet": unet,
								    "scheduler": scheduler,
								    "vae": vae,
								    "image_encoder": image_encoder,
								    "feature_extractor": feature_extractor,
								    "safety_checker": None,
								}
								return components
							def    lowerCamelCase__							(		self		:Optional[Any]	,   __magic_name__		:Optional[Any]	,   __magic_name__		:Dict=0       ):







								'''simple docstring'''







								a		       =							floats_tensor((1, 3, 32, 32)	,   rng=random.Random(lowerCAmelCase__       )       )
								a		       =							image.cpu().permute(0	,   2	,   3	,   1       )[0]
								a		       =							Image.fromarray(np.uinta(lowerCAmelCase__       )       ).convert("""RGB"""       ).resize((32, 32)       )
								if str(lowerCAmelCase__       ).startswith("""mps"""       ):
									a		       =							torch.manual_seed(lowerCAmelCase__       )
								else:
									a		       =							torch.Generator(device=lowerCAmelCase__       ).manual_seed(lowerCAmelCase__       )
								a		       =							{
								    "image": image,
								    "generator": generator,
								    "num_inference_steps": 2,
								    "guidance_scale": 6.0,
								    "output_type": "numpy",
								}
								return inputs
							def    lowerCamelCase__							(		self		:Union[str, Any]       ):







								'''simple docstring'''







								a		       =							"cpu"  # ensure determinism for the device-dependent torch.Generator
								a		       =							self.get_dummy_components()
								a		       =							StableDiffusionImageVariationPipeline(**lowerCAmelCase__       )
								a		       =							sd_pipe.to(lowerCAmelCase__       )
								sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__       )

								a		       =							self.get_dummy_inputs(lowerCAmelCase__       )
								a		       =							sd_pipe(**lowerCAmelCase__       ).images
								a		       =							image[0, -3:, -3:, -1]

								assert image.shape == (1, 64, 64, 3)
								a		       =							np.array([0.5239, 0.5723, 0.4796, 0.5049, 0.5550, 0.4685, 0.5329, 0.4891, 0.4921]       )

								assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1E-3
							def    lowerCamelCase__							(		self		:Union[str, Any]       ):







								'''simple docstring'''







								a		       =							"cpu"  # ensure determinism for the device-dependent torch.Generator
								a		       =							self.get_dummy_components()
								a		       =							StableDiffusionImageVariationPipeline(**lowerCAmelCase__       )
								a		       =							sd_pipe.to(lowerCAmelCase__       )
								sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__       )

								a		       =							self.get_dummy_inputs(lowerCAmelCase__       )
								a		       =							2 * [inputs["image"]]
								a		       =							sd_pipe(**lowerCAmelCase__       )

								a		       =							output.images

								a		       =							image[-1, -3:, -3:, -1]

								assert image.shape == (2, 64, 64, 3)
								a		       =							np.array([0.6892, 0.5637, 0.5836, 0.5771, 0.6254, 0.6409, 0.5580, 0.5569, 0.5289]       )

								assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1E-3





							def    lowerCamelCase__							(		self		:Any       ):







								'''simple docstring'''







								super().test_inference_batch_single_identical(expected_max_diff=3E-3       )







@slow
@require_torch_gpu
class 	__lowerCAmelCase			(			unittest.TestCase				):
							def    lowerCamelCase__							(		self		:int       ):







								'''simple docstring'''







								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()
							def    lowerCamelCase__							(		self		:int	,   __magic_name__		:List[str]	,   __magic_name__		:str="cpu"	,   __magic_name__		:int=torch.floataa	,   __magic_name__		:Any=0       ):







								'''simple docstring'''







								a		       =							torch.Generator(device=lowerCAmelCase__       ).manual_seed(lowerCAmelCase__       )
								a		       =							load_image(
								    """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"""
								    """/stable_diffusion_imgvar/input_image_vermeer.png"""       )
								a		       =							np.random.RandomState(lowerCAmelCase__       ).standard_normal((1, 4, 64, 64)       )
								a		       =							torch.from_numpy(lowerCAmelCase__       ).to(device=lowerCAmelCase__	,   dtype=lowerCAmelCase__       )
								a		       =							{
								    "image": init_image,
								    "latents": latents,
								    "generator": generator,
								    "num_inference_steps": 3,
								    "guidance_scale": 7.5,
								    "output_type": "numpy",
								}
								return inputs
							def    lowerCamelCase__							(		self		:List[str]       ):







								'''simple docstring'''







								a		       =							StableDiffusionImageVariationPipeline.from_pretrained(
								    """lambdalabs/sd-image-variations-diffusers"""	,   safety_checker=lowerCAmelCase__       )
								a		       =							sd_pipe.to(lowerCAmelCase__       )
								sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__       )

								a		       =							self.get_inputs(lowerCAmelCase__       )
								a		       =							sd_pipe(**lowerCAmelCase__       ).images
								a		       =							image[0, -3:, -3:, -1].flatten()

								assert image.shape == (1, 512, 512, 3)
								a		       =							np.array([0.84491, 0.90789, 0.75708, 0.78734, 0.83485, 0.70099, 0.66938, 0.68727, 0.61379]       )
								assert np.abs(image_slice - expected_slice       ).max() < 6E-3
							def    lowerCamelCase__							(		self		:Optional[Any]       ):







								'''simple docstring'''







								a		       =							0

								def callback_fn(__magic_name__		:Dict	,   __magic_name__		:List[Any]	,   __magic_name__		:List[str]       ) -> None:
									a		       =							True
									nonlocal number_of_steps
									number_of_steps += 1
									if step == 1:
										a		       =							latents.detach().cpu().numpy()
										assert latents.shape == (1, 4, 64, 64)
										a		       =							latents[0, -3:, -3:, -1]
										a		       =							np.array(
										    [-0.1621, 0.2837, -0.7979, -0.1221, -1.3057, 0.7681, -2.1191, 0.0464, 1.6309]       )

										assert np.abs(latents_slice.flatten() - expected_slice       ).max() < 5E-2
									elif step == 2:
										a		       =							latents.detach().cpu().numpy()
										assert latents.shape == (1, 4, 64, 64)
										a		       =							latents[0, -3:, -3:, -1]
										a		       =							np.array([0.6299, 1.7500, 1.1992, -2.1582, -1.8994, 0.7334, -0.7090, 1.0137, 1.5273]       )

										assert np.abs(latents_slice.flatten() - expected_slice       ).max() < 5E-2

								a		       =							False

								a		       =							StableDiffusionImageVariationPipeline.from_pretrained(
								    """fusing/sd-image-variations-diffusers"""	,   safety_checker=lowerCAmelCase__	,   torch_dtype=torch.floataa	,   )
								pipe.to(lowerCAmelCase__       )
								pipe.set_progress_bar_config(disable=lowerCAmelCase__       )
								pipe.enable_attention_slicing()

								a		       =							self.get_inputs(lowerCAmelCase__	,   dtype=torch.floataa       )
								pipe(**lowerCAmelCase__	,   callback=lowerCAmelCase__	,   callback_steps=1       )
								assert callback_fn.has_been_called
								assert number_of_steps == inputs["num_inference_steps"]





							def    lowerCamelCase__							(		self		:List[Any]       ):







								'''simple docstring'''







								torch.cuda.empty_cache()
								torch.cuda.reset_max_memory_allocated()
								torch.cuda.reset_peak_memory_stats()

								a		       =							"fusing/sd-image-variations-diffusers"
								a		       =							StableDiffusionImageVariationPipeline.from_pretrained(
								    lowerCAmelCase__	,   safety_checker=lowerCAmelCase__	,   torch_dtype=torch.floataa       )
								a		       =							pipe.to(lowerCAmelCase__       )
								pipe.set_progress_bar_config(disable=lowerCAmelCase__       )
								pipe.enable_attention_slicing(1       )
								pipe.enable_sequential_cpu_offload()

								a		       =							self.get_inputs(lowerCAmelCase__	,   dtype=torch.floataa       )
								a		       =							pipe(**lowerCAmelCase__       )

								a		       =							torch.cuda.max_memory_allocated()
								# make sure that less than 2.6 GB is allocated
								assert mem_bytes < 2.6 * 10**9







@nightly
@require_torch_gpu
class 	__lowerCAmelCase			(			unittest.TestCase				):
							def    lowerCamelCase__							(		self		:List[Any]       ):







								'''simple docstring'''







								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()
							def    lowerCamelCase__							(		self		:int	,   __magic_name__		:str	,   __magic_name__		:Tuple="cpu"	,   __magic_name__		:Dict=torch.floataa	,   __magic_name__		:Optional[int]=0       ):







								'''simple docstring'''







								a		       =							torch.Generator(device=lowerCAmelCase__       ).manual_seed(lowerCAmelCase__       )
								a		       =							load_image(
								    """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"""
								    """/stable_diffusion_imgvar/input_image_vermeer.png"""       )
								a		       =							np.random.RandomState(lowerCAmelCase__       ).standard_normal((1, 4, 64, 64)       )
								a		       =							torch.from_numpy(lowerCAmelCase__       ).to(device=lowerCAmelCase__	,   dtype=lowerCAmelCase__       )
								a		       =							{
								    "image": init_image,
								    "latents": latents,
								    "generator": generator,
								    "num_inference_steps": 50,
								    "guidance_scale": 7.5,
								    "output_type": "numpy",
								}
								return inputs
							def    lowerCamelCase__							(		self		:Any       ):







								'''simple docstring'''







								a		       =							StableDiffusionImageVariationPipeline.from_pretrained("""fusing/sd-image-variations-diffusers"""       )
								sd_pipe.to(lowerCAmelCase__       )
								sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__       )

								a		       =							self.get_inputs(lowerCAmelCase__       )
								a		       =							sd_pipe(**lowerCAmelCase__       ).images[0]

								a		       =							load_numpy(
								    """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"""
								    """/stable_diffusion_imgvar/lambdalabs_variations_pndm.npy"""       )
								a		       =							np.abs(expected_image - image       ).max()
								assert max_diff < 1E-3





							def    lowerCamelCase__							(		self		:Any       ):







								'''simple docstring'''







								a		       =							StableDiffusionImageVariationPipeline.from_pretrained("""fusing/sd-image-variations-diffusers"""       )
								a		       =							DPMSolverMultistepScheduler.from_config(sd_pipe.scheduler.config       )
								sd_pipe.to(lowerCAmelCase__       )
								sd_pipe.set_progress_bar_config(disable=lowerCAmelCase__       )

								a		       =							self.get_inputs(lowerCAmelCase__       )
								a		       =							25
								a		       =							sd_pipe(**lowerCAmelCase__       ).images[0]

								a		       =							load_numpy(
								    """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"""
								    """/stable_diffusion_imgvar/lambdalabs_variations_dpm_multi.npy"""       )
								a		       =							np.abs(expected_image - image       ).max()
								assert max_diff < 1E-3








import os
import tempfile
from pathlib import Path
from unittest import TestCase

import pyarrow as pa
import pytest

from datasets.arrow_dataset import Dataset
from datasets.arrow_reader import ArrowReader, BaseReader, FileInstructions, ReadInstruction, make_file_instructions
from datasets.info import DatasetInfo
from datasets.splits import NamedSplit, Split, SplitDict, SplitInfo

from .utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases

class 	__lowerCAmelCase			(			__magic_name__				):
							def    lowerCamelCase__							(		self		:List[str]	,   __magic_name__		:Dict	,   __magic_name__		:Union[str, Any]=False       ):







								'''simple docstring'''







								a       ,				a       ,				a		       =							(
								    filename_skip_take["""filename"""],
								    filename_skip_take["""skip"""] if """skip""" in filename_skip_take else None,
								    filename_skip_take["""take"""] if """take""" in filename_skip_take else None,
								)
								open(os.path.join(__magic_name__       )	,   """wb"""       ).close()
								a		       =							pa.Table.from_pydict({"""filename""": [Path(__magic_name__       ).name] * 100}       )
								if take == -1:
									a		       =							len(__magic_name__       ) - skip
								if skip is not None and take is not None:
									a		       =							pa_table.slice(__magic_name__	,   __magic_name__       )
								return pa_table







class 	__lowerCAmelCase			(			__magic_name__				):
							def    lowerCamelCase__							(		self		:List[Any]       ):







								'''simple docstring'''







								a		       =							"""my_name"""
								a		       =							SplitInfo(name="""train"""	,   num_examples=100       )
								a		       =							SplitInfo(name="""test"""	,   num_examples=100       )
								a		       =							[train_info, test_info]
								a		       =							SplitDict()
								split_dict.add(__magic_name__       )
								split_dict.add(__magic_name__       )
								a		       =							DatasetInfo(splits=__magic_name__       )

								with tempfile.TemporaryDirectory() as tmp_dir:
									a		       =							ReaderTest(__magic_name__	,   __magic_name__       )

									a		       =							"""test[:33%]"""
									a		       =							Dataset(**reader.read(__magic_name__	,   __magic_name__	,   __magic_name__       )       )
									self.assertEqual(dset["""filename"""][0]	,   F'{name}-test'       )
									self.assertEqual(dset.num_rows	,   33       )
									self.assertEqual(dset.num_columns	,   1       )

									a		       =							["""train""", """test[:33%]"""]
									a		       =							[Split.TRAIN, ReadInstruction.from_spec("""test[:33%]"""       )]
									for instructions in [instructionsa, instructionsa]:
										a		       =							[reader.read(__magic_name__	,   __magic_name__	,   __magic_name__       ) for instr in instructions]
										a       ,				a		       =							(Dataset(**__magic_name__       ) for dataset_kwargs in datasets_kwargs)
										self.assertEqual(train_dset["""filename"""][0]	,   F'{name}-train'       )
										self.assertEqual(train_dset.num_rows	,   100       )
										self.assertEqual(train_dset.num_columns	,   1       )
										self.assertIsInstance(train_dset.split	,   __magic_name__       )
										self.assertEqual(str(train_dset.split       )	,   """train"""       )
										self.assertEqual(test_dset["""filename"""][0]	,   F'{name}-test'       )
										self.assertEqual(test_dset.num_rows	,   33       )
										self.assertEqual(test_dset.num_columns	,   1       )
										self.assertIsInstance(test_dset.split	,   __magic_name__       )
										self.assertEqual(str(test_dset.split       )	,   """test[:33%]"""       )
										del train_dset, test_dset
							def    lowerCamelCase__							(		self		:Any       ):







								'''simple docstring'''







								a		       =							"""my_name"""
								a		       =							SplitInfo(name="""train"""	,   num_examples=1000	,   shard_lengths=[100] * 10       )
								a		       =							[train_info]
								a		       =							SplitDict()
								split_dict.add(__magic_name__       )
								a		       =							DatasetInfo(splits=__magic_name__       )

								with tempfile.TemporaryDirectory() as tmp_dir:
									a		       =							ReaderTest(__magic_name__	,   __magic_name__       )

									a		       =							"""train[:33%]"""
									a		       =							Dataset(**reader.read(__magic_name__	,   __magic_name__	,   __magic_name__       )       )
									self.assertEqual(dset["""filename"""][0]	,   F'{name}-train-00000-of-00010'       )
									self.assertEqual(dset["""filename"""][-1]	,   F'{name}-train-00003-of-00010'       )
									self.assertEqual(dset.num_rows	,   330       )
									self.assertEqual(dset.num_columns	,   1       )





							def    lowerCamelCase__							(		self		:List[str]       ):







								'''simple docstring'''







								a		       =							SplitInfo(name="""train"""	,   num_examples=100       )
								a		       =							SplitInfo(name="""test"""	,   num_examples=100       )
								a		       =							SplitDict()
								split_dict.add(__magic_name__       )
								split_dict.add(__magic_name__       )
								a		       =							DatasetInfo(splits=__magic_name__       )

								with tempfile.TemporaryDirectory() as tmp_dir:
									a		       =							ReaderTest(__magic_name__	,   __magic_name__       )

									a		       =							[
									    {"""filename""": os.path.join(__magic_name__	,   """train"""       )},
									    {"""filename""": os.path.join(__magic_name__	,   """test"""       ), """skip""": 10, """take""": 10},
									]
									a		       =							Dataset(**reader.read_files(__magic_name__	,   original_instructions="""train+test[10:20]"""       )       )
									self.assertEqual(dset.num_rows	,   110       )
									self.assertEqual(dset.num_columns	,   1       )
									del dset







@pytest.mark.parametrize("""in_memory"""							,    [False, True]					)
def 	__A	(			__lowerCamelCase							,    __lowerCamelCase							,    __lowerCamelCase					)   -> Optional[int]:
	a		       =							arrow_file
	with assert_arrow_memory_increases() if in_memory else assert_arrow_memory_doesnt_increase():
		a		       =							ArrowReader.read_table(__lowerCamelCase							,    in_memory=__lowerCamelCase					)
	assert table.shape == dataset.data.shape
	assert set(table.column_names					) == set(dataset.data.column_names					)
	assert dict(table.to_pydict()					) == dict(dataset.data.to_pydict()					)  # to_pydict returns OrderedDict





@pytest.mark.parametrize("""in_memory"""							,    [False, True]					)
def 	__A	(			__lowerCamelCase							,    __lowerCamelCase							,    __lowerCamelCase					)   -> str:
	a		       =							arrow_file
	a		       =							ArrowReader(""""""							,    __lowerCamelCase					)
	with assert_arrow_memory_increases() if in_memory else assert_arrow_memory_doesnt_increase():
		a		       =							reader.read_files([{"""filename""": filename}]							,    in_memory=__lowerCamelCase					)
	assert dataset_kwargs.keys() == {"arrow_table", "info", "split"}
	a		       =							dataset_kwargs["""arrow_table"""]
	assert table.shape == dataset.data.shape
	assert set(table.column_names					) == set(dataset.data.column_names					)
	assert dict(table.to_pydict()					) == dict(dataset.data.to_pydict()					)  # to_pydict returns OrderedDict





def 	__A	(			)   -> int:
	assert ReadInstruction("""train"""							,    to=10							,    unit="""abs"""					).to_spec() == "train[:10]"
	assert ReadInstruction("""train"""							,    from_=-80							,    to=10							,    unit="""%"""					).to_spec() == "train[-80%:10%]"

	a		       =							"""train+test"""
	assert ReadInstruction.from_spec(__lowerCamelCase					).to_spec() == spec_train_test

	a		       =							"""train[2:10]"""
	assert ReadInstruction.from_spec(__lowerCamelCase					).to_spec() == spec_train_abs

	a		       =							"""train[15%:-20%]"""
	assert ReadInstruction.from_spec(__lowerCamelCase					).to_spec() == spec_train_pct

	a		       =							"""train[:10%](closest)"""
	assert ReadInstruction.from_spec(__lowerCamelCase					).to_spec() == "train[:10%]"

	a		       =							"""train[:10%](pct1_dropremainder)"""
	assert ReadInstruction.from_spec(__lowerCamelCase					).to_spec() == spec_train_pct_rounding

	a		       =							"""train[:10%](pct1_dropremainder)+test[-10%:](pct1_dropremainder)"""
	assert ReadInstruction.from_spec(__lowerCamelCase					).to_spec() == spec_train_test_pct_rounding





def 	__A	(			)   -> Any:
	a		       =							"""dummy"""
	a		       =							[SplitInfo(name="""train"""							,    num_examples=100					)]
	a		       =							"""train[:33%]"""
	a		       =							"""arrow"""
	a		       =							"""prefix"""

	a		       =							make_file_instructions(__lowerCamelCase							,    __lowerCamelCase							,    __lowerCamelCase							,    __lowerCamelCase							,    __lowerCamelCase					)
	assert isinstance(__lowerCamelCase							,    __lowerCamelCase					)
	assert file_instructions.num_examples == 33
	assert file_instructions.file_instructions == [
	    {"filename": os.path.join(__lowerCamelCase							,    f'{name}-train.arrow'					), "skip": 0, "take": 33}
	]

	a		       =							[SplitInfo(name="""train"""							,    num_examples=100							,    shard_lengths=[10] * 10					)]
	a		       =							make_file_instructions(__lowerCamelCase							,    __lowerCamelCase							,    __lowerCamelCase							,    __lowerCamelCase							,    __lowerCamelCase					)
	assert isinstance(__lowerCamelCase							,    __lowerCamelCase					)
	assert file_instructions.num_examples == 33
	assert file_instructions.file_instructions == [
	    {"filename": os.path.join(__lowerCamelCase							,    f'{name}-train-00000-of-00010.arrow'					), "skip": 0, "take": -1},
	    {"filename": os.path.join(__lowerCamelCase							,    f'{name}-train-00001-of-00010.arrow'					), "skip": 0, "take": -1},
	    {"filename": os.path.join(__lowerCamelCase							,    f'{name}-train-00002-of-00010.arrow'					), "skip": 0, "take": -1},
	    {"filename": os.path.join(__lowerCamelCase							,    f'{name}-train-00003-of-00010.arrow'					), "skip": 0, "take": 3},
	]





@pytest.mark.parametrize("""name, expected_exception"""							,    [(None, TypeError), ("""""", ValueError)]					)
def 	__A	(			__lowerCamelCase							,    __lowerCamelCase					)   -> int:
	a		       =							[SplitInfo(name="""train"""							,    num_examples=100					)]
	a		       =							"""train"""
	a		       =							"""arrow"""
	a		       =							"""prefix_path"""
	with pytest.raises(__lowerCamelCase					):
		a		       =							make_file_instructions(__lowerCamelCase							,    __lowerCamelCase							,    __lowerCamelCase							,    __lowerCamelCase							,    __lowerCamelCase					)

