
# 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					)					)


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


A		: Dict								=     {
    '''configuration_x_clip''': [
        '''XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''XCLIPConfig''',
        '''XCLIPTextConfig''',
        '''XCLIPVisionConfig''',
    ],
    '''processing_x_clip''': ['''XCLIPProcessor'''],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		A		: Optional[Any]								=     [
		    '''XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''XCLIPModel''',
		    '''XCLIPPreTrainedModel''',
		    '''XCLIPTextModel''',
		    '''XCLIPVisionModel''',
		]

if TYPE_CHECKING:
		from .configuration_x_clip import (
		    XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
		    XCLIPConfig,
		    XCLIPTextConfig,
		    XCLIPVisionConfig,
		)
		from .processing_x_clip import XCLIPProcessor

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_x_clip import (
				    XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
				    XCLIPModel,
				    XCLIPPreTrainedModel,
				    XCLIPTextModel,
				    XCLIPVisionModel,
				)

else:
		import sys

		A		: List[str]								=     _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)