





"""simple docstring"""



import random
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, prepare_image_inputs


if is_torch_available():
       import torch

if is_vision_available():
       import PIL

       from transformers import FlavaImageProcessor
       from transformers.image_utils import PILImageResampling
       from transformers.models.flava.image_processing_flava import (
           FLAVA_CODEBOOK_MEAN,
           FLAVA_CODEBOOK_STD,
           FLAVA_IMAGE_MEAN,
           FLAVA_IMAGE_STD,
       )
else:
       a_				=		a_				=		a_				=		a_				=		None






class 	__snake_case      (	unittest.TestCase  ):





 """simple docstring"""


 def __init__(					self      ,		__lowerCamelCase      ,		__lowerCamelCase=7      ,		__lowerCamelCase=3      ,		__lowerCamelCase=30      ,		__lowerCamelCase=400      ,		__lowerCamelCase=True      ,		__lowerCamelCase=None      ,		__lowerCamelCase=True      ,		__lowerCamelCase=None      ,		__lowerCamelCase=None      ,		__lowerCamelCase=True      ,		__lowerCamelCase=1 / 255      ,		__lowerCamelCase=True      ,		__lowerCamelCase=FLAVA_IMAGE_MEAN      ,		__lowerCamelCase=FLAVA_IMAGE_STD      ,		__lowerCamelCase=14      ,		__lowerCamelCase=75      ,		__lowerCamelCase=None      ,		__lowerCamelCase=16      ,		__lowerCamelCase=0.3      ,		__lowerCamelCase=None      ,		__lowerCamelCase=True      ,		__lowerCamelCase=None      ,		__lowerCamelCase=None      ,		__lowerCamelCase=True      ,		__lowerCamelCase=None      ,		__lowerCamelCase=True      ,		__lowerCamelCase=True      ,		__lowerCamelCase=FLAVA_CODEBOOK_MEAN      ,		__lowerCamelCase=FLAVA_CODEBOOK_STD      ,		):



     '''simple docstring'''




     __A					:		Tuple						=  size if size is not None else {'''height''': 224, '''width''': 224}
     __A					:		Any						=  crop_size if crop_size is not None else {'''height''': 224, '''width''': 224}
     __A					:		Dict						=  codebook_size if codebook_size is not None else {'''height''': 112, '''width''': 112}
     __A					:		Tuple						=  codebook_crop_size if codebook_crop_size is not None else {'''height''': 112, '''width''': 112}

     __A					:		Any						=  parent
     __A					:		Tuple						=  batch_size
     __A					:		int						=  num_channels
     __A					:		Union[str, Any]						=  do_resize
     __A					:		str						=  do_rescale
     __A					:		Any						=  rescale_factor
     __A					:		Tuple						=  min_resolution
     __A					:		str						=  max_resolution
     __A					:		List[Any]						=  size
     __A					:		Optional[Any]						=  resample if resample is not None else PILImageResampling.BICUBIC
     __A					:		Optional[int]						=  do_normalize
     __A					:		Optional[Any]						=  image_mean
     __A					:		int						=  image_std
     __A					:		Dict						=  do_center_crop
     __A					:		List[Any]						=  crop_size

     __A					:		Any						=  input_size_patches
     __A					:		Dict						=  total_mask_patches
     __A					:		Optional[int]						=  mask_group_max_patches
     __A					:		Optional[Any]						=  mask_group_min_patches
     __A					:		List[str]						=  mask_group_min_aspect_ratio
     __A					:		Tuple						=  mask_group_max_aspect_ratio

     __A					:		int						=  codebook_do_resize
     __A					:		List[str]						=  codebook_size
     __A					:		int						=  codebook_resample if codebook_resample is not None else PILImageResampling.LANCZOS
     __A					:		Dict						=  codebook_do_center_crop
     __A					:		List[str]						=  codebook_crop_size
     __A					:		Dict						=  codebook_do_map_pixels
     __A					:		Any						=  codebook_do_normalize
     __A					:		Union[str, Any]						=  codebook_image_mean
     __A					:		List[Any]						=  codebook_image_std

 def       UpperCamelCase__(					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,
         "resample": self.resample,
         "do_rescale": self.do_rescale,
         "rescale_factor": self.rescale_factor,
         "do_center_crop": self.do_center_crop,
         "crop_size": self.crop_size,
         "input_size_patches": self.input_size_patches,
         "total_mask_patches": self.total_mask_patches,
         "mask_group_max_patches": self.mask_group_max_patches,
         "mask_group_min_patches": self.mask_group_min_patches,
         "mask_group_min_aspect_ratio": self.mask_group_min_aspect_ratio,
         "mask_group_max_aspect_ratio": self.mask_group_min_aspect_ratio,
         "codebook_do_resize": self.codebook_do_resize,
         "codebook_size": self.codebook_size,
         "codebook_resample": self.codebook_resample,
         "codebook_do_center_crop": self.codebook_do_center_crop,
         "codebook_crop_size": self.codebook_crop_size,
         "codebook_do_map_pixels": self.codebook_do_map_pixels,
         "codebook_do_normalize": self.codebook_do_normalize,
         "codebook_image_mean": self.codebook_image_mean,
         "codebook_image_std": self.codebook_image_std,
     }

 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     return (self.size["height"], self.size["width"])

 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     return (
         (self.input_size_patches, self.input_size_patches)
         if not isinstance(self.input_size_patches      ,		__lowerCamelCase						)
         else self.input_size_patches
     )







 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     return (self.codebook_size["height"], self.codebook_size["width"])






@require_torch
@require_vision
class 	__snake_case      (	A_							,							unittest.TestCase  ):





 """simple docstring"""


 _lowerCamelCase				 =  FlavaImageProcessor if is_vision_available() else None
 _lowerCamelCase				 =  None

 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     __A					:		Tuple						=  FlavaImageProcessingTester(self						)

 @property
 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     return self.image_processor_tester.prepare_image_processor_dict()

 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     __A					:		Tuple						=  self.image_processing_class(**self.image_processor_dict						)
     self.assertTrue(hasattr(__lowerCamelCase      ,		'''image_mean'''						)						)
     self.assertTrue(hasattr(__lowerCamelCase      ,		'''image_std'''						)						)
     self.assertTrue(hasattr(__lowerCamelCase      ,		'''do_normalize'''						)						)
     self.assertTrue(hasattr(__lowerCamelCase      ,		'''do_resize'''						)						)
     self.assertTrue(hasattr(__lowerCamelCase      ,		'''resample'''						)						)
     self.assertTrue(hasattr(__lowerCamelCase      ,		'''crop_size'''						)						)
     self.assertTrue(hasattr(__lowerCamelCase      ,		'''do_center_crop'''						)						)
     self.assertTrue(hasattr(__lowerCamelCase      ,		'''do_rescale'''						)						)
     self.assertTrue(hasattr(__lowerCamelCase      ,		'''rescale_factor'''						)						)
     self.assertTrue(hasattr(__lowerCamelCase      ,		'''masking_generator'''						)						)
     self.assertTrue(hasattr(__lowerCamelCase      ,		'''codebook_do_resize'''						)						)
     self.assertTrue(hasattr(__lowerCamelCase      ,		'''codebook_size'''						)						)
     self.assertTrue(hasattr(__lowerCamelCase      ,		'''codebook_resample'''						)						)
     self.assertTrue(hasattr(__lowerCamelCase      ,		'''codebook_do_center_crop'''						)						)
     self.assertTrue(hasattr(__lowerCamelCase      ,		'''codebook_crop_size'''						)						)
     self.assertTrue(hasattr(__lowerCamelCase      ,		'''codebook_do_map_pixels'''						)						)
     self.assertTrue(hasattr(__lowerCamelCase      ,		'''codebook_do_normalize'''						)						)
     self.assertTrue(hasattr(__lowerCamelCase      ,		'''codebook_image_mean'''						)						)
     self.assertTrue(hasattr(__lowerCamelCase      ,		'''codebook_image_std'''						)						)

 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     __A					:		int						=  self.image_processing_class.from_dict(self.image_processor_dict						)
     self.assertEqual(image_processor.size      ,		{'''height''': 224, '''width''': 224}						)
     self.assertEqual(image_processor.crop_size      ,		{'''height''': 224, '''width''': 224}						)
     self.assertEqual(image_processor.codebook_size      ,		{'''height''': 112, '''width''': 112}						)
     self.assertEqual(image_processor.codebook_crop_size      ,		{'''height''': 112, '''width''': 112}						)

     __A					:		List[str]						=  self.image_processing_class.from_dict(
         self.image_processor_dict      ,		size=42      ,		crop_size=84      ,		codebook_size=33      ,		codebook_crop_size=66						)
     self.assertEqual(image_processor.size      ,		{'''height''': 42, '''width''': 42}						)
     self.assertEqual(image_processor.crop_size      ,		{'''height''': 84, '''width''': 84}						)
     self.assertEqual(image_processor.codebook_size      ,		{'''height''': 33, '''width''': 33}						)
     self.assertEqual(image_processor.codebook_crop_size      ,		{'''height''': 66, '''width''': 66}						)

 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     pass

 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     __A					:		str						=  self.image_processing_class(**self.image_processor_dict						)
     # create random PIL images
     __A					:		Optional[int]						=  prepare_image_inputs(self.image_processor_tester      ,		equal_resolution=__lowerCamelCase						)
     for image in image_inputs:
         self.assertIsInstance(__lowerCamelCase      ,		PIL.Image.Image						)

     # Test not batched input
     __A					:		int						=  image_processing(image_inputs[0]      ,		return_tensors='''pt'''						)

     # Test no bool masked pos
     self.assertFalse('''bool_masked_pos''' in encoded_images						)

     __A					:		int						=  self.image_processor_tester.get_expected_image_size()

     self.assertEqual(
         encoded_images.pixel_values.shape      ,		(1, self.image_processor_tester.num_channels, expected_height, expected_width)      ,		)

     # Test batched
     __A					:		str						=  image_processing(__lowerCamelCase      ,		return_tensors='''pt'''						)
     __A					:		int						=  self.image_processor_tester.get_expected_image_size()

     # Test no bool masked pos
     self.assertFalse('''bool_masked_pos''' in encoded_images						)

     self.assertEqual(
         encoded_images.pixel_values.shape      ,		(
             self.image_processor_tester.batch_size,
             self.image_processor_tester.num_channels,
             expected_height,
             expected_width,
         )      ,		)

 def       UpperCamelCase__(					self      ,		__lowerCamelCase      ,		__lowerCamelCase						):



     '''simple docstring'''




     __A					:		List[Any]						=  self.image_processing_class(**self.image_processor_dict						)
     # create random tensors
     __A					:		int						=  prepare_image_inputs(self.image_processor_tester      ,		equal_resolution=__lowerCamelCase      ,		**__lowerCamelCase						)
     for image in image_inputs:
         self.assertIsInstance(__lowerCamelCase      ,		__lowerCamelCase						)

     # Test not batched input
     __A					:		Dict						=  image_processing(image_inputs[0]      ,		return_tensors='''pt'''						)

     __A					:		Optional[int]						=  self.image_processor_tester.get_expected_image_size()
     self.assertEqual(
         encoded_images.pixel_values.shape      ,		(1, self.image_processor_tester.num_channels, expected_height, expected_width)      ,		)

     __A					:		List[Any]						=  image_processing(__lowerCamelCase      ,		return_image_mask=__lowerCamelCase      ,		return_tensors='''pt'''						)

     __A					:		List[str]						=  self.image_processor_tester.get_expected_image_size()
     self.assertEqual(
         encoded_images.pixel_values.shape      ,		(
             self.image_processor_tester.batch_size,
             self.image_processor_tester.num_channels,
             expected_height,
             expected_width,
         )      ,		)

     __A					:		Tuple						=  self.image_processor_tester.get_expected_mask_size()
     self.assertEqual(
         encoded_images.bool_masked_pos.shape      ,		(
             self.image_processor_tester.batch_size,
             expected_height,
             expected_width,
         )      ,		)

     # Test batched
     __A					:		Union[str, Any]						=  image_processing(__lowerCamelCase      ,		return_tensors='''pt'''						).pixel_values

     __A					:		Optional[int]						=  self.image_processor_tester.get_expected_image_size()
     self.assertEqual(
         encoded_images.shape      ,		(
             self.image_processor_tester.batch_size,
             self.image_processor_tester.num_channels,
             expected_height,
             expected_width,
         )      ,		)

     # Test masking
     __A					:		Any						=  image_processing(__lowerCamelCase      ,		return_image_mask=__lowerCamelCase      ,		return_tensors='''pt'''						)

     __A					:		Any						=  self.image_processor_tester.get_expected_image_size()
     self.assertEqual(
         encoded_images.pixel_values.shape      ,		(
             self.image_processor_tester.batch_size,
             self.image_processor_tester.num_channels,
             expected_height,
             expected_width,
         )      ,		)

     __A					:		int						=  self.image_processor_tester.get_expected_mask_size()
     self.assertEqual(
         encoded_images.bool_masked_pos.shape      ,		(
             self.image_processor_tester.batch_size,
             expected_height,
             expected_width,
         )      ,		)

 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     self._test_call_framework(np.ndarray      ,		prepare_kwargs={'''numpify''': True}						)

 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     self._test_call_framework(torch.Tensor      ,		prepare_kwargs={'''torchify''': True}						)

 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     random.seed(1234						)
     __A					:		Union[str, Any]						=  self.image_processing_class(**self.image_processor_dict						)
     __A					:		Union[str, Any]						=  prepare_image_inputs(self.image_processor_tester      ,		equal_resolution=__lowerCamelCase      ,		torchify=__lowerCamelCase						)

     # Test not batched input
     __A					:		Union[str, Any]						=  image_processing(image_inputs[0]      ,		return_image_mask=__lowerCamelCase      ,		return_tensors='''pt'''						)
     self.assertEqual(encoded_images.bool_masked_pos.sum().item()      ,		75						)







 def       UpperCamelCase__(					self						):



     '''simple docstring'''




     __A					:		Optional[Any]						=  self.image_processing_class(**self.image_processor_dict						)
     # create random PIL images
     __A					:		Tuple						=  prepare_image_inputs(self.image_processor_tester      ,		equal_resolution=__lowerCamelCase						)
     for image in image_inputs:
         self.assertIsInstance(__lowerCamelCase      ,		PIL.Image.Image						)

     # Test not batched input
     __A					:		Union[str, Any]						=  image_processing(image_inputs[0]      ,		return_codebook_pixels=__lowerCamelCase      ,		return_tensors='''pt'''						)
     __A					:		List[Any]						=  self.image_processor_tester.get_expected_codebook_image_size()
     self.assertEqual(
         encoded_images.codebook_pixel_values.shape      ,		(1, self.image_processor_tester.num_channels, expected_height, expected_width)      ,		)

     # Test batched
     __A					:		List[str]						=  image_processing(__lowerCamelCase      ,		return_codebook_pixels=__lowerCamelCase      ,		return_tensors='''pt'''						)
     __A					:		Any						=  self.image_processor_tester.get_expected_codebook_image_size()
     self.assertEqual(
         encoded_images.codebook_pixel_values.shape      ,		(
             self.image_processor_tester.batch_size,
             self.image_processor_tester.num_channels,
             expected_height,
             expected_width,
         )      ,		)











"""simple docstring"""



from __future__ import annotations

import sys







def 	__lowercase  (     snake_case_						:						int       ,snake_case_						:						int		)     ->tuple[int, int]:



    '''simple docstring'''







    if abs(snake_case_		) == 1:
        return a, 0
    elif abs(snake_case_		) == 1:
        return 0, b

    __A				, __A					:		int						=  a, b
    __A				, __A					:		Any						=  1, 0
    __A				, __A					:		int						=  0, 1

    while remainder != 0:
        __A					:		List[Any]						=  old_remainder // remainder
        __A				, __A					:		int						=  remainder, old_remainder - quotient * remainder
        __A				, __A					:		List[Any]						=  coeff_a, old_coeff_a - quotient * coeff_a
        __A				, __A					:		Union[str, Any]						=  coeff_b, old_coeff_b - quotient * coeff_b

    # sign correction for negative numbers
    if a < 0:
        __A					:		Optional[Any]						=  -old_coeff_a
    if b < 0:
        __A					:		List[Any]						=  -old_coeff_b

    return old_coeff_a, old_coeff_b







def 	__lowercase  (     )     ->List[str]:



    '''simple docstring'''







    if len(sys.argv		) < 3:
        print('''2 integer arguments required'''		)
        return 1
    __A					:		Optional[int]						=  int(sys.argv[1]		)
    __A					:		Tuple						=  int(sys.argv[2]		)
    print(extended_euclidean_algorithm(snake_case_       ,snake_case_		)		)
    return 0


if __name__ == "__main__":
       raise SystemExit(main())




