


'''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=a__  )
class 		a__    :





							'''simple docstring'''






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

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

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

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

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

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


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

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

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

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

							if parents is None or len(A	) == 0:
														lowerCAmelCase__	       =     ['''N/A''']

							pdb_headers.append(F"""PARENT {" ".join(A	)}"""	)

							return pdb_headers


def  _snake_case       (					A			,   A	)						->   str:
							lowerCAmelCase__	       =     []
							lowerCAmelCase__	       =     pdb_str.split('''\n'''	)

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

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

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

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

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

							lowerCAmelCase__	       =     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	):
																												lowerCAmelCase__	       =     parents_per_chain[chain_counter]
																					else:
																												lowerCAmelCase__	       =     ['''N/A''']

																					out_pdb_lines.append(make_parent_line(A	)	)

							return "\n".join(A	)


def  _snake_case       (					A	)						->   str:
							lowerCAmelCase__	       =     residue_constants.restypes + ['''X''']

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

							lowerCAmelCase__	       =     residue_constants.atom_types

							lowerCAmelCase__	       =     []

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

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

							lowerCAmelCase__	       =     get_pdb_headers(A	)
							if len(A	) > 0:
														pdb_lines.extend(A	)

							lowerCAmelCase__	       =     aatype.shape[0]
							lowerCAmelCase__	       =     1
							lowerCAmelCase__	       =     0
							lowerCAmelCase__	       =     string.ascii_uppercase
							lowerCAmelCase__	       =     None
							# Add all atom sites.
							for i in range(A	):
														lowerCAmelCase__	       =     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

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

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

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

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

														if should_terminate:
																					# Close the chain.
																					lowerCAmelCase__	       =     '''TER'''
																					lowerCAmelCase__	       =     (
																					    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  _snake_case       (					A	)						->   np.ndarray:
							return residue_constants.STANDARD_ATOM_MASK[prot.aatype]






def  _snake_case       (					A			,   A			,   A = None			,   A = None			,   A = None			,   A = None			,   A = None			,   )						->   Protein:
							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'''






import json
import os
import unittest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_ftfy, require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin




@require_tokenizers
class 		a__    (							a__    ,    unittest.TestCase  ):





							'''simple docstring'''






							lowercase__      :       List[Any]     						=				CLIPTokenizer
							lowercase__      :       List[str]     						=				CLIPTokenizerFast
							lowercase__      :       Dict     						=				True
							lowercase__      :       Any     						=				{}
							lowercase__      :       Optional[int]     						=				False







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Any:
														super().setUp()

														# fmt: off
														lowerCAmelCase__	       =     ['''l''', '''o''', '''w''', '''e''', '''r''', '''s''', '''t''', '''i''', '''d''', '''n''', '''lo''', '''l</w>''', '''w</w>''', '''r</w>''', '''t</w>''', '''low</w>''', '''er</w>''', '''lowest</w>''', '''newer</w>''', '''wider''', '''<unk>''', '''<|startoftext|>''', '''<|endoftext|>''']
														# fmt: on
														lowerCAmelCase__	       =     dict(zip(lowerCamelCase_ ,   range(len(lowerCamelCase_       )       )       )       )
														lowerCAmelCase__	       =     ['''#version: 0.2''', '''l o''', '''lo w</w>''', '''e r</w>''']
														lowerCAmelCase__	       =     {'''unk_token''': '''<unk>'''}

														lowerCAmelCase__	       =     os.path.join(self.tmpdirname ,   VOCAB_FILES_NAMES['''vocab_file''']       )
														lowerCAmelCase__	       =     os.path.join(self.tmpdirname ,   VOCAB_FILES_NAMES['''merges_file''']       )
														with open(self.vocab_file ,   '''w''' ,   encoding='''utf-8'''       ) as fp:
																					fp.write(json.dumps(lowerCamelCase_       ) + '''\n'''       )
														with open(self.merges_file ,   '''w''' ,   encoding='''utf-8'''       ) as fp:
																					fp.write('''\n'''.join(lowerCamelCase_       )       )







							def   __SCREAMING_SNAKE_CASE							(		self ,   **lowerCamelCase_       )	->							Any:
														kwargs.update(self.special_tokens_map       )
														return CLIPTokenizer.from_pretrained(self.tmpdirname ,   **lowerCamelCase_       )







							def   __SCREAMING_SNAKE_CASE							(		self ,   **lowerCamelCase_       )	->							int:
														kwargs.update(self.special_tokens_map       )
														return CLIPTokenizerFast.from_pretrained(self.tmpdirname ,   **lowerCamelCase_       )







							def   __SCREAMING_SNAKE_CASE							(		self ,   lowerCamelCase_       )	->							Any:
														lowerCAmelCase__	       =     '''lower newer'''
														lowerCAmelCase__	       =     '''lower newer'''
														return input_text, output_text







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Union[str, Any]:
														lowerCAmelCase__	       =     CLIPTokenizer(self.vocab_file ,   self.merges_file ,   **self.special_tokens_map       )
														lowerCAmelCase__	       =     '''lower newer'''
														lowerCAmelCase__	       =     ['''lo''', '''w''', '''er</w>''', '''n''', '''e''', '''w''', '''er</w>''']
														lowerCAmelCase__	       =     tokenizer.tokenize(lowerCamelCase_       )
														self.assertListEqual(lowerCamelCase_ ,   lowerCamelCase_       )

														lowerCAmelCase__	       =     tokens + [tokenizer.unk_token]
														lowerCAmelCase__	       =     [10, 2, 16, 9, 3, 2, 16, 20]
														self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase_       ) ,   lowerCamelCase_       )







							@require_ftfy
							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Tuple:
														for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																					with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""       ):
																												lowerCAmelCase__	       =     self.tokenizer_class.from_pretrained(lowerCamelCase_ ,   **lowerCamelCase_       )
																												lowerCAmelCase__	       =     self.rust_tokenizer_class.from_pretrained(lowerCamelCase_ ,   **lowerCamelCase_       )

																												lowerCAmelCase__	       =     '''A\n\'ll 11p223RF☆ho!!to?\'d\'d\'\'d of a cat to-$\'\'d.'''
																												lowerCAmelCase__	       =     tokenizer_s.tokenize(lowerCamelCase_       )
																												lowerCAmelCase__	       =     tokenizer_r.tokenize(lowerCamelCase_       )

																												self.assertListEqual(lowerCamelCase_ ,   lowerCamelCase_       )

																												# Test that the tokenization is identical on an example containing a character (Latin Small Letter A
																												# with Tilde) encoded in 2 different ways
																												lowerCAmelCase__	       =     '''xa\u0303y''' + ''' ''' + '''x\xe3y'''
																												lowerCAmelCase__	       =     tokenizer_s.tokenize(lowerCamelCase_       )
																												lowerCAmelCase__	       =     tokenizer_r.tokenize(lowerCamelCase_       )

																												self.assertListEqual(lowerCamelCase_ ,   lowerCamelCase_       )

																												# Test that the tokenization is identical on unicode of space type
																												lowerCAmelCase__	       =     [
																												    '''\u0009''',  # (horizontal tab, '\t')
																												    '''\u000B''',  # (vertical tab)
																												    '''\u000C''',  # (form feed)
																												    '''\u0020''',  # (space, ' ')
																												    '''\u200E''',  # (left-to-right mark):w
																												    '''\u200F''',  # (right-to-left mark)
																												]
																												for unicode_seq in spaces_unicodes:
																																			lowerCAmelCase__	       =     tokenizer_s.tokenize(lowerCamelCase_       )
																																			lowerCAmelCase__	       =     tokenizer_r.tokenize(lowerCamelCase_       )

																																			self.assertListEqual(lowerCamelCase_ ,   lowerCamelCase_       )

																												# Test that the tokenization is identical on unicode of line break type
																												lowerCAmelCase__	       =     [
																												    '''\u000A''',  # (line feed, '\n')
																												    '''\r\n''',  # (carriage return and line feed, '\r\n')
																												    '''\u000D''',  # (carriage return, '\r')
																												    '''\r''',  # (carriage return, '\r')
																												    '''\u000D''',  # (carriage return, '\r')
																												    '''\u2028''',  # (line separator)
																												    '''\u2029''',  # (paragraph separator)
																												    # "\u0085", # (next line)
																												]

																												# The tokenization is not identical for the character "\u0085" (next line). The slow version using ftfy transforms
																												# it into the Horizontal Ellipsis character "…" ("\u2026") while the fast version transforms it into a
																												# space (and thus into an empty list).

																												for unicode_seq in line_break_unicodes:
																																			lowerCAmelCase__	       =     tokenizer_s.tokenize(lowerCamelCase_       )
																																			lowerCAmelCase__	       =     tokenizer_r.tokenize(lowerCamelCase_       )

																																			self.assertListEqual(lowerCamelCase_ ,   lowerCamelCase_       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							str:
														# Test which aims to verify that the offsets are well adapted to the argument `add_prefix_space`
														for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																					with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""       ):
																												lowerCAmelCase__	       =     '''hello'''  # `hello` is a token in the vocabulary of `pretrained_name`
																												lowerCAmelCase__	       =     F"""{text_of_1_token} {text_of_1_token}"""

																												lowerCAmelCase__	       =     self.rust_tokenizer_class.from_pretrained(
																												    lowerCamelCase_ ,   use_fast=lowerCamelCase_ ,   )
																												lowerCAmelCase__	       =     tokenizer_r(lowerCamelCase_ ,   return_offsets_mapping=lowerCamelCase_ ,   add_special_tokens=lowerCamelCase_       )
																												self.assertEqual(encoding.offset_mapping[0] ,   (0, len(lowerCamelCase_       ))       )
																												self.assertEqual(
																												    encoding.offset_mapping[1] ,   (len(lowerCamelCase_       ) + 1, len(lowerCamelCase_       ) + 1 + len(lowerCamelCase_       )) ,   )

																												lowerCAmelCase__	       =     F""" {text}"""

																												lowerCAmelCase__	       =     self.rust_tokenizer_class.from_pretrained(
																												    lowerCamelCase_ ,   use_fast=lowerCamelCase_ ,   )
																												lowerCAmelCase__	       =     tokenizer_r(lowerCamelCase_ ,   return_offsets_mapping=lowerCamelCase_ ,   add_special_tokens=lowerCamelCase_       )
																												self.assertEqual(encoding.offset_mapping[0] ,   (1, 1 + len(lowerCamelCase_       ))       )
																												self.assertEqual(
																												    encoding.offset_mapping[1] ,   (1 + len(lowerCamelCase_       ) + 1, 1 + len(lowerCamelCase_       ) + 1 + len(lowerCamelCase_       )) ,   )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Union[str, Any]:
														# Test related to the breaking change introduced in transformers v4.17.0
														# We need to check that an error in raised when the user try to load a previous version of the tokenizer.
														with self.assertRaises(lowerCamelCase_       ) as context:
																					self.rust_tokenizer_class.from_pretrained('''robot-test/old-clip-tokenizer'''       )

														self.assertTrue(
														    context.exception.args[0].startswith(
														        '''The `backend_tokenizer` provided does not match the expected format.'''       )       )







							@require_ftfy
							def   __SCREAMING_SNAKE_CASE							(		self       )	->							List[Any]:
														super().test_tokenization_python_rust_equals()







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Any:
														# CLIP always lower cases letters
														pass