
# 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 				UpperCAmelCase (    __SCREAMING_SNAKE_CASE    ):




	'''simple docstring'''





	snake_case_          =	(
	    "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_          =	"CIDAS/clipseg-rd64-refined"
	snake_case_          =	"image_segmenter"
	snake_case_          =	CLIPSegForImageSegmentation

	snake_case_          =	["image", "text"]
	snake_case_          =	["image"]






	def __init__(			self   :					List[Any]				,*A   :					List[Any]				,**A   :					Dict					):
					requires_backends(self				,["vision"]					)
					super().__init__(*A				,**A					)






	def 							UpperCamelCase_    (			self   :					int				,A   :					"Image"				,A   :					str					):
					return self.pre_processor(text=[label]				,images=[image]				,padding=A				,return_tensors="pt"					)






	def 							UpperCamelCase_    (			self   :					str				,A   :					List[Any]					):
					with torch.no_grad():
									__A       =					self.model(**A					).logits
					return logits







	def 							UpperCamelCase_    (			self   :					List[str]				,A   :					str					):
					__A       =					outputs.cpu().detach().numpy()
					__A       =					0
					__A       =					1
					return Image.fromarray((array * 2_55).astype(np.uinta					)					)


"""simple docstring"""
from __future__ import annotations

def  lowercase     (_lowerCAmelCase						):
						__lowerCAmelCase     =  2
						__lowerCAmelCase     =  []
						while i * i <= n:
												if n % i:
																		i += 1
												else:
																		n //= i
																		factors.append(_lowerCAmelCase						)
						if n > 1:
												factors.append(_lowerCAmelCase						)
						return factors


if __name__ == "__main__":
			import doctest

			doctest.testmod()
