"""simple docstring"""





# 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  _snake_case     (					a__		):
						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      :			Dict							,					*UpperCAmelCase      :			List[str]							,					**UpperCAmelCase      :			Dict    ):
													requires_backends(self							,					["vision"]    )
													super().__init__(*UpperCAmelCase							,					**UpperCAmelCase    )






						def       lowerCamelCase__     (       self      :			Tuple							,					UpperCAmelCase      :			"Image"							,					UpperCAmelCase      :			str    ):
													return self.pre_processor(text=[label]							,					images=[image]							,					padding=UpperCAmelCase							,					return_tensors="pt"    )






						def       lowerCamelCase__     (       self      :			Any							,					UpperCAmelCase      :			Any    ):
													with torch.no_grad():
																				__lowerCamelCase					:		Tuple		   =     self.model(**UpperCAmelCase    ).logits
													return logits







						def       lowerCamelCase__     (       self      :			Any							,					UpperCAmelCase      :			int    ):
													__lowerCamelCase					:		List[str]		   =     outputs.cpu().detach().numpy()
													__lowerCamelCase					:		str		   =     0
													__lowerCamelCase					:		Union[str, Any]		   =     1
													return Image.fromarray((array * 255).astype(np.uinta    )    )
"""simple docstring"""





# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import doctest
import sys
import warnings
from os.path import abspath, dirname, join

import _pytest

from transformers.testing_utils import HfDoctestModule, HfDocTestParser


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
__A  =				abspath(join(dirname(__file__), '''src'''))
sys.path.insert(1, git_repo_path)

# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action='''ignore''', category=FutureWarning)


def    lowercase_   (   _lowerCamelCase:	List[Any]      ) ->      Union[str, Any]:



							'''simple docstring'''

							config.addinivalue_line(
							    "markers"						,   "is_pt_tf_cross_test: mark test to run only when PT and TF interactions are tested"      )
							config.addinivalue_line(
							    "markers"						,   "is_pt_flax_cross_test: mark test to run only when PT and FLAX interactions are tested"      )
							config.addinivalue_line("markers"						,   "is_pipeline_test: mark test to run only when pipelines are tested"      )
							config.addinivalue_line("markers"						,   "is_staging_test: mark test to run only in the staging environment"      )
							config.addinivalue_line("markers"						,   "accelerate_tests: mark test that require accelerate"      )
							config.addinivalue_line("markers"						,   "tool_tests: mark the tool tests that are run on their specific schedule"      )


def    lowercase_   (   _lowerCamelCase:	Union[str, Any]      ) ->      Any:



							'''simple docstring'''

							from transformers.testing_utils import pytest_addoption_shared

							pytest_addoption_shared(_lowerCamelCase      )


def    lowercase_   (   _lowerCamelCase:	Optional[int]      ) ->      Tuple:



							'''simple docstring'''

							from transformers.testing_utils import pytest_terminal_summary_main

							__lowerCamelCase					:		Any		   =     terminalreporter.config.getoption("--make-reports"      )
							if make_reports:
														pytest_terminal_summary_main(_lowerCamelCase						,   id=_lowerCamelCase      )


def    lowercase_   (   _lowerCamelCase:	Union[str, Any]						,   _lowerCamelCase:	Tuple      ) ->      Dict:



							'''simple docstring'''

							if exitstatus == 5:
														__lowerCamelCase					:		Optional[int]		   =     0


# Doctest custom flag to ignore output.
__A  =				doctest.register_optionflag('''IGNORE_RESULT''')

__A  =				doctest.OutputChecker
class  _snake_case     (					a__		):






						def       lowerCamelCase__     (       self      :			List[str]							,					UpperCAmelCase      :			int							,					UpperCAmelCase      :			Any							,					UpperCAmelCase      :			int    ):
													if IGNORE_RESULT & optionflags:
																				return True
													return OutputChecker.check_output(self							,					UpperCAmelCase							,					UpperCAmelCase							,					UpperCAmelCase    )

__A  =				CustomOutputChecker
__A  =				HfDoctestModule







__A  =				HfDocTestParser