'''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 ChineseCLIPImageProcessor


class     __UpperCAmelCase       ( unittest.TestCase		):





  def __init__(	self    ,     _lowerCamelCase    ,     _lowerCamelCase=7    ,     _lowerCamelCase=3    ,     _lowerCamelCase=18    ,     _lowerCamelCase=30    ,     _lowerCamelCase=400    ,     _lowerCamelCase=True    ,     _lowerCamelCase=None    ,     _lowerCamelCase=True    ,     _lowerCamelCase=None    ,     _lowerCamelCase=True    ,     _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    ,     ):
     lowerCAmelCase_			=      size if size is not None else {'''height''': 224, '''width''': 224}
     lowerCAmelCase_			=      crop_size if crop_size is not None else {'''height''': 18, '''width''': 18}
     lowerCAmelCase_			=      parent
     lowerCAmelCase_			=      batch_size
     lowerCAmelCase_			=      num_channels
     lowerCAmelCase_			=      image_size
     lowerCAmelCase_			=      min_resolution
     lowerCAmelCase_			=      max_resolution
     lowerCAmelCase_			=      do_resize
     lowerCAmelCase_			=      size
     lowerCAmelCase_			=      do_center_crop
     lowerCAmelCase_			=      crop_size
     lowerCAmelCase_			=      do_normalize
     lowerCAmelCase_			=      image_mean
     lowerCAmelCase_			=      image_std
     lowerCAmelCase_			=      do_convert_rgb





  def 						UpperCAmelCase_	(	self ):
     return {
         "do_resize": self.do_resize,
         "size": self.size,
         "do_center_crop": self.do_center_crop,
         "crop_size": self.crop_size,
         "do_normalize": self.do_normalize,
         "image_mean": self.image_mean,
         "image_std": self.image_std,
         "do_convert_rgb": self.do_convert_rgb,
     }







  def 						UpperCAmelCase_	(	self    ,     _lowerCamelCase=False    ,     _lowerCamelCase=False    ,     _lowerCamelCase=False ):
     assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

     if equal_resolution:
        lowerCAmelCase_			=      []
        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:
        lowerCAmelCase_			=      []
        for i in range(self.batch_size ):
           lowerCAmelCase_	,lowerCAmelCase_			=      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
        lowerCAmelCase_			=      [Image.fromarray(np.moveaxis(_lowerCamelCase    ,     0    ,     -1 ) ) for x in image_inputs]

     if torchify:
        lowerCAmelCase_			=      [torch.from_numpy(_lowerCamelCase ) for x in image_inputs]

     return image_inputs






@require_torch
@require_vision
class     __UpperCAmelCase       ( __a						,       unittest.TestCase		):
  __A :				Union[str, Any]											= ChineseCLIPImageProcessor if is_vision_available() else None





  def 						UpperCAmelCase_	(	self ):
     lowerCAmelCase_			=      ChineseCLIPImageProcessingTester(self    ,     do_center_crop=_lowerCamelCase )





  @property
  def 						UpperCAmelCase_	(	self ):
     return self.image_processor_tester.prepare_image_processor_dict()





  def 						UpperCAmelCase_	(	self ):
     lowerCAmelCase_			=      self.image_processing_class(**self.image_processor_dict )
     self.assertTrue(hasattr(_lowerCamelCase    ,     '''do_resize''' ) )
     self.assertTrue(hasattr(_lowerCamelCase    ,     '''size''' ) )
     self.assertTrue(hasattr(_lowerCamelCase    ,     '''do_center_crop''' ) )
     self.assertTrue(hasattr(_lowerCamelCase    ,     '''center_crop''' ) )
     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 						UpperCAmelCase_	(	self ):
     lowerCAmelCase_			=      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''': 18, '''width''': 18} )

     lowerCAmelCase_			=      self.image_processing_class.from_dict(self.image_processor_dict    ,     size=42    ,     crop_size=84 )
     self.assertEqual(image_processor.size    ,     {'''shortest_edge''': 42} )
     self.assertEqual(image_processor.crop_size    ,     {'''height''': 84, '''width''': 84} )





  def 						UpperCAmelCase_	(	self ):
     pass





  def 						UpperCAmelCase_	(	self ):
     # Initialize image_processing
     lowerCAmelCase_			=      self.image_processing_class(**self.image_processor_dict )
     # create random PIL images
     lowerCAmelCase_			=      self.image_processor_tester.prepare_inputs(equal_resolution=_lowerCamelCase )
     for image in image_inputs:
        self.assertIsInstance(_lowerCamelCase    ,     Image.Image )

     # Test not batched input
     lowerCAmelCase_			=      image_processing(image_inputs[0]    ,     return_tensors='''pt''' ).pixel_values
     self.assertEqual(
         encoded_images.shape    ,     (
             1,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.crop_size['''height'''],
             self.image_processor_tester.crop_size['''width'''],
         )    ,     )

     # Test batched
     lowerCAmelCase_			=      image_processing(_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.crop_size['''height'''],
             self.image_processor_tester.crop_size['''width'''],
         )    ,     )





  def 						UpperCAmelCase_	(	self ):
     # Initialize image_processing
     lowerCAmelCase_			=      self.image_processing_class(**self.image_processor_dict )
     # create random numpy tensors
     lowerCAmelCase_			=      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
     lowerCAmelCase_			=      image_processing(image_inputs[0]    ,     return_tensors='''pt''' ).pixel_values
     self.assertEqual(
         encoded_images.shape    ,     (
             1,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.crop_size['''height'''],
             self.image_processor_tester.crop_size['''width'''],
         )    ,     )

     # Test batched
     lowerCAmelCase_			=      image_processing(_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.crop_size['''height'''],
             self.image_processor_tester.crop_size['''width'''],
         )    ,     )







  def 						UpperCAmelCase_	(	self ):
     # Initialize image_processing
     lowerCAmelCase_			=      self.image_processing_class(**self.image_processor_dict )
     # create random PyTorch tensors
     lowerCAmelCase_			=      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
     lowerCAmelCase_			=      image_processing(image_inputs[0]    ,     return_tensors='''pt''' ).pixel_values
     self.assertEqual(
         encoded_images.shape    ,     (
             1,
             self.image_processor_tester.num_channels,
             self.image_processor_tester.crop_size['''height'''],
             self.image_processor_tester.crop_size['''width'''],
         )    ,     )

     # Test batched
     lowerCAmelCase_			=      image_processing(_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.crop_size['''height'''],
             self.image_processor_tester.crop_size['''width'''],
         )    ,     )






@require_torch
@require_vision
class     __UpperCAmelCase       ( __a						,       unittest.TestCase		):
  __A :				Optional[int]											= ChineseCLIPImageProcessor if is_vision_available() else None





  def 						UpperCAmelCase_	(	self ):
     lowerCAmelCase_			=      ChineseCLIPImageProcessingTester(self    ,     num_channels=4    ,     do_center_crop=_lowerCamelCase )
     lowerCAmelCase_			=      3





  @property
  def 						UpperCAmelCase_	(	self ):
     return self.image_processor_tester.prepare_image_processor_dict()





  def 						UpperCAmelCase_	(	self ):
     lowerCAmelCase_			=      self.image_processing_class(**self.image_processor_dict )
     self.assertTrue(hasattr(_lowerCamelCase    ,     '''do_resize''' ) )
     self.assertTrue(hasattr(_lowerCamelCase    ,     '''size''' ) )
     self.assertTrue(hasattr(_lowerCamelCase    ,     '''do_center_crop''' ) )
     self.assertTrue(hasattr(_lowerCamelCase    ,     '''center_crop''' ) )
     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 						UpperCAmelCase_	(	self ):
     pass







  def 						UpperCAmelCase_	(	self ):
     # Initialize image_processing
     lowerCAmelCase_			=      self.image_processing_class(**self.image_processor_dict )
     # create random PIL images
     lowerCAmelCase_			=      self.image_processor_tester.prepare_inputs(equal_resolution=_lowerCamelCase )
     for image in image_inputs:
        self.assertIsInstance(_lowerCamelCase    ,     Image.Image )

     # Test not batched input
     lowerCAmelCase_			=      image_processing(image_inputs[0]    ,     return_tensors='''pt''' ).pixel_values
     self.assertEqual(
         encoded_images.shape    ,     (
             1,
             self.expected_encoded_image_num_channels,
             self.image_processor_tester.crop_size['''height'''],
             self.image_processor_tester.crop_size['''width'''],
         )    ,     )

     # Test batched
     lowerCAmelCase_			=      image_processing(_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.crop_size['''height'''],
             self.image_processor_tester.crop_size['''width'''],
         )    ,     )






'''simple docstring'''

import functools
import gc
import inspect

import torch

from .imports import is_npu_available, is_xpu_available



def snake_case_      (					*__snake_case  :							Optional[int])			->					int:
   if not isinstance(__snake_case	,   __snake_case):
      lowerCAmelCase_			=      list(__snake_case)
   for i in range(len(__snake_case)):
      lowerCAmelCase_			=      None
   gc.collect()
   if is_xpu_available():
      torch.xpu.empty_cache()
   elif is_npu_available():
      torch.npu.empty_cache()
   else:
      torch.cuda.empty_cache()
   return objects



def snake_case_      (					__snake_case  :							Exception)			->					bool:
   lowerCAmelCase_			=      [
       '''CUDA out of memory.''',  # CUDA OOM
       '''cuDNN error: CUDNN_STATUS_NOT_SUPPORTED.''',  # CUDNN SNAFU
       '''DefaultCPUAllocator: can\'t allocate memory''',  # CPU OOM
   ]
   if isinstance(__snake_case	,   __snake_case) and len(exception.args) == 1:
      return any(err in exception.args[0] for err in _statements)
   return False






def snake_case_      (					__snake_case  :							callable = None	,   __snake_case  :							int = 128)			->					List[Any]:
   if function is None:
      return functools.partial(__snake_case	,   starting_batch_size=__snake_case)

   lowerCAmelCase_			=      starting_batch_size

   def decorator(*__snake_case  :							List[str]	,   **__snake_case  :							Union[str, Any]):
      nonlocal batch_size
      gc.collect()
      if is_xpu_available():
         torch.xpu.empty_cache()
      elif is_npu_available():
         torch.npu.empty_cache()
      else:
         torch.cuda.empty_cache()
      lowerCAmelCase_			=      list(inspect.signature(__snake_case).parameters.keys())
      # Guard against user error
      if len(__snake_case) < (len(__snake_case) + 1):
         lowerCAmelCase_			=      ''', '''.join([F'''{arg}={value}''' for arg, value in zip(params[1:]	,   args[1:])])
         raise TypeError(
             F'''Batch size was passed into `{function.__name__}` as the first argument when called.'''
             F'''Remove this as the decorator already does so: `{function.__name__}({arg_str})`''')
      while True:
         if batch_size == 0:
            raise RuntimeError('''No executable batch size found, reached zero.''')
         try:
            return function(__snake_case	,   *__snake_case	,   **__snake_case)
         except Exception as e:
            if should_reduce_batch_size(__snake_case):
               gc.collect()
               if is_xpu_available():
                  torch.xpu.empty_cache()
               elif is_npu_available():
                  torch.npu.empty_cache()
               else:
                  torch.cuda.empty_cache()
               batch_size //= 2
            else:
               raise

   return decorator





