'''simple docstring'''

import json
import os
import unittest

from transformers import OpenAIGPTTokenizer, OpenAIGPTTokenizerFast
from transformers.models.openai.tokenization_openai import VOCAB_FILES_NAMES
from transformers.testing_utils import require_ftfy, require_spacy, require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin



@require_tokenizers
class       UpperCAmelCase  (						a__   ,						unittest.TestCase ):





       '''simple docstring'''



       SCREAMING_SNAKE_CASE 		=   OpenAIGPTTokenizer
       SCREAMING_SNAKE_CASE 		=   OpenAIGPTTokenizerFast
       SCREAMING_SNAKE_CASE 		=   True
       SCREAMING_SNAKE_CASE 		=   False

       def _lowerCAmelCase(						self			)  ->  Optional[int]:
        super().setUp()

        # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
        lowercase__    :   Optional[Any]						= [
            '''l''',
            '''o''',
            '''w''',
            '''e''',
            '''r''',
            '''s''',
            '''t''',
            '''i''',
            '''d''',
            '''n''',
            '''w</w>''',
            '''r</w>''',
            '''t</w>''',
            '''lo''',
            '''low''',
            '''er</w>''',
            '''low</w>''',
            '''lowest</w>''',
            '''newer</w>''',
            '''wider</w>''',
            '''<unk>''',
        ]
        lowercase__    :   Optional[int]						= dict(zip(__lowerCAmelCase     ,       range(len(__lowerCAmelCase			)			)			)			)
        lowercase__    :   Union[str, Any]						= ['''#version: 0.2''', '''l o''', '''lo w''', '''e r</w>''', '''''']

        lowercase__    :   Optional[int]						= os.path.join(self.tmpdirname     ,       VOCAB_FILES_NAMES['''vocab_file''']			)
        lowercase__    :   Optional[int]						= os.path.join(self.tmpdirname     ,       VOCAB_FILES_NAMES['''merges_file''']			)
        with open(self.vocab_file     ,       '''w'''			) as fp:
         fp.write(json.dumps(__lowerCAmelCase			)			)
        with open(self.merges_file     ,       '''w'''			) as fp:
         fp.write('''\n'''.join(__lowerCAmelCase			)			)

       def _lowerCAmelCase(						self     ,       __lowerCAmelCase			)  ->  Dict:
        return "lower newer", "lower newer"

       def _lowerCAmelCase(						self			)  ->  List[Any]:
        lowercase__    :   int						= OpenAIGPTTokenizer(self.vocab_file     ,       self.merges_file			)

        lowercase__    :   List[Any]						= '''lower'''
        lowercase__    :   Any						= ['''low''', '''er</w>''']
        lowercase__    :   Union[str, Any]						= tokenizer.tokenize(__lowerCAmelCase			)
        self.assertListEqual(__lowerCAmelCase     ,       __lowerCAmelCase			)

        lowercase__    :   Tuple						= tokens + ['''<unk>''']
        lowercase__    :   Optional[Any]						= [14, 15, 20]
        self.assertListEqual(tokenizer.convert_tokens_to_ids(__lowerCAmelCase			)     ,       __lowerCAmelCase			)

       def _lowerCAmelCase(						self     ,       __lowerCAmelCase=15			)  ->  Optional[int]:
        for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
         with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""			):
          lowercase__    :   List[str]						= self.rust_tokenizer_class.from_pretrained(__lowerCAmelCase     ,       **__lowerCAmelCase			)

          # Simple input
          lowercase__    :   List[str]						= '''This is a simple input'''
          lowercase__    :   Any						= ['''This is a simple input 1''', '''This is a simple input 2''']
          lowercase__    :   str						= ('''This is a simple input''', '''This is a pair''')
          lowercase__    :   str						= [
              ('''This is a simple input 1''', '''This is a simple input 2'''),
              ('''This is a simple pair 1''', '''This is a simple pair 2'''),
          ]

          # Simple input tests
          self.assertRaises(__lowerCAmelCase     ,       tokenizer_r.encode     ,       __lowerCAmelCase     ,       max_length=__lowerCAmelCase     ,       padding='''max_length'''			)

          # Simple input
          self.assertRaises(__lowerCAmelCase     ,       tokenizer_r.encode_plus     ,       __lowerCAmelCase     ,       max_length=__lowerCAmelCase     ,       padding='''max_length'''			)

          # Simple input
          self.assertRaises(
              __lowerCAmelCase     ,       tokenizer_r.batch_encode_plus     ,       __lowerCAmelCase     ,       max_length=__lowerCAmelCase     ,       padding='''max_length'''     ,       )

          # Pair input
          self.assertRaises(__lowerCAmelCase     ,       tokenizer_r.encode     ,       __lowerCAmelCase     ,       max_length=__lowerCAmelCase     ,       padding='''max_length'''			)

          # Pair input
          self.assertRaises(__lowerCAmelCase     ,       tokenizer_r.encode_plus     ,       __lowerCAmelCase     ,       max_length=__lowerCAmelCase     ,       padding='''max_length'''			)

          # Pair input
          self.assertRaises(
              __lowerCAmelCase     ,       tokenizer_r.batch_encode_plus     ,       __lowerCAmelCase     ,       max_length=__lowerCAmelCase     ,       padding='''max_length'''     ,       )


       def _lowerCAmelCase(						self			)  ->  Tuple:
        pass



@require_ftfy
@require_spacy
@require_tokenizers
class       UpperCAmelCase  (						a__ ):





       '''simple docstring'''



       pass


'''simple docstring'''

from collections import UserDict
from typing import List, Union

from ..utils import (
    add_end_docstrings,
    is_tf_available,
    is_torch_available,
    is_vision_available,
    logging,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
  from PIL import Image

  from ..image_utils import load_image

if is_torch_available():
  from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING

if is_tf_available():
  from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING
  from ..tf_utils import stable_softmax

__a:			Optional[Any]	       =       logging.get_logger(__name__)



@add_end_docstrings(a__ )
class       UpperCAmelCase  (						a__ ):





       '''simple docstring'''



       def __init__(						self     ,       **__lowerCAmelCase			)  ->  int:
        super().__init__(**__lowerCAmelCase			)

        requires_backends(self     ,       '''vision'''			)
        self.check_model_type(
            TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING
            if self.framework == '''tf'''
            else MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING			)

       def __call__(						self     ,       __lowerCAmelCase     ,       **__lowerCAmelCase			)  ->  List[str]:
        return super().__call__(__lowerCAmelCase     ,       **__lowerCAmelCase			)

       def _lowerCAmelCase(						self     ,       **__lowerCAmelCase			)  ->  Optional[Any]:
        lowercase__    :   str						= {}
        if "candidate_labels" in kwargs:
         lowercase__    :   str						= kwargs['''candidate_labels''']
        if "hypothesis_template" in kwargs:
         lowercase__    :   str						= kwargs['''hypothesis_template''']

        return preprocess_params, {}, {}

       def _lowerCAmelCase(						self     ,       __lowerCAmelCase     ,       __lowerCAmelCase=None     ,       __lowerCAmelCase="This is a photo of {}."			)  ->  Any:
        lowercase__    :   Union[str, Any]						= load_image(__lowerCAmelCase			)
        lowercase__    :   List[str]						= self.image_processor(images=[image]     ,       return_tensors=self.framework			)
        lowercase__    :   Union[str, Any]						= candidate_labels
        lowercase__    :   int						= [hypothesis_template.format(__lowerCAmelCase			) for x in candidate_labels]
        lowercase__    :   Any						= self.tokenizer(__lowerCAmelCase     ,       return_tensors=self.framework     ,       padding=__lowerCAmelCase			)
        lowercase__    :   Any						= [text_inputs]
        return inputs

       def _lowerCAmelCase(						self     ,       __lowerCAmelCase			)  ->  Optional[Any]:
        lowercase__    :   Any						= model_inputs.pop('''candidate_labels'''			)
        lowercase__    :   int						= model_inputs.pop('''text_inputs'''			)
        if isinstance(text_inputs[0]     ,       __lowerCAmelCase			):
         lowercase__    :   Union[str, Any]						= text_inputs[0]
        else:
         # Batching case.
         lowercase__    :   Optional[Any]						= text_inputs[0][0]

        lowercase__    :   Any						= self.model(**__lowerCAmelCase     ,       **__lowerCAmelCase			)

        lowercase__    :   Any						= {
            '''candidate_labels''': candidate_labels,
            '''logits''': outputs.logits_per_image,
        }
        return model_outputs


       def _lowerCAmelCase(						self     ,       __lowerCAmelCase			)  ->  List[str]:
        lowercase__    :   Union[str, Any]						= model_outputs.pop('''candidate_labels'''			)
        lowercase__    :   Optional[int]						= model_outputs['''logits'''][0]
        if self.framework == "pt":
         lowercase__    :   Optional[int]						= logits.softmax(dim=-1			).squeeze(-1			)
         lowercase__    :   Any						= probs.tolist()
         if not isinstance(__lowerCAmelCase     ,       __lowerCAmelCase			):
          lowercase__    :   Dict						= [scores]
        elif self.framework == "tf":
         lowercase__    :   List[Any]						= stable_softmax(__lowerCAmelCase     ,       axis=-1			)
         lowercase__    :   str						= probs.numpy().tolist()
        else:
         raise ValueError(F"""Unsupported framework: {self.framework}"""			)

        lowercase__    :   Optional[int]						= [
            {'''score''': score, '''label''': candidate_label}
            for score, candidate_label in sorted(zip(__lowerCAmelCase     ,       __lowerCAmelCase			)     ,       key=lambda __lowerCAmelCase			: -x[0]			)
        ]
        return result

