




'''simple docstring'''
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 BlipImageProcessor






class 			SCREAMING_SNAKE_CASE(							unittest.TestCase	):

       def __init__(       self   ,						lowerCamelCase__   ,						lowerCamelCase__=7   ,						lowerCamelCase__=3   ,						lowerCamelCase__=18   ,						lowerCamelCase__=30   ,						lowerCamelCase__=400   ,						lowerCamelCase__=True   ,						lowerCamelCase__=None   ,						lowerCamelCase__=True   ,						lowerCamelCase__=False   ,						lowerCamelCase__=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]   ,						lowerCamelCase__=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]   ,						lowerCamelCase__=True   ,						)       ->   int:

           """simple docstring"""



           __lowercase     							=		size if size is not None else {"""height""": 20, """width""": 20}
           __lowercase     							=		parent
           __lowercase     							=		batch_size
           __lowercase     							=		num_channels
           __lowercase     							=		image_size
           __lowercase     							=		min_resolution
           __lowercase     							=		max_resolution
           __lowercase     							=		do_resize
           __lowercase     							=		size
           __lowercase     							=		do_normalize
           __lowercase     							=		image_mean
           __lowercase     							=		image_std
           __lowercase     							=		do_pad
           __lowercase     							=		do_convert_rgb

       def        snake_case__     (       self	)       ->   Union[str, Any]:

           """simple docstring"""



           return {
               "do_resize": self.do_resize,
               "size": self.size,
               "do_normalize": self.do_normalize,
               "image_mean": self.image_mean,
               "image_std": self.image_std,
               "do_convert_rgb": self.do_convert_rgb,
               "do_pad": self.do_pad,
           }




       def        snake_case__     (       self   ,						lowerCamelCase__=False   ,						lowerCamelCase__=False   ,						lowerCamelCase__=False	)       ->   str:

           """simple docstring"""



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

           if equal_resolution:
               __lowercase     							=		[]
               for i in range(self.batch_size	):
                   image_inputs.append(
                       np.random.randint(
                           255   ,						size=(self.num_channels, self.max_resolution, self.max_resolution)   ,						dtype=np.uinta	)	)
           else:
               __lowercase     							=		[]
               for i in range(self.batch_size	):
                   __lowercase							,__lowercase     							=		np.random.choice(np.arange(self.min_resolution   ,						self.max_resolution	)   ,						2	)
                   image_inputs.append(np.random.randint(255   ,						size=(self.num_channels, width, height)   ,						dtype=np.uinta	)	)

           if not numpify and not torchify:
               # PIL expects the channel dimension as last dimension
               __lowercase     							=		[Image.fromarray(np.moveaxis(lowerCamelCase__   ,						0   ,						-1	)	) for x in image_inputs]

           if torchify:
               __lowercase     							=		[torch.from_numpy(lowerCamelCase__	) for x in image_inputs]

           return image_inputs






@require_torch
@require_vision
class 			SCREAMING_SNAKE_CASE(							__A  , unittest.TestCase	):
       snake_case_					:	Union[str, Any]       =   BlipImageProcessor if is_vision_available() else None

       def        snake_case__     (       self	)       ->   Union[str, Any]:

           """simple docstring"""



           __lowercase     							=		BlipImageProcessingTester(self	)

       @property
       def        snake_case__     (       self	)       ->   Union[str, Any]:

           """simple docstring"""



           return self.image_processor_tester.prepare_image_processor_dict()

       def        snake_case__     (       self	)       ->   Dict:

           """simple docstring"""



           __lowercase     							=		self.image_processing_class(**self.image_processor_dict	)
           self.assertTrue(hasattr(lowerCamelCase__   ,						"""do_resize"""	)	)
           self.assertTrue(hasattr(lowerCamelCase__   ,						"""size"""	)	)
           self.assertTrue(hasattr(lowerCamelCase__   ,						"""do_normalize"""	)	)
           self.assertTrue(hasattr(lowerCamelCase__   ,						"""image_mean"""	)	)
           self.assertTrue(hasattr(lowerCamelCase__   ,						"""image_std"""	)	)
           self.assertTrue(hasattr(lowerCamelCase__   ,						"""do_convert_rgb"""	)	)

       def        snake_case__     (       self	)       ->   Union[str, Any]:

           """simple docstring"""



           pass

       def        snake_case__     (       self	)       ->   Union[str, Any]:

           """simple docstring"""



           __lowercase     							=		self.image_processing_class(**self.image_processor_dict	)
           # create random PIL images
           __lowercase     							=		self.image_processor_tester.prepare_inputs(equal_resolution=lowerCamelCase__	)
           for image in image_inputs:
               self.assertIsInstance(lowerCamelCase__   ,						Image.Image	)

           # Test not batched input
           __lowercase     							=		image_processor(image_inputs[0]   ,						return_tensors="""pt"""	).pixel_values
           self.assertEqual(
               encoded_images.shape   ,						(
                   1,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )   ,						)

           # Test batched
           __lowercase     							=		image_processor(lowerCamelCase__   ,						return_tensors="""pt"""	).pixel_values
           self.assertEqual(
               encoded_images.shape   ,						(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )   ,						)

       def        snake_case__     (       self	)       ->   List[str]:

           """simple docstring"""



           __lowercase     							=		self.image_processing_class(**self.image_processor_dict	)
           # create random numpy tensors
           __lowercase     							=		self.image_processor_tester.prepare_inputs(equal_resolution=lowerCamelCase__   ,						numpify=lowerCamelCase__	)
           for image in image_inputs:
               self.assertIsInstance(lowerCamelCase__   ,						np.ndarray	)

           # Test not batched input
           __lowercase     							=		image_processor(image_inputs[0]   ,						return_tensors="""pt"""	).pixel_values
           self.assertEqual(
               encoded_images.shape   ,						(
                   1,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )   ,						)

           # Test batched
           __lowercase     							=		image_processor(lowerCamelCase__   ,						return_tensors="""pt"""	).pixel_values
           self.assertEqual(
               encoded_images.shape   ,						(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )   ,						)




       def        snake_case__     (       self	)       ->   Tuple:

           """simple docstring"""



           __lowercase     							=		self.image_processing_class(**self.image_processor_dict	)
           # create random PyTorch tensors
           __lowercase     							=		self.image_processor_tester.prepare_inputs(equal_resolution=lowerCamelCase__   ,						torchify=lowerCamelCase__	)
           for image in image_inputs:
               self.assertIsInstance(lowerCamelCase__   ,						torch.Tensor	)

           # Test not batched input
           __lowercase     							=		image_processor(image_inputs[0]   ,						return_tensors="""pt"""	).pixel_values
           self.assertEqual(
               encoded_images.shape   ,						(
                   1,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )   ,						)

           # Test batched
           __lowercase     							=		image_processor(lowerCamelCase__   ,						return_tensors="""pt"""	).pixel_values
           self.assertEqual(
               encoded_images.shape   ,						(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )   ,						)






@require_torch
@require_vision
class 			SCREAMING_SNAKE_CASE(							__A  , unittest.TestCase	):
       snake_case_					:	List[str]       =   BlipImageProcessor if is_vision_available() else None

       def        snake_case__     (       self	)       ->   List[str]:

           """simple docstring"""



           __lowercase     							=		BlipImageProcessingTester(self   ,						num_channels=4	)
           __lowercase     							=		3

       @property
       def        snake_case__     (       self	)       ->   Optional[int]:

           """simple docstring"""



           return self.image_processor_tester.prepare_image_processor_dict()

       def        snake_case__     (       self	)       ->   Dict:

           """simple docstring"""



           __lowercase     							=		self.image_processing_class(**self.image_processor_dict	)
           self.assertTrue(hasattr(lowerCamelCase__   ,						"""do_resize"""	)	)
           self.assertTrue(hasattr(lowerCamelCase__   ,						"""size"""	)	)
           self.assertTrue(hasattr(lowerCamelCase__   ,						"""do_normalize"""	)	)
           self.assertTrue(hasattr(lowerCamelCase__   ,						"""image_mean"""	)	)
           self.assertTrue(hasattr(lowerCamelCase__   ,						"""image_std"""	)	)
           self.assertTrue(hasattr(lowerCamelCase__   ,						"""do_convert_rgb"""	)	)

       def        snake_case__     (       self	)       ->   int:

           """simple docstring"""



           pass




       def        snake_case__     (       self	)       ->   List[Any]:

           """simple docstring"""



           __lowercase     							=		self.image_processing_class(**self.image_processor_dict	)
           # create random PIL images
           __lowercase     							=		self.image_processor_tester.prepare_inputs(equal_resolution=lowerCamelCase__	)
           for image in image_inputs:
               self.assertIsInstance(lowerCamelCase__   ,						Image.Image	)

           # Test not batched input
           __lowercase     							=		image_processor(image_inputs[0]   ,						return_tensors="""pt"""	).pixel_values
           self.assertEqual(
               encoded_images.shape   ,						(
                   1,
                   self.expected_encoded_image_num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )   ,						)

           # Test batched
           __lowercase     							=		image_processor(lowerCamelCase__   ,						return_tensors="""pt"""	).pixel_values
           self.assertEqual(
               encoded_images.shape   ,						(
                   self.image_processor_tester.batch_size,
                   self.expected_encoded_image_num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )   ,						)










'''simple docstring'''
from math import gcd
def 							snake_case_    (  a__						:      int = 1_20_00     ):



    """simple docstring"""




    __lowercase     							=		0
    for d in range(max_d + 1     ):
        for n in range(d // 3 + 1       ,(d + 1) // 2     ):
            if gcd(a__       ,a__     ) == 1:
                fractions_number += 1
    return fractions_number


if __name__ == "__main__":
  print(F"""{solution() = }""")




