


# 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.
from typing import TYPE_CHECKING

from ..models.auto import AutoModelForVisionaSeq
from ..utils import requires_backends
from .base import PipelineTool


if TYPE_CHECKING:
      from PIL import Image







class 				snake_case__(							snake_case__							):







      '''simple docstring'''




      SCREAMING_SNAKE_CASE__      :  int					=							'''Salesforce/blip-image-captioning-base'''
      SCREAMING_SNAKE_CASE__      :  str					=							(
          '''This is a tool that generates a description of an image. It takes an input named `image` which should be the '''
          '''image to caption, and returns a text that contains the description in English.'''
      )
      SCREAMING_SNAKE_CASE__      :  int					=							'''image_captioner'''
      SCREAMING_SNAKE_CASE__      :  Union[str, Any]					=							AutoModelForVisionaSeq

      SCREAMING_SNAKE_CASE__      :  Dict					=							['''image''']
      SCREAMING_SNAKE_CASE__      :  Union[str, Any]					=							['''text''']




      def __init__(				self   ,						*__lowercase   ,						**__lowercase							)					->    str:
          requires_backends(self   ,						['''vision''']							)
          super().__init__(*_A   ,						**_A							)




      def 						lowercase_ (				self   ,						__lowercase							)					->    int:
          return self.pre_processor(images=_A   ,						return_tensors='''pt'''							)




      def 						lowercase_ (				self   ,						__lowercase							)					->    int:
          return self.model.generate(**_A							)




      def 						lowercase_ (				self   ,						__lowercase							)					->    List[str]:
          return self.pre_processor.batch_decode(_A   ,						skip_special_tokens=_A							)[0].strip()



import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


_UpperCAmelCase			:  str     =logging.get_logger(__name__)







class 				snake_case__(							UpperCAmelCase__							):







						'''simple docstring'''




						SCREAMING_SNAKE_CASE__      :  Optional[int]					=							"""encoder-decoder"""
						SCREAMING_SNAKE_CASE__      :  str					=							True




						def __init__(				self   ,						**__lowercase							)					->    Union[str, Any]:
										super().__init__(**__lowercase							)
										assert (
										    "encoder" in kwargs and "decoder" in kwargs
										), "Config has to be initialized with encoder and decoder config"
										lowerCAmelCase_ :      str    				=				kwargs.pop('''encoder'''							)
										lowerCAmelCase_ :      int    				=				encoder_config.pop('''model_type'''							)
										lowerCAmelCase_ :      Optional[Any]    				=				kwargs.pop('''decoder'''							)
										lowerCAmelCase_ :      Optional[Any]    				=				decoder_config.pop('''model_type'''							)

										from ..auto.configuration_auto import AutoConfig

										lowerCAmelCase_ :      Union[str, Any]    				=				AutoConfig.for_model(__lowercase   ,						**__lowercase							)
										lowerCAmelCase_ :      List[str]    				=				AutoConfig.for_model(__lowercase   ,						**__lowercase							)
										lowerCAmelCase_ :      Any    				=				True




						@classmethod
						def 						lowercase_ (				cls   ,						__lowercase   ,						__lowercase   ,						**__lowercase							)					->    PretrainedConfig:
										logger.info('''Set `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config'''							)
										lowerCAmelCase_ :      int    				=				True
										lowerCAmelCase_ :      List[Any]    				=				True

										return cls(encoder=encoder_config.to_dict()   ,						decoder=decoder_config.to_dict()   ,						**__lowercase							)




						def 						lowercase_ (				self							)					->    Any:
										lowerCAmelCase_ :      Optional[Any]    				=				copy.deepcopy(self.__dict__							)
										lowerCAmelCase_ :      List[str]    				=				self.encoder.to_dict()
										lowerCAmelCase_ :      Dict    				=				self.decoder.to_dict()
										lowerCAmelCase_ :      Optional[Any]    				=				self.__class__.model_type
										return output