"""simple docstring"""




import ast
import os
import re
import shutil
import tempfile
import unittest
from unittest import mock

import torch

from accelerate.test_utils.examples import compare_against_test
from accelerate.test_utils.testing import TempDirTestCase, require_trackers, run_command, slow
from accelerate.utils import write_basic_config


# DataLoaders built from `test_samples/MRPC` for quick testing
# Should mock `{script_name}.get_dataloaders` via:
# @mock.patch("{script_name}.get_dataloaders", mocked_dataloaders)

__lowerCAmelCase    :							Dict													=						[
    "cross_validation.py",
    "gradient_accumulation.py",
    "local_sgd.py",
    "multi_process_metrics.py",
    "memory.py",
    "automatic_gradient_accumulation.py",
    "fsdp_with_peak_mem_tracking.py",
    "deepspeed_with_config_support.py",
    "megatron_lm_gpt_pretraining.py",
]

class       a_      (     unittest.TestCase			):




					def 						_SCREAMING_SNAKE_CASE						(	self						:     str  ,						snake_case__						:     str  ,						snake_case__						:     bool  ,						snake_case__						:     str = None  ,						snake_case__						:     list = None     ):
							lowerCAmelCase__        =   None
							lowerCAmelCase__        =   os.path.abspath(os.path.join("""examples"""  ,						"""by_feature"""     )     )
							lowerCAmelCase__        =   os.path.abspath("""examples"""     )
							for item in os.listdir(snake_case__     ):
									if item not in EXCLUDE_EXAMPLES:
											lowerCAmelCase__        =   os.path.join(snake_case__  ,						snake_case__     )
											if os.path.isfile(snake_case__     ) and ".py" in item_path:
													with self.subTest(
													    tested_script=snake_case__  ,						feature_script=snake_case__  ,						tested_section="""main()""" if parser_only else """training_function()"""  ,						):
															lowerCAmelCase__        =   compare_against_test(
															    os.path.join(snake_case__  ,						snake_case__     )  ,						snake_case__  ,						snake_case__  ,						snake_case__     )
															lowerCAmelCase__        =   """\n""".join(snake_case__     )
															if special_strings is not None:
																	for string in special_strings:
																			lowerCAmelCase__        =   diff.replace(snake_case__  ,						""""""     )
															self.assertEqual(snake_case__  ,						""""""     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[Any]     ):
							self.one_complete_example("""complete_nlp_example.py"""  ,						snake_case__     )
							self.one_complete_example("""complete_nlp_example.py"""  ,						snake_case__     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[Any]     ):
							lowerCAmelCase__        =   os.path.abspath(os.path.join("""examples"""  ,						"""cv_example.py"""     )     )
							lowerCAmelCase__        =   [
							    """ """ * 16 + """{\n\n""",
							    """ """ * 20 + """\"accuracy\": eval_metric[\"accuracy\"],\n\n""",
							    """ """ * 20 + """\"f1\": eval_metric[\"f1\"],\n\n""",
							    """ """ * 20 + """\"train_loss\": total_loss.item() / len(train_dataloader),\n\n""",
							    """ """ * 20 + """\"epoch\": epoch,\n\n""",
							    """ """ * 16 + """},\n\n""",
							    """ """ * 16 + """step=epoch,\n""",
							    """ """ * 12,
							    """ """ * 8 + """for step, batch in enumerate(active_dataloader):\n""",
							]
							self.one_complete_example("""complete_cv_example.py"""  ,						snake_case__  ,						snake_case__  ,						snake_case__     )
							self.one_complete_example("""complete_cv_example.py"""  ,						snake_case__  ,						snake_case__  ,						snake_case__     )

@mock.patch.dict(os.environ ,		{"TESTING_MOCKED_DATALOADERS": "1"}			)
class       a_      (     __UpperCamelCase			):
					UpperCamelCase_ :	Optional[Any]			=    False




					@classmethod
					def 						_SCREAMING_SNAKE_CASE						(	cls						:     Tuple     ):
							super().setUpClass()
							lowerCAmelCase__        =   tempfile.mkdtemp()
							lowerCAmelCase__        =   os.path.join(cls._tmpdir  ,						"""default_config.yml"""     )

							write_basic_config(save_location=cls.configPath     )
							lowerCAmelCase__        =   ["""accelerate""", """launch""", """--config_file""", cls.configPath]




					@classmethod
					def 						_SCREAMING_SNAKE_CASE						(	cls						:     Dict     ):
							super().tearDownClass()
							shutil.rmtree(cls._tmpdir     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[str]     ):
							lowerCAmelCase__        =   F"""
        examples/by_feature/checkpointing.py
        --checkpointing_steps epoch
        --output_dir {self.tmpdir}
        """.split()
							run_command(self._launch_args + testargs     )
							self.assertTrue(os.path.exists(os.path.join(self.tmpdir  ,						"""epoch_0"""     )     )     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[str]     ):
							lowerCAmelCase__        =   F"""
        examples/by_feature/checkpointing.py
        --checkpointing_steps 1
        --output_dir {self.tmpdir}
        """.split()
							lowerCAmelCase__        =   run_command(self._launch_args + testargs     )
							self.assertTrue(os.path.exists(os.path.join(self.tmpdir  ,						"""step_2"""     )     )     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Any     ):
							lowerCAmelCase__        =   F"""
        examples/by_feature/checkpointing.py
        --resume_from_checkpoint {os.path.join(self.tmpdir  ,						'epoch_0'     )}
        """.split()
							lowerCAmelCase__        =   run_command(self._launch_args + testargs  ,						return_stdout=snake_case__     )
							self.assertNotIn("""epoch 0:"""  ,						snake_case__     )
							self.assertIn("""epoch 1:"""  ,						snake_case__     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[Any]     ):
							lowerCAmelCase__        =   F"""
        examples/by_feature/checkpointing.py
        --resume_from_checkpoint {os.path.join(self.tmpdir  ,						'step_2'     )}
        """.split()
							lowerCAmelCase__        =   run_command(self._launch_args + testargs  ,						return_stdout=snake_case__     )
							if torch.cuda.is_available():
									lowerCAmelCase__        =   torch.cuda.device_count()
							else:
									lowerCAmelCase__        =   1
							if num_processes > 1:
									self.assertNotIn("""epoch 0:"""  ,						snake_case__     )
									self.assertIn("""epoch 1:"""  ,						snake_case__     )
							else:
									self.assertIn("""epoch 0:"""  ,						snake_case__     )
									self.assertIn("""epoch 1:"""  ,						snake_case__     )




					@slow
					def 						_SCREAMING_SNAKE_CASE						(	self						:     str     ):
							lowerCAmelCase__        =   """
        examples/by_feature/cross_validation.py
        --num_folds 2
        """.split()
							with mock.patch.dict(os.environ  ,						{"""TESTING_MOCKED_DATALOADERS""": """0"""}     ):
									lowerCAmelCase__        =   run_command(self._launch_args + testargs  ,						return_stdout=snake_case__     )
									lowerCAmelCase__        =   re.findall("""({.+})"""  ,						snake_case__     )
									lowerCAmelCase__        =   [r for r in results if """accuracy""" in r][-1]
									lowerCAmelCase__        =   ast.literal_eval(snake_case__     )
									self.assertGreaterEqual(results["""accuracy"""]  ,						0.75     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     str     ):
							lowerCAmelCase__        =   ["""examples/by_feature/multi_process_metrics.py"""]
							run_command(self._launch_args + testargs     )




					@require_trackers
					@mock.patch.dict(os.environ  ,						{"""WANDB_MODE""": """offline"""}     )
					def 						_SCREAMING_SNAKE_CASE						(	self						:     Dict     ):
							with tempfile.TemporaryDirectory() as tmpdir:
									lowerCAmelCase__        =   F"""
            examples/by_feature/tracking.py
            --with_tracking
            --project_dir {tmpdir}
            """.split()
									run_command(self._launch_args + testargs     )
									self.assertTrue(os.path.exists(os.path.join(snake_case__  ,						"""tracking"""     )     )     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     str     ):
							lowerCAmelCase__        =   ["""examples/by_feature/gradient_accumulation.py"""]
							run_command(self._launch_args + testargs     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[int]     ):
							lowerCAmelCase__        =   ["""examples/by_feature/local_sgd.py"""]
							run_command(self._launch_args + testargs     )



"""simple docstring"""




def 							_UpperCAmelCase		(       lowerCamelCase__ = 50     ):





		"""simple docstring"""




		lowerCAmelCase__        =   [[0] * 3 for _ in range(length + 1     )]

		for row_length in range(length + 1     ):
				for tile_length in range(2			,  5     ):
						for tile_start in range(row_length - tile_length + 1     ):
								different_colour_ways_number[row_length][tile_length - 2] += (
								    different_colour_ways_number[row_length - tile_start - tile_length][
								        tile_length - 2
								    ]
								    + 1
								)

		return sum(different_colour_ways_number[length]     )


if __name__ == "__main__":
			print(F"{solution() = }")




