

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							:	Union[str, Any]											=       Mapping[str, Any]  # Is a nested dict.
__snake_case							:	List[str]											=       0.01



@dataclasses.dataclass(frozen=a_				)
class     A__:
						"""simple docstring"""






						_A  :							List[str]     =       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'.
						_A  :							str     =       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.
						_A  :							List[Any]     =       42  # [num_res, num_atom_type]

						# Residue index as used in PDB. It is not necessarily continuous or 0-indexed.
						_A  :							List[Any]     =       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.
						_A  :							Optional[int]     =       42  # [num_res, num_atom_type]

						# Chain indices for multi-chain predictions
						_A  :							List[Any]     =       None

						# Optional remark about the protein. Included as a comment in output PDB
						# files
						_A  :							Optional[Any]     =       None

						# Templates used to generate this protein (prediction-only)
						_A  :							str     =       None

						# Chain corresponding to each parent
						_A  :							Dict     =       None







def  _UpperCAmelCase							(		a__):

			'''simple docstring'''



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

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

			'''simple docstring'''



			a_		:		Union[str, Any]      				=      []

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

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

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

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

			return pdb_headers


def  _UpperCAmelCase							(		a__   ,     a__):

			'''simple docstring'''



			a_		:		List[str]      				=      []
			a_		:		Dict      				=      pdb_str.split("""\n""")

			a_		:		Tuple      				=      prot.remark
			if remark is not None:
						out_pdb_lines.append(f'''REMARK {remark}''')

			a_		:		Optional[int]      				=      4_2
			if prot.parents is not None and len(prot.parents) > 0:
						a_		:		Optional[int]      				=      []
						if prot.parents_chain_index is not None:
									a_		:		Dict      				=      {}
									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)

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

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

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

			a_		:		Tuple      				=      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):
												a_		:		List[str]      				=      parents_per_chain[chain_counter]
									else:
												a_		:		Optional[int]      				=      ["""N/A"""]

									out_pdb_lines.append(make_parent_line(__snake_case))

			return "\n".join(__snake_case)


def  _UpperCAmelCase							(		a__):

			'''simple docstring'''



			a_		:		str      				=      residue_constants.restypes + ["""X"""]

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

			a_		:		Any      				=      residue_constants.atom_types

			a_		:		Optional[int]      				=      []

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

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

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

			a_		:		Optional[Any]      				=      aatype.shape[0]
			a_		:		Any      				=      1
			a_		:		Tuple      				=      0
			a_		:		Optional[Any]      				=      string.ascii_uppercase
			a_		:		Any      				=      None
			# Add all atom sites.
			for i in range(__snake_case):
						a_		:		List[str]      				=      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

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

									a_		:		int      				=      """A"""
									if chain_index is not None:
												a_		:		Tuple      				=      chain_tags[chain_index[i]]

									# PDB is a columnar format, every space matters here!
									a_		:		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(__snake_case)
									atom_index += 1

						a_		:		int      				=      i == n - 1
						if chain_index is not None:
									if i != n - 1 and chain_index[i + 1] != prev_chain_index:
												a_		:		int      				=      True
												a_		:		List[str]      				=      chain_index[i + 1]

						if should_terminate:
									# Close the chain.
									a_		:		List[str]      				=      """TER"""
									a_		:		Dict      				=      (
									    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  _UpperCAmelCase							(		a__):

			'''simple docstring'''



			return residue_constants.STANDARD_ATOM_MASK[prot.aatype]



def  _UpperCAmelCase							(		a__   ,     a__   ,     a__ = None   ,     a__ = None   ,     a__ = None   ,     a__ = None   ,     a__ = 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=__snake_case   ,     remark=__snake_case   ,     parents=__snake_case   ,     parents_chain_index=__snake_case   ,     )






# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


UpperCAmelCase__   	=							{
    '''configuration_efficientnet''': [
        '''EFFICIENTNET_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''EfficientNetConfig''',
        '''EfficientNetOnnxConfig''',
    ]
}

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase__   	=							['''EfficientNetImageProcessor''']

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase__   	=							[
      '''EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST''',
      '''EfficientNetForImageClassification''',
      '''EfficientNetModel''',
      '''EfficientNetPreTrainedModel''',
  ]

if TYPE_CHECKING:
  from .configuration_efficientnet import (
      EFFICIENTNET_PRETRAINED_CONFIG_ARCHIVE_MAP,
      EfficientNetConfig,
      EfficientNetOnnxConfig,
  )

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .image_processing_efficientnet import EfficientNetImageProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_efficientnet import (
        EFFICIENTNET_PRETRAINED_MODEL_ARCHIVE_LIST,
        EfficientNetForImageClassification,
        EfficientNetModel,
        EfficientNetPreTrainedModel,
    )

else:
  import sys

  UpperCAmelCase__   	=							_LazyModule(__name__, globals()['''__file__'''], _import_structure)

