



"""simple docstring"""






import dataclasses
import re
import string
from typing import Any, Dict, Iterator, List, Mapping, Optional, Sequence, Tuple

import numpy as np

from . import residue_constants


__snake_case							:   Union[str, Any]      =    Mapping[str, np.ndarray]
__snake_case							:   Tuple      =    Mapping[str, Any]  # Is a nested dict.
__snake_case							:   int      =    0.01



@dataclasses.dataclass(frozen=__SCREAMING_SNAKE_CASE							)
class 			A__   :




	'''simple docstring'''





	SCREAMING_SNAKE_CASE          =	42  # [num_res, num_atom_type, 3]

	# Amino-acid type for each residue represented as an integer between 0 and
	# 20, where 20 is 'X'.
	SCREAMING_SNAKE_CASE          =	42  # [num_res]

	# Binary float mask to indicate presence of a particular atom. 1.0 if an atom
	# is present and 0.0 if not. This should be used for loss masking.
	SCREAMING_SNAKE_CASE          =	42  # [num_res, num_atom_type]

	# Residue index as used in PDB. It is not necessarily continuous or 0-indexed.
	SCREAMING_SNAKE_CASE          =	42  # [num_res]

	# B-factors, or temperature factors, of each residue (in sq. angstroms units),
	# representing the displacement of the residue from its ground truth mean
	# value.
	SCREAMING_SNAKE_CASE          =	42  # [num_res, num_atom_type]

	# Chain indices for multi-chain predictions
	SCREAMING_SNAKE_CASE          =	None

	# Optional remark about the protein. Included as a comment in output PDB
	# files
	SCREAMING_SNAKE_CASE          =	None

	# Templates used to generate this protein (prediction-only)
	SCREAMING_SNAKE_CASE          =	None

	# Chain corresponding to each parent
	SCREAMING_SNAKE_CASE          =	None






def 			_lowercase				(  __snake_case	)						->   Protein:
			__lowerCAmelCase      :  Union[str, Any]												=       r"(\[[A-Z]+\]\n)"
			__lowerCAmelCase      :  List[str]												=       [tag.strip() for tag in re.split(__snake_case					,__snake_case	) if len(__snake_case	) > 0]
			__lowerCAmelCase      :  Iterator[Tuple[str, List[str]]]												=       zip(tags[0::2]					,[l.split("\n"	) for l in tags[1::2]]	)

			__lowerCAmelCase      :  List[str]												=       ["N", "CA", "C"]
			__lowerCAmelCase      :  List[Any]												=       None
			__lowerCAmelCase      :  List[Any]												=       None
			__lowerCAmelCase      :  Tuple												=       None
			for g in groups:
						if "[PRIMARY]" == g[0]:
									__lowerCAmelCase      :  List[Any]												=       g[1][0].strip()
									for i in range(len(__snake_case	)	):
												if seq[i] not in residue_constants.restypes:
															__lowerCAmelCase      :  Optional[int]												=       "X"  # FIXME: strings are immutable
									__lowerCAmelCase      :  str												=       np.array(
									    [residue_constants.restype_order.get(__snake_case					,residue_constants.restype_num	) for res_symbol in seq]	)
						elif "[TERTIARY]" == g[0]:
									__lowerCAmelCase      :  List[List[float]]												=       []
									for axis in range(3	):
												tertiary.append(list(map(__snake_case					,g[1][axis].split()	)	)	)
									__lowerCAmelCase      :  List[Any]												=       np.array(__snake_case	)
									__lowerCAmelCase      :  Optional[int]												=       np.zeros((len(tertiary[0]	) // 3, residue_constants.atom_type_num, 3)	).astype(np.floataa	)
									for i, atom in enumerate(__snake_case	):
												__lowerCAmelCase      :  List[Any]												=       np.transpose(tertiary_np[:, i::3]	)
									atom_positions *= PICO_TO_ANGSTROM
						elif "[MASK]" == g[0]:
									__lowerCAmelCase      :  Tuple												=       np.array(list(map({"-": 0, "+": 1}.get					,g[1][0].strip()	)	)	)
									__lowerCAmelCase      :  List[str]												=       np.zeros(
									    (
									        len(__snake_case	),
									        residue_constants.atom_type_num,
									    )	).astype(np.floataa	)
									for i, atom in enumerate(__snake_case	):
												__lowerCAmelCase      :  Dict												=       1
									atom_mask *= mask[..., None]

			assert aatype is not None

			return Protein(
			    atom_positions=__snake_case					,atom_mask=__snake_case					,aatype=__snake_case					,residue_index=np.arange(len(__snake_case	)	)					,b_factors=__snake_case					,)


def 			_lowercase				(  __snake_case					,__snake_case = 0	)						->   List[str]:
			__lowerCAmelCase      :  List[str]												=       []

			__lowerCAmelCase      :  str												=       prot.remark
			if remark is not None:
						pdb_headers.append(F"""REMARK {remark}"""	)

			__lowerCAmelCase      :  Any												=       prot.parents
			__lowerCAmelCase      :  List[Any]												=       prot.parents_chain_index
			if parents is not None and parents_chain_index is not None:
						__lowerCAmelCase      :  Optional[int]												=       [p for i, p in zip(__snake_case					,__snake_case	) if i == chain_id]

			if parents is None or len(__snake_case	) == 0:
						__lowerCAmelCase      :  Optional[int]												=       ["N/A"]

			pdb_headers.append(F"""PARENT {' '.join(__snake_case	)}"""	)

			return pdb_headers


def 			_lowercase				(  __snake_case					,__snake_case	)						->   str:
			__lowerCAmelCase      :  List[str]												=       []
			__lowerCAmelCase      :  int												=       pdb_str.split("\n"	)

			__lowerCAmelCase      :  Any												=       prot.remark
			if remark is not None:
						out_pdb_lines.append(F"""REMARK {remark}"""	)

			__lowerCAmelCase      :  List[List[str]]
			if prot.parents is not None and len(prot.parents	) > 0:
						__lowerCAmelCase      :  Any												=       []
						if prot.parents_chain_index is not None:
									__lowerCAmelCase      :  Dict[str, List[str]]												=       {}
									for p, i in zip(prot.parents					,prot.parents_chain_index	):
												parent_dict.setdefault(str(__snake_case	)					,[]	)
												parent_dict[str(__snake_case	)].append(__snake_case	)

									__lowerCAmelCase      :  List[str]												=       max([int(__snake_case	) for chain_idx in parent_dict]	)
									for i in range(max_idx + 1	):
												__lowerCAmelCase      :  Dict												=       parent_dict.get(str(__snake_case	)					,["N/A"]	)
												parents_per_chain.append(__snake_case	)
						else:
									parents_per_chain.append(list(prot.parents	)	)
			else:
						__lowerCAmelCase      :  List[Any]												=       [["N/A"]]

			def make_parent_line(__snake_case	) -> str:
						return F"""PARENT {' '.join(__snake_case	)}"""

			out_pdb_lines.append(make_parent_line(parents_per_chain[0]	)	)

			__lowerCAmelCase      :  str												=       0
			for i, l in enumerate(__snake_case	):
						if "PARENT" not in l and "REMARK" not in l:
									out_pdb_lines.append(__snake_case	)
						if "TER" in l and "END" not in lines[i + 1]:
									chain_counter += 1
									if not chain_counter >= len(__snake_case	):
												__lowerCAmelCase      :  Any												=       parents_per_chain[chain_counter]
									else:
												__lowerCAmelCase      :  Dict												=       ["N/A"]

									out_pdb_lines.append(make_parent_line(__snake_case	)	)

			return "\n".join(__snake_case	)


def 			_lowercase				(  __snake_case	)						->   str:
			__lowerCAmelCase      :  List[Any]												=       residue_constants.restypes + ["X"]

			def res_atoa(__snake_case	) -> str:
						return residue_constants.restype_atoa.get(restypes[r]					,"UNK"	)

			__lowerCAmelCase      :  Tuple												=       residue_constants.atom_types

			__lowerCAmelCase      :  List[str]												=       []

			__lowerCAmelCase      :  List[Any]												=       prot.atom_mask
			__lowerCAmelCase      :  List[str]												=       prot.aatype
			__lowerCAmelCase      :  List[Any]												=       prot.atom_positions
			__lowerCAmelCase      :  Optional[int]												=       prot.residue_index.astype(np.intaa	)
			__lowerCAmelCase      :  str												=       prot.b_factors
			__lowerCAmelCase      :  Optional[Any]												=       prot.chain_index

			if np.any(aatype > residue_constants.restype_num	):
						raise ValueError("Invalid aatypes."	)

			__lowerCAmelCase      :  List[Any]												=       get_pdb_headers(__snake_case	)
			if len(__snake_case	) > 0:
						pdb_lines.extend(__snake_case	)

			__lowerCAmelCase      :  str												=       aatype.shape[0]
			__lowerCAmelCase      :  Optional[Any]												=       1
			__lowerCAmelCase      :  Optional[int]												=       0
			__lowerCAmelCase      :  Tuple												=       string.ascii_uppercase
			__lowerCAmelCase      :  List[str]												=       None
			# Add all atom sites.
			for i in range(__snake_case	):
						__lowerCAmelCase      :  List[Any]												=       res_atoa(aatype[i]	)
						for atom_name, pos, mask, b_factor in zip(__snake_case					,atom_positions[i]					,atom_mask[i]					,b_factors[i]	):
									if mask < 0.5:
												continue

									__lowerCAmelCase      :  List[str]												=       "ATOM"
									__lowerCAmelCase      :  Tuple												=       atom_name if len(__snake_case	) == 4 else F""" {atom_name}"""
									__lowerCAmelCase      :  Tuple												=       ""
									__lowerCAmelCase      :  str												=       ""
									__lowerCAmelCase      :  Tuple												=       1.00
									__lowerCAmelCase      :  Union[str, Any]												=       atom_name[0]  # Protein supports only C, N, O, S, this works.
									__lowerCAmelCase      :  List[str]												=       ""

									__lowerCAmelCase      :  List[Any]												=       "A"
									if chain_index is not None:
												__lowerCAmelCase      :  Optional[Any]												=       chain_tags[chain_index[i]]

									# PDB is a columnar format, every space matters here!
									__lowerCAmelCase      :  Union[str, Any]												=       (
									    F"""{record_type:<6}{atom_index:>5} {name:<4}{alt_loc:>1}"""
									    F"""{res_name_a:>3} {chain_tag:>1}"""
									    F"""{residue_index[i]:>4}{insertion_code:>1}   """
									    F"""{pos[0]:>8.3f}{pos[1]:>8.3f}{pos[2]:>8.3f}"""
									    F"""{occupancy:>6.2f}{b_factor:>6.2f}          """
									    F"""{element:>2}{charge:>2}"""
									)
									pdb_lines.append(__snake_case	)
									atom_index += 1

						__lowerCAmelCase      :  Union[str, Any]												=       i == n - 1
						if chain_index is not None:
									if i != n - 1 and chain_index[i + 1] != prev_chain_index:
												__lowerCAmelCase      :  Tuple												=       True
												__lowerCAmelCase      :  Optional[int]												=       chain_index[i + 1]

						if should_terminate:
									# Close the chain.
									__lowerCAmelCase      :  Optional[int]												=       "TER"
									__lowerCAmelCase      :  Optional[int]												=       (
									    F"""{chain_end:<6}{atom_index:>5}      {res_atoa(aatype[i]	):>3} {chain_tag:>1}{residue_index[i]:>4}"""
									)
									pdb_lines.append(__snake_case	)
									atom_index += 1

									if i != n - 1:
												# "prev" is a misnomer here. This happens at the beginning of
												# each new chain.
												pdb_lines.extend(get_pdb_headers(__snake_case					,__snake_case	)	)

			pdb_lines.append("END"	)
			pdb_lines.append(""	)
			return "\n".join(__snake_case	)


def 			_lowercase				(  __snake_case	)						->   np.ndarray:
			return residue_constants.STANDARD_ATOM_MASK[prot.aatype]





def 			_lowercase				(  __snake_case					,__snake_case					,__snake_case = None					,__snake_case = None					,__snake_case = None					,__snake_case = None					,__snake_case = None					,)						->   Protein:
			return Protein(
			    aatype=features["aatype"]					,atom_positions=result["final_atom_positions"]					,atom_mask=result["final_atom_mask"]					,residue_index=features["residue_index"] + 1					,b_factors=b_factors if b_factors is not None else np.zeros_like(result["final_atom_mask"]	)					,chain_index=__snake_case					,remark=__snake_case					,parents=__snake_case					,parents_chain_index=__snake_case					,)




"""simple docstring"""






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


__snake_case							:   List[Any]      =    logging.get_logger(__name__)

__snake_case							:   Any      =    {
    'speechbrain/m-ctc-t-large': 'https://huggingface.co/speechbrain/m-ctc-t-large/resolve/main/config.json',
    # See all M-CTC-T models at https://huggingface.co/models?filter=mctct
}



class 			A__   (  __SCREAMING_SNAKE_CASE							):




	'''simple docstring'''





	SCREAMING_SNAKE_CASE          =	'mctct'

	def __init__(     self:		Union[str, Any]       ,			_SCREAMING_SNAKE_CASE:		str=8065       ,			_SCREAMING_SNAKE_CASE:		str=1536       ,			_SCREAMING_SNAKE_CASE:		str=36       ,			_SCREAMING_SNAKE_CASE:		Optional[Any]=6144       ,			_SCREAMING_SNAKE_CASE:		Optional[Any]=4       ,			_SCREAMING_SNAKE_CASE:		Union[str, Any]=384       ,			_SCREAMING_SNAKE_CASE:		Optional[Any]=920       ,			_SCREAMING_SNAKE_CASE:		Union[str, Any]=1e-5       ,			_SCREAMING_SNAKE_CASE:		List[Any]=0.3       ,			_SCREAMING_SNAKE_CASE:		Optional[Any]="relu"       ,			_SCREAMING_SNAKE_CASE:		Optional[int]=0.02       ,			_SCREAMING_SNAKE_CASE:		Optional[Any]=0.3       ,			_SCREAMING_SNAKE_CASE:		Dict=0.3       ,			_SCREAMING_SNAKE_CASE:		List[Any]=1       ,			_SCREAMING_SNAKE_CASE:		Optional[Any]=0       ,			_SCREAMING_SNAKE_CASE:		List[str]=2       ,			_SCREAMING_SNAKE_CASE:		Union[str, Any]=1       ,			_SCREAMING_SNAKE_CASE:		Tuple=0.3       ,			_SCREAMING_SNAKE_CASE:		Dict=1       ,			_SCREAMING_SNAKE_CASE:		int=(7,)       ,			_SCREAMING_SNAKE_CASE:		str=(3,)       ,			_SCREAMING_SNAKE_CASE:		Union[str, Any]=80       ,			_SCREAMING_SNAKE_CASE:		Tuple=1       ,			_SCREAMING_SNAKE_CASE:		Dict=None       ,			_SCREAMING_SNAKE_CASE:		Tuple="sum"       ,			_SCREAMING_SNAKE_CASE:		List[str]=False       ,			**_SCREAMING_SNAKE_CASE:		Tuple       ,			)				->       Tuple:

				"""simple docstring"""

				super().__init__(**_SCREAMING_SNAKE_CASE       ,			pad_token_id=_SCREAMING_SNAKE_CASE       ,			bos_token_id=_SCREAMING_SNAKE_CASE       ,			eos_token_id=_SCREAMING_SNAKE_CASE)
				__lowerCAmelCase      :  str												=       vocab_size
				__lowerCAmelCase      :  str												=       hidden_size
				__lowerCAmelCase      :  str												=       num_hidden_layers
				__lowerCAmelCase      :  str												=       intermediate_size
				__lowerCAmelCase      :  List[Any]												=       num_attention_heads
				__lowerCAmelCase      :  Dict												=       attention_head_dim
				__lowerCAmelCase      :  Optional[int]												=       max_position_embeddings
				__lowerCAmelCase      :  str												=       layer_norm_eps
				__lowerCAmelCase      :  Tuple												=       layerdrop
				__lowerCAmelCase      :  str												=       hidden_act
				__lowerCAmelCase      :  List[Any]												=       initializer_range
				__lowerCAmelCase      :  int												=       hidden_dropout_prob
				__lowerCAmelCase      :  Optional[Any]												=       attention_probs_dropout_prob
				__lowerCAmelCase      :  str												=       pad_token_id
				__lowerCAmelCase      :  Optional[int]												=       bos_token_id
				__lowerCAmelCase      :  Union[str, Any]												=       eos_token_id
				__lowerCAmelCase      :  Any												=       conv_glu_dim
				__lowerCAmelCase      :  Optional[int]												=       conv_dropout
				__lowerCAmelCase      :  Union[str, Any]												=       num_conv_layers
				__lowerCAmelCase      :  Optional[int]												=       input_feat_per_channel
				__lowerCAmelCase      :  Union[str, Any]												=       input_channels
				__lowerCAmelCase      :  Optional[Any]												=       conv_channels
				__lowerCAmelCase      :  Dict												=       ctc_loss_reduction
				__lowerCAmelCase      :  int												=       ctc_zero_infinity

				# prevents config testing fail with exporting to json
				__lowerCAmelCase      :  List[str]												=       list(_SCREAMING_SNAKE_CASE)
				__lowerCAmelCase      :  Dict												=       list(_SCREAMING_SNAKE_CASE)

				if len(self.conv_kernel) != self.num_conv_layers:
							raise ValueError(
							    "Configuration for convolutional module is incorrect. "
							    "It is required that `len(config.conv_kernel)` == `config.num_conv_layers` "
							    F"""but is `len(config.conv_kernel) = {len(self.conv_kernel)}`, """
							    F"""`config.num_conv_layers = {self.num_conv_layers}`.""")