



import unittest

import requests

from transformers import MODEL_FOR_VISION_2_SEQ_MAPPING, TF_MODEL_FOR_VISION_2_SEQ_MAPPING, is_vision_available
from transformers.pipelines import pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    is_torch_available,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_torch_available():
 from transformers.pytorch_utils import is_torch_greater_or_equal_than_1_11
else:
 UpperCAmelCase				:							List[str]								=False


if is_vision_available():
 from PIL import Image
else:


 class  _lowercase				:
     '''simple docstring'''







     @staticmethod
     def  _lowerCamelCase   (	*snake_case__       ,	**snake_case__      ):

          '''simple docstring'''


          pass


@is_pipeline_test
@require_vision
class  _lowercase				(unittest.TestCase ):
    '''simple docstring'''







    lowercase__				  =  MODEL_FOR_VISION_2_SEQ_MAPPING
    lowercase__				  =  TF_MODEL_FOR_VISION_2_SEQ_MAPPING

    def  _lowerCamelCase   (	self       ,	snake_case__       ,	snake_case__       ,	snake_case__      ):

         '''simple docstring'''


         UpperCamelCase_											=				pipeline("image-to-text"       ,	model=snake_case_       ,	tokenizer=snake_case_       ,	image_processor=snake_case_      )
         UpperCamelCase_											=				[
             Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"      ),
             './tests/fixtures/tests_samples/COCO/000000039769.png',
         ]
         return pipe, examples

    def  _lowerCamelCase   (	self       ,	snake_case__       ,	snake_case__      ):

         '''simple docstring'''


         UpperCamelCase_											=				pipe(snake_case_      )
         self.assertEqual(
             snake_case_       ,	[
                 [{"generated_text": ANY(snake_case_      )}],
                 [{"generated_text": ANY(snake_case_      )}],
             ]       ,	)

    @require_tf
    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         UpperCamelCase_											=				pipeline("image-to-text"       ,	model="hf-internal-testing/tiny-random-vit-gpt2"       ,	framework="tf"      )
         UpperCamelCase_											=				'./tests/fixtures/tests_samples/COCO/000000039769.png'

         UpperCamelCase_											=				pipe(snake_case_      )
         self.assertEqual(
             snake_case_       ,	[
                 {
                     "generated_text": "growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"
                 },
             ]       ,	)

         UpperCamelCase_											=				pipe([image, image]      )
         self.assertEqual(
             snake_case_       ,	[
                 [
                     {
                         "generated_text": "growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"
                     }
                 ],
                 [
                     {
                         "generated_text": "growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"
                     }
                 ],
             ]       ,	)

         UpperCamelCase_											=				pipe(snake_case_       ,	max_new_tokens=1      )
         self.assertEqual(
             snake_case_       ,	[{"generated_text": "growth"}]       ,	)

    @require_torch
    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         UpperCamelCase_											=				pipeline("image-to-text"       ,	model="hf-internal-testing/tiny-random-vit-gpt2"      )
         UpperCamelCase_											=				'./tests/fixtures/tests_samples/COCO/000000039769.png'

         UpperCamelCase_											=				pipe(snake_case_      )
         self.assertEqual(
             snake_case_       ,	[
                 {
                     "generated_text": "growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"
                 },
             ]       ,	)

         UpperCamelCase_											=				pipe([image, image]      )
         self.assertEqual(
             snake_case_       ,	[
                 [
                     {
                         "generated_text": "growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"
                     }
                 ],
                 [
                     {
                         "generated_text": "growthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthgrowthGOGO"
                     }
                 ],
             ]       ,	)

    @require_torch
    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         UpperCamelCase_											=				pipeline("image-to-text"       ,	model="hf-internal-testing/tiny-random-BlipForConditionalGeneration"      )
         UpperCamelCase_											=				'./tests/fixtures/tests_samples/COCO/000000039769.png'
         UpperCamelCase_											=				'a photo of'

         UpperCamelCase_											=				pipe(snake_case_       ,	prompt=snake_case_      )
         self.assertTrue(outputs[0]["generated_text"].startswith(snake_case_      )      )

    @slow
    @require_torch
    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         UpperCamelCase_											=				pipeline("image-to-text"       ,	model="ydshieh/vit-gpt2-coco-en"      )
         UpperCamelCase_											=				'./tests/fixtures/tests_samples/COCO/000000039769.png'

         UpperCamelCase_											=				pipe(snake_case_      )
         self.assertEqual(snake_case_       ,	[{"generated_text": "a cat laying on a blanket next to a cat laying on a bed "}]      )

         UpperCamelCase_											=				pipe([image, image]      )
         self.assertEqual(
             snake_case_       ,	[
                 [{"generated_text": "a cat laying on a blanket next to a cat laying on a bed "}],
                 [{"generated_text": "a cat laying on a blanket next to a cat laying on a bed "}],
             ]       ,	)

    @slow
    @require_torch
    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         UpperCamelCase_											=				pipeline("image-to-text"       ,	model="Salesforce/blip-image-captioning-base"      )
         UpperCamelCase_											=				'https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/pokemon.png'
         UpperCamelCase_											=				Image.open(requests.get(snake_case_       ,	stream=snake_case_      ).raw      )

         UpperCamelCase_											=				pipe(snake_case_      )
         self.assertEqual(snake_case_       ,	[{"generated_text": "a pink pokemon pokemon with a blue shirt and a blue shirt"}]      )

    @slow
    @require_torch
    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         UpperCamelCase_											=				pipeline("image-to-text"       ,	model="microsoft/git-base-coco"      )
         UpperCamelCase_											=				'https://huggingface.co/datasets/sayakpaul/sample-datasets/resolve/main/pokemon.png'
         UpperCamelCase_											=				Image.open(requests.get(snake_case_       ,	stream=snake_case_      ).raw      )

         UpperCamelCase_											=				pipe(snake_case_      )
         self.assertEqual(snake_case_       ,	[{"generated_text": "a cartoon of a purple character."}]      )

    @slow
    @require_torch
    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         UpperCamelCase_											=				pipeline("image-to-text"       ,	model="Salesforce/blip-image-captioning-base"      )
         UpperCamelCase_											=				'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg'
         UpperCamelCase_											=				Image.open(requests.get(snake_case_       ,	stream=snake_case_      ).raw      )

         UpperCamelCase_											=				'a photography of'

         UpperCamelCase_											=				pipe(snake_case_       ,	prompt=snake_case_      )
         self.assertEqual(snake_case_       ,	[{"generated_text": "a photography of a volcano"}]      )

         with self.assertRaises(snake_case_      ):
              UpperCamelCase_											=				pipe([image, image]       ,	prompt=[prompt, prompt]      )

    @slow
    @require_torch
    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         UpperCamelCase_											=				pipeline("image-to-text"       ,	model="microsoft/git-base-coco"      )
         UpperCamelCase_											=				'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg'
         UpperCamelCase_											=				Image.open(requests.get(snake_case_       ,	stream=snake_case_      ).raw      )

         UpperCamelCase_											=				'a photo of a'

         UpperCamelCase_											=				pipe(snake_case_       ,	prompt=snake_case_      )
         self.assertEqual(snake_case_       ,	[{"generated_text": "a photo of a tent with a tent and a tent in the background."}]      )

         with self.assertRaises(snake_case_      ):
              UpperCamelCase_											=				pipe([image, image]       ,	prompt=[prompt, prompt]      )

    @unittest.skipIf(
        not is_torch_greater_or_equal_than_1_11       ,	reason="`Pix2StructImageProcessor` requires `torch>=1.11.0`."      )
    @slow
    @require_torch
    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         UpperCamelCase_											=				pipeline("image-to-text"       ,	model="google/pix2struct-ai2d-base"      )
         UpperCamelCase_											=				'https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg'
         UpperCamelCase_											=				Image.open(requests.get(snake_case_       ,	stream=snake_case_      ).raw      )

         UpperCamelCase_											=				'What does the label 15 represent? (1) lava (2) core (3) tunnel (4) ash cloud'

         UpperCamelCase_											=				pipe(snake_case_       ,	prompt=snake_case_      )
         self.assertEqual(snake_case_       ,	[{"generated_text": "ash cloud"}]      )

         with self.assertRaises(snake_case_      ):
              UpperCamelCase_											=				pipe([image, image]       ,	prompt=[prompt, prompt]      )

    @slow
    @require_tf
    def  _lowerCamelCase   (	self      ):

         '''simple docstring'''


         UpperCamelCase_											=				pipeline("image-to-text"       ,	model="ydshieh/vit-gpt2-coco-en"       ,	framework="tf"      )
         UpperCamelCase_											=				'./tests/fixtures/tests_samples/COCO/000000039769.png'

         UpperCamelCase_											=				pipe(snake_case_      )
         self.assertEqual(snake_case_       ,	[{"generated_text": "a cat laying on a blanket next to a cat laying on a bed "}]      )

         UpperCamelCase_											=				pipe([image, image]      )
         self.assertEqual(
             snake_case_       ,	[
                 [{"generated_text": "a cat laying on a blanket next to a cat laying on a bed "}],
                 [{"generated_text": "a cat laying on a blanket next to a cat laying on a bed "}],
             ]       ,	)





import json
import os
import shutil
import tempfile
import unittest

from transformers.models.wavaveca import WavaVecaCTCTokenizer, WavaVecaFeatureExtractor, WavaVecaProcessor
from transformers.models.wavaveca.tokenization_wavaveca import VOCAB_FILES_NAMES
from transformers.utils import FEATURE_EXTRACTOR_NAME

from .test_feature_extraction_wavaveca import floats_list


class  _lowercase				(unittest.TestCase ):
				'''simple docstring'''







				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				"<pad> <s> </s> <unk> | E T A O N I H S R D L U M W C F G Y P B V K ' X J Q Z".split(" "      )
									UpperCamelCase_											=				dict(zip(snake_case__       ,	range(len(snake_case__      )      )      )      )

									UpperCamelCase_											=				{
									    "pad_token": "<pad>",
									    "unk_token": "<unk>",
									    "bos_token": "<s>",
									    "eos_token": "</s>",
									}
									UpperCamelCase_											=				{
									    "feature_size": 1,
									    "padding_value": 0.0,
									    "sampling_rate": 1_6000,
									    "return_attention_mask": False,
									    "do_normalize": True,
									}

									UpperCamelCase_											=				tempfile.mkdtemp()
									UpperCamelCase_											=				os.path.join(self.tmpdirname       ,	VOCAB_FILES_NAMES["vocab_file"]      )
									UpperCamelCase_											=				os.path.join(self.tmpdirname       ,	snake_case__      )
									with open(self.vocab_file       ,	"w"       ,	encoding="utf-8"      ) as fp:
														fp.write(json.dumps(snake_case__      ) + "\n"      )

									with open(self.feature_extraction_file       ,	"w"       ,	encoding="utf-8"      ) as fp:
														fp.write(json.dumps(snake_case__      ) + "\n"      )

				def  _lowerCamelCase   (	self       ,	**snake_case__      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.add_kwargs_tokens_map.copy()
									kwargs.update(snake_case__      )
									return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname       ,	**snake_case__      )

				def  _lowerCamelCase   (	self       ,	**snake_case__      ):

									'''simple docstring'''


									return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname       ,	**snake_case__      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									shutil.rmtree(self.tmpdirname      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.get_tokenizer()
									UpperCamelCase_											=				self.get_feature_extractor()

									UpperCamelCase_											=				WavaVecaProcessor(tokenizer=snake_case__       ,	feature_extractor=snake_case__      )

									processor.save_pretrained(self.tmpdirname      )
									UpperCamelCase_											=				WavaVecaProcessor.from_pretrained(self.tmpdirname      )

									self.assertEqual(processor.tokenizer.get_vocab()       ,	tokenizer.get_vocab()      )
									self.assertIsInstance(processor.tokenizer       ,	snake_case__      )

									self.assertEqual(processor.feature_extractor.to_json_string()       ,	feature_extractor.to_json_string()      )
									self.assertIsInstance(processor.feature_extractor       ,	snake_case__      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				WavaVecaProcessor(tokenizer=self.get_tokenizer()       ,	feature_extractor=self.get_feature_extractor()      )
									processor.save_pretrained(self.tmpdirname      )

									UpperCamelCase_											=				self.get_tokenizer(bos_token="(BOS)"       ,	eos_token="(EOS)"      )
									UpperCamelCase_											=				self.get_feature_extractor(do_normalize=snake_case__       ,	padding_value=1.0      )

									UpperCamelCase_											=				WavaVecaProcessor.from_pretrained(
									    self.tmpdirname       ,	bos_token="(BOS)"       ,	eos_token="(EOS)"       ,	do_normalize=snake_case__       ,	padding_value=1.0      )

									self.assertEqual(processor.tokenizer.get_vocab()       ,	tokenizer_add_kwargs.get_vocab()      )
									self.assertIsInstance(processor.tokenizer       ,	snake_case__      )

									self.assertEqual(processor.feature_extractor.to_json_string()       ,	feature_extractor_add_kwargs.to_json_string()      )
									self.assertIsInstance(processor.feature_extractor       ,	snake_case__      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.get_feature_extractor()
									UpperCamelCase_											=				self.get_tokenizer()

									UpperCamelCase_											=				WavaVecaProcessor(tokenizer=snake_case__       ,	feature_extractor=snake_case__      )

									UpperCamelCase_											=				floats_list((3, 1000)      )

									UpperCamelCase_											=				feature_extractor(snake_case__       ,	return_tensors="np"      )
									UpperCamelCase_											=				processor(snake_case__       ,	return_tensors="np"      )

									for key in input_feat_extract.keys():
														self.assertAlmostEqual(input_feat_extract[key].sum()       ,	input_processor[key].sum()       ,	delta=1e-2      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.get_feature_extractor()
									UpperCamelCase_											=				self.get_tokenizer()

									UpperCamelCase_											=				WavaVecaProcessor(tokenizer=snake_case__       ,	feature_extractor=snake_case__      )

									UpperCamelCase_											=				"This is a test string"

									UpperCamelCase_											=				processor(text=snake_case__      )

									UpperCamelCase_											=				tokenizer(snake_case__      )

									for key in encoded_tok.keys():
														self.assertListEqual(encoded_tok[key]       ,	encoded_processor[key]      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.get_feature_extractor()
									UpperCamelCase_											=				self.get_tokenizer()

									UpperCamelCase_											=				WavaVecaProcessor(tokenizer=snake_case__       ,	feature_extractor=snake_case__      )

									UpperCamelCase_											=				[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

									UpperCamelCase_											=				processor.batch_decode(snake_case__      )
									UpperCamelCase_											=				tokenizer.batch_decode(snake_case__      )

									self.assertListEqual(snake_case__       ,	snake_case__      )

				def  _lowerCamelCase   (	self      ):

									'''simple docstring'''


									UpperCamelCase_											=				self.get_feature_extractor()
									UpperCamelCase_											=				self.get_tokenizer()

									UpperCamelCase_											=				WavaVecaProcessor(tokenizer=snake_case__       ,	feature_extractor=snake_case__      )

									self.assertListEqual(
									    processor.model_input_names       ,	feature_extractor.model_input_names       ,	msg="`processor` and `feature_extractor` model input names do not match"       ,	)
