
from typing import List

from packaging import version
from sklearn.metrics import fa_score

import datasets
from datasets.config import PY_VERSION


if PY_VERSION < version.parse('3.8'):
	import importlib_metadata
else:
	import importlib.metadata as importlib_metadata


# TODO(Patrick/Anton)
snake_case_      :					Optional[int]				      =     '\\n'

snake_case_      :					Tuple				      =     '\\n    XTREME-S is a benchmark to evaluate universal cross-lingual speech representations in many languages.\n    XTREME-S covers four task families: speech recognition, classification, speech-to-text translation and retrieval.\n'

snake_case_      :					Tuple				      =     '\nCompute XTREME-S evaluation metric associated to each XTREME-S dataset.\nArgs:\n    predictions: list of predictions to score.\n        Each translation should be tokenized into a list of tokens.\n    references: list of lists of references for each translation.\n        Each reference should be tokenized into a list of tokens.\n    bleu_kwargs: optional dict of keywords to be passed when computing \'bleu\'.\n        Keywords include Dict can be one of \'smooth_method\', \'smooth_value\', \'force\', \'lowercase\',\n        \'tokenize\', \'use_effective_order\'.\n    wer_kwargs: optional dict of keywords to be passed when computing \'wer\' and \'cer\'.\n        Keywords include \'concatenate_texts\'.\nReturns: depending on the XTREME-S task, one or several of:\n    "accuracy": Accuracy - for \'fleurs-lang_id\', \'minds14\'\n    "f1": F1 score - for \'minds14\'\n    "wer": Word error rate - for \'mls\', \'fleurs-asr\', \'voxpopuli\', \'babel\'\n    "cer": Character error rate - for \'mls\', \'fleurs-asr\', \'voxpopuli\', \'babel\'\n    "bleu": BLEU score according to the `sacrebleu` metric - for \'covost2\'\nExamples:\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'mls\')  # \'mls\', \'voxpopuli\', \'fleurs-asr\' or \'babel\'\n    >>> references = ["it is sunny here", "paper and pen are essentials"]\n    >>> predictions = ["it\'s sunny", "paper pen are essential"]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'wer\': 0.56, \'cer\': 0.27}\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'covost2\')\n    >>> references = ["bonjour paris", "il est necessaire de faire du sport de temps en temp"]\n    >>> predictions = ["bonjour paris", "il est important de faire du sport souvent"]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'bleu\': 31.65}\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'fleurs-lang_id\')\n    >>> references = [0, 1, 0, 0, 1]\n    >>> predictions = [0, 1, 1, 0, 0]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'accuracy\': 0.6}\n\n    >>> xtreme_s_metric = datasets.load_metric(\'xtreme_s\', \'minds14\')\n    >>> references = [0, 1, 0, 0, 1]\n    >>> predictions = [0, 1, 1, 0, 0]\n    >>> results = xtreme_s_metric.compute(predictions=predictions, references=references)\n    >>> print({k: round(v, 2) for k, v in results.items()})\n    {\'f1\': 0.58, \'accuracy\': 0.6}\n'

snake_case_      :					Optional[Any]				      =     ['fleurs-asr', 'mls', 'voxpopuli', 'babel', 'covost2', 'fleurs-lang_id', 'minds14']
snake_case_      :					List[Any]				      =     ''

try:
	from jiwer import transforms as tr

	snake_case_      :					Optional[int]				      =     True
except ImportError:
	snake_case_      :					Any				      =     False

if _jiwer_available and version.parse(importlib_metadata.version('jiwer')) < version.parse('2.3.0'):





	class 		__lowerCamelCase     (   tr.AbstractTransform		):



								def __init__(     self	,				__snake_case = " "							)						->     Tuple:






									"""simple docstring"""



									UpperCAmelCase:					Any 						=     sentence_delimiter



								def     A__ (     self	,				__snake_case							)						->     List[str]:






									"""simple docstring"""



									return list(__snake_case							)




								def     A__ (     self	,				__snake_case							)						->     List[str]:






									"""simple docstring"""



									UpperCAmelCase:					Union[str, Any] 						=     []
									for sent_idx, sentence in enumerate(__snake_case							):
										chars.extend(self.process_string(__snake_case							)							)
										if self.sentence_delimiter is not None and self.sentence_delimiter != "" and sent_idx < len(__snake_case							) - 1:
											chars.append(self.sentence_delimiter							)
									return chars


	snake_case_      :					Union[str, Any]				      =     tr.Compose(
	    [tr.RemoveMultipleSpaces(), tr.Strip(), SentencesToListOfCharacters(SENTENCE_DELIMITER)]
	)
elif _jiwer_available:
	snake_case_      :					str				      =     tr.Compose(
	    [
	        tr.RemoveMultipleSpaces(),
	        tr.Strip(),
	        tr.ReduceToSingleSentence(SENTENCE_DELIMITER),
	        tr.ReduceToListOfListOfChars(),
	    ]
	)
else:
	snake_case_      :					List[Any]				      =     None



def      __UpperCAmelCase    (  snake_case_							:		Optional[Any]				,					snake_case_							:		int				):



	'''simple docstring'''



	return float((preds == labels).mean()				)



def      __UpperCAmelCase    (  snake_case_							:		List[str]				,					snake_case_							:		str				):



	'''simple docstring'''



	return {
	    "f1": float(fa_score(y_true=snake_case_				,					y_pred=snake_case_				,					average="macro"				)				),
	    "accuracy": simple_accuracy(snake_case_				,					snake_case_				),
	}



def      __UpperCAmelCase    (  snake_case_							:		int				,					snake_case_							:		List[Any]				,					snake_case_							:		Optional[int]="exp"				,					snake_case_							:		Union[str, Any]=None				,					snake_case_							:		List[str]=False				,					snake_case_							:		int=False				,					snake_case_							:		Dict=None				,					snake_case_							:		List[Any]=False				,					):



	'''simple docstring'''



	UpperCAmelCase:					List[Any] 						=     [[label] for label in labels]
	UpperCAmelCase:					Union[str, Any] 						=     list(snake_case_				)
	try:
		import sacrebleu as scb
	except ImportError:
		raise ValueError(
		    "sacrebleu has to be installed in order to apply the bleu metric for covost2."
		    "You can install it via `pip install sacrebleu`."				)

	if version.parse(scb.__version__				) < version.parse("1.4.12"				):
		raise ImportWarning(
		    "To use `sacrebleu`, the module `sacrebleu>=1.4.12` is required, and the current version of `sacrebleu` doesn't match this condition.\n"
		    "You can install it with `pip install \"sacrebleu>=1.4.12\"`."				)

	UpperCAmelCase:					List[Any] 						=     len(labels[0]				)
	if any(len(snake_case_				) != references_per_prediction for refs in labels				):
		raise ValueError("Sacrebleu requires the same number of references for each prediction"				)
	UpperCAmelCase:					List[Any] 						=     [[refs[i] for refs in labels] for i in range(snake_case_				)]
	UpperCAmelCase:					Optional[Any] 						=     scb.corpus_bleu(
	    snake_case_				,					snake_case_				,					smooth_method=snake_case_				,					smooth_value=snake_case_				,					force=snake_case_				,					lowercase=snake_case_				,					use_effective_order=snake_case_				,					**({"tokenize": tokenize} if tokenize else {})				,					)
	return {"bleu": output.score}



def      __UpperCAmelCase    (  snake_case_							:		str				,					snake_case_							:		List[Any]				,					snake_case_							:		Optional[int]				,					snake_case_							:		List[Any]				):



	'''simple docstring'''



	try:
		from jiwer import compute_measures
	except ImportError:
		raise ValueError(
		    F'jiwer has to be installed in order to apply the wer metric for {config_name}.'
		    "You can install it via `pip install jiwer`."				)

	if concatenate_texts:
		UpperCAmelCase:					List[str] 						=     compute_measures(snake_case_				,					snake_case_				)["wer"]

		UpperCAmelCase:					List[Any] 						=     compute_measures(snake_case_				,					snake_case_				,					truth_transform=snake_case_				,					hypothesis_transform=snake_case_				)["wer"]
		return {"wer": wer, "cer": cer}
	else:

		def compute_score(snake_case_							:		int				,					snake_case_							:		Tuple				,					snake_case_							:		List[Any]="wer"				):
			UpperCAmelCase:					Dict 						=     0
			UpperCAmelCase:					Union[str, Any] 						=     0
			for prediction, reference in zip(snake_case_				,					snake_case_				):
				if score_type == "wer":
					UpperCAmelCase:					Any 						=     compute_measures(snake_case_				,					snake_case_				)
				elif score_type == "cer":
					UpperCAmelCase:					Union[str, Any] 						=     compute_measures(
					    snake_case_				,					snake_case_				,					truth_transform=snake_case_				,					hypothesis_transform=snake_case_				)
				incorrect += measures["substitutions"] + measures["deletions"] + measures["insertions"]
				total += measures["substitutions"] + measures["deletions"] + measures["hits"]
			return incorrect / total

		return {"wer": compute_score(snake_case_				,					snake_case_				,					"wer"				), "cer": compute_score(snake_case_				,					snake_case_				,					"cer"				)}





@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION							, _KWARGS_DESCRIPTION		)
class 		__lowerCamelCase     (   datasets.Metric		):



							def     A__ (     self							)						->     int:






								"""simple docstring"""



								if self.config_name not in _CONFIG_NAMES:
									raise KeyError(F'You should supply a configuration name selected in {_CONFIG_NAMES}'							)

								UpperCAmelCase:					List[Any] 						=     "int64" if self.config_name in ["fleurs-lang_id", "minds14"] else "string"

								return datasets.MetricInfo(
								    description=_DESCRIPTION	,				citation=_CITATION	,				inputs_description=_KWARGS_DESCRIPTION	,				features=datasets.Features(
								        {"predictions": datasets.Value(__snake_case							), "references": datasets.Value(__snake_case							)}							)	,				codebase_urls=[]	,				reference_urls=[]	,				format="numpy"	,				)




							def     A__ (     self	,				__snake_case	,				__snake_case	,				__snake_case=None	,				__snake_case=None							)						->     Optional[Any]:






								"""simple docstring"""



								UpperCAmelCase:					Dict 						=     bleu_kwargs if bleu_kwargs is not None else {}
								UpperCAmelCase:					int 						=     wer_kwargs if wer_kwargs is not None else {}

								if self.config_name == "fleurs-lang_id":
									return {"accuracy": simple_accuracy(__snake_case	,				__snake_case							)}
								elif self.config_name == "minds14":
									return fa_and_simple_accuracy(__snake_case	,				__snake_case							)
								elif self.config_name == "covost2":
									UpperCAmelCase:					Tuple 						=     bleu_kwargs.pop("smooth_method"	,				"exp"							)
									UpperCAmelCase:					str 						=     bleu_kwargs.pop("smooth_value"	,				__snake_case							)
									UpperCAmelCase:					int 						=     bleu_kwargs.pop("force"	,				__snake_case							)
									UpperCAmelCase:					Dict 						=     bleu_kwargs.pop("lowercase"	,				__snake_case							)
									UpperCAmelCase:					int 						=     bleu_kwargs.pop("tokenize"	,				__snake_case							)
									UpperCAmelCase:					Tuple 						=     bleu_kwargs.pop("use_effective_order"	,				__snake_case							)
									return bleu(
									    preds=__snake_case	,				labels=__snake_case	,				smooth_method=__snake_case	,				smooth_value=__snake_case	,				force=__snake_case	,				lowercase=__snake_case	,				tokenize=__snake_case	,				use_effective_order=__snake_case	,				)
								elif self.config_name in ["fleurs-asr", "mls", "voxpopuli", "babel"]:
									UpperCAmelCase:					Union[str, Any] 						=     wer_kwargs.pop("concatenate_texts"	,				__snake_case							)
									return wer_and_cer(__snake_case	,				__snake_case	,				__snake_case	,				self.config_name							)
								else:
									raise KeyError(F'You should supply a configuration name selected in {_CONFIG_NAMES}'							)


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		):



							def     A__ (     self	,				__snake_case	,				__snake_case=False							)						->     Tuple:






								"""simple docstring"""



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





class 		__lowerCamelCase     (   lowercase		):



							def     A__ (     self							)						->     int:






								"""simple docstring"""



								UpperCAmelCase:					Tuple 						=     "my_name"
								UpperCAmelCase:					str 						=     SplitInfo(name="train"	,				num_examples=1_0_0							)
								UpperCAmelCase:					Optional[int] 						=     SplitInfo(name="test"	,				num_examples=1_0_0							)
								UpperCAmelCase:					Optional[int] 						=     [train_info, test_info]
								UpperCAmelCase:					Tuple 						=     SplitDict()
								split_dict.add(__snake_case							)
								split_dict.add(__snake_case							)
								UpperCAmelCase:					Optional[int] 						=     DatasetInfo(splits=__snake_case							)

								with tempfile.TemporaryDirectory() as tmp_dir:
									UpperCAmelCase:					int 						=     ReaderTest(__snake_case	,				__snake_case							)

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

									UpperCAmelCase:					int 						=     ["train", "test[:33%]"]
									UpperCAmelCase:					str 						=     [Split.TRAIN, ReadInstruction.from_spec("test[:33%]"							)]
									for instructions in [instructionsa, instructionsa]:
										UpperCAmelCase:					List[str] 						=     [reader.read(__snake_case	,				__snake_case	,				__snake_case							) for instr in instructions]
										UpperCAmelCase						,   UpperCAmelCase:					List[Any] 						=     (Dataset(**__snake_case							) 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	,				__snake_case							)
										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	,				__snake_case							)
										self.assertEqual(str(test_dset.split							)	,				"test[:33%]"							)
										del train_dset, test_dset



							def     A__ (     self							)						->     Optional[Any]:






								"""simple docstring"""



								UpperCAmelCase:					str 						=     "my_name"
								UpperCAmelCase:					List[Any] 						=     SplitInfo(name="train"	,				num_examples=1_0_0_0	,				shard_lengths=[1_0_0] * 1_0							)
								UpperCAmelCase:					List[Any] 						=     [train_info]
								UpperCAmelCase:					Dict 						=     SplitDict()
								split_dict.add(__snake_case							)
								UpperCAmelCase:					int 						=     DatasetInfo(splits=__snake_case							)

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

									UpperCAmelCase:					Optional[Any] 						=     "train[:33%]"
									UpperCAmelCase:					Tuple 						=     Dataset(**reader.read(__snake_case	,				__snake_case	,				__snake_case							)							)
									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     A__ (     self							)						->     Any:






								"""simple docstring"""



								UpperCAmelCase:					Union[str, Any] 						=     SplitInfo(name="train"	,				num_examples=1_0_0							)
								UpperCAmelCase:					int 						=     SplitInfo(name="test"	,				num_examples=1_0_0							)
								UpperCAmelCase:					List[Any] 						=     SplitDict()
								split_dict.add(__snake_case							)
								split_dict.add(__snake_case							)
								UpperCAmelCase:					Optional[Any] 						=     DatasetInfo(splits=__snake_case							)

								with tempfile.TemporaryDirectory() as tmp_dir:
									UpperCAmelCase:					List[Any] 						=     ReaderTest(__snake_case	,				__snake_case							)

									UpperCAmelCase:					List[str] 						=     [
									    {"filename": os.path.join(__snake_case	,				"train"							)},
									    {"filename": os.path.join(__snake_case	,				"test"							), "skip": 1_0, "take": 1_0},
									]
									UpperCAmelCase:					Tuple 						=     Dataset(**reader.read_files(__snake_case	,				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      __UpperCAmelCase    (  snake_case_							:		str				,					snake_case_							:		str				,					snake_case_							:		Any				):



	'''simple docstring'''



	UpperCAmelCase:					Union[str, Any] 						=     arrow_file
	with assert_arrow_memory_increases() if in_memory else assert_arrow_memory_doesnt_increase():
		UpperCAmelCase:					int 						=     ArrowReader.read_table(snake_case_				,					in_memory=snake_case_				)
	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      __UpperCAmelCase    (  snake_case_							:		List[str]				,					snake_case_							:		Optional[int]				,					snake_case_							:		int				):



	'''simple docstring'''



	UpperCAmelCase:					List[Any] 						=     arrow_file
	UpperCAmelCase:					Tuple 						=     ArrowReader(""				,					snake_case_				)
	with assert_arrow_memory_increases() if in_memory else assert_arrow_memory_doesnt_increase():
		UpperCAmelCase:					Any 						=     reader.read_files([{"filename": filename}]				,					in_memory=snake_case_				)
	assert dataset_kwargs.keys() == {"arrow_table", "info", "split"}
	UpperCAmelCase:					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      __UpperCAmelCase    (  ):



	'''simple docstring'''



	assert ReadInstruction("train"				,					to=1_0				,					unit="abs"				).to_spec() == "train[:10]"
	assert ReadInstruction("train"				,					from_=-8_0				,					to=1_0				,					unit="%"				).to_spec() == "train[-80%:10%]"

	UpperCAmelCase:					str 						=     "train+test"
	assert ReadInstruction.from_spec(snake_case_				).to_spec() == spec_train_test

	UpperCAmelCase:					List[Any] 						=     "train[2:10]"
	assert ReadInstruction.from_spec(snake_case_				).to_spec() == spec_train_abs

	UpperCAmelCase:					Tuple 						=     "train[15%:-20%]"
	assert ReadInstruction.from_spec(snake_case_				).to_spec() == spec_train_pct

	UpperCAmelCase:					Dict 						=     "train[:10%](closest)"
	assert ReadInstruction.from_spec(snake_case_				).to_spec() == "train[:10%]"

	UpperCAmelCase:					List[str] 						=     "train[:10%](pct1_dropremainder)"
	assert ReadInstruction.from_spec(snake_case_				).to_spec() == spec_train_pct_rounding

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



def      __UpperCAmelCase    (  ):



	'''simple docstring'''



	UpperCAmelCase:					Dict 						=     "dummy"
	UpperCAmelCase:					int 						=     [SplitInfo(name="train"				,					num_examples=1_0_0				)]
	UpperCAmelCase:					List[str] 						=     "train[:33%]"
	UpperCAmelCase:					Optional[int] 						=     "arrow"
	UpperCAmelCase:					List[Any] 						=     "prefix"

	UpperCAmelCase:					List[Any] 						=     make_file_instructions(snake_case_				,					snake_case_				,					snake_case_				,					snake_case_				,					snake_case_				)
	assert isinstance(snake_case_				,					snake_case_				)
	assert file_instructions.num_examples == 3_3
	assert file_instructions.file_instructions == [
	    {"filename": os.path.join(snake_case_				,					F'{name}-train.arrow'				), "skip": 0, "take": 3_3}
	]

	UpperCAmelCase:					int 						=     [SplitInfo(name="train"				,					num_examples=1_0_0				,					shard_lengths=[1_0] * 1_0				)]
	UpperCAmelCase:					List[Any] 						=     make_file_instructions(snake_case_				,					snake_case_				,					snake_case_				,					snake_case_				,					snake_case_				)
	assert isinstance(snake_case_				,					snake_case_				)
	assert file_instructions.num_examples == 3_3
	assert file_instructions.file_instructions == [
	    {"filename": os.path.join(snake_case_				,					F'{name}-train-00000-of-00010.arrow'				), "skip": 0, "take": -1},
	    {"filename": os.path.join(snake_case_				,					F'{name}-train-00001-of-00010.arrow'				), "skip": 0, "take": -1},
	    {"filename": os.path.join(snake_case_				,					F'{name}-train-00002-of-00010.arrow'				), "skip": 0, "take": -1},
	    {"filename": os.path.join(snake_case_				,					F'{name}-train-00003-of-00010.arrow'				), "skip": 0, "take": 3},
	]



@pytest.mark.parametrize("name, expected_exception"				,					[(None, TypeError), ("", ValueError)]				)
def      __UpperCAmelCase    (  snake_case_							:		Union[str, Any]				,					snake_case_							:		Dict				):



	'''simple docstring'''



	UpperCAmelCase:					Optional[int] 						=     [SplitInfo(name="train"				,					num_examples=1_0_0				)]
	UpperCAmelCase:					Union[str, Any] 						=     "train"
	UpperCAmelCase:					List[str] 						=     "arrow"
	UpperCAmelCase:					Any 						=     "prefix_path"
	with pytest.raises(snake_case_				):
		UpperCAmelCase:					List[Any] 						=     make_file_instructions(snake_case_				,					snake_case_				,					snake_case_				,					snake_case_				,					snake_case_				)
