






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


_A     :      Union[str, Any]   					=Mapping[str, np.ndarray]
_A     :      Tuple   					=Mapping[str, Any]  # Is a nested dict.
_A     :      Union[str, Any]   					=0.01

@dataclasses.dataclass(frozen=_lowercase		)
class _lowercase     :
							a    				=	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    				=	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    				=	42  # [num_res, num_atom_type]

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

							# Chain indices for multi-chain predictions
							a    				=	None

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

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

							# Chain corresponding to each parent
							a    				=	None





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase				)				->	Protein:
							lowerCamelCase__ :     Optional[Any]	  =	r"""(\[[A-Z]+\]\n)"""
							lowerCamelCase__ :     List[str]	  =	[tag.strip() for tag in re.split(UpperCamelCase    ,      UpperCamelCase				) if len(UpperCamelCase				) > 0]
							lowerCamelCase__ :     Iterator[Tuple[str, List[str]]]	  =	zip(tags[0::2]    ,      [l.split("""\n"""				) for l in tags[1::2]]				)

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

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

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

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

							pdb_headers.append(f'''PARENT {' '.join(UpperCamelCase				)}'''				)

							return pdb_headers





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase    ,      UpperCamelCase				)				->	str:
							lowerCamelCase__ :     List[str]	  =	[]
							lowerCamelCase__ :     Dict	  =	pdb_str.split("""\n"""				)

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

							lowerCamelCase__ :     List[List[str]]
							if prot.parents is not None and len(prot.parents				) > 0:
														lowerCamelCase__ :     List[Any]	  =	[]
														if prot.parents_chain_index is not None:
																					lowerCamelCase__ :     Dict[str, List[str]]	  =	{}
																					for p, i in zip(prot.parents    ,      prot.parents_chain_index				):
																												parent_dict.setdefault(str(UpperCamelCase				)    ,      []				)
																												parent_dict[str(UpperCamelCase				)].append(UpperCamelCase				)

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

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

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

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

																					out_pdb_lines.append(make_parent_line(UpperCamelCase				)				)

							return "\n".join(UpperCamelCase				)





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase				)				->	str:
							lowerCamelCase__ :     Union[str, Any]	  =	residue_constants.restypes + ["""X"""]

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

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

							lowerCamelCase__ :     List[str]	  =	[]

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

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

							lowerCamelCase__ :     Dict	  =	get_pdb_headers(UpperCamelCase				)
							if len(UpperCamelCase				) > 0:
														pdb_lines.extend(UpperCamelCase				)

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

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

																					lowerCamelCase__ :     Dict	  =	"""A"""
																					if chain_index is not None:
																												lowerCamelCase__ :     Optional[int]	  =	chain_tags[chain_index[i]]

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

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

														if should_terminate:
																					# Close the chain.
																					lowerCamelCase__ :     Dict	  =	"""TER"""
																					lowerCamelCase__ :     List[Any]	  =	(
																					    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_	(UpperCamelCase				)				->	np.ndarray:
							return residue_constants.STANDARD_ATOM_MASK[prot.aatype]





def 			SCREAMING_SNAKE_CASE_	(UpperCamelCase    ,      UpperCamelCase    ,      UpperCamelCase = None    ,      UpperCamelCase = None    ,      UpperCamelCase = None    ,      UpperCamelCase = None    ,      UpperCamelCase = 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=UpperCamelCase    ,      remark=UpperCamelCase    ,      parents=UpperCamelCase    ,      parents_chain_index=UpperCamelCase    ,      )









'''simple docstring'''







from collections import UserDict
from typing import Union

import numpy as np
import requests

from ..utils import (
    add_end_docstrings,
    logging,
)
from .audio_classification import ffmpeg_read
from .base import PIPELINE_INIT_ARGS, Pipeline


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

@add_end_docstrings(_lowercase		)
class _lowercase     (    _lowercase		):




							def __init__(							self:    Union[str, Any]      ,							**UpperCamelCase__:    str					):
														super().__init__(**UpperCamelCase__					)

														if self.framework != "pt":
																					raise ValueError(F'''The {self.__class__} is only available in PyTorch.'''					)
														# No specific FOR_XXX available yet




							def __call__(							self:    Optional[Any]      ,							UpperCamelCase__:    Union[np.ndarray, bytes, str]      ,							**UpperCamelCase__:    int					):
														return super().__call__(UpperCamelCase__      ,							**UpperCamelCase__					)




							def 		lowerCamelCase_    (							self:    Optional[Any]      ,							**UpperCamelCase__:    int					):
														lowerCamelCase__ :     Optional[Any]	  =	{}
														if "candidate_labels" in kwargs:
																					lowerCamelCase__ :     str	  =	kwargs["""candidate_labels"""]
														if "hypothesis_template" in kwargs:
																					lowerCamelCase__ :     int	  =	kwargs["""hypothesis_template"""]

														return preprocess_params, {}, {}




							def 		lowerCamelCase_    (							self:    Optional[Any]      ,							UpperCamelCase__:    int      ,							UpperCamelCase__:    List[str]=None      ,							UpperCamelCase__:    Dict="This is a sound of {}."					):
														if isinstance(UpperCamelCase__      ,							UpperCamelCase__					):
																					if audio.startswith("""http://"""					) or audio.startswith("""https://"""					):
																												# We need to actually check for a real protocol, otherwise it's impossible to use a local file
																												# like http_huggingface_co.png
																												lowerCamelCase__ :     int	  =	requests.get(UpperCamelCase__					).content
																					else:
																												with open(UpperCamelCase__      ,							"""rb"""					) as f:
																																			lowerCamelCase__ :     Dict	  =	f.read()

														if isinstance(UpperCamelCase__      ,							UpperCamelCase__					):
																					lowerCamelCase__ :     str	  =	ffmpeg_read(UpperCamelCase__      ,							self.feature_extractor.sampling_rate					)

														if not isinstance(UpperCamelCase__      ,							np.ndarray					):
																					raise ValueError("""We expect a numpy ndarray as input"""					)
														if len(audio.shape					) != 1:
																					raise ValueError("""We expect a single channel audio input for ZeroShotAudioClassificationPipeline"""					)

														lowerCamelCase__ :     Optional[Any]	  =	self.feature_extractor(
														    [audio]      ,							sampling_rate=self.feature_extractor.sampling_rate      ,							return_tensors="""pt"""					)
														lowerCamelCase__ :     Any	  =	candidate_labels
														lowerCamelCase__ :     Any	  =	[hypothesis_template.format(UpperCamelCase__					) for x in candidate_labels]
														lowerCamelCase__ :     int	  =	self.tokenizer(UpperCamelCase__      ,							return_tensors=self.framework      ,							padding=UpperCamelCase__					)
														lowerCamelCase__ :     Tuple	  =	[text_inputs]
														return inputs




							def 		lowerCamelCase_    (							self:    Tuple      ,							UpperCamelCase__:    Union[str, Any]					):
														lowerCamelCase__ :     Any	  =	model_inputs.pop("""candidate_labels"""					)
														lowerCamelCase__ :     Union[str, Any]	  =	model_inputs.pop("""text_inputs"""					)
														if isinstance(text_inputs[0]      ,							UpperCamelCase__					):
																					lowerCamelCase__ :     Optional[int]	  =	text_inputs[0]
														else:
																					# Batching case.
																					lowerCamelCase__ :     Tuple	  =	text_inputs[0][0]

														lowerCamelCase__ :     Tuple	  =	self.model(**UpperCamelCase__      ,							**UpperCamelCase__					)

														lowerCamelCase__ :     str	  =	{
														    """candidate_labels""": candidate_labels,
														    """logits""": outputs.logits_per_audio,
														}
														return model_outputs




							def 		lowerCamelCase_    (							self:    List[str]      ,							UpperCamelCase__:    Union[str, Any]					):
														lowerCamelCase__ :     List[str]	  =	model_outputs.pop("""candidate_labels"""					)
														lowerCamelCase__ :     int	  =	model_outputs["""logits"""][0]

														if self.framework == "pt":
																					lowerCamelCase__ :     Optional[int]	  =	logits.softmax(dim=0					)
																					lowerCamelCase__ :     Any	  =	probs.tolist()
														else:
																					raise ValueError("""`tf` framework not supported."""					)

														lowerCamelCase__ :     Tuple	  =	[
														    {"""score""": score, """label""": candidate_label}
														    for score, candidate_label in sorted(zip(UpperCamelCase__      ,							UpperCamelCase__					)      ,							key=lambda UpperCamelCase__					: -x[0]					)
														]
														return result

