



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[Any]     						=					Mapping[str, np.ndarray]
lowercase_:  int     						=					Mapping[str, Any]  # Is a nested dict.
lowercase_:  int     						=					0.0_1



@dataclasses.dataclass(frozen=__lowercase						)
class 						lowercase__      :

     """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 	_lowercase	(     UpperCAmelCase_):




 """simple docstring"""




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

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




 """simple docstring"""




 snake_case__				:							List[str]      							= []

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

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

 if parents is None or len(_lowerCamelCase) == 0:
  snake_case__				:							str      							= ["""N/A"""]

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

 return pdb_headers
def 	_lowercase	(     UpperCAmelCase_						,   UpperCAmelCase_):




 """simple docstring"""




 snake_case__				:							List[str]      							= []
 snake_case__				:							int      							= pdb_str.split("""\n""")

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

 snake_case__				:							List[List[str]]
 if prot.parents is not None and len(prot.parents) > 0:
  snake_case__				:							Union[str, Any]      							= []
  if prot.parents_chain_index is not None:
   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)

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

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

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

 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):
    snake_case__				:							int      							= parents_per_chain[chain_counter]
   else:
    snake_case__				:							int      							= ["""N/A"""]

   out_pdb_lines.append(make_parent_line(_lowerCamelCase))

 return "\n".join(_lowerCamelCase)
def 	_lowercase	(     UpperCAmelCase_):




 """simple docstring"""




 snake_case__				:							Optional[int]      							= residue_constants.restypes + ["""X"""]

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

 snake_case__				:							Union[str, Any]      							= residue_constants.atom_types

 snake_case__				:							List[str]      							= []

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

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

 snake_case__				:							Optional[int]      							= get_pdb_headers(_lowerCamelCase)
 if len(_lowerCamelCase) > 0:
  pdb_lines.extend(_lowerCamelCase)

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

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

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

   # PDB is a columnar format, every space matters here!
   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

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

  if should_terminate:
   # Close the chain.
   snake_case__				:							Optional[Any]      							= """TER"""
   snake_case__				:							List[str]      							= (
       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 	_lowercase	(     UpperCAmelCase_):




 """simple docstring"""




 return residue_constants.STANDARD_ATOM_MASK[prot.aatype]
def 	_lowercase	(     UpperCAmelCase_						,   UpperCAmelCase_						,   UpperCAmelCase_ = None						,   UpperCAmelCase_ = None						,   UpperCAmelCase_ = None						,   UpperCAmelCase_ = None						,   UpperCAmelCase_ = 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'''






import argparse
import os
import re

import packaging.version


__UpperCamelCase					    =	"examples/"
__UpperCamelCase					    =	{
    "examples": (re.compile(R"^check_min_version\(\"[^\"]+\"\)\s*$", re.MULTILINE), "check_min_version(\"VERSION\")\n"),
    "init": (re.compile(R"^__version__\s+=\s+\"([^\"]+)\"\s*$", re.MULTILINE), "__version__ = \"VERSION\"\n"),
    "setup": (re.compile(R"^(\s*)version\s*=\s*\"[^\"]+\",", re.MULTILINE), R"\1version=\"VERSION\","),
    "doc": (re.compile(R"^(\s*)release\s*=\s*\"[^\"]+\"$", re.MULTILINE), "release = \"VERSION\"\n"),
}
__UpperCamelCase					    =	{
    "init": "src/transformers/__init__.py",
    "setup": "setup.py",
}
__UpperCamelCase					    =	"README.md"







def 					_a						(       _lowerCamelCase    ,	_lowerCamelCase    ,	_lowerCamelCase ) ->				Tuple:



			"""simple docstring"""


			with open(_lowerCamelCase    ,	"""r"""    ,	encoding="""utf-8"""    ,	newline="""\n""" ) as f:
						__snake_case					:      Union[str, Any]							      =     f.read()
			__snake_case      ,     __snake_case					:      List[Any]							      =     REPLACE_PATTERNS[pattern]
			__snake_case					:      Optional[Any]							      =     replace.replace("""VERSION"""    ,	_lowerCamelCase )
			__snake_case					:      Optional[Any]							      =     re_pattern.sub(_lowerCamelCase    ,	_lowerCamelCase )
			with open(_lowerCamelCase    ,	"""w"""    ,	encoding="""utf-8"""    ,	newline="""\n""" ) as f:
						f.write(_lowerCamelCase )







def 					_a						(       _lowerCamelCase ) ->				Union[str, Any]:



			"""simple docstring"""


			for folder, directories, fnames in os.walk(_lowerCamelCase ):
						# Removing some of the folders with non-actively maintained examples from the walk
						if "research_projects" in directories:
									directories.remove("""research_projects""" )
						if "legacy" in directories:
									directories.remove("""legacy""" )
						for fname in fnames:
									if fname.endswith(""".py""" ):
												update_version_in_file(os.path.join(_lowerCamelCase    ,	_lowerCamelCase )    ,	_lowerCamelCase    ,	pattern="""examples""" )







def 					_a						(       _lowerCamelCase    ,	_lowerCamelCase=False ) ->				str:



			"""simple docstring"""


			for pattern, fname in REPLACE_FILES.items():
						update_version_in_file(_lowerCamelCase    ,	_lowerCamelCase    ,	_lowerCamelCase )
			if not patch:
						update_version_in_examples(_lowerCamelCase )







def 					_a						(       ) ->				Optional[int]:



			"""simple docstring"""


			__snake_case					:      str							      =     """🤗 Transformers currently provides the following architectures"""
			__snake_case					:      List[Any]							      =     """1. Want to contribute a new model?"""
			with open(_lowerCamelCase    ,	"""r"""    ,	encoding="""utf-8"""    ,	newline="""\n""" ) as f:
						__snake_case					:      List[str]							      =     f.readlines()

			# Find the start of the list.
			__snake_case					:      Optional[Any]							      =     0
			while not lines[start_index].startswith(_start_prompt ):
						start_index += 1
			start_index += 1

			__snake_case					:      int							      =     start_index
			# Update the lines in the model list.
			while not lines[index].startswith(_end_prompt ):
						if lines[index].startswith("""1.""" ):
									__snake_case					:      Optional[Any]							      =     lines[index].replace(
									    """https://huggingface.co/docs/transformers/main/model_doc"""    ,	"""https://huggingface.co/docs/transformers/model_doc"""    ,	)
						index += 1

			with open(_lowerCamelCase    ,	"""w"""    ,	encoding="""utf-8"""    ,	newline="""\n""" ) as f:
						f.writelines(_lowerCamelCase )







def 					_a						(       ) ->				Union[str, Any]:



			"""simple docstring"""


			with open(REPLACE_FILES["""init"""]    ,	"""r""" ) as f:
						__snake_case					:      List[Any]							      =     f.read()
			__snake_case					:      str							      =     REPLACE_PATTERNS["""init"""][0].search(_lowerCamelCase ).groups()[0]
			return packaging.version.parse(_lowerCamelCase )







def 					_a						(       _lowerCamelCase=False ) ->				int:



			"""simple docstring"""


			__snake_case					:      List[Any]							      =     get_version()
			if patch and default_version.is_devrelease:
						raise ValueError("""Can't create a patch version from the dev branch, checkout a released version!""" )
			if default_version.is_devrelease:
						__snake_case					:      str							      =     default_version.base_version
			elif patch:
						__snake_case					:      Optional[int]							      =     F'''{default_version.major}.{default_version.minor}.{default_version.micro + 1}'''
			else:
						__snake_case					:      Dict							      =     F'''{default_version.major}.{default_version.minor + 1}.0'''

			# Now let's ask nicely if that's the right one.
			__snake_case					:      Dict							      =     input(F'''Which version are you releasing? [{default_version}]''' )
			if len(_lowerCamelCase ) == 0:
						__snake_case					:      Any							      =     default_version

			print(F'''Updating version to {version}.''' )
			global_version_update(_lowerCamelCase    ,	patch=_lowerCamelCase )
			if not patch:
						print("""Cleaning main README, don't forget to run `make fix-copies`.""" )
						clean_main_ref_in_model_list()







def 					_a						(       ) ->				Tuple:



			"""simple docstring"""


			__snake_case					:      Optional[Any]							      =     get_version()
			__snake_case					:      Tuple							      =     F'''{current_version.major}.{current_version.minor + 1}.0.dev0'''
			__snake_case					:      Union[str, Any]							      =     current_version.base_version

			# Check with the user we got that right.
			__snake_case					:      int							      =     input(F'''Which version are we developing now? [{dev_version}]''' )
			if len(_lowerCamelCase ) == 0:
						__snake_case					:      Optional[int]							      =     dev_version

			print(F'''Updating version to {version}.''' )
			global_version_update(_lowerCamelCase )
			print("""Cleaning main README, don't forget to run `make fix-copies`.""" )
			clean_main_ref_in_model_list()


if __name__ == "__main__":
	__UpperCamelCase					    =	argparse.ArgumentParser()
	parser.add_argument("--post_release", action="store_true", help="Whether this is pre or post release.")
	parser.add_argument("--patch", action="store_true", help="Whether or not this is a patch release.")
	__UpperCamelCase					    =	parser.parse_args()
	if not args.post_release:
		pre_release_work(patch=args.patch)
	elif args.patch:
		print("Nothing to do after a patch :-)")
	else:
		post_release_work()


