






# 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 				_A			(     UpperCamelCase				):
    """simple docstring"""

    lowerCamelCase	:							Optional[int]				= 'Salesforce/blip-image-captioning-base'
    lowerCamelCase	:							List[Any]				= (
        '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.'
    )
    lowerCamelCase	:							Union[str, Any]				= 'image_captioner'
    lowerCamelCase	:							Union[str, Any]				= AutoModelForVisionaSeq

    lowerCamelCase	:							Tuple				= ['image']
    lowerCamelCase	:							Optional[Any]				= ['text']



    def __init__(				self      :     Dict ,     *__SCREAMING_SNAKE_CASE      :     Optional[int] ,     **__SCREAMING_SNAKE_CASE      :     List[str]      )      ->							Dict:
           requires_backends(self ,     ["""vision"""]      )
           super().__init__(*__SCREAMING_SNAKE_CASE ,     **__SCREAMING_SNAKE_CASE      )



    def _a							(				self      :     Tuple ,     __SCREAMING_SNAKE_CASE      :     "Image"      )      ->							Dict:
           return self.pre_processor(images=__SCREAMING_SNAKE_CASE ,     return_tensors="""pt"""      )



    def _a							(				self      :     str ,     __SCREAMING_SNAKE_CASE      :     Tuple      )      ->							Optional[Any]:
           return self.model.generate(**__SCREAMING_SNAKE_CASE      )



    def _a							(				self      :     Dict ,     __SCREAMING_SNAKE_CASE      :     Union[str, Any]      )      ->							Dict:
           return self.pre_processor.batch_decode(__SCREAMING_SNAKE_CASE ,     skip_special_tokens=__SCREAMING_SNAKE_CASE      )[0].strip()









import re






def  lowerCamelCase_	(      lowerCAmelCase__	:	str				)       ->							str:

							'''simple docstring'''






							if len(re.findall('[ATCG]'			,	lowerCAmelCase__				)				) != len(lowerCAmelCase__				):
														raise ValueError('Invalid Strand'				)

							return dna.translate(dna.maketrans('ATCG'			,	'TAGC'				)				)


if __name__ == "__main__":
				import doctest

				doctest.testmod()