






"""simple docstring"""



import json
import os
import random
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import BertTokenizer, BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
 from PIL import Image

 from transformers import FlavaImageProcessor, FlavaProcessor
 from transformers.models.flava.image_processing_flava import (
     FLAVA_CODEBOOK_MEAN,
     FLAVA_CODEBOOK_STD,
     FLAVA_IMAGE_MEAN,
     FLAVA_IMAGE_STD,
 )




@require_vision
class        lowerCAmelCase__       (  unittest.TestCase					):
   def 	__a				(						self	:     List[str]				):


        '''simple docstring'''
        UpperCAmelCase__		:  str				=				tempfile.mkdtemp()

        # fmt: off
        UpperCAmelCase__		:  List[Any]				=				["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "want", "##want", "##ed", "wa", "un", "runn", "##ing", ",", "low", "lowest"]
        # fmt: on
        UpperCAmelCase__		:  List[Any]				=				os.path.join(self.tmpdirname				,       VOCAB_FILES_NAMES["vocab_file"]				)

        with open(self.vocab_file				,       "w"				,       encoding="utf-8"				) as fp:
             fp.write("".join([x + "\n" for x in vocab_tokens]				)				)

        UpperCAmelCase__		:  str				=				{
            "image_mean": FLAVA_IMAGE_MEAN,
            "image_std": FLAVA_IMAGE_STD,
            "do_normalize": True,
            "do_resize": True,
            "size": 2_2_4,
            "do_center_crop": True,
            "crop_size": 2_2_4,
            "input_size_patches": 1_4,
            "total_mask_patches": 7_5,
            "mask_group_max_patches": None,
            "mask_group_min_patches": 1_6,
            "mask_group_min_aspect_ratio": 0.3,
            "mask_group_max_aspect_ratio": None,
            "codebook_do_resize": True,
            "codebook_size": 1_1_2,
            "codebook_do_center_crop": True,
            "codebook_crop_size": 1_1_2,
            "codebook_do_map_pixels": True,
            "codebook_do_normalize": True,
            "codebook_image_mean": FLAVA_CODEBOOK_MEAN,
            "codebook_image_std": FLAVA_CODEBOOK_STD,
        }

        UpperCAmelCase__		:  str				=				os.path.join(self.tmpdirname				,       snake_case__				)
        with open(self.image_processor_file				,       "w"				,       encoding="utf-8"				) as fp:
             json.dump(snake_case__				,       snake_case__				)
   def 	__a				(						self	:     Union[str, Any]				,       **snake_case__	:     List[str]				):


        '''simple docstring'''
        return BertTokenizer.from_pretrained(self.tmpdirname				,       **snake_case__				)
   def 	__a				(						self	:     List[str]				,       **snake_case__	:     Union[str, Any]				):


        '''simple docstring'''
        return BertTokenizerFast.from_pretrained(self.tmpdirname				,       **snake_case__				)
   def 	__a				(						self	:     Optional[int]				,       **snake_case__	:     Optional[Any]				):


        '''simple docstring'''
        return FlavaImageProcessor.from_pretrained(self.tmpdirname				,       **snake_case__				)
   def 	__a				(						self	:     List[str]				):


        '''simple docstring'''
        shutil.rmtree(self.tmpdirname				)
   def 	__a				(						self	:     Optional[int]				):


        '''simple docstring'''
        UpperCAmelCase__		:  Optional[Any]				=				[np.random.randint(2_5_5				,       size=(3, 3_0, 4_0_0)				,       dtype=np.uinta				)]

        UpperCAmelCase__		:  Union[str, Any]				=				[Image.fromarray(np.moveaxis(snake_case__				,       0				,       -1				)				) for x in image_inputs]

        return image_inputs
   def 	__a				(						self	:     int				):


        '''simple docstring'''
        UpperCAmelCase__		:  Tuple				=				self.get_tokenizer()
        UpperCAmelCase__		:  List[Any]				=				self.get_rust_tokenizer()
        UpperCAmelCase__		:  Dict				=				self.get_image_processor()

        UpperCAmelCase__		:  List[str]				=				FlavaProcessor(tokenizer=snake_case__				,       image_processor=snake_case__				)
        processor_slow.save_pretrained(self.tmpdirname				)
        UpperCAmelCase__		:  Dict				=				FlavaProcessor.from_pretrained(self.tmpdirname				,       use_fast=snake_case__				)

        UpperCAmelCase__		:  Optional[Any]				=				FlavaProcessor(tokenizer=snake_case__				,       image_processor=snake_case__				)
        processor_fast.save_pretrained(self.tmpdirname				)
        UpperCAmelCase__		:  Dict				=				FlavaProcessor.from_pretrained(self.tmpdirname				)

        self.assertEqual(processor_slow.tokenizer.get_vocab()				,       tokenizer_slow.get_vocab()				)
        self.assertEqual(processor_fast.tokenizer.get_vocab()				,       tokenizer_fast.get_vocab()				)
        self.assertEqual(tokenizer_slow.get_vocab()				,       tokenizer_fast.get_vocab()				)
        self.assertIsInstance(processor_slow.tokenizer				,       snake_case__				)
        self.assertIsInstance(processor_fast.tokenizer				,       snake_case__				)

        self.assertEqual(processor_slow.image_processor.to_json_string()				,       image_processor.to_json_string()				)
        self.assertEqual(processor_fast.image_processor.to_json_string()				,       image_processor.to_json_string()				)
        self.assertIsInstance(processor_slow.image_processor				,       snake_case__				)
        self.assertIsInstance(processor_fast.image_processor				,       snake_case__				)
   def 	__a				(						self	:     Union[str, Any]				):


        '''simple docstring'''
        UpperCAmelCase__		:  Dict				=				FlavaProcessor(tokenizer=self.get_tokenizer()				,       image_processor=self.get_image_processor()				)
        processor.save_pretrained(self.tmpdirname				)

        UpperCAmelCase__		:  List[str]				=				self.get_tokenizer(bos_token="(BOS)"				,       eos_token="(EOS)"				)
        UpperCAmelCase__		:  Optional[Any]				=				self.get_image_processor(do_normalize=snake_case__				,       padding_value=1.0				)

        UpperCAmelCase__		:  Any				=				FlavaProcessor.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.image_processor.to_json_string()				,       image_processor_add_kwargs.to_json_string()				)
        self.assertIsInstance(processor.image_processor				,       snake_case__				)
   def 	__a				(						self	:     List[Any]				):


        '''simple docstring'''
        UpperCAmelCase__		:  str				=				self.get_image_processor()
        UpperCAmelCase__		:  int				=				self.get_tokenizer()

        UpperCAmelCase__		:  List[str]				=				FlavaProcessor(tokenizer=snake_case__				,       image_processor=snake_case__				)

        UpperCAmelCase__		:  Dict				=				self.prepare_image_inputs()

        UpperCAmelCase__		:  Optional[int]				=				image_processor(snake_case__				,       return_tensors="np"				)
        UpperCAmelCase__		:  Any				=				processor(images=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				)

        # With rest of the args
        random.seed(1_2_3_4				)
        UpperCAmelCase__		:  Dict				=				image_processor(
            snake_case__				,       return_image_mask=snake_case__				,       return_codebook_pixels=snake_case__				,       return_tensors="np"				)
        random.seed(1_2_3_4				)
        UpperCAmelCase__		:  List[str]				=				processor(
            images=snake_case__				,       return_image_mask=snake_case__				,       return_codebook_pixels=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 	__a				(						self	:     List[Any]				):


        '''simple docstring'''
        UpperCAmelCase__		:  Tuple				=				self.get_image_processor()
        UpperCAmelCase__		:  Dict				=				self.get_tokenizer()

        UpperCAmelCase__		:  Any				=				FlavaProcessor(tokenizer=snake_case__				,       image_processor=snake_case__				)

        UpperCAmelCase__		:  int				=				"lower newer"

        UpperCAmelCase__		:  List[str]				=				processor(text=snake_case__				)

        UpperCAmelCase__		:  Optional[int]				=				tokenizer(snake_case__				)

        for key in encoded_tok.keys():
             self.assertListEqual(encoded_tok[key]				,       encoded_processor[key]				)
   def 	__a				(						self	:     List[Any]				):


        '''simple docstring'''
        UpperCAmelCase__		:  Tuple				=				self.get_image_processor()
        UpperCAmelCase__		:  int				=				self.get_tokenizer()

        UpperCAmelCase__		:  Dict				=				FlavaProcessor(tokenizer=snake_case__				,       image_processor=snake_case__				)

        UpperCAmelCase__		:  Tuple				=				"lower newer"
        UpperCAmelCase__		:  Optional[int]				=				self.prepare_image_inputs()

        UpperCAmelCase__		:  Tuple				=				processor(text=snake_case__				,       images=snake_case__				)

        self.assertListEqual(list(inputs.keys()				)				,       ["input_ids", "token_type_ids", "attention_mask", "pixel_values"]				)

        # add extra args
        UpperCAmelCase__		:  Dict				=				processor(text=snake_case__				,       images=snake_case__				,       return_codebook_pixels=snake_case__				,       return_image_mask=snake_case__				)

        self.assertListEqual(
            list(inputs.keys()				)				,       [
                "input_ids",
                "token_type_ids",
                "attention_mask",
                "pixel_values",
                "codebook_pixel_values",
                "bool_masked_pos",
            ]				,       )

        # test if it raises when no input is passed
        with pytest.raises(snake_case__				):
             processor()
   def 	__a				(						self	:     int				):


        '''simple docstring'''
        UpperCAmelCase__		:  Any				=				self.get_image_processor()
        UpperCAmelCase__		:  Any				=				self.get_tokenizer()

        UpperCAmelCase__		:  List[Any]				=				FlavaProcessor(tokenizer=snake_case__				,       image_processor=snake_case__				)

        UpperCAmelCase__		:  List[str]				=				[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

        UpperCAmelCase__		:  Union[str, Any]				=				processor.batch_decode(snake_case__				)
        UpperCAmelCase__		:  Dict				=				tokenizer.batch_decode(snake_case__				)

        self.assertListEqual(snake_case__				,       snake_case__				)




   def 	__a				(						self	:     Any				):


        '''simple docstring'''
        UpperCAmelCase__		:  List[str]				=				self.get_image_processor()
        UpperCAmelCase__		:  Dict				=				self.get_tokenizer()

        UpperCAmelCase__		:  List[str]				=				FlavaProcessor(tokenizer=snake_case__				,       image_processor=snake_case__				)

        UpperCAmelCase__		:  Union[str, Any]				=				"lower newer"
        UpperCAmelCase__		:  Optional[Any]				=				self.prepare_image_inputs()

        UpperCAmelCase__		:  Any				=				processor(text=snake_case__				,       images=snake_case__				)

        self.assertListEqual(list(inputs.keys()				)				,       processor.model_input_names				)








import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
							import torch

if is_vision_available():
							from PIL import Image

							from transformers import TvltImageProcessor






def 					snake_case					(							A						,   A=10						,   A=10						,   A=False						,   A=False			)							->							str:




	'''simple docstring'''


	lowerCamelCase_							:		Any							   =							[]
	for i in range(image_processor_tester.num_frames			):
		video.append(np.random.randint(255						,   size=(image_processor_tester.num_channels, width, height)						,   dtype=np.uinta			)			)

	if not numpify and not torchify:
		# PIL expects the channel dimension as last dimension
		lowerCamelCase_							:		Any							   =							[Image.fromarray(np.moveaxis(A						,   0						,   -1			)			) for frame in video]

	if torchify:
		lowerCamelCase_							:		List[str]							   =							[torch.from_numpy(A			) for frame in video]

	return video






def 					snake_case					(							A						,   A=False						,   A=False						,   A=False			)							->							Dict:




	'''simple docstring'''


	assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

	lowerCamelCase_							:		int							   =							[]
	for i in range(image_processor_tester.batch_size			):
		if equal_resolution:
			lowerCamelCase_							:		Union[str, Any]							   =							image_processor_tester.max_resolution
		else:
			lowerCamelCase_   ,			lowerCamelCase_							:		Optional[int]							   =							np.random.choice(
			    np.arange(image_processor_tester.min_resolution						,   image_processor_tester.max_resolution			)						,   2			)
			lowerCamelCase_							:		str							   =							prepare_video(
			    image_processor_tester=A						,   width=A						,   height=A						,   numpify=A						,   torchify=A						,   )
		video_inputs.append(A			)

	return video_inputs


class 				__SCREAMING_SNAKE_CASE							(		unittest.TestCase  ):

					def __init__(				self ,       __lowercase ,       __lowercase=7 ,       __lowercase=3 ,       __lowercase=4 ,       __lowercase=18 ,       __lowercase=30 ,       __lowercase=400 ,       __lowercase=True ,       __lowercase=None ,       __lowercase=True ,       __lowercase=[0.5, 0.5, 0.5] ,       __lowercase=[0.5, 0.5, 0.5] ,       __lowercase=True ,       __lowercase=None ,       ):







						'''simple docstring'''




						lowerCamelCase_							:		Optional[int]							   =							size if size is not None else {'shortest_edge': 18}
						lowerCamelCase_							:		Union[str, Any]							   =							crop_size if crop_size is not None else {'height': 18, 'width': 18}

						lowerCamelCase_							:		List[Any]							   =							parent
						lowerCamelCase_							:		Optional[Any]							   =							batch_size
						lowerCamelCase_							:		Tuple							   =							num_channels
						lowerCamelCase_							:		Dict							   =							num_frames
						lowerCamelCase_							:		Dict							   =							image_size
						lowerCamelCase_							:		Optional[Any]							   =							min_resolution
						lowerCamelCase_							:		List[Any]							   =							max_resolution
						lowerCamelCase_							:		Dict							   =							do_resize
						lowerCamelCase_							:		List[Any]							   =							size
						lowerCamelCase_							:		Dict							   =							do_normalize
						lowerCamelCase_							:		Optional[Any]							   =							image_mean
						lowerCamelCase_							:		List[str]							   =							image_std
						lowerCamelCase_							:		Tuple							   =							do_center_crop
						lowerCamelCase_							:		List[Any]							   =							crop_size





					def 	lowercase_							(				self					):







						'''simple docstring'''




						return {
						    "image_mean": self.image_mean,
						    "image_std": self.image_std,
						    "do_normalize": self.do_normalize,
						    "do_resize": self.do_resize,
						    "size": self.size,
						    "do_center_crop": self.do_center_crop,
						    "crop_size": self.crop_size,
						}


@require_torch
@require_vision
class 				__SCREAMING_SNAKE_CASE							(		lowerCamelCase   ,     unittest.TestCase  ):
					_lowerCamelCase		  = TvltImageProcessor if is_vision_available() else None

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		Optional[Any]							   =							TvltImageProcessorTester(self					)

					@property
					def 	lowercase_							(				self					):







						'''simple docstring'''




						return self.image_processor_tester.prepare_image_processor_dict()

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		int							   =							self.image_processing_class(**self.image_processor_dict					)
						self.assertTrue(hasattr(__lowercase ,       'image_mean'					)					)
						self.assertTrue(hasattr(__lowercase ,       'image_std'					)					)
						self.assertTrue(hasattr(__lowercase ,       'do_normalize'					)					)
						self.assertTrue(hasattr(__lowercase ,       'do_resize'					)					)
						self.assertTrue(hasattr(__lowercase ,       'do_center_crop'					)					)
						self.assertTrue(hasattr(__lowercase ,       'size'					)					)

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		Optional[Any]							   =							self.image_processing_class(**self.image_processor_dict					)
						# create random PIL videos
						lowerCamelCase_							:		Dict							   =							prepare_video_inputs(self.image_processor_tester ,       equal_resolution=__lowercase					)
						for video in video_inputs:
							self.assertIsInstance(__lowercase ,       __lowercase					)
							self.assertIsInstance(video[0] ,       Image.Image					)

						# Test not batched input
						lowerCamelCase_							:		Any							   =							image_processor(video_inputs[0] ,       return_tensors='pt'					).pixel_values
						self.assertEqual(
						    encoded_videos.shape ,       (
						        1,
						        self.image_processor_tester.num_frames,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    ) ,       )

						# Test batched
						lowerCamelCase_							:		List[Any]							   =							image_processor(__lowercase ,       return_tensors='pt'					).pixel_values
						self.assertEqual(
						    encoded_videos.shape ,       (
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_frames,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    ) ,       )

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		Dict							   =							self.image_processing_class(**self.image_processor_dict					)
						# create random numpy tensors
						lowerCamelCase_							:		Union[str, Any]							   =							prepare_video_inputs(self.image_processor_tester ,       equal_resolution=__lowercase ,       numpify=__lowercase					)
						for video in video_inputs:
							self.assertIsInstance(__lowercase ,       __lowercase					)
							self.assertIsInstance(video[0] ,       np.ndarray					)

						# Test not batched input
						lowerCamelCase_							:		Union[str, Any]							   =							image_processor(video_inputs[0] ,       return_tensors='pt'					).pixel_values
						self.assertEqual(
						    encoded_videos.shape ,       (
						        1,
						        self.image_processor_tester.num_frames,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    ) ,       )

						# Test batched
						lowerCamelCase_							:		Tuple							   =							image_processor(__lowercase ,       return_tensors='pt'					).pixel_values
						self.assertEqual(
						    encoded_videos.shape ,       (
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_frames,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    ) ,       )





					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		str							   =							self.image_processing_class(**self.image_processor_dict					)
						# create random PyTorch tensors
						lowerCamelCase_							:		Union[str, Any]							   =							prepare_video_inputs(self.image_processor_tester ,       equal_resolution=__lowercase ,       torchify=__lowercase					)
						for video in video_inputs:
							self.assertIsInstance(__lowercase ,       __lowercase					)
							self.assertIsInstance(video[0] ,       torch.Tensor					)

						# Test not batched input
						lowerCamelCase_							:		Optional[Any]							   =							image_processor(video_inputs[0] ,       return_tensors='pt'					).pixel_values
						self.assertEqual(
						    encoded_videos.shape ,       (
						        1,
						        self.image_processor_tester.num_frames,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    ) ,       )

						# Test batched
						lowerCamelCase_							:		Tuple							   =							image_processor(__lowercase ,       return_tensors='pt'					).pixel_values
						self.assertEqual(
						    encoded_videos.shape ,       (
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_frames,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    ) ,       )
