code: 
  
  
  '''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, prepare_image_inputs
  
  
  if is_torch_available():
  							import torch
  
  if is_vision_available():
  							from PIL import Image
  
  							from transformers import OwlViTImageProcessor
  class _lowerCamelCase (		unittest.TestCase							):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		def __init__(      self	:		str						,  _A	:		Any						,  _A	:		str=7						,  _A	:		List[str]=3						,  _A	:		Optional[Any]=18						,  _A	:		str=30						,  _A	:		List[Any]=400						,  _A	:		List[Any]=True						,  _A	:		List[Any]=None						,  _A	:		List[str]=True						,  _A	:		Optional[int]=None						,  _A	:		List[Any]=True						,  _A	:		List[str]=[0.4814_5466, 0.457_8275, 0.4082_1073]						,  _A	:		Optional[Any]=[0.2686_2954, 0.2613_0258, 0.2757_7711]						,  _A	:		str=True						,  )						->				Any:
  			__magic_name__ :					str  			=  parent
  			__magic_name__ :					Dict  			=  batch_size
  			__magic_name__ :					int  			=  num_channels
  			__magic_name__ :					Union[str, Any]  			=  image_size
  			__magic_name__ :					Union[str, Any]  			=  min_resolution
  			__magic_name__ :					int  			=  max_resolution
  			__magic_name__ :					str  			=  do_resize
  			__magic_name__ :					Optional[Any]  			=  size if size is not None else {'height': 18, 'width': 18}
  			__magic_name__ :					Tuple  			=  do_center_crop
  			__magic_name__ :					Dict  			=  crop_size if crop_size is not None else {'height': 18, 'width': 18}
  			__magic_name__ :					Dict  			=  do_normalize
  			__magic_name__ :					List[str]  			=  image_mean
  			__magic_name__ :					Optional[int]  			=  image_std
  			__magic_name__ :					Tuple  			=  do_convert_rgb
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		Union[str, Any]    )						->				str:
  			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,
  			}
  
  
  
  
  
  
  
  @require_torch
  @require_vision
  class _lowerCamelCase (		lowercase__	,  unittest.TestCase							):
  
  
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		A_			:    Any   					=       OwlViTImageProcessor if is_vision_available() else None
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		Tuple    )						->				Union[str, Any]:
  			__magic_name__ :					str  			=  OwlViTImageProcessingTester(self    )
  
  
  
  
  
  
  
  		@property
  		def      __lowerCAmelCase	(      self	:		str    )						->				List[str]:
  			return self.image_processor_tester.prepare_image_processor_dict()
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		int    )						->				Union[str, Any]:
  			__magic_name__ :					Union[str, Any]  			=  self.image_processing_class(**self.image_processor_dict    )
  			self.assertTrue(hasattr(_A						,  'do_resize'    )    )
  			self.assertTrue(hasattr(_A						,  'size'    )    )
  			self.assertTrue(hasattr(_A						,  'do_center_crop'    )    )
  			self.assertTrue(hasattr(_A						,  'center_crop'    )    )
  			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      __lowerCAmelCase	(      self	:		List[str]    )						->				List[Any]:
  			__magic_name__ :					int  			=  self.image_processing_class.from_dict(self.image_processor_dict    )
  			self.assertEqual(image_processor.size						,  {'height': 18, 'width': 18}    )
  			self.assertEqual(image_processor.crop_size						,  {'height': 18, 'width': 18}    )
  
  			__magic_name__ :					List[str]  			=  self.image_processing_class.from_dict(self.image_processor_dict						,  size=42						,  crop_size=84    )
  			self.assertEqual(image_processor.size						,  {'height': 42, 'width': 42}    )
  			self.assertEqual(image_processor.crop_size						,  {'height': 84, 'width': 84}    )
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		Tuple    )						->				Dict:
  			# Initialize image_processing
  			__magic_name__ :					List[str]  			=  self.image_processing_class(**self.image_processor_dict    )
  			# create random PIL images
  			__magic_name__ :					Optional[int]  			=  prepare_image_inputs(self.image_processor_tester						,  equal_resolution=_A    )
  
  			for image in image_inputs:
  				self.assertIsInstance(_A						,  Image.Image    )
  
  			# Test not batched input
  			__magic_name__ :					Optional[int]  			=  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
  			__magic_name__ :					str  			=  image_processing(_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.crop_size['height'],
  			        self.image_processor_tester.crop_size['width'],
  			    )						,  )
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		Tuple    )						->				Any:
  			# Initialize image_processing
  			__magic_name__ :					Optional[int]  			=  self.image_processing_class(**self.image_processor_dict    )
  			# create random numpy tensors
  			__magic_name__ :					Optional[Any]  			=  prepare_image_inputs(self.image_processor_tester						,  equal_resolution=_A						,  numpify=_A    )
  			for image in image_inputs:
  				self.assertIsInstance(_A						,  np.ndarray    )
  
  			# Test not batched input
  			__magic_name__ :					Optional[Any]  			=  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
  			__magic_name__ :					Optional[int]  			=  image_processing(_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.crop_size['height'],
  			        self.image_processor_tester.crop_size['width'],
  			    )						,  )
  
  
  
  
  
  
  
  		def      __lowerCAmelCase	(      self	:		List[str]    )						->				Optional[Any]:
  			# Initialize image_processing
  			__magic_name__ :					Tuple  			=  self.image_processing_class(**self.image_processor_dict    )
  			# create random PyTorch tensors
  			__magic_name__ :					Optional[int]  			=  prepare_image_inputs(self.image_processor_tester						,  equal_resolution=_A						,  torchify=_A    )
  			for image in image_inputs:
  				self.assertIsInstance(_A						,  torch.Tensor    )
  
  			# Test not batched input
  			__magic_name__ :					Optional[Any]  			=  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
  			__magic_name__ :					int  			=  image_processing(_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.crop_size['height'],
  			        self.image_processor_tester.crop_size['width'],
  			    )						,  )
style_context: 
  
  
  '''simple docstring'''
  
  import math
  
  
  
  
  
  def lowerCamelCase    (    lowerCAmelCase       :			int	):
  
  
  
  
  
  	"""simple docstring"""
  
  
  
  
  
  
  
  	if not isinstance(lowerCAmelCase	,	lowerCAmelCase	):
  		__magic_name__ :					str  			=  f'Input value of [number={number}] must be an integer'
  		raise TypeError(lowerCAmelCase	)
  	if number < 1:
  		__magic_name__ :					Tuple  			=  f'Input value of [number={number}] must be a positive integer'
  		raise ValueError(lowerCAmelCase	)
  	__magic_name__ :					Tuple  			=  [number]
  	while number != 1:
  		if number % 2 == 0:
  			__magic_name__ :					Optional[int]  			=  math.floor(math.sqrt(lowerCAmelCase	)	)
  		else:
  			__magic_name__ :					Union[str, Any]  			=  math.floor(
  			    math.sqrt(lowerCAmelCase	) * math.sqrt(lowerCAmelCase	) * math.sqrt(lowerCAmelCase	)	)
  		sequence.append(lowerCAmelCase	)
  	return sequence
  
  
  if __name__ == "__main__":
  							import doctest
  
  							doctest.testmod()