



'''simple docstring'''






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""": 42,
    """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""": 12,
    """max_target_length""": 12,
    """val_max_target_length""": 12,
    """test_max_target_length""": 12,
    """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 				_SCREAMING_SNAKE_CASE(					snake_case_    :     Path ,       snake_case_    :     list  )		->Dict:






							'''simple docstring'''
							_lowercase							:		int				=   '''\n'''.join(a__  )
							Path(a__  ).open('''w'''  ).writelines(a__  )


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 				_SCREAMING_SNAKE_CASE(					snake_case_    :     Dict  )		->Optional[int]:






							'''simple docstring'''



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

class 	_lowerCAmelCase     (    __A       ):






		'''simple docstring'''
		@classmethod
		def 						__lowercase      (						cls							:       Tuple		)      ->			Optional[int]:







									'''simple docstring'''





									logging.disable(logging.CRITICAL		)  # remove noisy download output from tracebacks
									return cls
		@slow
		@require_torch_gpu
		def 						__lowercase      (						self							:       Union[str, Any]		)      ->			Any:







									'''simple docstring'''





									_lowercase							:		str				=   list_models()
									_lowercase							:		List[Any]				=   '''sshleifer'''
									_lowercase							:		int				=   [x.modelId for x in model_list if x.modelId.startswith(UpperCAmelCase_		)]
									_lowercase							:		Any				=   ['''sshleifer/blenderbot-3B''', '''sshleifer/blenderbot-90M''']
									_lowercase							:		List[str]				=   []
									for m in model_ids:
																if m in allowed_to_be_broken:
																							continue
																try:
																							AutoConfig.from_pretrained(UpperCAmelCase_		)
																except Exception:
																							failures.append(UpperCAmelCase_		)
									assert not failures, F"The following models could not be loaded through AutoConfig: {failures}"
		def 						__lowercase      (						self							:       Union[str, Any]		)      ->			Dict:







									'''simple docstring'''





									_lowercase							:		List[str]				=   {'''student_encoder_layers''': 2, '''student_decoder_layers''': 1, '''no_teacher''': True}
									self._test_distiller_cli(UpperCAmelCase_		)
		def 						__lowercase      (						self							:       Union[str, Any]		)      ->			Tuple:







									'''simple docstring'''





									_lowercase							:		Tuple				=   {
									    '''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''',
									}
									_lowercase							:		List[str]				=   self._test_distiller_cli(UpperCAmelCase_      ,		check_contents=UpperCAmelCase_		)

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

									_lowercase							:		Optional[Any]				=   self.get_auto_remove_tmp_dir()
									convert_pl_to_hf(ckpts[0]      ,		transformer_ckpts[0].parent      ,		UpperCAmelCase_		)
									assert os.path.exists(os.path.join(UpperCAmelCase_      ,		'''pytorch_model.bin'''		)		)
		def 						__lowercase      (						self							:       Dict		)      ->			Dict:







									'''simple docstring'''





									_lowercase							:		Optional[int]				=   AutoModelForSeqaSeqLM.from_pretrained(UpperCAmelCase_		)
									_lowercase			, _lowercase							:		List[str]				=   model.dummy_inputs['''input_ids'''], model.dummy_inputs['''attention_mask''']
									_lowercase							:		str				=   torch.tensor([[0, 4, 8, 2], [0, 8, 2, 1]]      ,		dtype=torch.long      ,		device=model.device		)
									_lowercase							:		Any				=   target_ids[:, :-1].contiguous()  # Why this line?
									_lowercase							:		str				=   target_ids[:, 1:].clone()  # why clone?
									_lowercase							:		List[Any]				=   model(
									    UpperCAmelCase_      ,		attention_mask=UpperCAmelCase_      ,		decoder_input_ids=UpperCAmelCase_      ,		labels=UpperCAmelCase_      ,		use_cache=UpperCAmelCase_		).loss

									_lowercase							:		Dict				=   model(UpperCAmelCase_      ,		attention_mask=UpperCAmelCase_      ,		decoder_input_ids=UpperCAmelCase_      ,		use_cache=UpperCAmelCase_		).logits

									_lowercase							:		List[Any]				=   nn.functional.log_softmax(UpperCAmelCase_      ,		dim=-1		)
									_lowercase			, _lowercase							:		Union[str, Any]				=   label_smoothed_nll_loss(
									    UpperCAmelCase_      ,		UpperCAmelCase_      ,		0.1      ,		ignore_index=model.config.pad_token_id		)
									with self.assertRaises(UpperCAmelCase_		):
																# TODO: understand why this breaks
																self.assertEqual(UpperCAmelCase_      ,		UpperCAmelCase_		)
		def 						__lowercase      (						self							:       int		)      ->			Tuple:







									'''simple docstring'''





									_lowercase							:		str				=   {
									    '''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''',
									}
									_lowercase							:		str				=   self._test_distiller_cli(UpperCAmelCase_      ,		check_contents=UpperCAmelCase_		)
									assert model.model.config.model_type == "mbart"

									_lowercase							:		Any				=   list(Path(model.output_dir		).glob('''*.ckpt'''		)		)
									self.assertEqual(1      ,		len(UpperCAmelCase_		)		)
									_lowercase							:		Any				=   list(Path(model.output_dir		).glob('''**/*.bin'''		)		)
									_lowercase							:		Dict				=   list(Path(model.output_dir		).glob('''best_tfmr/*'''		)		)
									assert len(UpperCAmelCase_		) > 2
									self.assertEqual(len(UpperCAmelCase_		)      ,		2		)
		def 						__lowercase      (						self							:       List[str]		)      ->			List[str]:







									'''simple docstring'''





									_lowercase							:		Union[str, 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(UpperCAmelCase_		)
		def 						__lowercase      (						self							:       Optional[int]		)      ->			Union[str, Any]:







									'''simple docstring'''





									_lowercase							:		List[str]				=   {
									    '''teacher''': T5_TINY,
									    '''student''': T5_TINIER,
									    '''model_name_or_path''': T5_TINIER,
									    '''tokenizer_name''': T5_TINIER,
									}
									self._test_distiller_cli(UpperCAmelCase_		)





		def 						__lowercase      (						self							:       Union[str, Any]      ,		UpperCamelCase_							:       Optional[Any]      ,		UpperCamelCase_							:       Any=True		)      ->			Optional[int]:







									'''simple docstring'''





									_lowercase							:		Any				=   {
									    '''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(UpperCAmelCase_		)
									_lowercase							:		Union[str, Any]				=   CHEAP_ARGS.copy()
									_lowercase							:		Any				=   make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()		)
									_lowercase							:		str				=   self.get_auto_remove_tmp_dir()

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

									self.assertIn('''test_generations.txt'''      ,		UpperCAmelCase_		)
									self.assertIn('''test_results.txt'''      ,		UpperCAmelCase_		)

									_lowercase							:		Union[str, Any]				=   load_json(model.metrics_save_path		)
									_lowercase							:		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}"]      ,		UpperCAmelCase_		)
									_lowercase							:		str				=   int(args_d['''max_epochs'''] * (1 / args_d['''val_check_interval''']) + 1		)
									self.assertEqual(len(metrics['''val''']		)      ,		UpperCAmelCase_		)
									self.assertEqual(len(metrics['''test''']		)      ,		1		)
									return model




class 	_lowerCAmelCase     (    __A       ):






		'''simple docstring'''
		@parameterized.expand(
		    [T5_TINY, BART_TINY, MBART_TINY, MARIAN_TINY, FSMT_TINY]      ,		)
		def 						__lowercase      (						self							:       Dict      ,		UpperCamelCase_							:       str		)      ->			Tuple:







									'''simple docstring'''





									_lowercase							:		List[str]				=   CHEAP_ARGS.copy()
									_lowercase							:		Union[str, Any]				=   '''translation''' if model in [MBART_TINY, MARIAN_TINY, FSMT_TINY] else '''summarization'''
									_lowercase							:		Optional[int]				=   0.1 if task == '''translation''' else 0

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

									_lowercase							:		Dict				=   module.model.get_input_embeddings()
									assert not input_embeds.weight.requires_grad
									if model == T5_TINY:
																_lowercase							:		Tuple				=   module.model.lm_head
																assert not lm_head.weight.requires_grad
																assert (lm_head.weight == input_embeds.weight).all().item()
									elif model == FSMT_TINY:
																_lowercase							:		Optional[Any]				=   module.model.model
																_lowercase							:		Optional[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:
																_lowercase							:		Tuple				=   module.model.model
																_lowercase							:		List[str]				=   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

									_lowercase							:		Tuple				=   load_json(module.output_dir / '''text_batch.json'''		)
									assert isinstance(UpperCAmelCase_      ,		UpperCAmelCase_		)
									assert len(UpperCAmelCase_		) >= 4
		def 						__lowercase      (						self							:       Optional[Any]		)      ->			List[Any]:







									'''simple docstring'''





									_lowercase							:		List[str]				=   CHEAP_ARGS.copy()

									_lowercase							:		str				=   '''summarization'''
									_lowercase							:		Any				=   make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()		)

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

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

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





		def 						__lowercase      (						self							:       Any		)      ->			Optional[int]:







									'''simple docstring'''





									_lowercase							:		Any				=   CHEAP_ARGS.copy()

									_lowercase							:		Tuple				=   '''summarization'''
									_lowercase							:		Dict				=   make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir()		)

									_lowercase							:		List[Any]				=   BART_TINY
									_lowercase							:		List[str]				=   self.get_auto_remove_tmp_dir()

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

									# emulate finetune.py
									_lowercase							:		Dict				=   argparse.ArgumentParser()
									_lowercase							:		Any				=   pl.Trainer.add_argparse_args(UpperCAmelCase_		)
									_lowercase							:		Optional[Any]				=   SummarizationModule.add_model_specific_args(UpperCAmelCase_      ,		os.getcwd()		)
									_lowercase							:		int				=   {'''--help''': True}

									# --help test
									with pytest.raises(UpperCAmelCase_		) as excinfo:
																with CaptureStdout() as cs:
																							_lowercase							:		Optional[int]				=   parser.parse_args(UpperCAmelCase_		)
																assert False, "--help is expected to sys.exit"
									assert excinfo.type == SystemExit
									_lowercase							:		Optional[Any]				=   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
									_lowercase							:		int				=   '''non_existing_scheduler'''
									_lowercase							:		List[Any]				=   {F"--lr_scheduler={unsupported_param}"}
									with pytest.raises(UpperCAmelCase_		) as excinfo:
																with CaptureStderr() as cs:
																							_lowercase							:		int				=   parser.parse_args(UpperCAmelCase_		)
																assert False, "invalid argument is expected to sys.exit"
									assert excinfo.type == SystemExit
									_lowercase							:		List[Any]				=   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
									_lowercase							:		Optional[int]				=   '''cosine'''
									_lowercase							:		List[str]				=   args_d.copy()
									_lowercase							:		Optional[Any]				=   supported_param
									_lowercase							:		Optional[Any]				=   argparse.Namespace(**UpperCAmelCase_		)
									_lowercase							:		Tuple				=   main(UpperCAmelCase_		)
									assert (
									    getattr(model.hparams      ,		'''lr_scheduler'''		) == supported_param
									), F"lr_scheduler={supported_param} shouldn\'t fail"






"""simple docstring"""

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


a__			:						str							=			{
    """configuration_rwkv""": ["""RWKV_PRETRAINED_CONFIG_ARCHIVE_MAP""", """RwkvConfig""", """RwkvOnnxConfig"""],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							a__			:						Optional[int]							=			[
							    """RWKV_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """RwkvForCausalLM""",
							    """RwkvModel""",
							    """RwkvPreTrainedModel""",
							]


if TYPE_CHECKING:
							from .configuration_rwkv import RWKV_PRETRAINED_CONFIG_ARCHIVE_MAP, RwkvConfig, RwkvOnnxConfig

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_rwkv import (
														    RWKV_PRETRAINED_MODEL_ARCHIVE_LIST,
														    RwkvForCausalLM,
														    RwkvModel,
														    RwkvPreTrainedModel,
														)
else:
							import sys

							a__			:						List[str]							=			_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


