



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  _snake_case	(    unittest.TestCase):




				def 							A__					(  self    :  Optional[int]  ):
							lowercase__         = tempfile.mkdtemp()

							# fmt: off
							lowercase__         = ["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "want", "##want", "##ed", "wa", "un", "runn", "##ing", ",", "low", "lowest"]
							# fmt: on
							lowercase__         = 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]  )  )

							lowercase__         = {
							    "image_mean": FLAVA_IMAGE_MEAN,
							    "image_std": FLAVA_IMAGE_STD,
							    "do_normalize": True,
							    "do_resize": True,
							    "size": 224,
							    "do_center_crop": True,
							    "crop_size": 224,
							    "input_size_patches": 14,
							    "total_mask_patches": 75,
							    "mask_group_max_patches": None,
							    "mask_group_min_patches": 16,
							    "mask_group_min_aspect_ratio": 0.3,
							    "mask_group_max_aspect_ratio": None,
							    "codebook_do_resize": True,
							    "codebook_size": 112,
							    "codebook_do_center_crop": True,
							    "codebook_crop_size": 112,
							    "codebook_do_map_pixels": True,
							    "codebook_do_normalize": True,
							    "codebook_image_mean": FLAVA_CODEBOOK_MEAN,
							    "codebook_image_std": FLAVA_CODEBOOK_STD,
							}

							lowercase__         = os.path.join(self.tmpdirname,    __a  )
							with open(self.image_processor_file,    "w",    encoding="utf-8"  ) as fp:
										json.dump(__a,    __a  )




				def 							A__					(  self    :  Optional[Any],    **__lowercase    :  Dict  ):
							return BertTokenizer.from_pretrained(self.tmpdirname,    **__a  )




				def 							A__					(  self    :  str,    **__lowercase    :  Dict  ):
							return BertTokenizerFast.from_pretrained(self.tmpdirname,    **__a  )




				def 							A__					(  self    :  Union[str, Any],    **__lowercase    :  Tuple  ):
							return FlavaImageProcessor.from_pretrained(self.tmpdirname,    **__a  )




				def 							A__					(  self    :  List[Any]  ):
							shutil.rmtree(self.tmpdirname  )




				def 							A__					(  self    :  List[str]  ):
							lowercase__         = [np.random.randint(255,    size=(3, 30, 400),    dtype=np.uinta  )]

							lowercase__         = [Image.fromarray(np.moveaxis(__a,    0,    -1  )  ) for x in image_inputs]

							return image_inputs




				def 							A__					(  self    :  str  ):
							lowercase__         = self.get_tokenizer()
							lowercase__         = self.get_rust_tokenizer()
							lowercase__         = self.get_image_processor()

							lowercase__         = FlavaProcessor(tokenizer=__a,    image_processor=__a  )
							processor_slow.save_pretrained(self.tmpdirname  )
							lowercase__         = FlavaProcessor.from_pretrained(self.tmpdirname,    use_fast=__a  )

							lowercase__         = FlavaProcessor(tokenizer=__a,    image_processor=__a  )
							processor_fast.save_pretrained(self.tmpdirname  )
							lowercase__         = 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,    __a  )
							self.assertIsInstance(processor_fast.tokenizer,    __a  )

							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,    __a  )
							self.assertIsInstance(processor_fast.image_processor,    __a  )




				def 							A__					(  self    :  List[Any]  ):
							lowercase__         = FlavaProcessor(tokenizer=self.get_tokenizer(),    image_processor=self.get_image_processor()  )
							processor.save_pretrained(self.tmpdirname  )

							lowercase__         = self.get_tokenizer(bos_token="(BOS)",    eos_token="(EOS)"  )
							lowercase__         = self.get_image_processor(do_normalize=__a,    padding_value=1.0  )

							lowercase__         = FlavaProcessor.from_pretrained(
							    self.tmpdirname,    bos_token="(BOS)",    eos_token="(EOS)",    do_normalize=__a,    padding_value=1.0  )

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

							self.assertEqual(processor.image_processor.to_json_string(),    image_processor_add_kwargs.to_json_string()  )
							self.assertIsInstance(processor.image_processor,    __a  )




				def 							A__					(  self    :  Tuple  ):
							lowercase__         = self.get_image_processor()
							lowercase__         = self.get_tokenizer()

							lowercase__         = FlavaProcessor(tokenizer=__a,    image_processor=__a  )

							lowercase__         = self.prepare_image_inputs()

							lowercase__         = image_processor(__a,    return_tensors="np"  )
							lowercase__         = processor(images=__a,    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(1234  )
							lowercase__         = image_processor(
							    __a,    return_image_mask=__a,    return_codebook_pixels=__a,    return_tensors="np"  )
							random.seed(1234  )
							lowercase__         = processor(
							    images=__a,    return_image_mask=__a,    return_codebook_pixels=__a,    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    :  int  ):
							lowercase__         = self.get_image_processor()
							lowercase__         = self.get_tokenizer()

							lowercase__         = FlavaProcessor(tokenizer=__a,    image_processor=__a  )

							lowercase__         = "lower newer"

							lowercase__         = processor(text=__a  )

							lowercase__         = tokenizer(__a  )

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




				def 							A__					(  self    :  Optional[int]  ):
							lowercase__         = self.get_image_processor()
							lowercase__         = self.get_tokenizer()

							lowercase__         = FlavaProcessor(tokenizer=__a,    image_processor=__a  )

							lowercase__         = "lower newer"
							lowercase__         = self.prepare_image_inputs()

							lowercase__         = processor(text=__a,    images=__a  )

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

							# add extra args
							lowercase__         = processor(text=__a,    images=__a,    return_codebook_pixels=__a,    return_image_mask=__a  )

							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(__a  ):
										processor()




				def 							A__					(  self    :  List[str]  ):
							lowercase__         = self.get_image_processor()
							lowercase__         = self.get_tokenizer()

							lowercase__         = FlavaProcessor(tokenizer=__a,    image_processor=__a  )

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

							lowercase__         = processor.batch_decode(__a  )
							lowercase__         = tokenizer.batch_decode(__a  )

							self.assertListEqual(__a,    __a  )




				def 							A__					(  self    :  List[Any]  ):
							lowercase__         = self.get_image_processor()
							lowercase__         = self.get_tokenizer()

							lowercase__         = FlavaProcessor(tokenizer=__a,    image_processor=__a  )

							lowercase__         = "lower newer"
							lowercase__         = self.prepare_image_inputs()

							lowercase__         = processor(text=__a,    images=__a  )

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











"""simple docstring"""


from __future__ import annotations




def     lowercase__			(    lowercase_						,lowercase_						,lowercase_	)    ->						int:




      """simple docstring"""

      assert n > 1 and a > 0 and greatest_common_divisor(lowercase_						,lowercase_	) == 1
      ((_UpperCamelCase),     (_UpperCamelCase),     (_UpperCamelCase))					:		int  =				extended_gcd(lowercase_						,lowercase_	)  # Implemented below
      _UpperCamelCase					:		Any  =				(b * s) % n
      return x




def     lowercase__			(    lowercase_						,lowercase_	)    ->						int:




      """simple docstring"""

      ((_UpperCamelCase),     (_UpperCamelCase))					:		List[Any]  =				extended_euclid(lowercase_						,lowercase_	)  # Implemented below
      if b < 0:
            _UpperCamelCase					:		Any  =				(b % n + n) % n
      return b




def     lowercase__			(    lowercase_						,lowercase_						,lowercase_	)    ->						int:




      """simple docstring"""

      _UpperCamelCase					:		Union[str, Any]  =				invert_modulo(lowercase_						,lowercase_	)
      _UpperCamelCase					:		Any  =				(b * s) % n
      return x




def     lowercase__			(    lowercase_						,lowercase_	)    ->						tuple[int, int, int]:




      """simple docstring"""

      assert a >= 0 and b >= 0

      if b == 0:
            _UpperCamelCase,     _UpperCamelCase,     _UpperCamelCase					:		str  =				a, 1, 0
      else:
            ((_UpperCamelCase),     (_UpperCamelCase),     (_UpperCamelCase))					:		str  =				extended_gcd(lowercase_						,a % b	)
            _UpperCamelCase					:		Dict  =				q
            _UpperCamelCase					:		Tuple  =				p - q * (a // b)

      assert a % d == 0 and b % d == 0
      assert d == a * x + b * y

      return (d, x, y)




def     lowercase__			(    lowercase_						,lowercase_	)    ->						tuple[int, int]:




      """simple docstring"""

      if b == 0:
            return (1, 0)
      ((_UpperCamelCase),     (_UpperCamelCase))					:		Optional[Any]  =				extended_euclid(lowercase_						,a % b	)
      _UpperCamelCase					:		Dict  =				a // b
      return (y, x - k * y)




def     lowercase__			(    lowercase_						,lowercase_	)    ->						int:




      """simple docstring"""

      if a < b:
            _UpperCamelCase,     _UpperCamelCase					:		List[Any]  =				b, a

      while a % b != 0:
            _UpperCamelCase,     _UpperCamelCase					:		List[Any]  =				b, a % b

      return b


if __name__ == "__main__":
  from doctest import testmod

  testmod(name="modular_division", verbose=True)
  testmod(name="modular_division2", verbose=True)
  testmod(name="invert_modulo", verbose=True)
  testmod(name="extended_gcd", verbose=True)
  testmod(name="extended_euclid", verbose=True)
  testmod(name="greatest_common_divisor", verbose=True)
