






"""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_     :				Optional[Any]         =				Mapping[str, np.ndarray]
UpperCAmelCase_     :				Tuple         =				Mapping[str, Any]  # Is a nested dict.
UpperCAmelCase_     :				Tuple         =				0.0_1




@dataclasses.dataclass(frozen=UpperCAmelCase__				)
class 							lowerCAmelCase__       :






      '''simple docstring'''

      __UpperCamelCase							=						4_2  # [num_res, num_atom_type, 3]

      # Amino-acid type for each residue represented as an integer between 0 and
      # 20, where 20 is 'X'.
      __UpperCamelCase							=						4_2  # [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.
      __UpperCamelCase							=						4_2  # [num_res, num_atom_type]

      # Residue index as used in PDB. It is not necessarily continuous or 0-indexed.
      __UpperCamelCase							=						4_2  # [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.
      __UpperCamelCase							=						4_2  # [num_res, num_atom_type]

      # Chain indices for multi-chain predictions
      __UpperCamelCase							=						None

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

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

      # Chain corresponding to each parent
      __UpperCamelCase							=						None



def       _A    (__a							)				-> Protein:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_   :						int							=	R'''(\[[A-Z]+\]\n)'''
    SCREAMING_SNAKE_CASE_   :						List[str]							=	[tag.strip() for tag in re.split(__a					,       __a							) if len(__a							) > 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_   :						Optional[int]							=	None
    SCREAMING_SNAKE_CASE_   :						Tuple							=	None
    SCREAMING_SNAKE_CASE_   :						Dict							=	None
    for g in groups:
        if "[PRIMARY]" == g[0]:
            SCREAMING_SNAKE_CASE_   :						Any							=	g[1][0].strip()
            for i in range(len(__a							)							):
                if seq[i] not in residue_constants.restypes:
                    SCREAMING_SNAKE_CASE_   :						str							=	'''X'''  # FIXME: strings are immutable
            SCREAMING_SNAKE_CASE_   :						str							=	np.array(
                [residue_constants.restype_order.get(__a					,       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(__a					,       g[1][axis].split()							)							)							)
            SCREAMING_SNAKE_CASE_   :						Optional[int]							=	np.array(__a							)
            SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	np.zeros((len(tertiary[0]							) // 3, residue_constants.atom_type_num, 3)							).astype(np.floataa							)
            for i, atom in enumerate(__a							):
                SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	np.transpose(tertiary_np[:, i::3]							)
            atom_positions *= PICO_TO_ANGSTROM
        elif "[MASK]" == g[0]:
            SCREAMING_SNAKE_CASE_   :						str							=	np.array(list(map({'''-''': 0, '''+''': 1}.get					,       g[1][0].strip()							)							)							)
            SCREAMING_SNAKE_CASE_   :						Tuple							=	np.zeros(
                (
                    len(__a							),
                    residue_constants.atom_type_num,
                )							).astype(np.floataa							)
            for i, atom in enumerate(__a							):
                SCREAMING_SNAKE_CASE_   :						str							=	1
            atom_mask *= mask[..., None]

    assert aatype is not None

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



def       _A    (__a					,       __a = 0							)				-> List[str]:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_   :						List[str]							=	[]

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

    SCREAMING_SNAKE_CASE_   :						Dict							=	prot.parents
    SCREAMING_SNAKE_CASE_   :						Any							=	prot.parents_chain_index
    if parents is not None and parents_chain_index is not None:
        SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	[p for i, p in zip(__a					,       __a							) if i == chain_id]

    if parents is None or len(__a							) == 0:
        SCREAMING_SNAKE_CASE_   :						List[str]							=	['''N/A''']

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

    return pdb_headers



def       _A    (__a					,       __a							)				-> str:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_   :						List[str]							=	[]
    SCREAMING_SNAKE_CASE_   :						str							=	pdb_str.split('''\n'''							)

    SCREAMING_SNAKE_CASE_   :						Optional[int]							=	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_   :						Optional[int]							=	[]
        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(__a							)					,       []							)
                parent_dict[str(__a							)].append(__a							)

            SCREAMING_SNAKE_CASE_   :						int							=	max([int(__a							) for chain_idx in parent_dict]							)
            for i in range(max_idx + 1							):
                SCREAMING_SNAKE_CASE_   :						Tuple							=	parent_dict.get(str(__a							)					,       ['''N/A''']							)
                parents_per_chain.append(__a							)
        else:
            parents_per_chain.append(list(prot.parents							)							)
    else:
        SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	[['''N/A''']]

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

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

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

            out_pdb_lines.append(make_parent_line(__a							)							)

    return "\n".join(__a							)



def       _A    (__a							)				-> str:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_   :						Dict							=	residue_constants.restypes + ['''X''']

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

    SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	residue_constants.atom_types

    SCREAMING_SNAKE_CASE_   :						List[str]							=	[]

    SCREAMING_SNAKE_CASE_   :						List[Any]							=	prot.atom_mask
    SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	prot.aatype
    SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	prot.atom_positions
    SCREAMING_SNAKE_CASE_   :						List[Any]							=	prot.residue_index.astype(np.intaa							)
    SCREAMING_SNAKE_CASE_   :						str							=	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_   :						Dict							=	get_pdb_headers(__a							)
    if len(__a							) > 0:
        pdb_lines.extend(__a							)

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

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

            SCREAMING_SNAKE_CASE_   :						Tuple							=	'''A'''
            if chain_index is not None:
                SCREAMING_SNAKE_CASE_   :						Tuple							=	chain_tags[chain_index[i]]

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

        SCREAMING_SNAKE_CASE_   :						List[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_   :						Tuple							=	True
                SCREAMING_SNAKE_CASE_   :						Optional[int]							=	chain_index[i + 1]

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

    pdb_lines.append('''END'''							)
    pdb_lines.append(''''''							)
    return "\n".join(__a							)



def       _A    (__a							)				-> np.ndarray:
    """simple docstring"""






    return residue_constants.STANDARD_ATOM_MASK[prot.aatype]





def       _A    (__a					,       __a					,       __a = None					,       __a = None					,       __a = None					,       __a = None					,       __a = None					,       )				-> Protein:
    """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=__a					,       remark=__a					,       parents=__a					,       parents_chain_index=__a					,       )










"""simple docstring"""






from typing import List, Union

import numpy as np

from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
  from PIL import Image

  from ..image_utils import load_image

if is_torch_available():
  import torch

  from ..models.auto.modeling_auto import MODEL_FOR_DEPTH_ESTIMATION_MAPPING

UpperCAmelCase_     :				Optional[Any]         =				logging.get_logger(__name__)




@add_end_docstrings(UpperCAmelCase__				)
class 							lowerCAmelCase__       (    UpperCAmelCase__				):






      '''simple docstring'''

      def __init__(		self  :						Union[str, Any]		,			*lowercase_  :						Any		,			**lowercase_  :						Any):




          '''simple docstring'''


          super().__init__(*lowercase_		,			**lowercase_)
          requires_backends(self		,			'''vision''')
          self.check_model_type(lowercase_)
      def __call__(		self  :						int		,			lowercase_  :						Union[str, List[str], "Image.Image", List["Image.Image"]]		,			**lowercase_  :						Optional[Any]):




          '''simple docstring'''


          return super().__call__(lowercase_		,			**lowercase_)
      def _SCREAMING_SNAKE_CASE				(		self  :						List[str]		,			**lowercase_  :						List[str]):




          '''simple docstring'''


          return {}, {}, {}
      def _SCREAMING_SNAKE_CASE				(		self  :						List[Any]		,			lowercase_  :						Dict):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Dict							=	load_image(lowercase_)
          SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	image.size
          SCREAMING_SNAKE_CASE_   :						int							=	self.image_processor(images=lowercase_		,			return_tensors=self.framework)
          return model_inputs
      def _SCREAMING_SNAKE_CASE				(		self  :						Dict		,			lowercase_  :						int):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Any							=	self.model(**lowercase_)
          return model_outputs



      def _SCREAMING_SNAKE_CASE				(		self  :						Any		,			lowercase_  :						int):




          '''simple docstring'''


          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	model_outputs.predicted_depth
          SCREAMING_SNAKE_CASE_   :						List[Any]							=	torch.nn.functional.interpolate(
              predicted_depth.unsqueeze(1)		,			size=self.image_size[::-1]		,			mode='''bicubic'''		,			align_corners=lowercase_)
          SCREAMING_SNAKE_CASE_   :						Any							=	prediction.squeeze().cpu().numpy()
          SCREAMING_SNAKE_CASE_   :						List[str]							=	(output * 255 / np.max(lowercase_)).astype('''uint8''')
          SCREAMING_SNAKE_CASE_   :						List[Any]							=	Image.fromarray(lowercase_)
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	{}
          SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	predicted_depth
          SCREAMING_SNAKE_CASE_   :						Optional[int]							=	depth
          return output_dict


