
"""simple docstring"""





import unittest

from transformers import (
    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    TextaTextGenerationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, require_tf, require_torch
from transformers.utils import is_torch_available

from .test_pipelines_common import ANY


if is_torch_available():
				import torch






@is_pipeline_test
class    _UpperCAmelCase(   unittest.TestCase     ):
		lowercase__      =				MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
		lowercase__      =				TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING



		def 						UpperCAmelCase							( self    ,		__a    ,		__a    ,		__a)	->	Dict:






							'''simple docstring'''
							_UpperCamelCase										=  TextaTextGenerationPipeline(model=__a    ,		tokenizer=__a)
							return generator, ["Something to write", "Something else"]



		def 						UpperCAmelCase							( self    ,		__a    ,		__a)	->	Optional[Any]:






							'''simple docstring'''
							_UpperCamelCase										=  generator('''Something there''')
							self.assertEqual(__a    ,		[{'''generated_text''': ANY(__a)}])
							# These are encoder decoder, they don't just append to incoming string
							self.assertFalse(outputs[0]['''generated_text'''].startswith('''Something there'''))

							_UpperCamelCase										=  generator(['''This is great !''', '''Something else''']    ,		num_return_sequences=2    ,		do_sample=__a)
							self.assertEqual(
							    __a    ,		[
							        [{'''generated_text''': ANY(__a)}, {'''generated_text''': ANY(__a)}],
							        [{'''generated_text''': ANY(__a)}, {'''generated_text''': ANY(__a)}],
							    ]    ,		)

							_UpperCamelCase										=  generator(
							    ['''This is great !''', '''Something else''']    ,		num_return_sequences=2    ,		batch_size=2    ,		do_sample=__a)
							self.assertEqual(
							    __a    ,		[
							        [{'''generated_text''': ANY(__a)}, {'''generated_text''': ANY(__a)}],
							        [{'''generated_text''': ANY(__a)}, {'''generated_text''': ANY(__a)}],
							    ]    ,		)

							with self.assertRaises(__a):
												generator(4)



		@require_torch
		def 						UpperCAmelCase							( self)	->	Union[str, Any]:






							'''simple docstring'''
							_UpperCamelCase										=  pipeline('''text2text-generation'''    ,		model='''patrickvonplaten/t5-tiny-random'''    ,		framework='''pt''')
							# do_sample=False necessary for reproducibility
							_UpperCamelCase										=  generator('''Something there'''    ,		do_sample=__a)
							self.assertEqual(__a    ,		[{'''generated_text''': ''''''}])

							_UpperCamelCase										=  3
							_UpperCamelCase										=  generator(
							    '''Something there'''    ,		num_return_sequences=__a    ,		num_beams=__a    ,		)
							_UpperCamelCase										=  [
							    {'''generated_text''': '''Beide Beide Beide Beide Beide Beide Beide Beide Beide'''},
							    {'''generated_text''': '''Beide Beide Beide Beide Beide Beide Beide Beide'''},
							    {'''generated_text''': ''''''},
							]
							self.assertEqual(__a    ,		__a)

							_UpperCamelCase										=  generator('''This is a test'''    ,		do_sample=__a    ,		num_return_sequences=2    ,		return_tensors=__a)
							self.assertEqual(
							    __a    ,		[
							        {'''generated_token_ids''': ANY(torch.Tensor)},
							        {'''generated_token_ids''': ANY(torch.Tensor)},
							    ]    ,		)
							_UpperCamelCase										=  generator.model.config.eos_token_id
							_UpperCamelCase										=  '''<pad>'''
							_UpperCamelCase										=  generator(
							    ['''This is a test''', '''This is a second test''']    ,		do_sample=__a    ,		num_return_sequences=2    ,		batch_size=2    ,		return_tensors=__a    ,		)
							self.assertEqual(
							    __a    ,		[
							        [
							            {'''generated_token_ids''': ANY(torch.Tensor)},
							            {'''generated_token_ids''': ANY(torch.Tensor)},
							        ],
							        [
							            {'''generated_token_ids''': ANY(torch.Tensor)},
							            {'''generated_token_ids''': ANY(torch.Tensor)},
							        ],
							    ]    ,		)




		@require_tf
		def 						UpperCAmelCase							( self)	->	int:






							'''simple docstring'''
							_UpperCamelCase										=  pipeline('''text2text-generation'''    ,		model='''patrickvonplaten/t5-tiny-random'''    ,		framework='''tf''')
							# do_sample=False necessary for reproducibility
							_UpperCamelCase										=  generator('''Something there'''    ,		do_sample=__a)
							self.assertEqual(__a    ,		[{'''generated_text''': ''''''}])








"""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    _UpperCAmelCase(   lowerCamelCase     ):
		lowercase__      =				(
		    '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.'
		)
		lowercase__      =				'CIDAS/clipseg-rd64-refined'
		lowercase__      =				'image_segmenter'
		lowercase__      =				CLIPSegForImageSegmentation

		lowercase__      =				['image', 'text']
		lowercase__      =				['image']



		def __init__( self    ,		*__a    ,		**__a)	->	Any:






							'''simple docstring'''
							requires_backends(self    ,		['''vision'''])
							super().__init__(*__a    ,		**__a)



		def 						UpperCAmelCase							( self    ,		__a    ,		__a)	->	Dict:






							'''simple docstring'''
							return self.pre_processor(text=[label]    ,		images=[image]    ,		padding=__a    ,		return_tensors='''pt''')



		def 						UpperCAmelCase							( self    ,		__a)	->	Tuple:






							'''simple docstring'''
							with torch.no_grad():
												_UpperCamelCase										=  self.model(**__a).logits
							return logits




		def 						UpperCAmelCase							( self    ,		__a)	->	Any:






							'''simple docstring'''
							_UpperCamelCase										=  outputs.cpu().detach().numpy()
							_UpperCamelCase										=  0
							_UpperCamelCase										=  1
							return Image.fromarray((array * 2_55).astype(np.uinta))






