



"""simple docstring"""







import json
import os
import unittest

from transformers import BatchEncoding, LEDTokenizer, LEDTokenizerFast
from transformers.models.led.tokenization_led import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, require_torch
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin







@require_tokenizers
class       UpperCamelCase__   (	lowercase_,					unittest.TestCase  ):




      """simple docstring"""




      _SCREAMING_SNAKE_CASE  				=     LEDTokenizer
      _SCREAMING_SNAKE_CASE  				=     LEDTokenizerFast
      _SCREAMING_SNAKE_CASE  				=     True



      def      SCREAMING_SNAKE_CASE__ (      self				:      str       ):
        super().setUp()
        lowerCAmelCase_   :				Any								= [
            'l',
            'o',
            'w',
            'e',
            'r',
            's',
            't',
            'i',
            'd',
            'n',
            '\u0120',
            '\u0120l',
            '\u0120n',
            '\u0120lo',
            '\u0120low',
            'er',
            '\u0120lowest',
            '\u0120newer',
            '\u0120wider',
            '<unk>',
        ]
        lowerCAmelCase_   :				Dict								= dict(zip(SCREAMING_SNAKE_CASE_    ,			range(len(SCREAMING_SNAKE_CASE_       )       )       )       )
        lowerCAmelCase_   :				Union[str, Any]								= ['#version: 0.2', '\u0120 l', '\u0120l o', '\u0120lo w', 'e r', '']
        lowerCAmelCase_   :				Any								= {'unk_token': '<unk>'}

        lowerCAmelCase_   :				Optional[Any]								= os.path.join(self.tmpdirname    ,			VOCAB_FILES_NAMES['vocab_file']       )
        lowerCAmelCase_   :				Union[str, Any]								= os.path.join(self.tmpdirname    ,			VOCAB_FILES_NAMES['merges_file']       )
        with open(self.vocab_file    ,			'w'    ,			encoding='utf-8'       ) as fp:
          fp.write(json.dumps(SCREAMING_SNAKE_CASE_       ) + '\n'       )
        with open(self.merges_file    ,			'w'    ,			encoding='utf-8'       ) as fp:
          fp.write('\n'.join(SCREAMING_SNAKE_CASE_       )       )



      def      SCREAMING_SNAKE_CASE__ (      self				:      List[Any]    ,			**SCREAMING_SNAKE_CASE_				:      Optional[Any]       ):
        kwargs.update(self.special_tokens_map       )
        return self.tokenizer_class.from_pretrained(self.tmpdirname    ,			**SCREAMING_SNAKE_CASE_       )



      def      SCREAMING_SNAKE_CASE__ (      self				:      List[Any]    ,			**SCREAMING_SNAKE_CASE_				:      List[str]       ):
        kwargs.update(self.special_tokens_map       )
        return self.rust_tokenizer_class.from_pretrained(self.tmpdirname    ,			**SCREAMING_SNAKE_CASE_       )



      def      SCREAMING_SNAKE_CASE__ (      self				:      Optional[int]    ,			SCREAMING_SNAKE_CASE_				:      int       ):
        return "lower newer", "lower newer"



      @cached_property
      def      SCREAMING_SNAKE_CASE__ (      self				:      Optional[int]       ):
        return LEDTokenizer.from_pretrained('allenai/led-base-16384'       )



      @cached_property
      def      SCREAMING_SNAKE_CASE__ (      self				:      List[str]       ):
        return LEDTokenizerFast.from_pretrained('allenai/led-base-16384'       )



      @require_torch
      def      SCREAMING_SNAKE_CASE__ (      self				:      Tuple       ):
        lowerCAmelCase_   :				Optional[Any]								= ['A long paragraph for summarization.', 'Another paragraph for summarization.']
        lowerCAmelCase_   :				Optional[Any]								= [0, 2_5_0, 2_5_1, 1_7_8_1_8, 1_3, 3_9_1_8_6, 1_9_3_8, 4, 2]

        for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
          lowerCAmelCase_   :				int								= tokenizer(SCREAMING_SNAKE_CASE_    ,			max_length=len(SCREAMING_SNAKE_CASE_       )    ,			padding=SCREAMING_SNAKE_CASE_    ,			return_tensors='pt'       )
          self.assertIsInstance(SCREAMING_SNAKE_CASE_    ,			SCREAMING_SNAKE_CASE_       )

          self.assertEqual((2, 9)    ,			batch.input_ids.shape       )
          self.assertEqual((2, 9)    ,			batch.attention_mask.shape       )
          lowerCAmelCase_   :				int								= batch.input_ids.tolist()[0]
          self.assertListEqual(SCREAMING_SNAKE_CASE_    ,			SCREAMING_SNAKE_CASE_       )



      @require_torch
      def      SCREAMING_SNAKE_CASE__ (      self				:      Union[str, Any]       ):
        lowerCAmelCase_   :				List[Any]								= ['A long paragraph for summarization.', 'Another paragraph for summarization.']
        for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
          lowerCAmelCase_   :				Optional[int]								= tokenizer(SCREAMING_SNAKE_CASE_    ,			padding=SCREAMING_SNAKE_CASE_    ,			return_tensors='pt'       )
          self.assertIn('input_ids'    ,			SCREAMING_SNAKE_CASE_       )
          self.assertIn('attention_mask'    ,			SCREAMING_SNAKE_CASE_       )
          self.assertNotIn('labels'    ,			SCREAMING_SNAKE_CASE_       )
          self.assertNotIn('decoder_attention_mask'    ,			SCREAMING_SNAKE_CASE_       )



      @require_torch
      def      SCREAMING_SNAKE_CASE__ (      self				:      int       ):
        lowerCAmelCase_   :				Any								= [
            'Summary of the text.',
            'Another summary.',
        ]
        for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
          lowerCAmelCase_   :				Tuple								= tokenizer(text_target=SCREAMING_SNAKE_CASE_    ,			max_length=3_2    ,			padding='max_length'    ,			return_tensors='pt'       )
          self.assertEqual(3_2    ,			targets['input_ids'].shape[1]       )



      @require_torch
      def      SCREAMING_SNAKE_CASE__ (      self				:      str       ):
        for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
          lowerCAmelCase_   :				Union[str, Any]								= tokenizer(
              ['I am a small frog' * 1_0_2_4, 'I am a small frog']    ,			padding=SCREAMING_SNAKE_CASE_    ,			truncation=SCREAMING_SNAKE_CASE_    ,			return_tensors='pt'       )
          self.assertIsInstance(SCREAMING_SNAKE_CASE_    ,			SCREAMING_SNAKE_CASE_       )
          self.assertEqual(batch.input_ids.shape    ,			(2, 5_1_2_2)       )



      @require_torch
      def      SCREAMING_SNAKE_CASE__ (      self				:      str       ):
        lowerCAmelCase_   :				Optional[Any]								= ['A long paragraph for summarization.']
        lowerCAmelCase_   :				Tuple								= [
            'Summary of the text.',
        ]
        for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
          lowerCAmelCase_   :				int								= tokenizer(SCREAMING_SNAKE_CASE_    ,			return_tensors='pt'       )
          lowerCAmelCase_   :				List[str]								= tokenizer(text_target=SCREAMING_SNAKE_CASE_    ,			return_tensors='pt'       )
          lowerCAmelCase_   :				str								= inputs['input_ids']
          lowerCAmelCase_   :				List[str]								= targets['input_ids']
          self.assertTrue((input_ids[:, 0] == tokenizer.bos_token_id).all().item()       )
          self.assertTrue((labels[:, 0] == tokenizer.bos_token_id).all().item()       )
          self.assertTrue((input_ids[:, -1] == tokenizer.eos_token_id).all().item()       )
          self.assertTrue((labels[:, -1] == tokenizer.eos_token_id).all().item()       )



      @require_torch
      def      SCREAMING_SNAKE_CASE__ (      self				:      Union[str, Any]       ):
        for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
          lowerCAmelCase_   :				Dict								= ['Summary of the text.', 'Another summary.']
          lowerCAmelCase_   :				Tuple								= [[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, -1, -1]]

          lowerCAmelCase_   :				Optional[int]								= tokenizer(SCREAMING_SNAKE_CASE_    ,			padding=SCREAMING_SNAKE_CASE_       )
          lowerCAmelCase_   :				List[Any]								= [[0] * len(SCREAMING_SNAKE_CASE_       ) for x in encoded_output['input_ids']]
          lowerCAmelCase_   :				int								= tokenizer.pad(SCREAMING_SNAKE_CASE_       )
          self.assertSequenceEqual(outputs['global_attention_mask']    ,			SCREAMING_SNAKE_CASE_       )



      def      SCREAMING_SNAKE_CASE__ (      self				:      Optional[Any]       ):
        pass





      def      SCREAMING_SNAKE_CASE__ (      self				:      Any       ):
        for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
          with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"       ):
            lowerCAmelCase_   :				Union[str, Any]								= self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_    ,			**SCREAMING_SNAKE_CASE_       )
            lowerCAmelCase_   :				List[Any]								= self.tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE_    ,			**SCREAMING_SNAKE_CASE_       )
            lowerCAmelCase_   :				str								= 'A, <mask> AllenNLP sentence.'
            lowerCAmelCase_   :				Union[str, Any]								= tokenizer_r.encode_plus(SCREAMING_SNAKE_CASE_    ,			add_special_tokens=SCREAMING_SNAKE_CASE_    ,			return_token_type_ids=SCREAMING_SNAKE_CASE_       )
            lowerCAmelCase_   :				Dict								= tokenizer_p.encode_plus(SCREAMING_SNAKE_CASE_    ,			add_special_tokens=SCREAMING_SNAKE_CASE_    ,			return_token_type_ids=SCREAMING_SNAKE_CASE_       )
            self.assertEqual(sum(tokens_r['token_type_ids']       )    ,			sum(tokens_p['token_type_ids']       )       )
            self.assertEqual(
                sum(tokens_r['attention_mask']       ) / len(tokens_r['attention_mask']       )    ,			sum(tokens_p['attention_mask']       ) / len(tokens_p['attention_mask']       )    ,			)

            lowerCAmelCase_   :				Union[str, Any]								= tokenizer_r.convert_ids_to_tokens(tokens_r['input_ids']       )
            lowerCAmelCase_   :				Optional[Any]								= tokenizer_p.convert_ids_to_tokens(tokens_p['input_ids']       )
            self.assertSequenceEqual(tokens_p['input_ids']    ,			[0, 2_5_0, 6, 5_0_2_6_4, 3_8_2_3, 4_8_7, 2_1_9_9_2, 3_6_4_5, 4, 2]       )
            self.assertSequenceEqual(tokens_r['input_ids']    ,			[0, 2_5_0, 6, 5_0_2_6_4, 3_8_2_3, 4_8_7, 2_1_9_9_2, 3_6_4_5, 4, 2]       )

            self.assertSequenceEqual(
                SCREAMING_SNAKE_CASE_    ,			['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>']       )
            self.assertSequenceEqual(
                SCREAMING_SNAKE_CASE_    ,			['<s>', 'A', ',', '<mask>', 'ĠAllen', 'N', 'LP', 'Ġsentence', '.', '</s>']       )










"""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__   (	lowercase_  ):




      """simple docstring"""




      _SCREAMING_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."""
      )
      _SCREAMING_SNAKE_CASE  				=     """CIDAS/clipseg-rd64-refined"""
      _SCREAMING_SNAKE_CASE  				=     """image_segmenter"""
      _SCREAMING_SNAKE_CASE  				=     CLIPSegForImageSegmentation

      _SCREAMING_SNAKE_CASE  				=     ["""image""", """text"""]
      _SCREAMING_SNAKE_CASE  				=     ["""image"""]



      def __init__(      self				:      Dict    ,			*SCREAMING_SNAKE_CASE_				:      Tuple    ,			**SCREAMING_SNAKE_CASE_				:      Optional[int]       ):
        requires_backends(self    ,			['vision']       )
        super().__init__(*SCREAMING_SNAKE_CASE_    ,			**SCREAMING_SNAKE_CASE_       )



      def      SCREAMING_SNAKE_CASE__ (      self				:      Optional[int]    ,			SCREAMING_SNAKE_CASE_				:      "Image"    ,			SCREAMING_SNAKE_CASE_				:      str       ):
        return self.pre_processor(text=[label]    ,			images=[image]    ,			padding=SCREAMING_SNAKE_CASE_    ,			return_tensors='pt'       )



      def      SCREAMING_SNAKE_CASE__ (      self				:      List[str]    ,			SCREAMING_SNAKE_CASE_				:      int       ):
        with torch.no_grad():
          lowerCAmelCase_   :				List[str]								= self.model(**SCREAMING_SNAKE_CASE_       ).logits
        return logits





      def      SCREAMING_SNAKE_CASE__ (      self				:      Optional[int]    ,			SCREAMING_SNAKE_CASE_				:      Optional[Any]       ):
        lowerCAmelCase_   :				Dict								= outputs.cpu().detach().numpy()
        lowerCAmelCase_   :				Optional[Any]								= 0
        lowerCAmelCase_   :				Optional[Any]								= 1
        return Image.fromarray((array * 2_5_5).astype(np.uinta       )       )





