





# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import numpy as np
import torch

from ..models.clipseg import CLIPSegForImageSegmentation
from ..utils import is_vision_available, requires_backends
from .base import PipelineTool


if is_vision_available():
					from PIL import Image

class     __SCREAMING_SNAKE_CASE   (       _a    ):
							snake_case       : Optional[Any]         =    (
							    """This is a tool that creates a segmentation mask of an image according to a label. It cannot create an image."""
							    """It takes two arguments named `image` which should be the original image, and `label` which should be a text """
							    """describing the elements what should be identified in the segmentation mask. The tool returns the mask."""
							)
							snake_case       : List[str]         =    """CIDAS/clipseg-rd64-refined"""
							snake_case       : str         =    """image_segmenter"""
							snake_case       : int         =    CLIPSegForImageSegmentation

							snake_case       : Optional[int]         =    ["""image""", """text"""]
							snake_case       : str         =    ["""image"""]






							def __init__(  self					,	*__lowerCAmelCase					,	**__lowerCAmelCase					):
														requires_backends(self					,	["""vision"""]					)
														super().__init__(*__lowerCAmelCase					,	**__lowerCAmelCase					)






							def 			_lowerCamelCase						(  self					,	__lowerCAmelCase					,	__lowerCAmelCase					):
														return self.pre_processor(text=[label]					,	images=[image]					,	padding=__lowerCAmelCase					,	return_tensors="""pt"""					)






							def 			_lowerCamelCase						(  self					,	__lowerCAmelCase					):
														with torch.no_grad():
																					UpperCamelCase__			       =     self.model(**__lowerCAmelCase					).logits
														return logits







							def 			_lowerCamelCase						(  self					,	__lowerCAmelCase					):
														UpperCamelCase__			       =     outputs.cpu().detach().numpy()
														UpperCamelCase__			       =     0
														UpperCamelCase__			       =     1
														return Image.fromarray((array * 255).astype(np.uinta					)					)











from typing import Dict

import numpy as np
import torch

from . import residue_constants as rc
from .tensor_utils import tensor_tree_map, tree_map





def       _UpperCamelCase       (a__				:Dict[str, torch.Tensor]    ):






							"""simple docstring"""





							UpperCamelCase__			       =     []
							UpperCamelCase__			       =     []
							UpperCamelCase__			       =     []

							for rt in rc.restypes:
														UpperCamelCase__			       =     rc.restype_name_to_atomaa_names[rc.restype_atoa[rt]]
														restype_atomaa_to_atomaa_list.append([(rc.atom_order[name] if name else 0) for name in atom_names]    )
														UpperCamelCase__			       =     {name: i for i, name in enumerate(a__    )}
														restype_atomaa_to_atomaa_list.append(
														    [(atom_name_to_idxaa[name] if name in atom_name_to_idxaa else 0) for name in rc.atom_types]    )

														restype_atomaa_mask_list.append([(1.0 if name else 0.0) for name in atom_names]    )

							# Add dummy mapping for restype 'UNK'
							restype_atomaa_to_atomaa_list.append([0] * 14    )
							restype_atomaa_to_atomaa_list.append([0] * 37    )
							restype_atomaa_mask_list.append([0.0] * 14    )

							UpperCamelCase__			       =     torch.tensor(
							    a__				,     dtype=torch.intaa				,     device=protein["""aatype"""].device				,     )
							UpperCamelCase__			       =     torch.tensor(
							    a__				,     dtype=torch.intaa				,     device=protein["""aatype"""].device				,     )
							UpperCamelCase__			       =     torch.tensor(
							    a__				,     dtype=torch.floataa				,     device=protein["""aatype"""].device				,     )
							UpperCamelCase__			       =     protein["""aatype"""].to(torch.long    )

							# create the mapping for (residx, atom14) --> atom37, i.e. an array
							# with shape (num_res, 14) containing the atom37 indices for this protein
							UpperCamelCase__			       =     restype_atomaa_to_atomaa[protein_aatype]
							UpperCamelCase__			       =     restype_atomaa_mask[protein_aatype]

							UpperCamelCase__			       =     residx_atomaa_mask
							UpperCamelCase__			       =     residx_atomaa_to_atomaa.long()

							# create the gather indices for mapping back
							UpperCamelCase__			       =     restype_atomaa_to_atomaa[protein_aatype]
							UpperCamelCase__			       =     residx_atomaa_to_atomaa.long()

							# create the corresponding mask
							UpperCamelCase__			       =     torch.zeros([21, 37]				,     dtype=torch.floataa				,     device=protein["""aatype"""].device    )
							for restype, restype_letter in enumerate(rc.restypes    ):
														UpperCamelCase__			       =     rc.restype_atoa[restype_letter]
														UpperCamelCase__			       =     rc.residue_atoms[restype_name]
														for atom_name in atom_names:
																					UpperCamelCase__			       =     rc.atom_order[atom_name]
																					UpperCamelCase__			       =     1

							UpperCamelCase__			       =     restype_atomaa_mask[protein_aatype]
							UpperCamelCase__			       =     residx_atomaa_mask

							return protein





def       _UpperCamelCase       (a__				:Dict[str, torch.Tensor]    ):






							"""simple docstring"""





							UpperCamelCase__			       =     tree_map(lambda a__    : torch.tensor(a__				,     device=batch["""aatype"""].device    )				,     a__				,     np.ndarray    )
							UpperCamelCase__			       =     tensor_tree_map(lambda a__    : np.array(a__    )				,     make_atomaa_masks(a__    )    )
							return out




