





'''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


__UpperCAmelCase            =       Mapping[str, np.ndarray]
__UpperCAmelCase            =       Mapping[str, Any]  # Is a nested dict.
__UpperCAmelCase            =       0.01




@dataclasses.dataclass(frozen=lowercase_			)
class      UpperCamelCase__					:




					"""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 		__A		(  lowerCamelCase_	):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE :				str		=			R"""(\[[A-Z]+\]\n)"""
		SCREAMING_SNAKE_CASE :				List[str]		=			[tag.strip() for tag in re.split(lowerCamelCase_			,			lowerCamelCase_	) if len(lowerCamelCase_	) > 0]
		SCREAMING_SNAKE_CASE :				Iterator[Tuple[str, List[str]]]		=			zip(tags[0::2]			,			[l.split("""\n"""	) for l in tags[1::2]]	)

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

		assert aatype is not None

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



def 		__A		(  lowerCamelCase_			,			lowerCamelCase_ = 0	):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE :				List[str]		=			[]

		SCREAMING_SNAKE_CASE :				Optional[int]		=			prot.remark
		if remark is not None:
				pdb_headers.append(f'''REMARK {remark}'''	)

		SCREAMING_SNAKE_CASE :				Optional[int]		=			prot.parents
		SCREAMING_SNAKE_CASE :				Tuple		=			prot.parents_chain_index
		if parents is not None and parents_chain_index is not None:
				SCREAMING_SNAKE_CASE :				Union[str, Any]		=			[p for i, p in zip(lowerCamelCase_			,			lowerCamelCase_	) if i == chain_id]

		if parents is None or len(lowerCamelCase_	) == 0:
				SCREAMING_SNAKE_CASE :				Any		=			["""N/A"""]

		pdb_headers.append(f'''PARENT {" ".join(lowerCamelCase_	)}'''	)

		return pdb_headers



def 		__A		(  lowerCamelCase_			,			lowerCamelCase_	):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE :				List[str]		=			[]
		SCREAMING_SNAKE_CASE :				Union[str, Any]		=			pdb_str.split("""\n"""	)

		SCREAMING_SNAKE_CASE :				Union[str, Any]		=			prot.remark
		if remark is not None:
				out_pdb_lines.append(f'''REMARK {remark}'''	)

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

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

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

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

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

						out_pdb_lines.append(make_parent_line(lowerCamelCase_	)	)

		return "\n".join(lowerCamelCase_	)



def 		__A		(  lowerCamelCase_	):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE :				List[str]		=			residue_constants.restypes + ["""X"""]

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

		SCREAMING_SNAKE_CASE :				str		=			residue_constants.atom_types

		SCREAMING_SNAKE_CASE :				List[str]		=			[]

		SCREAMING_SNAKE_CASE :				Dict		=			prot.atom_mask
		SCREAMING_SNAKE_CASE :				Dict		=			prot.aatype
		SCREAMING_SNAKE_CASE :				Any		=			prot.atom_positions
		SCREAMING_SNAKE_CASE :				str		=			prot.residue_index.astype(np.intaa	)
		SCREAMING_SNAKE_CASE :				Union[str, Any]		=			prot.b_factors
		SCREAMING_SNAKE_CASE :				List[Any]		=			prot.chain_index

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

		SCREAMING_SNAKE_CASE :				Optional[Any]		=			get_pdb_headers(lowerCamelCase_	)
		if len(lowerCamelCase_	) > 0:
				pdb_lines.extend(lowerCamelCase_	)

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

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

						SCREAMING_SNAKE_CASE :				Union[str, Any]		=			"""A"""
						if chain_index is not None:
								SCREAMING_SNAKE_CASE :				Union[str, Any]		=			chain_tags[chain_index[i]]

						# PDB is a columnar format, every space matters here!
						SCREAMING_SNAKE_CASE :				Optional[int]		=			(
						    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(lowerCamelCase_	)
						atom_index += 1

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

				if should_terminate:
						# Close the chain.
						SCREAMING_SNAKE_CASE :				List[Any]		=			"""TER"""
						SCREAMING_SNAKE_CASE :				Tuple		=			(
						    f'''{chain_end:<6}{atom_index:>5}      {res_atoa(aatype[i]	):>3} {chain_tag:>1}{residue_index[i]:>4}'''
						)
						pdb_lines.append(lowerCamelCase_	)
						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(lowerCamelCase_			,			lowerCamelCase_	)	)

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



def 		__A		(  lowerCamelCase_	):


		"""simple docstring"""



		return residue_constants.STANDARD_ATOM_MASK[prot.aatype]



def 		__A		(  lowerCamelCase_			,			lowerCamelCase_			,			lowerCamelCase_ = None			,			lowerCamelCase_ = None			,			lowerCamelCase_ = None			,			lowerCamelCase_ = None			,			lowerCamelCase_ = None			,			):


		"""simple docstring"""



		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=lowerCamelCase_			,			remark=lowerCamelCase_			,			parents=lowerCamelCase_			,			parents_chain_index=lowerCamelCase_			,			)










'''simple docstring'''




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


__UpperCAmelCase            =       logging.get_logger(__name__)

__UpperCAmelCase            =       {
    """naver-clova-ix/donut-base""": """https://huggingface.co/naver-clova-ix/donut-base/resolve/main/config.json""",
    # See all Donut models at https://huggingface.co/models?filter=donut-swin
}




class      UpperCamelCase__					(					lowercase_			):




					"""simple docstring"""
					SCREAMING_SNAKE_CASE__				=	'''donut-swin'''

					SCREAMING_SNAKE_CASE__				=	{
					    '''num_attention_heads''': '''num_heads''',
					    '''num_hidden_layers''': '''num_layers''',
					}


					def __init__(						self				:			str      ,						lowerCamelCase_				:			Union[str, Any]=2_24      ,						lowerCamelCase_				:			Union[str, Any]=4      ,						lowerCamelCase_				:			Optional[Any]=3      ,						lowerCamelCase_				:			Dict=96      ,						lowerCamelCase_				:			int=[2, 2, 6, 2]      ,						lowerCamelCase_				:			Optional[Any]=[3, 6, 12, 24]      ,						lowerCamelCase_				:			List[str]=7      ,						lowerCamelCase_				:			List[str]=4.0      ,						lowerCamelCase_				:			Optional[Any]=True      ,						lowerCamelCase_				:			List[str]=0.0      ,						lowerCamelCase_				:			Dict=0.0      ,						lowerCamelCase_				:			Dict=0.1      ,						lowerCamelCase_				:			Union[str, Any]="gelu"      ,						lowerCamelCase_				:			List[str]=False      ,						lowerCamelCase_				:			Optional[int]=0.02      ,						lowerCamelCase_				:			Any=1e-5      ,						**lowerCamelCase_				:			Union[str, Any]      ,						):

							'''simple docstring'''



							super().__init__(**lowerCamelCase_						)

							SCREAMING_SNAKE_CASE :				int		=			image_size
							SCREAMING_SNAKE_CASE :				Dict		=			patch_size
							SCREAMING_SNAKE_CASE :				str		=			num_channels
							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			embed_dim
							SCREAMING_SNAKE_CASE :				Optional[int]		=			depths
							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			len(lowerCamelCase_						)
							SCREAMING_SNAKE_CASE :				Optional[int]		=			num_heads
							SCREAMING_SNAKE_CASE :				Optional[int]		=			window_size
							SCREAMING_SNAKE_CASE :				Optional[Any]		=			mlp_ratio
							SCREAMING_SNAKE_CASE :				Dict		=			qkv_bias
							SCREAMING_SNAKE_CASE :				Optional[int]		=			hidden_dropout_prob
							SCREAMING_SNAKE_CASE :				Tuple		=			attention_probs_dropout_prob
							SCREAMING_SNAKE_CASE :				Dict		=			drop_path_rate
							SCREAMING_SNAKE_CASE :				List[str]		=			hidden_act
							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			use_absolute_embeddings
							SCREAMING_SNAKE_CASE :				Tuple		=			layer_norm_eps
							SCREAMING_SNAKE_CASE :				Optional[Any]		=			initializer_range
							# we set the hidden_size attribute in order to make Swin work with VisionEncoderDecoderModel
							# this indicates the channel dimension after the last stage of the model
							SCREAMING_SNAKE_CASE :				str		=			int(embed_dim * 2 ** (len(lowerCamelCase_						) - 1)						)



