



import importlib.util
import os
import platform
from argparse import ArgumentParser

import huggingface_hub

from .. import __version__ as version
from ..utils import (
    is_accelerate_available,
    is_flax_available,
    is_safetensors_available,
    is_tf_available,
    is_torch_available,
)
from . import BaseTransformersCLICommand






def  UpperCAmelCase__    (    lowercase__   ) ->      Tuple:
						return EnvironmentCommand()






def  UpperCAmelCase__    (    lowercase__   ) ->      Union[str, Any]:
						return EnvironmentCommand(args.accelerate_config_file   )







class 			_lowerCAmelCase   ( _UpperCAmelCase			):






			"""simple docstring"""





			@staticmethod
			def 		snake_case__			(				lowercase	:       ArgumentParser   )						->					Any:
									"""simple docstring"""







									__lowercase					=				parser.add_parser("""env"""   )
									download_parser.set_defaults(func=lowercase   )
									download_parser.add_argument(
									    """--accelerate-config_file"""			,     default=lowercase			,     help="""The accelerate config file to use for the default values in the launching script."""			,     )
									download_parser.set_defaults(func=lowercase   )





			def __init__(				self	:       Dict			,     lowercase	:       Tuple			,     *lowercase	:       Optional[int]   )						->					None:
									"""simple docstring"""







									__lowercase					=				accelerate_config_file





			def 		snake_case__			(				self	:       List[Any]   )						->					Any:
									"""simple docstring"""







									__lowercase					=				"""not installed"""
									if is_safetensors_available():
															import safetensors

															__lowercase					=				safetensors.__version__
									elif importlib.util.find_spec("""safetensors"""   ) is not None:
															import safetensors

															__lowercase					=				F"{safetensors.__version__} but is ignored because of PyTorch version too old."

									__lowercase					=				"""not installed"""
									__lowercase					=				__lowercase					=				"""not found"""
									if is_accelerate_available():
															import accelerate
															from accelerate.commands.config import default_config_file, load_config_from_file

															__lowercase					=				accelerate.__version__
															# Get the default from the config file.
															if self._accelerate_config_file is not None or os.path.isfile(lowercase   ):
																					__lowercase					=				load_config_from_file(self._accelerate_config_file   ).to_dict()

															__lowercase					=				(
															    """\n""".join([F"\t- {prop}: {val}" for prop, val in accelerate_config.items()]   )
															    if isinstance(lowercase			,     lowercase   )
															    else F"\t{accelerate_config}"
															)

									__lowercase					=				"""not installed"""
									__lowercase					=				"""NA"""
									if is_torch_available():
															import torch

															__lowercase					=				torch.__version__
															__lowercase					=				torch.cuda.is_available()

									__lowercase					=				"""not installed"""
									__lowercase					=				"""NA"""
									if is_tf_available():
															import tensorflow as tf

															__lowercase					=				tf.__version__
															try:
																					# deprecated in v2.1
																					__lowercase					=				tf.test.is_gpu_available()
															except AttributeError:
																					# returns list of devices, convert to bool
																					__lowercase					=				bool(tf.config.list_physical_devices("""GPU"""   )   )

									__lowercase					=				"""not installed"""
									__lowercase					=				"""not installed"""
									__lowercase					=				"""not installed"""
									__lowercase					=				"""NA"""
									if is_flax_available():
															import flax
															import jax
															import jaxlib

															__lowercase					=				flax.__version__
															__lowercase					=				jax.__version__
															__lowercase					=				jaxlib.__version__
															__lowercase					=				jax.lib.xla_bridge.get_backend().platform

									__lowercase					=				{
									    """`transformers` version""": version,
									    """Platform""": platform.platform(),
									    """Python version""": platform.python_version(),
									    """Huggingface_hub version""": huggingface_hub.__version__,
									    """Safetensors version""": F"{safetensors_version}",
									    """Accelerate version""": F"{accelerate_version}",
									    """Accelerate config""": F"{accelerate_config_str}",
									    """PyTorch version (GPU?)""": F"{pt_version} ({pt_cuda_available})",
									    """Tensorflow version (GPU?)""": F"{tf_version} ({tf_cuda_available})",
									    """Flax version (CPU?/GPU?/TPU?)""": F"{flax_version} ({jax_backend})",
									    """Jax version""": F"{jax_version}",
									    """JaxLib version""": F"{jaxlib_version}",
									    """Using GPU in script?""": """<fill in>""",
									    """Using distributed or parallel set-up in script?""": """<fill in>""",
									}

									print("""\nCopy-and-paste the text below in your GitHub issue and FILL OUT the two last points.\n"""   )
									print(self.format_dict(lowercase   )   )

									return info







			@staticmethod
			def 		snake_case__			(				lowercase	:       str   )						->					str:
									"""simple docstring"""







									return "\n".join([F"- {prop}: {val}" for prop, val in d.items()]   ) + "\n"










from dataclasses import asdict, dataclass
from typing import Optional

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


UpperCamelCase__ =						logging.get_logger(__name__)

# TODO Update this
UpperCamelCase__ =						{
    "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 			_lowerCAmelCase   ( _UpperCAmelCase			):






			"""simple docstring"""





			lowercase__      :  Union[str, Any]      =			"""esm"""





			def __init__(				self	:       Any			,     lowercase	:       Optional[Any]=None			,     lowercase	:       Optional[int]=None			,     lowercase	:       List[Any]=None			,     lowercase	:       Optional[int]=768			,     lowercase	:       str=12			,     lowercase	:       Union[str, Any]=12			,     lowercase	:       Dict=3_072			,     lowercase	:       Optional[int]=0.1			,     lowercase	:       str=0.1			,     lowercase	:       Dict=1_026			,     lowercase	:       Tuple=0.02			,     lowercase	:       str=1E-1_2			,     lowercase	:       Dict="absolute"			,     lowercase	:       Optional[Any]=True			,     lowercase	:       int=None			,     lowercase	:       int=False			,     lowercase	:       List[str]=False			,     lowercase	:       Tuple=None			,     lowercase	:       Tuple=None			,     **lowercase	:       Union[str, Any]			,     )						->					int:
									"""simple docstring"""







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

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







			def 		snake_case__			(				self	:       Optional[Any]   )						->					Tuple:
									"""simple docstring"""







									__lowercase					=				super().to_dict()
									if isinstance(self.esmfold_config			,     lowercase   ):
															__lowercase					=				self.esmfold_config.to_dict()
									return output





@dataclass
class 			_lowerCAmelCase   :






			"""simple docstring"""





			lowercase__      :  str      =			None
			lowercase__      :  bool      =			True
			lowercase__      :  bool      =			False
			lowercase__      :  bool      =			False
			lowercase__      :  bool      =			False
			lowercase__      :  float      =			0

			lowercase__      :  bool      =			True
			lowercase__      :  bool      =			False

			lowercase__      :  int      =			128
			lowercase__      :  "TrunkConfig"      =			None





			def 		snake_case__			(				self	:       List[str]   )						->					Any:
									"""simple docstring"""







									if self.trunk is None:
															__lowercase					=				TrunkConfig()
									elif isinstance(self.trunk			,     lowercase   ):
															__lowercase					=				TrunkConfig(**self.trunk   )







			def 		snake_case__			(				self	:       Dict   )						->					Any:
									"""simple docstring"""







									__lowercase					=				asdict(self   )
									__lowercase					=				self.trunk.to_dict()
									return output





@dataclass
class 			_lowerCAmelCase   :






			"""simple docstring"""





			lowercase__      :  int      =			48
			lowercase__      :  int      =			1_024
			lowercase__      :  int      =			128
			lowercase__      :  int      =			32
			lowercase__      :  int      =			32
			lowercase__      :  int      =			32
			lowercase__      :  float      =			0
			lowercase__      :  float      =			0
			lowercase__      :  bool      =			False
			lowercase__      :  int      =			4
			lowercase__      :  Optional[int]      =			128
			lowercase__      :  "StructureModuleConfig"      =			None





			def 		snake_case__			(				self	:       Tuple   )						->					str:
									"""simple docstring"""







									if self.structure_module is None:
															__lowercase					=				StructureModuleConfig()
									elif isinstance(self.structure_module			,     lowercase   ):
															__lowercase					=				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}."   )

									__lowercase					=				self.sequence_state_dim // self.sequence_head_width
									__lowercase					=				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 		snake_case__			(				self	:       List[str]   )						->					Union[str, Any]:
									"""simple docstring"""







									__lowercase					=				asdict(self   )
									__lowercase					=				self.structure_module.to_dict()
									return output





@dataclass
class 			_lowerCAmelCase   :






			"""simple docstring"""





			lowercase__      :  int      =			384
			lowercase__      :  int      =			128
			lowercase__      :  int      =			16
			lowercase__      :  int      =			128
			lowercase__      :  int      =			12
			lowercase__      :  int      =			4
			lowercase__      :  int      =			8
			lowercase__      :  float      =			0.1
			lowercase__      :  int      =			8
			lowercase__      :  int      =			1
			lowercase__      :  int      =			2
			lowercase__      :  int      =			7
			lowercase__      :  int      =			10
			lowercase__      :  float      =			1E-8
			lowercase__      :  float      =			1E5





			def 		snake_case__			(				self	:       Tuple   )						->					List[str]:
									"""simple docstring"""







									return asdict(self   )






def  UpperCAmelCase__    (    ) ->      List[Any]:
						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>",
						)





