import tempfile

import torch

from diffusers import (
    DEISMultistepScheduler,
    DPMSolverMultistepScheduler,
    DPMSolverSinglestepScheduler,
    UniPCMultistepScheduler,
)

from .test_schedulers import SchedulerCommonTest





class       lowercase__		(     UpperCamelCase_):
						UpperCamelCase_  =	(UniPCMultistepScheduler,)
						UpperCamelCase_  =	(("""num_inference_steps""", 25),)


						def  __A ( self			:       Any					,	**UpperCamelCase__			:       Tuple		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Any           =							{
												    '''num_train_timesteps''': 1000,
												    '''beta_start''': 0.0001,
												    '''beta_end''': 0.02,
												    '''beta_schedule''': '''linear''',
												    '''solver_order''': 2,
												    '''solver_type''': '''bh2''',
												}

												config.update(**UpperCamelCase__		)
												return config


						def  __A ( self			:       Union[str, Any]					,	UpperCamelCase__			:       Any=0					,	**UpperCamelCase__			:       Any		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Optional[int]           =							dict(self.forward_default_kwargs		)
												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							kwargs.pop('''num_inference_steps'''					,	UpperCamelCase__		)
												SCREAMING_SNAKE_CASE							:					Any           =							self.dummy_sample
												SCREAMING_SNAKE_CASE							:					Any           =							0.1 * sample
												SCREAMING_SNAKE_CASE							:					str           =							[residual + 0.2, residual + 0.15, residual + 0.10]

												for scheduler_class in self.scheduler_classes:
																		SCREAMING_SNAKE_CASE							:					str           =							self.get_scheduler_config(**UpperCamelCase__		)
																		SCREAMING_SNAKE_CASE							:					List[Any]           =							scheduler_class(**UpperCamelCase__		)
																		scheduler.set_timesteps(UpperCamelCase__		)
																		# copy over dummy past residuals
																		SCREAMING_SNAKE_CASE							:					int           =							dummy_past_residuals[: scheduler.config.solver_order]

																		with tempfile.TemporaryDirectory() as tmpdirname:
																								scheduler.save_config(UpperCamelCase__		)
																								SCREAMING_SNAKE_CASE							:					Optional[int]           =							scheduler_class.from_pretrained(UpperCamelCase__		)
																								new_scheduler.set_timesteps(UpperCamelCase__		)
																								# copy over dummy past residuals
																								SCREAMING_SNAKE_CASE							:					Optional[int]           =							dummy_past_residuals[: new_scheduler.config.solver_order]

																		SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE							:					Optional[Any]           =							sample, sample
																		for t in range(UpperCamelCase__					,	time_step + scheduler.config.solver_order + 1		):
																								SCREAMING_SNAKE_CASE							:					List[str]           =							scheduler.step(UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__					,	**UpperCamelCase__		).prev_sample
																								SCREAMING_SNAKE_CASE							:					Any           =							new_scheduler.step(UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__					,	**UpperCamelCase__		).prev_sample

																								assert torch.sum(torch.abs(output - new_output		)		) < 1E-5, "Scheduler outputs are not identical"


						def  __A ( self			:       Optional[Any]					,	UpperCamelCase__			:       List[str]=0					,	**UpperCamelCase__			:       Optional[int]		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Any           =							dict(self.forward_default_kwargs		)
												SCREAMING_SNAKE_CASE							:					Tuple           =							kwargs.pop('''num_inference_steps'''					,	UpperCamelCase__		)
												SCREAMING_SNAKE_CASE							:					Optional[int]           =							self.dummy_sample
												SCREAMING_SNAKE_CASE							:					str           =							0.1 * sample
												SCREAMING_SNAKE_CASE							:					Dict           =							[residual + 0.2, residual + 0.15, residual + 0.10]

												for scheduler_class in self.scheduler_classes:
																		SCREAMING_SNAKE_CASE							:					List[Any]           =							self.get_scheduler_config()
																		SCREAMING_SNAKE_CASE							:					int           =							scheduler_class(**UpperCamelCase__		)
																		scheduler.set_timesteps(UpperCamelCase__		)

																		# copy over dummy past residuals (must be after setting timesteps)
																		SCREAMING_SNAKE_CASE							:					Dict           =							dummy_past_residuals[: scheduler.config.solver_order]

																		with tempfile.TemporaryDirectory() as tmpdirname:
																								scheduler.save_config(UpperCamelCase__		)
																								SCREAMING_SNAKE_CASE							:					List[Any]           =							scheduler_class.from_pretrained(UpperCamelCase__		)
																								# copy over dummy past residuals
																								new_scheduler.set_timesteps(UpperCamelCase__		)

																								# copy over dummy past residual (must be after setting timesteps)
																								SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							dummy_past_residuals[: new_scheduler.config.solver_order]

																		SCREAMING_SNAKE_CASE							:					Optional[int]           =							scheduler.step(UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__					,	**UpperCamelCase__		).prev_sample
																		SCREAMING_SNAKE_CASE							:					str           =							new_scheduler.step(UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__					,	**UpperCamelCase__		).prev_sample

																		assert torch.sum(torch.abs(output - new_output		)		) < 1E-5, "Scheduler outputs are not identical"


						def  __A ( self			:       Union[str, Any]					,	UpperCamelCase__			:       List[Any]=None					,	**UpperCamelCase__			:       Optional[int]		):





												'''simple docstring'''





												if scheduler is None:
																		SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							self.scheduler_classes[0]
																		SCREAMING_SNAKE_CASE							:					Optional[Any]           =							self.get_scheduler_config(**UpperCamelCase__		)
																		SCREAMING_SNAKE_CASE							:					str           =							scheduler_class(**UpperCamelCase__		)

												SCREAMING_SNAKE_CASE							:					int           =							self.scheduler_classes[0]
												SCREAMING_SNAKE_CASE							:					int           =							self.get_scheduler_config(**UpperCamelCase__		)
												SCREAMING_SNAKE_CASE							:					List[Any]           =							scheduler_class(**UpperCamelCase__		)

												SCREAMING_SNAKE_CASE							:					Any           =							10
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							self.dummy_model()
												SCREAMING_SNAKE_CASE							:					int           =							self.dummy_sample_deter
												scheduler.set_timesteps(UpperCamelCase__		)

												for i, t in enumerate(scheduler.timesteps		):
																		SCREAMING_SNAKE_CASE							:					Optional[int]           =							model(UpperCamelCase__					,	UpperCamelCase__		)
																		SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							scheduler.step(UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__		).prev_sample

												return sample


						def  __A ( self			:       str		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							dict(self.forward_default_kwargs		)

												SCREAMING_SNAKE_CASE							:					List[str]           =							kwargs.pop('''num_inference_steps'''					,	UpperCamelCase__		)

												for scheduler_class in self.scheduler_classes:
																		SCREAMING_SNAKE_CASE							:					List[Any]           =							self.get_scheduler_config()
																		SCREAMING_SNAKE_CASE							:					List[Any]           =							scheduler_class(**UpperCamelCase__		)

																		SCREAMING_SNAKE_CASE							:					Optional[Any]           =							self.dummy_sample
																		SCREAMING_SNAKE_CASE							:					int           =							0.1 * sample

																		if num_inference_steps is not None and hasattr(UpperCamelCase__					,	'''set_timesteps'''		):
																								scheduler.set_timesteps(UpperCamelCase__		)
																		elif num_inference_steps is not None and not hasattr(UpperCamelCase__					,	'''set_timesteps'''		):
																								SCREAMING_SNAKE_CASE							:					List[str]           =							num_inference_steps

																		# copy over dummy past residuals (must be done after set_timesteps)
																		SCREAMING_SNAKE_CASE							:					Any           =							[residual + 0.2, residual + 0.15, residual + 0.10]
																		SCREAMING_SNAKE_CASE							:					int           =							dummy_past_residuals[: scheduler.config.solver_order]

																		SCREAMING_SNAKE_CASE							:					List[str]           =							scheduler.timesteps[5]
																		SCREAMING_SNAKE_CASE							:					Dict           =							scheduler.timesteps[6]

																		SCREAMING_SNAKE_CASE							:					Optional[Any]           =							scheduler.step(UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__					,	**UpperCamelCase__		).prev_sample
																		SCREAMING_SNAKE_CASE							:					List[str]           =							scheduler.step(UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__					,	**UpperCamelCase__		).prev_sample

																		self.assertEqual(output_a.shape					,	sample.shape		)
																		self.assertEqual(output_a.shape					,	output_a.shape		)


						def  __A ( self			:       int		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							UniPCMultistepScheduler(**self.get_scheduler_config()		)
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							self.full_loop(scheduler=UpperCamelCase__		)
												SCREAMING_SNAKE_CASE							:					Any           =							torch.mean(torch.abs(UpperCamelCase__		)		)

												assert abs(result_mean.item() - 0.2464		) < 1E-3

												SCREAMING_SNAKE_CASE							:					Dict           =							DPMSolverSinglestepScheduler.from_config(scheduler.config		)
												SCREAMING_SNAKE_CASE							:					Any           =							DEISMultistepScheduler.from_config(scheduler.config		)
												SCREAMING_SNAKE_CASE							:					Optional[int]           =							DPMSolverMultistepScheduler.from_config(scheduler.config		)
												SCREAMING_SNAKE_CASE							:					Any           =							UniPCMultistepScheduler.from_config(scheduler.config		)

												SCREAMING_SNAKE_CASE							:					str           =							self.full_loop(scheduler=UpperCamelCase__		)
												SCREAMING_SNAKE_CASE							:					Optional[int]           =							torch.mean(torch.abs(UpperCamelCase__		)		)

												assert abs(result_mean.item() - 0.2464		) < 1E-3


						def  __A ( self			:       List[str]		):





												'''simple docstring'''





												for timesteps in [25, 50, 100, 999, 1000]:
																		self.check_over_configs(num_train_timesteps=UpperCamelCase__		)


						def  __A ( self			:       Any		):





												'''simple docstring'''





												self.check_over_configs(thresholding=UpperCamelCase__		)
												for order in [1, 2, 3]:
																		for solver_type in ["bh1", "bh2"]:
																								for threshold in [0.5, 1.0, 2.0]:
																														for prediction_type in ["epsilon", "sample"]:
																																				self.check_over_configs(
																																				    thresholding=UpperCamelCase__					,	prediction_type=UpperCamelCase__					,	sample_max_value=UpperCamelCase__					,	solver_order=UpperCamelCase__					,	solver_type=UpperCamelCase__					,	)


						def  __A ( self			:       Optional[Any]		):





												'''simple docstring'''





												for prediction_type in ["epsilon", "v_prediction"]:
																		self.check_over_configs(prediction_type=UpperCamelCase__		)


						def  __A ( self			:       Dict		):





												'''simple docstring'''





												for solver_type in ["bh1", "bh2"]:
																		for order in [1, 2, 3]:
																								for prediction_type in ["epsilon", "sample"]:
																														self.check_over_configs(
																														    solver_order=UpperCamelCase__					,	solver_type=UpperCamelCase__					,	prediction_type=UpperCamelCase__					,	)
																														SCREAMING_SNAKE_CASE							:					str           =							self.full_loop(
																														    solver_order=UpperCamelCase__					,	solver_type=UpperCamelCase__					,	prediction_type=UpperCamelCase__					,	)
																														assert not torch.isnan(UpperCamelCase__		).any(), "Samples have nan numbers"


						def  __A ( self			:       List[Any]		):





												'''simple docstring'''





												self.check_over_configs(lower_order_final=UpperCamelCase__		)
												self.check_over_configs(lower_order_final=UpperCamelCase__		)


						def  __A ( self			:       Optional[Any]		):





												'''simple docstring'''





												for num_inference_steps in [1, 2, 3, 5, 10, 50, 100, 999, 1000]:
																		self.check_over_forward(num_inference_steps=UpperCamelCase__					,	time_step=0		)


						def  __A ( self			:       Union[str, Any]		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Dict           =							self.full_loop()
												SCREAMING_SNAKE_CASE							:					List[Any]           =							torch.mean(torch.abs(UpperCamelCase__		)		)

												assert abs(result_mean.item() - 0.2464		) < 1E-3


						def  __A ( self			:       Dict		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Dict           =							self.full_loop(prediction_type='''v_prediction'''		)
												SCREAMING_SNAKE_CASE							:					List[str]           =							torch.mean(torch.abs(UpperCamelCase__		)		)

												assert abs(result_mean.item() - 0.1014		) < 1E-3


						def  __A ( self			:       Tuple		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					List[Any]           =							self.scheduler_classes[0]
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							self.get_scheduler_config(thresholding=UpperCamelCase__					,	dynamic_thresholding_ratio=0		)
												SCREAMING_SNAKE_CASE							:					List[str]           =							scheduler_class(**UpperCamelCase__		)

												SCREAMING_SNAKE_CASE							:					List[str]           =							10
												SCREAMING_SNAKE_CASE							:					List[str]           =							self.dummy_model()
												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							self.dummy_sample_deter.half()
												scheduler.set_timesteps(UpperCamelCase__		)

												for i, t in enumerate(scheduler.timesteps		):
																		SCREAMING_SNAKE_CASE							:					List[str]           =							model(UpperCamelCase__					,	UpperCamelCase__		)
																		SCREAMING_SNAKE_CASE							:					List[Any]           =							scheduler.step(UpperCamelCase__					,	UpperCamelCase__					,	UpperCamelCase__		).prev_sample

												assert sample.dtype == torch.floataa



						def  __A ( self			:       int					,	**UpperCamelCase__			:       List[Any]		):





												'''simple docstring'''





												for scheduler_class in self.scheduler_classes:
																		SCREAMING_SNAKE_CASE							:					Tuple           =							self.get_scheduler_config(**UpperCamelCase__		)
																		SCREAMING_SNAKE_CASE							:					List[Any]           =							scheduler_class(**UpperCamelCase__		)

																		scheduler.set_timesteps(scheduler.config.num_train_timesteps		)
																		assert len(scheduler.timesteps.unique()		) == scheduler.num_inference_steps






from dataclasses import asdict, dataclass
from typing import Optional

from ...configuration_utils import PretrainedConfig
from ...utils import logging


__UpperCamelCase	: Tuple    		=  logging.get_logger(__name__)

# TODO Update this
__UpperCamelCase	: List[str]    		=  {
    'facebook/esm-1b': 'https://huggingface.co/facebook/esm-1b/resolve/main/config.json',
    # See all ESM models at https://huggingface.co/models?filter=esm
}





class       lowercase__		(     UpperCamelCase_):
						UpperCamelCase_  =	"""esm"""


						def __init__( self			:       Tuple					,	UpperCamelCase__			:       Optional[Any]=None					,	UpperCamelCase__			:       int=None					,	UpperCamelCase__			:       List[str]=None					,	UpperCamelCase__			:       Any=768					,	UpperCamelCase__			:       Optional[Any]=12					,	UpperCamelCase__			:       str=12					,	UpperCamelCase__			:       Optional[int]=3072					,	UpperCamelCase__			:       Optional[Any]=0.1					,	UpperCamelCase__			:       Any=0.1					,	UpperCamelCase__			:       Union[str, Any]=1026					,	UpperCamelCase__			:       Dict=0.02					,	UpperCamelCase__			:       Any=1E-12					,	UpperCamelCase__			:       Dict="absolute"					,	UpperCamelCase__			:       Optional[Any]=True					,	UpperCamelCase__			:       int=None					,	UpperCamelCase__			:       Optional[int]=False					,	UpperCamelCase__			:       Tuple=False					,	UpperCamelCase__			:       List[str]=None					,	UpperCamelCase__			:       Optional[Any]=None					,	**UpperCamelCase__			:       Any					,	):





												'''simple docstring'''





												super().__init__(pad_token_id=UpperCamelCase__					,	mask_token_id=UpperCamelCase__					,	**UpperCamelCase__		)

												SCREAMING_SNAKE_CASE							:					List[Any]           =							vocab_size
												SCREAMING_SNAKE_CASE							:					Any           =							hidden_size
												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							num_hidden_layers
												SCREAMING_SNAKE_CASE							:					Dict           =							num_attention_heads
												SCREAMING_SNAKE_CASE							:					Any           =							intermediate_size
												SCREAMING_SNAKE_CASE							:					str           =							hidden_dropout_prob
												SCREAMING_SNAKE_CASE							:					List[Any]           =							attention_probs_dropout_prob
												SCREAMING_SNAKE_CASE							:					str           =							max_position_embeddings
												SCREAMING_SNAKE_CASE							:					Tuple           =							initializer_range
												SCREAMING_SNAKE_CASE							:					Optional[int]           =							layer_norm_eps
												SCREAMING_SNAKE_CASE							:					Dict           =							position_embedding_type
												SCREAMING_SNAKE_CASE							:					Any           =							use_cache
												SCREAMING_SNAKE_CASE							:					Dict           =							emb_layer_norm_before
												SCREAMING_SNAKE_CASE							:					List[str]           =							token_dropout
												SCREAMING_SNAKE_CASE							:					List[Any]           =							is_folding_model
												if is_folding_model:
																		if esmfold_config is None:
																								logger.info('''No esmfold_config supplied for folding model, using default values.'''		)
																								SCREAMING_SNAKE_CASE							:					List[Any]           =							EsmFoldConfig()
																		elif isinstance(UpperCamelCase__					,	UpperCamelCase__		):
																								SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							EsmFoldConfig(**UpperCamelCase__		)
																		SCREAMING_SNAKE_CASE							:					List[Any]           =							esmfold_config
																		if vocab_list is None:
																								logger.warning('''No vocab_list supplied for folding model, assuming the ESM-2 vocabulary!'''		)
																								SCREAMING_SNAKE_CASE							:					Optional[int]           =							get_default_vocab_list()
																		else:
																								SCREAMING_SNAKE_CASE							:					Optional[Any]           =							vocab_list
												else:
																		SCREAMING_SNAKE_CASE							:					str           =							None
																		SCREAMING_SNAKE_CASE							:					int           =							None
												if self.esmfold_config is not None and getattr(self.esmfold_config					,	'''use_esm_attn_map'''					,	UpperCamelCase__		):
																		raise ValueError('''The HuggingFace port of ESMFold does not support use_esm_attn_map at this time!'''		)



						def  __A ( self			:       Dict		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							super().to_dict()
												if isinstance(self.esmfold_config					,	UpperCamelCase__		):
																		SCREAMING_SNAKE_CASE							:					Optional[Any]           =							self.esmfold_config.to_dict()
												return output






@dataclass
class       lowercase__		:
						UpperCamelCase_  =	None
						UpperCamelCase_  =	True
						UpperCamelCase_  =	False
						UpperCamelCase_  =	False
						UpperCamelCase_  =	False
						UpperCamelCase_  =	0

						UpperCamelCase_  =	True
						UpperCamelCase_  =	False

						UpperCamelCase_  =	128
						UpperCamelCase_  =	None


						def  __A ( self			:       Optional[int]		):





												'''simple docstring'''





												if self.trunk is None:
																		SCREAMING_SNAKE_CASE							:					Optional[Any]           =							TrunkConfig()
												elif isinstance(self.trunk					,	UpperCamelCase__		):
																		SCREAMING_SNAKE_CASE							:					Tuple           =							TrunkConfig(**self.trunk		)



						def  __A ( self			:       str		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					str           =							asdict(self		)
												SCREAMING_SNAKE_CASE							:					Tuple           =							self.trunk.to_dict()
												return output






@dataclass
class       lowercase__		:
						UpperCamelCase_  =	48
						UpperCamelCase_  =	1_024
						UpperCamelCase_  =	128
						UpperCamelCase_  =	32
						UpperCamelCase_  =	32
						UpperCamelCase_  =	32
						UpperCamelCase_  =	0
						UpperCamelCase_  =	0
						UpperCamelCase_  =	False
						UpperCamelCase_  =	4
						UpperCamelCase_  =	128
						UpperCamelCase_  =	None


						def  __A ( self			:       Any		):





												'''simple docstring'''





												if self.structure_module is None:
																		SCREAMING_SNAKE_CASE							:					Optional[int]           =							StructureModuleConfig()
												elif isinstance(self.structure_module					,	UpperCamelCase__		):
																		SCREAMING_SNAKE_CASE							:					Optional[Any]           =							StructureModuleConfig(**self.structure_module		)

												if self.max_recycles <= 0:
																		raise ValueError(f"""`max_recycles` should be positive, got {self.max_recycles}."""		)
												if self.sequence_state_dim % self.sequence_state_dim != 0:
																		raise ValueError(
																		    '''`sequence_state_dim` should be a round multiple of `sequence_state_dim`, got'''
																		    f""" {self.sequence_state_dim} and {self.sequence_state_dim}."""		)
												if self.pairwise_state_dim % self.pairwise_state_dim != 0:
																		raise ValueError(
																		    '''`pairwise_state_dim` should be a round multiple of `pairwise_state_dim`, got'''
																		    f""" {self.pairwise_state_dim} and {self.pairwise_state_dim}."""		)

												SCREAMING_SNAKE_CASE							:					Dict           =							self.sequence_state_dim // self.sequence_head_width
												SCREAMING_SNAKE_CASE							:					Tuple           =							self.pairwise_state_dim // self.pairwise_head_width

												if self.sequence_state_dim != sequence_num_heads * self.sequence_head_width:
																		raise ValueError(
																		    '''`sequence_state_dim` should be equal to `sequence_num_heads * sequence_head_width, got'''
																		    f""" {self.sequence_state_dim} != {sequence_num_heads} * {self.sequence_head_width}."""		)
												if self.pairwise_state_dim != pairwise_num_heads * self.pairwise_head_width:
																		raise ValueError(
																		    '''`pairwise_state_dim` should be equal to `pairwise_num_heads * pairwise_head_width, got'''
																		    f""" {self.pairwise_state_dim} != {pairwise_num_heads} * {self.pairwise_head_width}."""		)
												if self.pairwise_state_dim % 2 != 0:
																		raise ValueError(f"""`pairwise_state_dim` should be even, got {self.pairwise_state_dim}."""		)

												if self.dropout >= 0.4:
																		raise ValueError(f"""`dropout` should not be greater than 0.4, got {self.dropout}."""		)



						def  __A ( self			:       Union[str, Any]		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Any           =							asdict(self		)
												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							self.structure_module.to_dict()
												return output






@dataclass
class       lowercase__		:
						UpperCamelCase_  =	384
						UpperCamelCase_  =	128
						UpperCamelCase_  =	16
						UpperCamelCase_  =	128
						UpperCamelCase_  =	12
						UpperCamelCase_  =	4
						UpperCamelCase_  =	8
						UpperCamelCase_  =	0.1
						UpperCamelCase_  =	8
						UpperCamelCase_  =	1
						UpperCamelCase_  =	2
						UpperCamelCase_  =	7
						UpperCamelCase_  =	10
						UpperCamelCase_  =	1E-8
						UpperCamelCase_  =	1E5


						def  __A ( self			:       Dict		):





												'''simple docstring'''





												return asdict(self		)






def    A			(					):
						return (
						    "<cls>",
						    "<pad>",
						    "<eos>",
						    "<unk>",
						    "L",
						    "A",
						    "G",
						    "V",
						    "S",
						    "E",
						    "R",
						    "T",
						    "I",
						    "D",
						    "P",
						    "K",
						    "Q",
						    "N",
						    "F",
						    "Y",
						    "M",
						    "H",
						    "W",
						    "C",
						    "X",
						    "B",
						    "U",
						    "Z",
						    "O",
						    ".",
						    "-",
						    "<null_1>",
						    "<mask>",
						)





