






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







   """simple docstring"""







   def __init__( self   ,   _A   ,   _A=7   ,   _A=3   ,   _A=18   ,   _A=30   ,   _A=400   ,   _A=True   ,   _A=None   ,   _A=True   ,   _A=False   ,   _A=[0.48_145_466, 0.4_578_275, 0.40_821_073]   ,   _A=[0.26_862_954, 0.26_130_258, 0.27_577_711]   ,   _A=True   ,   )    ->   Any:
    __a    :	Optional[Any]									=						size if size is not None else {'height': 20, 'width': 20}
    __a    :	List[str]									=						parent
    __a    :	Dict									=						batch_size
    __a    :	Tuple									=						num_channels
    __a    :	str									=						image_size
    __a    :	Optional[Any]									=						min_resolution
    __a    :	int									=						max_resolution
    __a    :	Optional[Any]									=						do_resize
    __a    :	List[Any]									=						size
    __a    :	Optional[int]									=						do_normalize
    __a    :	int									=						image_mean
    __a    :	Tuple									=						image_std
    __a    :	List[Any]									=						do_pad
    __a    :	List[Any]									=						do_convert_rgb



   def    __magic_name__    ( self			)    ->   List[Any]:
    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    __magic_name__    ( self   ,   _A=False   ,   _A=False   ,   _A=False			)    ->   str:
    assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

    if equal_resolution:
     __a    :	str									=						[]
     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:
     __a    :	Union[str, Any]									=						[]
     for i in range(self.batch_size			):
      __a			,    __a    :	Optional[int]									=						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
     __a    :	Union[str, Any]									=						[Image.fromarray(np.moveaxis(_A   ,   0   ,   -1			)			) for x in image_inputs]

    if torchify:
     __a    :	List[str]									=						[torch.from_numpy(_A			) for x in image_inputs]

    return image_inputs




@require_torch
@require_vision
class 							lowerCAmelCase					(							lowerCamelCase__							,      unittest.TestCase   ):







   """simple docstring"""







   _A						=   BlipImageProcessor if is_vision_available() else None



   def    __magic_name__    ( self			)    ->   Tuple:
    __a    :	Tuple									=						BlipImageProcessingTester(self			)



   @property
   def    __magic_name__    ( self			)    ->   int:
    return self.image_processor_tester.prepare_image_processor_dict()



   def    __magic_name__    ( self			)    ->   Union[str, Any]:
    __a    :	List[str]									=						self.image_processing_class(**self.image_processor_dict			)
    self.assertTrue(hasattr(_A   ,   'do_resize'			)			)
    self.assertTrue(hasattr(_A   ,   'size'			)			)
    self.assertTrue(hasattr(_A   ,   'do_normalize'			)			)
    self.assertTrue(hasattr(_A   ,   'image_mean'			)			)
    self.assertTrue(hasattr(_A   ,   'image_std'			)			)
    self.assertTrue(hasattr(_A   ,   'do_convert_rgb'			)			)



   def    __magic_name__    ( self			)    ->   int:
    pass



   def    __magic_name__    ( self			)    ->   Optional[int]:
    # Initialize image_processor
    __a    :	Dict									=						self.image_processing_class(**self.image_processor_dict			)
    # create random PIL images
    __a    :	List[str]									=						self.image_processor_tester.prepare_inputs(equal_resolution=_A			)
    for image in image_inputs:
     self.assertIsInstance(_A   ,   Image.Image			)

    # Test not batched input
    __a    :	Optional[int]									=						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
    __a    :	Optional[int]									=						image_processor(_A   ,   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    __magic_name__    ( self			)    ->   Tuple:
    # Initialize image_processor
    __a    :	Dict									=						self.image_processing_class(**self.image_processor_dict			)
    # create random numpy tensors
    __a    :	List[str]									=						self.image_processor_tester.prepare_inputs(equal_resolution=_A   ,   numpify=_A			)
    for image in image_inputs:
     self.assertIsInstance(_A   ,   np.ndarray			)

    # Test not batched input
    __a    :	int									=						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
    __a    :	Tuple									=						image_processor(_A   ,   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    __magic_name__    ( self			)    ->   Any:
    # Initialize image_processor
    __a    :	Any									=						self.image_processing_class(**self.image_processor_dict			)
    # create random PyTorch tensors
    __a    :	Union[str, Any]									=						self.image_processor_tester.prepare_inputs(equal_resolution=_A   ,   torchify=_A			)
    for image in image_inputs:
     self.assertIsInstance(_A   ,   torch.Tensor			)

    # Test not batched input
    __a    :	Optional[int]									=						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
    __a    :	Optional[Any]									=						image_processor(_A   ,   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 							lowerCAmelCase					(							lowerCamelCase__							,      unittest.TestCase   ):







   """simple docstring"""







   _A						=   BlipImageProcessor if is_vision_available() else None



   def    __magic_name__    ( self			)    ->   Tuple:
    __a    :	Dict									=						BlipImageProcessingTester(self   ,   num_channels=4			)
    __a    :	List[Any]									=						3



   @property
   def    __magic_name__    ( self			)    ->   int:
    return self.image_processor_tester.prepare_image_processor_dict()



   def    __magic_name__    ( self			)    ->   Any:
    __a    :	int									=						self.image_processing_class(**self.image_processor_dict			)
    self.assertTrue(hasattr(_A   ,   'do_resize'			)			)
    self.assertTrue(hasattr(_A   ,   'size'			)			)
    self.assertTrue(hasattr(_A   ,   'do_normalize'			)			)
    self.assertTrue(hasattr(_A   ,   'image_mean'			)			)
    self.assertTrue(hasattr(_A   ,   'image_std'			)			)
    self.assertTrue(hasattr(_A   ,   'do_convert_rgb'			)			)



   def    __magic_name__    ( self			)    ->   List[str]:
    pass



   def    __magic_name__    ( self			)    ->   Optional[int]:
    # Initialize image_processor
    __a    :	Any									=						self.image_processing_class(**self.image_processor_dict			)
    # create random PIL images
    __a    :	List[str]									=						self.image_processor_tester.prepare_inputs(equal_resolution=_A			)
    for image in image_inputs:
     self.assertIsInstance(_A   ,   Image.Image			)

    # Test not batched input
    __a    :	Any									=						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
    __a    :	Union[str, Any]									=						image_processor(_A   ,   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'''


import math
from timeit import timeit






def   lowerCAmelCase__			(					SCREAMING_SNAKE_CASE__		):
 __a    :	Any									=						0
 __a    :	List[Any]									=						abs(SCREAMING_SNAKE_CASE__		)
 while True:
  __a    :	int									=						n // 10
  digits += 1
  if n == 0:
   break
 return digits






def   lowerCAmelCase__			(					SCREAMING_SNAKE_CASE__		):
 return 1 if n == 0 else math.floor(math.log(abs(SCREAMING_SNAKE_CASE__		)       ,		10		) + 1		)






def   lowerCAmelCase__			(					SCREAMING_SNAKE_CASE__		):
 return len(str(abs(SCREAMING_SNAKE_CASE__		)		)		)






def   lowerCAmelCase__			(					):
 from collections.abc import Callable

 def benchmark_a_function(SCREAMING_SNAKE_CASE__       ,		SCREAMING_SNAKE_CASE__		) -> None:
  __a    :	Tuple									=						f'''{func.__name__}({value})'''
  __a    :	List[Any]									=						timeit(f'''__main__.{call}'''       ,		setup='import __main__'		)
  print(f'''{call}: {func(SCREAMING_SNAKE_CASE__		)} -- {timing} seconds'''		)

 for value in (262144, 1125899906842624, 1267650600228229401496703205376):
  for func in (num_digits, num_digits_fast, num_digits_faster):
   benchmark_a_function(SCREAMING_SNAKE_CASE__       ,		SCREAMING_SNAKE_CASE__		)
  print()


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  benchmark()




