
import argparse
import logging
import os
import sys
import tempfile
from pathlib import Path

import lightning_base
import pytest
import pytorch_lightning as pl
import torch
from convert_pl_checkpoint_to_hf import convert_pl_to_hf
from distillation import distill_main
from finetune import SummarizationModule, main
from huggingface_hub import list_models
from parameterized import parameterized
from run_eval import generate_summaries_or_translations
from torch import nn

from transformers import AutoConfig, AutoModelForSeqaSeqLM
from transformers.testing_utils import CaptureStderr, CaptureStdout, TestCasePlus, require_torch_gpu, slow
from utils import label_smoothed_nll_loss, lmap, load_json


logging.basicConfig(level=logging.DEBUG)

__lowerCamelCase								=					logging.getLogger()
__lowerCamelCase								=					torch.cuda.is_available()
__lowerCamelCase								=					{
    'max_tokens_per_batch': None,
    'supervise_forward': True,
    'normalize_hidden': True,
    'label_smoothing': 0.2,
    'eval_max_gen_length': None,
    'eval_beams': 1,
    'val_metric': 'loss',
    'save_top_k': 1,
    'adafactor': True,
    'early_stopping_patience': 2,
    'logger_name': 'default',
    'length_penalty': 0.5,
    'cache_dir': '',
    'task': 'summarization',
    'num_workers': 2,
    'alpha_hid': 0,
    'freeze_embeds': True,
    'enc_only': False,
    'tgt_suffix': '',
    'resume_from_checkpoint': None,
    'sortish_sampler': True,
    'student_decoder_layers': 1,
    'val_check_interval': 1.0,
    'output_dir': '',
    'fp16': False,  # TODO(SS): set this to CUDA_AVAILABLE if ci installs apex or start using native amp
    'no_teacher': False,
    'fp16_opt_level': 'O1',
    'gpus': 1 if CUDA_AVAILABLE else 0,
    'n_tpu_cores': 0,
    'max_grad_norm': 1.0,
    'do_train': True,
    'do_predict': True,
    'accumulate_grad_batches': 1,
    'server_ip': '',
    'server_port': '',
    'seed': 4_2,
    'model_name_or_path': 'sshleifer/bart-tiny-random',
    'config_name': '',
    'tokenizer_name': 'facebook/bart-large',
    'do_lower_case': False,
    'learning_rate': 0.3,
    'lr_scheduler': 'linear',
    'weight_decay': 0.0,
    'adam_epsilon': 1e-08,
    'warmup_steps': 0,
    'max_epochs': 1,
    'train_batch_size': 2,
    'eval_batch_size': 2,
    'max_source_length': 1_2,
    'max_target_length': 1_2,
    'val_max_target_length': 1_2,
    'test_max_target_length': 1_2,
    'fast_dev_run': False,
    'no_cache': False,
    'n_train': -1,
    'n_val': -1,
    'n_test': -1,
    'student_encoder_layers': 1,
    'freeze_encoder': False,
    'auto_scale_batch_size': False,
    'overwrite_output_dir': False,
    'student': None,
}




def 		lowerCAmelCase_     (     _SCREAMING_SNAKE_CASE      ,	_SCREAMING_SNAKE_CASE  )   ->      Optional[Any]:

							"""simple docstring"""






							_UpperCAmelCase  :			Optional[Any]	       =		"\n".join(_UpperCamelCase  )
							Path(_UpperCamelCase  ).open("w"  ).writelines(_UpperCamelCase  )


__lowerCamelCase								=					[' Sam ate lunch today.', 'Sams lunch ingredients.']
__lowerCamelCase								=					['A very interesting story about what I ate for lunch.', 'Avocado, celery, turkey, coffee']
__lowerCamelCase								=					'patrickvonplaten/t5-tiny-random'
__lowerCamelCase								=					'sshleifer/t5-tinier-random'
__lowerCamelCase								=					'sshleifer/bart-tiny-random'
__lowerCamelCase								=					'sshleifer/tiny-mbart'
__lowerCamelCase								=					'sshleifer/tiny-marian-en-de'
__lowerCamelCase								=					'stas/tiny-wmt19-en-de'


__lowerCamelCase								=					logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)
logging.disable(logging.CRITICAL)  # remove noisy download output from tracebacks




def 		lowerCAmelCase_     (     _SCREAMING_SNAKE_CASE  )   ->      List[str]:

							"""simple docstring"""






							for split in ["train", "val", "test"]:
														_dump_articles(os.path.join(_UpperCamelCase      ,	F"""{split}.source"""  )      ,	_UpperCamelCase  )
														_dump_articles(os.path.join(_UpperCamelCase      ,	F"""{split}.target"""  )      ,	_UpperCamelCase  )
							return tmp_dir
class    _UpperCamelCase(   __lowercase				):

						@classmethod
						def 						a__ (					cls		:			int			):
													logging.disable(logging.CRITICAL			)  # remove noisy download output from tracebacks
													return cls

						@slow
						@require_torch_gpu
						def 						a__ (					self		:			int			):
													_UpperCAmelCase  :			str	       =		list_models()
													_UpperCAmelCase  :			str	       =		"sshleifer"
													_UpperCAmelCase  :			Optional[Any]	       =		[x.modelId for x in model_list if x.modelId.startswith(A__			)]
													_UpperCAmelCase  :			str	       =		["sshleifer/blenderbot-3B", "sshleifer/blenderbot-90M"]
													_UpperCAmelCase  :			Any	       =		[]
													for m in model_ids:
																				if m in allowed_to_be_broken:
																											continue
																				try:
																											AutoConfig.from_pretrained(A__			)
																				except Exception:
																											failures.append(A__			)
													assert not failures, f"""The following models could not be loaded through AutoConfig: {failures}"""

						def 						a__ (					self		:			Optional[Any]			):
													_UpperCAmelCase  :			List[str]	       =		{"student_encoder_layers": 2, "student_decoder_layers": 1, "no_teacher": True}
													self._test_distiller_cli(A__			)

						def 						a__ (					self		:			Union[str, Any]			):
													_UpperCAmelCase  :			int	       =		{
													    "student_encoder_layers": 2,
													    "student_decoder_layers": 1,
													    "max_epochs": 4,
													    "val_check_interval": 0.25,
													    "alpha_hid": 2.0,
													    "model_name_or_path": "IGNORE_THIS_IT_DOESNT_GET_USED",
													}
													_UpperCAmelCase  :			int	       =		self._test_distiller_cli(A__	,						check_contents=A__			)

													_UpperCAmelCase  :			Any	       =		list(Path(model.output_dir			).glob("*.ckpt"			)			)
													self.assertEqual(1	,						len(A__			)			)
													_UpperCAmelCase  :			List[str]	       =		list(Path(model.output_dir			).glob("**/*.bin"			)			)
													self.assertEqual(len(A__			)	,						2			)
													_UpperCAmelCase  :			Union[str, Any]	       =		lmap(str.strip	,						Path(model.hparams.data_dir			).joinpath("test.source"			).open().readlines()			)
													_UpperCAmelCase  :			Dict	       =		tempfile.mktemp()  # XXX: not being cleaned up
													generate_summaries_or_translations(A__	,						A__	,						str(model.output_dir / "best_tfmr"			)			)
													self.assertTrue(Path(A__			).exists()			)

													_UpperCAmelCase  :			Union[str, Any]	       =		self.get_auto_remove_tmp_dir()
													convert_pl_to_hf(ckpts[0]	,						transformer_ckpts[0].parent	,						A__			)
													assert os.path.exists(os.path.join(A__	,						"pytorch_model.bin"			)			)

						def 						a__ (					self		:			Any			):
													_UpperCAmelCase  :			Dict	       =		AutoModelForSeqaSeqLM.from_pretrained(A__			)
													_UpperCAmelCase       ,_UpperCAmelCase  :			Tuple	       =		model.dummy_inputs["input_ids"], model.dummy_inputs["attention_mask"]
													_UpperCAmelCase  :			str	       =		torch.tensor([[0, 4, 8, 2], [0, 8, 2, 1]]	,						dtype=torch.long	,						device=model.device			)
													_UpperCAmelCase  :			Optional[Any]	       =		target_ids[:, :-1].contiguous()  # Why this line?
													_UpperCAmelCase  :			Dict	       =		target_ids[:, 1:].clone()  # why clone?
													_UpperCAmelCase  :			Tuple	       =		model(
													    A__	,						attention_mask=A__	,						decoder_input_ids=A__	,						labels=A__	,						use_cache=A__			).loss

													_UpperCAmelCase  :			Any	       =		model(A__	,						attention_mask=A__	,						decoder_input_ids=A__	,						use_cache=A__			).logits

													_UpperCAmelCase  :			int	       =		nn.functional.log_softmax(A__	,						dim=-1			)
													_UpperCAmelCase       ,_UpperCAmelCase  :			Tuple	       =		label_smoothed_nll_loss(
													    A__	,						A__	,						0.1	,						ignore_index=model.config.pad_token_id			)
													with self.assertRaises(A__			):
																				# TODO: understand why this breaks
																				self.assertEqual(A__	,						A__			)

						def 						a__ (					self		:			Optional[Any]			):
													_UpperCAmelCase  :			Optional[Any]	       =		{
													    "student_encoder_layers": 2,
													    "student_decoder_layers": 1,
													    "num_train_epochs": 4,
													    "val_check_interval": 0.25,
													    "alpha_hid": 2.0,
													    "task": "translation",
													    "model_name_or_path": "IGNORE_THIS_IT_DOESNT_GET_USED",
													    "tokenizer_name": MBART_TINY,
													    "teacher": MBART_TINY,
													    "src_lang": "en_XX",
													    "tgt_lang": "ro_RO",
													}
													_UpperCAmelCase  :			int	       =		self._test_distiller_cli(A__	,						check_contents=A__			)
													assert model.model.config.model_type == "mbart"

													_UpperCAmelCase  :			Optional[int]	       =		list(Path(model.output_dir			).glob("*.ckpt"			)			)
													self.assertEqual(1	,						len(A__			)			)
													_UpperCAmelCase  :			Dict	       =		list(Path(model.output_dir			).glob("**/*.bin"			)			)
													_UpperCAmelCase  :			List[str]	       =		list(Path(model.output_dir			).glob("best_tfmr/*"			)			)
													assert len(A__			) > 2
													self.assertEqual(len(A__			)	,						2			)

						def 						a__ (					self		:			Union[str, Any]			):
													_UpperCAmelCase  :			List[Any]	       =		{
													    "student_encoder_layers": 1,
													    "student_decoder_layers": 1,
													    "alpha_hid": 2.0,
													    "teacher": T5_TINY,
													    "model_name_or_path": T5_TINY,
													    "tokenizer_name": T5_TINY,
													}
													self._test_distiller_cli(A__			)

						def 						a__ (					self		:			Tuple			):
													_UpperCAmelCase  :			Optional[int]	       =		{
													    "teacher": T5_TINY,
													    "student": T5_TINIER,
													    "model_name_or_path": T5_TINIER,
													    "tokenizer_name": T5_TINIER,
													}
													self._test_distiller_cli(A__			)






						def 						a__ (					self		:			Optional[Any]	,						_lowerCamelCase		:			Union[str, Any]	,						_lowerCamelCase		:			List[Any]=True			):
													_UpperCAmelCase  :			Dict	       =		{
													    "label_smoothing": 0.0,
													    "early_stopping_patience": -1,
													    "train_batch_size": 1,
													    "eval_batch_size": 2,
													    "max_epochs": 2,
													    "alpha_mlm": 0.2,
													    "alpha_ce": 0.8,
													    "do_predict": True,
													    "model_name_or_path": "sshleifer/tinier_bart",
													    "teacher": CHEAP_ARGS["model_name_or_path"],
													    "val_check_interval": 0.5,
													}
													default_updates.update(A__			)
													_UpperCAmelCase  :			Union[str, Any]	       =		CHEAP_ARGS.copy()
													_UpperCAmelCase  :			Union[str, Any]	       =		make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()			)
													_UpperCAmelCase  :			Tuple	       =		self.get_auto_remove_tmp_dir()

													args_d.update(data_dir=A__	,						output_dir=A__	,						**A__			)
													_UpperCAmelCase  :			Optional[Any]	       =		distill_main(argparse.Namespace(**A__			)			)
													if not check_contents:
																				return model
													_UpperCAmelCase  :			List[Any]	       =		os.listdir(A__			)
													_UpperCAmelCase  :			List[str]	       =		{os.path.basename(A__			) for p in contents}
													_UpperCAmelCase  :			Dict	       =		[p for p in contents if p.endswith("ckpt"			)]
													assert len(A__			) > 0

													self.assertIn("test_generations.txt"	,						A__			)
													self.assertIn("test_results.txt"	,						A__			)

													_UpperCAmelCase  :			Optional[Any]	       =		load_json(model.metrics_save_path			)
													_UpperCAmelCase  :			Tuple	       =		metrics["val"][-1]
													self.assertGreaterEqual(last_step_stats["val_avg_gen_time"]	,						0.01			)
													self.assertGreaterEqual(1.0	,						last_step_stats["val_avg_gen_time"]			)
													self.assertIsInstance(last_step_stats[f"""val_avg_{model.val_metric}"""]	,						A__			)
													_UpperCAmelCase  :			int	       =		int(args_d["max_epochs"] * (1 / args_d["val_check_interval"]) + 1			)
													self.assertEqual(len(metrics["val"]			)	,						A__			)
													self.assertEqual(len(metrics["test"]			)	,						1			)
													return model







class    _UpperCamelCase(   __lowercase				):

						@parameterized.expand(
						    [T5_TINY, BART_TINY, MBART_TINY, MARIAN_TINY, FSMT_TINY]	,						)
						def 						a__ (					self		:			Union[str, Any]	,						_lowerCamelCase		:			List[str]			):
													_UpperCAmelCase  :			Tuple	       =		CHEAP_ARGS.copy()
													_UpperCAmelCase  :			Dict	       =		"translation" if model in [MBART_TINY, MARIAN_TINY, FSMT_TINY] else "summarization"
													_UpperCAmelCase  :			List[str]	       =		0.1 if task == "translation" else 0

													_UpperCAmelCase  :			Union[str, Any]	       =		make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()			)
													_UpperCAmelCase  :			List[Any]	       =		self.get_auto_remove_tmp_dir()
													args_d.update(
													    data_dir=A__	,						model_name_or_path=A__	,						tokenizer_name=A__	,						train_batch_size=2	,						eval_batch_size=2	,						output_dir=A__	,						do_predict=A__	,						task=A__	,						src_lang="en_XX"	,						tgt_lang="ro_RO"	,						freeze_encoder=A__	,						freeze_embeds=A__	,						)
													assert "n_train" in args_d
													_UpperCAmelCase  :			int	       =		argparse.Namespace(**A__			)
													_UpperCAmelCase  :			List[str]	       =		main(A__			)

													_UpperCAmelCase  :			Any	       =		module.model.get_input_embeddings()
													assert not input_embeds.weight.requires_grad
													if model == T5_TINY:
																				_UpperCAmelCase  :			Optional[Any]	       =		module.model.lm_head
																				assert not lm_head.weight.requires_grad
																				assert (lm_head.weight == input_embeds.weight).all().item()
													elif model == FSMT_TINY:
																				_UpperCAmelCase  :			Any	       =		module.model.model
																				_UpperCAmelCase  :			int	       =		fsmt.decoder.embed_positions
																				assert not embed_pos.weight.requires_grad
																				assert not fsmt.decoder.embed_tokens.weight.requires_grad
																				# check that embeds are not the same
																				assert fsmt.decoder.embed_tokens != fsmt.encoder.embed_tokens
													else:
																				_UpperCAmelCase  :			Any	       =		module.model.model
																				_UpperCAmelCase  :			Optional[int]	       =		bart.decoder.embed_positions
																				assert not embed_pos.weight.requires_grad
																				assert not bart.shared.weight.requires_grad
																				# check that embeds are the same
																				assert bart.decoder.embed_tokens == bart.encoder.embed_tokens
																				assert bart.decoder.embed_tokens == bart.shared

													_UpperCAmelCase  :			Optional[int]	       =		load_json(module.output_dir / "text_batch.json"			)
													assert isinstance(A__	,						A__			)
													assert len(A__			) >= 4

						def 						a__ (					self		:			List[str]			):
													_UpperCAmelCase  :			List[Any]	       =		CHEAP_ARGS.copy()

													_UpperCAmelCase  :			List[str]	       =		"summarization"
													_UpperCAmelCase  :			List[str]	       =		make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()			)

													args_d.update(
													    data_dir=A__	,						tokenizer_name=A__	,						train_batch_size=2	,						eval_batch_size=2	,						do_predict=A__	,						task=A__	,						src_lang="en_XX"	,						tgt_lang="ro_RO"	,						freeze_encoder=A__	,						freeze_embeds=A__	,						)

													# test models whose config includes the extra_model_args
													_UpperCAmelCase  :			str	       =		BART_TINY
													_UpperCAmelCase  :			Optional[int]	       =		self.get_auto_remove_tmp_dir()
													_UpperCAmelCase  :			int	       =		args_d.copy()
													args_da.update(
													    model_name_or_path=A__	,						output_dir=A__	,						)
													_UpperCAmelCase  :			Tuple	       =		("encoder_layerdrop", "decoder_layerdrop", "dropout", "attention_dropout")
													for p in extra_model_params:
																				_UpperCAmelCase  :			Dict	       =		0.5
													_UpperCAmelCase  :			Dict	       =		argparse.Namespace(**A__			)
													_UpperCAmelCase  :			Optional[Any]	       =		main(A__			)
													for p in extra_model_params:
																				assert getattr(model.config	,						A__			) == 0.5, f"""failed to override the model config for param {p}"""

													# test models whose config doesn't include the extra_model_args
													_UpperCAmelCase  :			Optional[Any]	       =		T5_TINY
													_UpperCAmelCase  :			Dict	       =		self.get_auto_remove_tmp_dir()
													_UpperCAmelCase  :			Optional[int]	       =		args_d.copy()
													args_da.update(
													    model_name_or_path=A__	,						output_dir=A__	,						)
													_UpperCAmelCase  :			Optional[Any]	       =		"encoder_layerdrop"
													_UpperCAmelCase  :			str	       =		0.5
													_UpperCAmelCase  :			Any	       =		argparse.Namespace(**A__			)
													with pytest.raises(A__			) as excinfo:
																				_UpperCAmelCase  :			Dict	       =		main(A__			)
													assert str(excinfo.value			) == f"""model config doesn't have a `{unsupported_param}` attribute"""






						def 						a__ (					self		:			Union[str, Any]			):
													_UpperCAmelCase  :			int	       =		CHEAP_ARGS.copy()

													_UpperCAmelCase  :			Optional[Any]	       =		"summarization"
													_UpperCAmelCase  :			Any	       =		make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()			)

													_UpperCAmelCase  :			List[Any]	       =		BART_TINY
													_UpperCAmelCase  :			Dict	       =		self.get_auto_remove_tmp_dir()

													args_d.update(
													    data_dir=A__	,						model_name_or_path=A__	,						output_dir=A__	,						tokenizer_name=A__	,						train_batch_size=2	,						eval_batch_size=2	,						do_predict=A__	,						task=A__	,						src_lang="en_XX"	,						tgt_lang="ro_RO"	,						freeze_encoder=A__	,						freeze_embeds=A__	,						)

													# emulate finetune.py
													_UpperCAmelCase  :			List[Any]	       =		argparse.ArgumentParser()
													_UpperCAmelCase  :			List[str]	       =		pl.Trainer.add_argparse_args(A__			)
													_UpperCAmelCase  :			Optional[Any]	       =		SummarizationModule.add_model_specific_args(A__	,						os.getcwd()			)
													_UpperCAmelCase  :			Optional[int]	       =		{"--help": True}

													# --help test
													with pytest.raises(A__			) as excinfo:
																				with CaptureStdout() as cs:
																											_UpperCAmelCase  :			List[str]	       =		parser.parse_args(A__			)
																				assert False, "--help is expected to sys.exit"
													assert excinfo.type == SystemExit
													_UpperCAmelCase  :			str	       =		lightning_base.arg_to_scheduler_metavar
													assert expected in cs.out, "--help is expected to list the supported schedulers"

													# --lr_scheduler=non_existing_scheduler test
													_UpperCAmelCase  :			str	       =		"non_existing_scheduler"
													_UpperCAmelCase  :			List[Any]	       =		{f"""--lr_scheduler={unsupported_param}"""}
													with pytest.raises(A__			) as excinfo:
																				with CaptureStderr() as cs:
																											_UpperCAmelCase  :			List[str]	       =		parser.parse_args(A__			)
																				assert False, "invalid argument is expected to sys.exit"
													assert excinfo.type == SystemExit
													_UpperCAmelCase  :			List[str]	       =		f"""invalid choice: '{unsupported_param}'"""
													assert expected in cs.err, f"""should have bailed on invalid choice of scheduler {unsupported_param}"""

													# --lr_scheduler=existing_scheduler test
													_UpperCAmelCase  :			Optional[int]	       =		"cosine"
													_UpperCAmelCase  :			Optional[int]	       =		args_d.copy()
													_UpperCAmelCase  :			int	       =		supported_param
													_UpperCAmelCase  :			Any	       =		argparse.Namespace(**A__			)
													_UpperCAmelCase  :			Dict	       =		main(A__			)
													assert (
													    getattr(model.hparams	,						"lr_scheduler"			) == supported_param
													), f"""lr_scheduler={supported_param} shouldn't fail"""







import functools
from math import sqrt
from time import time



def  snake_case_(_UpperCamelCase					,			*_UpperCamelCase					,			**_UpperCamelCase	)				->      str:



  """simple docstring"""






  _snake_case		=				time()
  _snake_case		=				func(*_UpperCamelCase					,			**_UpperCamelCase	)
  _snake_case		=				time()
  if int(end - start	) > 0:
    print(F"""{func.__name__} runtime: {(end - start):0.4f} s"""	)
  else:
    print(F"""{func.__name__} runtime: {(end - start) * 1_000:0.4f} ms"""	)
  return output



def  snake_case_(_UpperCamelCase	)				->      list[int]:



  """simple docstring"""






  if n < 0:
    raise Exception('''n is negative'''	)
  if n == 0:
    return [0]
  _snake_case		=				[0, 1]
  for _ in range(n - 1	):
    fib.append(fib[-1] + fib[-2]	)
  return fib



def  snake_case_(_UpperCamelCase	)				->      list[int]:



  """simple docstring"""






  def fib_recursive_term(_UpperCamelCase	) -> int:
    if i < 0:
      raise Exception('''n is negative'''	)
    if i < 2:
      return i
    return fib_recursive_term(i - 1	) + fib_recursive_term(i - 2	)

  if n < 0:
    raise Exception('''n is negative'''	)
  return [fib_recursive_term(_UpperCamelCase	) for i in range(n + 1	)]



def  snake_case_(_UpperCamelCase	)				->      list[int]:



  """simple docstring"""






  @functools.cache
  def fib_recursive_term(_UpperCamelCase	) -> int:
    if i < 0:
      raise Exception('''n is negative'''	)
    if i < 2:
      return i
    return fib_recursive_term(i - 1	) + fib_recursive_term(i - 2	)

  if n < 0:
    raise Exception('''n is negative'''	)
  return [fib_recursive_term(_UpperCamelCase	) for i in range(n + 1	)]



def  snake_case_(_UpperCamelCase	)				->      list[int]:



  """simple docstring"""






  if n < 0:
    raise Exception('''n is negative'''	)
  # Cache must be outside recursuive function
  # other it will reset every time it calls itself.
  _snake_case		=				{0: 0, 1: 1, 2: 1}  # Prefilled cache

  def rec_fn_memoized(_UpperCamelCase	) -> int:
    if num in cache:
      return cache[num]

    _snake_case		=				rec_fn_memoized(num - 1	) + rec_fn_memoized(num - 2	)
    _snake_case		=				value
    return value

  return [rec_fn_memoized(_UpperCamelCase	) for i in range(n + 1	)]



def  snake_case_(_UpperCamelCase	)				->      list[int]:



  """simple docstring"""






  if n < 0:
    raise Exception('''n is negative'''	)
  if n >= 1_475:
    raise Exception('''n is too large'''	)
  _snake_case		=				sqrt(5	)
  _snake_case		=				(1 + sqrt_a) / 2
  return [round(phi**i / sqrt_a	) for i in range(n + 1	)]


if __name__ == "__main__":
 __A     						=      30
 time_func(fib_iterative, num)
 time_func(fib_recursive, num)  # Around 3s runtime
 time_func(fib_recursive_cached, num)  # Around 0ms runtime
 time_func(fib_memoization, num)
 time_func(fib_binet, num)

