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


__lowercase		:		List[str]								=				Mapping[str, np.ndarray]
__lowercase		:		Any								=				Mapping[str, Any]  # Is a nested dict.
__lowercase		:		Optional[int]								=				0.01



@dataclasses.dataclass(frozen=_UpperCAmelCase       )
class   _A						:




    """simple docstring"""




    UpperCamelCase_						:       np.ndarray  # [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_						:       np.ndarray  # [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_						:       np.ndarray  # [num_res, num_atom_type]

    # Residue index as used in PDB. It is not necessarily continuous or 0-indexed.
    UpperCamelCase_						:       np.ndarray  # [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_						:       np.ndarray  # [num_res, num_atom_type]

    # Chain indices for multi-chain predictions
    UpperCamelCase_						:       Optional[np.ndarray]      					=       None

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

    # Templates used to generate this protein (prediction-only)
    UpperCamelCase_						:       Optional[Sequence[str]]      					=       None

    # Chain corresponding to each parent
    UpperCamelCase_						:       Optional[Sequence[int]]      					=       None






def  SCREAMING_SNAKE_CASE							(  snake_case):
     __snake_case				=				R"(\[[A-Z]+\]\n)"
     __snake_case				=				[tag.strip() for tag in re.split(_UpperCamelCase,   _UpperCamelCase) if len(_UpperCamelCase) > 0]
     __snake_case				=				zip(tags[0::2],   [l.split('''\n''') for l in tags[1::2]])

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

     assert aatype is not None

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





def  SCREAMING_SNAKE_CASE							(  snake_case,   snake_case = 0):
     __snake_case				=				[]

     __snake_case				=				prot.remark
     if remark is not None:
          pdb_headers.append(f"REMARK {remark}")

     __snake_case				=				prot.parents
     __snake_case				=				prot.parents_chain_index
     if parents is not None and parents_chain_index is not None:
          __snake_case				=				[p for i, p in zip(_UpperCamelCase,   _UpperCamelCase) if i == chain_id]

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

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

     return pdb_headers





def  SCREAMING_SNAKE_CASE							(  snake_case,   snake_case):
     __snake_case				=				[]
     __snake_case				=				pdb_str.split('''\n''')

     __snake_case				=				prot.remark
     if remark is not None:
          out_pdb_lines.append(f"REMARK {remark}")

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

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

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

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

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

               out_pdb_lines.append(make_parent_line(_UpperCamelCase))

     return "\n".join(_UpperCamelCase)





def  SCREAMING_SNAKE_CASE							(  snake_case):
     __snake_case				=				residue_constants.restypes + ["X"]

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

     __snake_case				=				residue_constants.atom_types

     __snake_case				=				[]

     __snake_case				=				prot.atom_mask
     __snake_case				=				prot.aatype
     __snake_case				=				prot.atom_positions
     __snake_case				=				prot.residue_index.astype(np.intaa)
     __snake_case				=				prot.b_factors
     __snake_case				=				prot.chain_index

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

     __snake_case				=				get_pdb_headers(_UpperCamelCase)
     if len(_UpperCamelCase) > 0:
          pdb_lines.extend(_UpperCamelCase)

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

               __snake_case				=				"ATOM"
               __snake_case				=				atom_name if len(_UpperCamelCase) == 4 else f" {atom_name}"
               __snake_case				=				""
               __snake_case				=				""
               __snake_case				=				1.00
               __snake_case				=				atom_name[0]  # Protein supports only C, N, O, S, this works.
               __snake_case				=				""

               __snake_case				=				"A"
               if chain_index is not None:
                    __snake_case				=				chain_tags[chain_index[i]]

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

          __snake_case				=				i == n - 1
          if chain_index is not None:
               if i != n - 1 and chain_index[i + 1] != prev_chain_index:
                    __snake_case				=				True
                    __snake_case				=				chain_index[i + 1]

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

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





def  SCREAMING_SNAKE_CASE							(  snake_case):
     return residue_constants.STANDARD_ATOM_MASK[prot.aatype]





def  SCREAMING_SNAKE_CASE							(  snake_case,   snake_case,   snake_case = None,   snake_case = None,   snake_case = None,   snake_case = None,   snake_case = None,   ):
     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=_UpperCamelCase,   remark=_UpperCamelCase,   parents=_UpperCamelCase,   parents_chain_index=_UpperCamelCase,   )







'''simple docstring'''
from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import DeiTConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
 import tensorflow as tf

 from transformers import (
     TFDeiTForImageClassification,
     TFDeiTForImageClassificationWithTeacher,
     TFDeiTForMaskedImageModeling,
     TFDeiTModel,
 )
 from transformers.models.deit.modeling_tf_deit import TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 from PIL import Image

 from transformers import DeiTImageProcessor


class 							_UpperCAmelCase    :




    def __init__(      self	:							int	,  a	:							Dict	,  a	:							Optional[Any]=1_3	,  a	:							str=3_0	,  a	:							Dict=2	,  a	:							List[Any]=3	,  a	:							Optional[int]=True	,  a	:							Tuple=True	,  a	:							List[Any]=3_2	,  a	:							int=2	,  a	:							List[str]=4	,  a	:							Dict=3_7	,  a	:							Optional[Any]="gelu"	,  a	:							List[str]=0.1	,  a	:							Dict=0.1	,  a	:							List[Any]=1_0	,  a	:							Union[str, Any]=0.02	,  a	:							Union[str, Any]=3	,  a	:							int=None	,  a	:							Any=2	,  ):






       '''simple docstring'''






       lowercase_						:     Any							     =  parent
       lowercase_						:     Union[str, Any]							     =  batch_size
       lowercase_						:     Any							     =  image_size
       lowercase_						:     str							     =  patch_size
       lowercase_						:     int							     =  num_channels
       lowercase_						:     str							     =  is_training
       lowercase_						:     str							     =  use_labels
       lowercase_						:     List[Any]							     =  hidden_size
       lowercase_						:     List[str]							     =  num_hidden_layers
       lowercase_						:     Dict							     =  num_attention_heads
       lowercase_						:     Optional[int]							     =  intermediate_size
       lowercase_						:     str							     =  hidden_act
       lowercase_						:     Union[str, Any]							     =  hidden_dropout_prob
       lowercase_						:     List[str]							     =  attention_probs_dropout_prob
       lowercase_						:     List[str]							     =  type_sequence_label_size
       lowercase_						:     List[Any]							     =  initializer_range
       lowercase_						:     str							     =  scope
       lowercase_						:     Tuple							     =  encoder_stride

       # in DeiT, the seq length equals the number of patches + 2 (we add 2 for the [CLS] and distilation tokens)
       lowercase_						:     Any							     =  (image_size // patch_size) ** 2
       lowercase_						:     str							     =  num_patches + 2




    def 					lowerCAmelCase__					(      self	:							Dict      ):






       '''simple docstring'''






       lowercase_						:     Any							     =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

       lowercase_						:     List[Any]							     =  None
       if self.use_labels:
          lowercase_						:     int							     =  ids_tensor([self.batch_size]	,  self.type_sequence_label_size      )

       lowercase_						:     Optional[Any]							     =  self.get_config()

       return config, pixel_values, labels




    def 					lowerCAmelCase__					(      self	:							Dict      ):






       '''simple docstring'''






       return DeiTConfig(
           image_size=self.image_size	,  patch_size=self.patch_size	,  num_channels=self.num_channels	,  hidden_size=self.hidden_size	,  num_hidden_layers=self.num_hidden_layers	,  num_attention_heads=self.num_attention_heads	,  intermediate_size=self.intermediate_size	,  hidden_act=self.hidden_act	,  hidden_dropout_prob=self.hidden_dropout_prob	,  attention_probs_dropout_prob=self.attention_probs_dropout_prob	,  is_decoder=a	,  initializer_range=self.initializer_range	,  encoder_stride=self.encoder_stride	,  )




    def 					lowerCAmelCase__					(      self	:							Any	,  a	:							List[str]	,  a	:							str	,  a	:							Tuple      ):






       '''simple docstring'''






       lowercase_						:     List[str]							     =  TFDeiTModel(config=a      )
       lowercase_						:     int							     =  model(a      )
       self.parent.assertEqual(result.last_hidden_state.shape	,  (self.batch_size, self.seq_length, self.hidden_size)      )




    def 					lowerCAmelCase__					(      self	:							Dict	,  a	:							Optional[int]	,  a	:							List[Any]	,  a	:							Union[str, Any]      ):






       '''simple docstring'''






       lowercase_						:     List[str]							     =  TFDeiTForMaskedImageModeling(config=a      )
       lowercase_						:     Union[str, Any]							     =  model(a      )
       self.parent.assertEqual(
           result.reconstruction.shape	,  (self.batch_size, self.num_channels, self.image_size, self.image_size)      )

       # test greyscale images
       lowercase_						:     Dict							     =  1
       lowercase_						:     Tuple							     =  TFDeiTForMaskedImageModeling(a      )

       lowercase_						:     Tuple							     =  floats_tensor([self.batch_size, 1, self.image_size, self.image_size]      )
       lowercase_						:     Dict							     =  model(a      )
       self.parent.assertEqual(result.reconstruction.shape	,  (self.batch_size, 1, self.image_size, self.image_size)      )




    def 					lowerCAmelCase__					(      self	:							int	,  a	:							List[str]	,  a	:							List[str]	,  a	:							Optional[int]      ):






       '''simple docstring'''






       lowercase_						:     str							     =  self.type_sequence_label_size
       lowercase_						:     Union[str, Any]							     =  TFDeiTForImageClassification(a      )
       lowercase_						:     int							     =  model(a	,  labels=a      )
       self.parent.assertEqual(result.logits.shape	,  (self.batch_size, self.type_sequence_label_size)      )

       # test greyscale images
       lowercase_						:     Dict							     =  1
       lowercase_						:     str							     =  TFDeiTForImageClassification(a      )

       lowercase_						:     Tuple							     =  floats_tensor([self.batch_size, 1, self.image_size, self.image_size]      )
       lowercase_						:     Any							     =  model(a	,  labels=a      )
       self.parent.assertEqual(result.logits.shape	,  (self.batch_size, self.type_sequence_label_size)      )





    def 					lowerCAmelCase__					(      self	:							Tuple      ):






       '''simple docstring'''






       lowercase_						:     Dict							     =  self.prepare_config_and_inputs()
       lowercase_     ,		lowercase_     ,		lowercase_						:     Optional[int]							     =  config_and_inputs
       lowercase_						:     Optional[Any]							     =  {"pixel_values": pixel_values}
       return config, inputs_dict


@require_tf
class 							_UpperCAmelCase    (		snake_case					,       snake_case					,       unittest.TestCase      ):
    __lowerCamelCase: Tuple									=     (
        (
            TFDeiTModel,
            TFDeiTForImageClassification,
            TFDeiTForImageClassificationWithTeacher,
            TFDeiTForMaskedImageModeling,
        )
        if is_tf_available()
        else ()
    )
    __lowerCamelCase: Tuple									=     (
        {
            'feature-extraction': TFDeiTModel,
            'image-classification': (TFDeiTForImageClassification, TFDeiTForImageClassificationWithTeacher),
        }
        if is_tf_available()
        else {}
    )

    __lowerCamelCase: Union[str, Any]									=     False
    __lowerCamelCase: Any									=     False
    __lowerCamelCase: List[str]									=     False
    __lowerCamelCase: Optional[Any]									=     False




    def 					lowerCAmelCase__					(      self	:							int      ):






       '''simple docstring'''






       lowercase_						:     int							     =  TFDeiTModelTester(self      )
       lowercase_						:     Any							     =  ConfigTester(self	,  config_class=a	,  has_text_modality=a	,  hidden_size=3_7      )




    def 					lowerCAmelCase__					(      self	:							int      ):






       '''simple docstring'''






       self.config_tester.run_common_tests()




    @unittest.skip(reason="DeiT does not use inputs_embeds"      )
    def 					lowerCAmelCase__					(      self	:							Optional[int]      ):






       '''simple docstring'''






       pass




    def 					lowerCAmelCase__					(      self	:							int      ):






       '''simple docstring'''






       lowercase_     ,		lowercase_						:     Tuple							     =  self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
          lowercase_						:     Dict							     =  model_class(a      )
          self.assertIsInstance(model.get_input_embeddings()	,  (tf.keras.layers.Layer)      )
          lowercase_						:     Optional[int]							     =  model.get_output_embeddings()
          self.assertTrue(x is None or isinstance(a	,  tf.keras.layers.Dense      )      )




    def 					lowerCAmelCase__					(      self	:							str      ):






       '''simple docstring'''






       lowercase_     ,		lowercase_						:     Union[str, Any]							     =  self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
          lowercase_						:     Any							     =  model_class(a      )
          lowercase_						:     str							     =  inspect.signature(model.call      )
          # signature.parameters is an OrderedDict => so arg_names order is deterministic
          lowercase_						:     int							     =  [*signature.parameters.keys()]

          lowercase_						:     Dict							     =  ["pixel_values"]
          self.assertListEqual(arg_names[:1]	,  a      )




    def 					lowerCAmelCase__					(      self	:							Optional[Any]      ):






       '''simple docstring'''






       lowercase_						:     int							     =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*a      )




    def 					lowerCAmelCase__					(      self	:							str      ):






       '''simple docstring'''






       lowercase_						:     int							     =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_image_modeling(*a      )




    def 					lowerCAmelCase__					(      self	:							List[Any]      ):






       '''simple docstring'''






       lowercase_						:     int							     =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*a      )




    def 					lowerCAmelCase__					(      self	:							Any	,  a	:							int	,  a	:							Union[str, Any]	,  a	:							Any=False      ):






       '''simple docstring'''






       lowercase_						:     Union[str, Any]							     =  super()._prepare_for_class(a	,  a	,  return_labels=a      )

       if return_labels:
          if "labels" in inputs_dict and "labels" not in inspect.signature(model_class.call      ).parameters:
             del inputs_dict["labels"]

       return inputs_dict





    @slow
    def 					lowerCAmelCase__					(      self	:							Optional[Any]      ):






       '''simple docstring'''






       for model_name in TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          lowercase_						:     List[Any]							     =  TFDeiTModel.from_pretrained(a      )
          self.assertIsNotNone(a      )




def 		__SCREAMING_SNAKE_CASE       (	):


   """simple docstring"""




   lowercase_						:     str							     =  Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"				)
   return image





@require_tf
@require_vision
class 							_UpperCAmelCase    (		unittest.TestCase      ):




    @cached_property
    def 					lowerCAmelCase__					(      self	:							List[Any]      ):






       '''simple docstring'''






       return (
           DeiTImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224"      )
           if is_vision_available()
           else None
       )





    @slow
    def 					lowerCAmelCase__					(      self	:							List[Any]      ):






       '''simple docstring'''






       lowercase_						:     Optional[Any]							     =  TFDeiTForImageClassificationWithTeacher.from_pretrained("facebook/deit-base-distilled-patch16-224"      )

       lowercase_						:     Union[str, Any]							     =  self.default_image_processor
       lowercase_						:     Tuple							     =  prepare_img()
       lowercase_						:     Optional[Any]							     =  image_processor(images=a	,  return_tensors="tf"      )

       # forward pass
       lowercase_						:     int							     =  model(**a      )

       # verify the logits
       lowercase_						:     Union[str, Any]							     =  tf.TensorShape((1, 1_0_0_0)      )
       self.assertEqual(outputs.logits.shape	,  a      )

       lowercase_						:     Optional[Any]							     =  tf.constant([-1.0266, 0.1912, -1.2861]      )

       self.assertTrue(np.allclose(outputs.logits[0, :3]	,  a	,  atol=1e-4      )      )




