





"""simple docstring"""
from dataclasses import dataclass
from typing import List, Optional, Tuple, Union

import numpy as np
import torch

from ..configuration_utils import ConfigMixin, register_to_config
from ..utils import BaseOutput, logging, randn_tensor
from .scheduling_utils import SchedulerMixin


__UpperCamelCase			:		Optional[Any]		    =   logging.get_logger(__name__)  # pylint: disable=invalid-name







@dataclass
class 	a				(					a__   ):
 snake_case__    	=    42







class 	a				(					a__					,      a__   ):
 snake_case__    	=    1



 @register_to_config
 def __init__(			self							,    _snake_case = 40							,    _snake_case = 0.002							,    _snake_case = 80.0							,    _snake_case = 0.5							,    _snake_case = 1.0							,    _snake_case = 7.0							,    _snake_case = True							,    ):







  """simple docstring"""






  lowerCAmelCase  							=      sigma_max

  lowerCAmelCase  							=      np.linspace(0							,    1							,    _snake_case			)
  lowerCAmelCase  							=      self._convert_to_karras(_snake_case			)
  lowerCAmelCase  							=      self.sigma_to_t(_snake_case			)

  # setable values
  lowerCAmelCase  							=      None
  lowerCAmelCase  							=      torch.from_numpy(_snake_case			)
  lowerCAmelCase  							=      torch.from_numpy(_snake_case			)
  lowerCAmelCase  							=      False
  lowerCAmelCase  							=      False



 def 					UpperCamelCase__   (			self							,    _snake_case							,    _snake_case=None			):







  """simple docstring"""






  if schedule_timesteps is None:
   lowerCAmelCase  							=      self.timesteps

  lowerCAmelCase  							=      (schedule_timesteps == timestep).nonzero()
  return indices.item()



 def 					UpperCamelCase__   (			self							,    _snake_case							,    _snake_case			):







  """simple docstring"""






  if isinstance(_snake_case							,    torch.Tensor			):
   lowerCAmelCase  							=      timestep.to(self.timesteps.device			)
  lowerCAmelCase  							=      self.index_for_timestep(_snake_case			)
  lowerCAmelCase  							=      self.sigmas[step_idx]

  lowerCAmelCase  							=      sample / ((sigma**2 + self.config.sigma_data**2) ** 0.5)

  lowerCAmelCase  							=      True
  return sample



 def 					UpperCamelCase__   (			self							,    _snake_case			):







  """simple docstring"""






  if not isinstance(_snake_case							,    np.ndarray			):
   lowerCAmelCase  							=      np.array(_snake_case							,    dtype=np.floataa			)

  lowerCAmelCase  							=      10_00 * 0.25 * np.log(sigmas + 1E-44			)

  return timesteps



 def 					UpperCamelCase__   (			self							,    _snake_case = None							,    _snake_case = None							,    _snake_case = None							,    ):







  """simple docstring"""






  if num_inference_steps is None and timesteps is None:
   raise ValueError('Exactly one of `num_inference_steps` or `timesteps` must be supplied.'			)

  if num_inference_steps is not None and timesteps is not None:
   raise ValueError('Can only pass one of `num_inference_steps` or `timesteps`.'			)

  # Follow DDPMScheduler custom timesteps logic
  if timesteps is not None:
   for i in range(1							,    len(_snake_case			)			):
    if timesteps[i] >= timesteps[i - 1]:
     raise ValueError('`timesteps` must be in descending order.'			)

   if timesteps[0] >= self.config.num_train_timesteps:
    raise ValueError(
        F'`timesteps` must start before `self.config.train_timesteps`:'
        F' {self.config.num_train_timesteps}.'			)

   lowerCAmelCase  							=      np.array(_snake_case							,    dtype=np.intaa			)
   lowerCAmelCase  							=      True
  else:
   if num_inference_steps > self.config.num_train_timesteps:
    raise ValueError(
        F'`num_inference_steps`: {num_inference_steps} cannot be larger than `self.config.train_timesteps`:'
        F' {self.config.num_train_timesteps} as the unet model trained with this scheduler can only handle'
        F' maximal {self.config.num_train_timesteps} timesteps.'			)

   lowerCAmelCase  							=      num_inference_steps

   lowerCAmelCase  							=      self.config.num_train_timesteps // self.num_inference_steps
   lowerCAmelCase  							=      (np.arange(0							,    _snake_case			) * step_ratio).round()[::-1].copy().astype(np.intaa			)
   lowerCAmelCase  							=      False

  # Map timesteps to Karras sigmas directly for multistep sampling
  # See https://github.com/openai/consistency_models/blob/main/cm/karras_diffusion.py#L675
  lowerCAmelCase  							=      self.config.num_train_timesteps
  lowerCAmelCase  							=      timesteps[::-1].copy()
  lowerCAmelCase  							=      ramp / (num_train_timesteps - 1)
  lowerCAmelCase  							=      self._convert_to_karras(_snake_case			)
  lowerCAmelCase  							=      self.sigma_to_t(_snake_case			)

  lowerCAmelCase  							=      np.concatenate([sigmas, [self.sigma_min]]			).astype(np.floataa			)
  lowerCAmelCase  							=      torch.from_numpy(_snake_case			).to(device=_snake_case			)

  if str(_snake_case			).startswith('mps'			):
   # mps does not support float64
   lowerCAmelCase  							=      torch.from_numpy(_snake_case			).to(_snake_case							,    dtype=torch.floataa			)
  else:
   lowerCAmelCase  							=      torch.from_numpy(_snake_case			).to(device=_snake_case			)



 def 					UpperCamelCase__   (			self							,    _snake_case			):







  """simple docstring"""






  lowerCAmelCase  							=      self.config.sigma_min
  lowerCAmelCase  							=      self.config.sigma_max

  lowerCAmelCase  							=      self.config.rho
  lowerCAmelCase  							=      sigma_min ** (1 / rho)
  lowerCAmelCase  							=      sigma_max ** (1 / rho)
  lowerCAmelCase  							=      (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho
  return sigmas



 def 					UpperCamelCase__   (			self							,    _snake_case			):







  """simple docstring"""






  lowerCAmelCase  							=      self.config.sigma_data

  lowerCAmelCase  							=      sigma_data**2 / (sigma**2 + sigma_data**2)
  lowerCAmelCase  							=      sigma * sigma_data / (sigma**2 + sigma_data**2) ** 0.5
  return c_skip, c_out



 def 					UpperCamelCase__   (			self							,    _snake_case			):







  """simple docstring"""






  lowerCAmelCase  							=      self.config.sigma_min
  lowerCAmelCase  							=      self.config.sigma_data

  lowerCAmelCase  							=      sigma_data**2 / ((sigma - sigma_min) ** 2 + sigma_data**2)
  lowerCAmelCase  							=      (sigma - sigma_min) * sigma_data / (sigma**2 + sigma_data**2) ** 0.5
  return c_skip, c_out



 def 					UpperCamelCase__   (			self							,    _snake_case							,    _snake_case							,    _snake_case							,    _snake_case = None							,    _snake_case = True							,    ):







  """simple docstring"""






  if (
      isinstance(_snake_case							,    _snake_case			)
      or isinstance(_snake_case							,    torch.IntTensor			)
      or isinstance(_snake_case							,    torch.LongTensor			)
  ):
   raise ValueError(
       (
           'Passing integer indices (e.g. from `enumerate(timesteps)`) as timesteps to'
           F' `{self.__class__}.step()` is not supported. Make sure to pass'
           ' one of the `scheduler.timesteps` as a timestep.'
       )							,    )

  if not self.is_scale_input_called:
   logger.warning(
       'The `scale_model_input` function should be called before `step` to ensure correct denoising. '
       'See `StableDiffusionPipeline` for a usage example.'			)

  if isinstance(_snake_case							,    torch.Tensor			):
   lowerCAmelCase  							=      timestep.to(self.timesteps.device			)

  lowerCAmelCase  							=      self.config.sigma_min
  lowerCAmelCase  							=      self.config.sigma_max

  lowerCAmelCase  							=      self.index_for_timestep(_snake_case			)

  # sigma_next corresponds to next_t in original implementation
  lowerCAmelCase  							=      self.sigmas[step_index]
  if step_index + 1 < self.config.num_train_timesteps:
   lowerCAmelCase  							=      self.sigmas[step_index + 1]
  else:
   # Set sigma_next to sigma_min
   lowerCAmelCase  							=      self.sigmas[-1]

  # Get scalings for boundary conditions
  lowerCAmelCase							,lowerCAmelCase  							=      self.get_scalings_for_boundary_condition(_snake_case			)

  # 1. Denoise model output using boundary conditions
  lowerCAmelCase  							=      c_out * model_output + c_skip * sample
  if self.config.clip_denoised:
   lowerCAmelCase  							=      denoised.clamp(-1							,    1			)

  # 2. Sample z ~ N(0, s_noise^2 * I)
  # Noise is not used for onestep sampling.
  if len(self.timesteps			) > 1:
   lowerCAmelCase  							=      randn_tensor(
       model_output.shape							,    dtype=model_output.dtype							,    device=model_output.device							,    generator=_snake_case			)
  else:
   lowerCAmelCase  							=      torch.zeros_like(_snake_case			)
  lowerCAmelCase  							=      noise * self.config.s_noise

  lowerCAmelCase  							=      sigma_next.clamp(min=_snake_case							,    max=_snake_case			)

  # 3. Return noisy sample
  # tau = sigma_hat, eps = sigma_min
  lowerCAmelCase  							=      denoised + z * (sigma_hat**2 - sigma_min**2) ** 0.5

  if not return_dict:
   return (prev_sample,)

  return CMStochasticIterativeSchedulerOutput(prev_sample=_snake_case			)



 def 					UpperCamelCase__   (			self							,    _snake_case							,    _snake_case							,    _snake_case							,    ):







  """simple docstring"""






  lowerCAmelCase  							=      self.sigmas.to(device=original_samples.device							,    dtype=original_samples.dtype			)
  if original_samples.device.type == "mps" and torch.is_floating_point(_snake_case			):
   # mps does not support float64
   lowerCAmelCase  							=      self.timesteps.to(original_samples.device							,    dtype=torch.floataa			)
   lowerCAmelCase  							=      timesteps.to(original_samples.device							,    dtype=torch.floataa			)
  else:
   lowerCAmelCase  							=      self.timesteps.to(original_samples.device			)
   lowerCAmelCase  							=      timesteps.to(original_samples.device			)

  lowerCAmelCase  							=      [(schedule_timesteps == t).nonzero().item() for t in timesteps]

  lowerCAmelCase  							=      sigmas[step_indices].flatten()
  while len(sigma.shape			) < len(original_samples.shape			):
   lowerCAmelCase  							=      sigma.unsqueeze(-1			)

  lowerCAmelCase  							=      original_samples + noise * sigma
  return noisy_samples



 def __len__(			self			):







  """simple docstring"""






  return self.config.num_train_timesteps












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__(       __lowercase			):






       '''simple docstring'''


       def 			UpperCamelCase_	(					self			,  __lowerCamelCase			,  __lowerCamelCase=False							)	->   List[Any]:
            _SCREAMING_SNAKE_CASE			,	_SCREAMING_SNAKE_CASE			,	_SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							(
                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(__lowerCamelCase							)			,  "wb"							).close()
            _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							pa.Table.from_pydict({"filename": [Path(__lowerCamelCase							).name] * 1_0_0}							)
            if take == -1:
                 _SCREAMING_SNAKE_CASE				:		int  			=							len(__lowerCamelCase							) - skip
            if skip is not None and take is not None:
                 _SCREAMING_SNAKE_CASE				:		List[str]  			=							pa_table.slice(__lowerCamelCase			,  __lowerCamelCase							)
            return pa_table





class 	lowerCAmelCase__(       __lowercase			):






       '''simple docstring'''


       def 			UpperCamelCase_	(					self							)	->   List[Any]:
            _SCREAMING_SNAKE_CASE				:		Tuple  			=							"my_name"
            _SCREAMING_SNAKE_CASE				:		List[str]  			=							SplitInfo(name="train"			,  num_examples=1_0_0							)
            _SCREAMING_SNAKE_CASE				:		Tuple  			=							SplitInfo(name="test"			,  num_examples=1_0_0							)
            _SCREAMING_SNAKE_CASE				:		List[Any]  			=							[train_info, test_info]
            _SCREAMING_SNAKE_CASE				:		str  			=							SplitDict()
            split_dict.add(__lowerCamelCase							)
            split_dict.add(__lowerCamelCase							)
            _SCREAMING_SNAKE_CASE				:		str  			=							DatasetInfo(splits=__lowerCamelCase							)

            with tempfile.TemporaryDirectory() as tmp_dir:
                 _SCREAMING_SNAKE_CASE				:		Tuple  			=							ReaderTest(__lowerCamelCase			,  __lowerCamelCase							)

                 _SCREAMING_SNAKE_CASE				:		Dict  			=							"test[:33%]"
                 _SCREAMING_SNAKE_CASE				:		Tuple  			=							Dataset(**reader.read(__lowerCamelCase			,  __lowerCamelCase			,  __lowerCamelCase							)							)
                 self.assertEqual(dset["filename"][0]			,  F"""{name}-test"""							)
                 self.assertEqual(dset.num_rows			,  3_3							)
                 self.assertEqual(dset.num_columns			,  1							)

                 _SCREAMING_SNAKE_CASE				:		List[str]  			=							["train", "test[:33%]"]
                 _SCREAMING_SNAKE_CASE				:		Tuple  			=							[Split.TRAIN, ReadInstruction.from_spec("test[:33%]"							)]
                 for instructions in [instructionsa, instructionsa]:
                      _SCREAMING_SNAKE_CASE				:		List[Any]  			=							[reader.read(__lowerCamelCase			,  __lowerCamelCase			,  __lowerCamelCase							) for instr in instructions]
                      _SCREAMING_SNAKE_CASE			,	_SCREAMING_SNAKE_CASE				:		Any  			=							(Dataset(**__lowerCamelCase							) for dataset_kwargs in datasets_kwargs)
                      self.assertEqual(train_dset["filename"][0]			,  F"""{name}-train"""							)
                      self.assertEqual(train_dset.num_rows			,  1_0_0							)
                      self.assertEqual(train_dset.num_columns			,  1							)
                      self.assertIsInstance(train_dset.split			,  __lowerCamelCase							)
                      self.assertEqual(str(train_dset.split							)			,  "train"							)
                      self.assertEqual(test_dset["filename"][0]			,  F"""{name}-test"""							)
                      self.assertEqual(test_dset.num_rows			,  3_3							)
                      self.assertEqual(test_dset.num_columns			,  1							)
                      self.assertIsInstance(test_dset.split			,  __lowerCamelCase							)
                      self.assertEqual(str(test_dset.split							)			,  "test[:33%]"							)
                      del train_dset, test_dset




       def 			UpperCamelCase_	(					self							)	->   int:
            _SCREAMING_SNAKE_CASE				:		List[str]  			=							"my_name"
            _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							SplitInfo(name="train"			,  num_examples=1_0_0_0			,  shard_lengths=[1_0_0] * 1_0							)
            _SCREAMING_SNAKE_CASE				:		str  			=							[train_info]
            _SCREAMING_SNAKE_CASE				:		Dict  			=							SplitDict()
            split_dict.add(__lowerCamelCase							)
            _SCREAMING_SNAKE_CASE				:		Tuple  			=							DatasetInfo(splits=__lowerCamelCase							)

            with tempfile.TemporaryDirectory() as tmp_dir:
                 _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							ReaderTest(__lowerCamelCase			,  __lowerCamelCase							)

                 _SCREAMING_SNAKE_CASE				:		int  			=							"train[:33%]"
                 _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							Dataset(**reader.read(__lowerCamelCase			,  __lowerCamelCase			,  __lowerCamelCase							)							)
                 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			,  3_3_0							)
                 self.assertEqual(dset.num_columns			,  1							)







       def 			UpperCamelCase_	(					self							)	->   str:
            _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							SplitInfo(name="train"			,  num_examples=1_0_0							)
            _SCREAMING_SNAKE_CASE				:		Dict  			=							SplitInfo(name="test"			,  num_examples=1_0_0							)
            _SCREAMING_SNAKE_CASE				:		Tuple  			=							SplitDict()
            split_dict.add(__lowerCamelCase							)
            split_dict.add(__lowerCamelCase							)
            _SCREAMING_SNAKE_CASE				:		Any  			=							DatasetInfo(splits=__lowerCamelCase							)

            with tempfile.TemporaryDirectory() as tmp_dir:
                 _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							ReaderTest(__lowerCamelCase			,  __lowerCamelCase							)

                 _SCREAMING_SNAKE_CASE				:		List[Any]  			=							[
                     {"filename": os.path.join(__lowerCamelCase			,  "train"							)},
                     {"filename": os.path.join(__lowerCamelCase			,  "test"							), "skip": 1_0, "take": 1_0},
                 ]
                 _SCREAMING_SNAKE_CASE				:		Any  			=							Dataset(**reader.read_files(__lowerCamelCase			,  original_instructions="train+test[10:20]"							)							)
                 self.assertEqual(dset.num_rows			,  1_1_0							)
                 self.assertEqual(dset.num_columns			,  1							)
                 del dset






@pytest.mark.parametrize("in_memory",				[False, True]		)
def 			lowerCamelCase__	(__lowerCamelCase,				__lowerCamelCase,				__lowerCamelCase		):
     _SCREAMING_SNAKE_CASE				:		Dict  			=							arrow_file
     with assert_arrow_memory_increases() if in_memory else assert_arrow_memory_doesnt_increase():
          _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							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 			lowerCamelCase__	(__lowerCamelCase,				__lowerCamelCase,				__lowerCamelCase		):
     _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							arrow_file
     _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							ArrowReader("",				__lowerCamelCase		)
     with assert_arrow_memory_increases() if in_memory else assert_arrow_memory_doesnt_increase():
          _SCREAMING_SNAKE_CASE				:		Dict  			=							reader.read_files([{"filename": filename}],				in_memory=__lowerCamelCase		)
     assert dataset_kwargs.keys() == {"arrow_table", "info", "split"}
     _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							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 			lowerCamelCase__	():
     assert ReadInstruction("train",				to=10,				unit="abs"		).to_spec() == "train[:10]"
     assert ReadInstruction("train",				from_=-80,				to=10,				unit="%"		).to_spec() == "train[-80%:10%]"

     _SCREAMING_SNAKE_CASE				:		str  			=							"train+test"
     assert ReadInstruction.from_spec(__lowerCamelCase		).to_spec() == spec_train_test

     _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							"train[2:10]"
     assert ReadInstruction.from_spec(__lowerCamelCase		).to_spec() == spec_train_abs

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

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

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

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






def 			lowerCamelCase__	():
     _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							"dummy"
     _SCREAMING_SNAKE_CASE				:		List[str]  			=							[SplitInfo(name="train",				num_examples=100		)]
     _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							"train[:33%]"
     _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							"arrow"
     _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							"prefix"

     _SCREAMING_SNAKE_CASE				:		Any  			=							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}
     ]

     _SCREAMING_SNAKE_CASE				:		List[str]  			=							[SplitInfo(name="train",				num_examples=100,				shard_lengths=[10] * 10		)]
     _SCREAMING_SNAKE_CASE				:		Tuple  			=							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 			lowerCamelCase__	(__lowerCamelCase,				__lowerCamelCase		):
     _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							[SplitInfo(name="train",				num_examples=100		)]
     _SCREAMING_SNAKE_CASE				:		int  			=							"train"
     _SCREAMING_SNAKE_CASE				:		int  			=							"arrow"
     _SCREAMING_SNAKE_CASE				:		Tuple  			=							"prefix_path"
     with pytest.raises(__lowerCamelCase		):
          _SCREAMING_SNAKE_CASE				:		List[str]  			=							make_file_instructions(__lowerCamelCase,				__lowerCamelCase,				__lowerCamelCase,				__lowerCamelCase,				__lowerCamelCase		)