

import unittest

import numpy as np
from datasets import load_dataset

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 BeitImageProcessor






class 	UpperCAmelCase__		(	unittest.TestCase	):






  """simple docstring"""


  def __init__(							self						:		Any     ,       __lowerCamelCase						:		Optional[int]     ,       __lowerCamelCase						:		Optional[int]=7     ,       __lowerCamelCase						:		int=3     ,       __lowerCamelCase						:		int=18     ,       __lowerCamelCase						:		Any=30     ,       __lowerCamelCase						:		Dict=400     ,       __lowerCamelCase						:		Optional[int]=True     ,       __lowerCamelCase						:		Union[str, Any]=None     ,       __lowerCamelCase						:		Optional[int]=True     ,       __lowerCamelCase						:		Dict=None     ,       __lowerCamelCase						:		Any=True     ,       __lowerCamelCase						:		Dict=[0.5, 0.5, 0.5]     ,       __lowerCamelCase						:		str=[0.5, 0.5, 0.5]     ,       __lowerCamelCase						:		Any=False     ,       )		->							Optional[Any]:
       SCREAMING_SNAKE_CASE__   =   size if size is not None else {'''height''': 20, '''width''': 20}
       SCREAMING_SNAKE_CASE__   =   crop_size if crop_size is not None else {'''height''': 18, '''width''': 18}
       SCREAMING_SNAKE_CASE__   =   parent
       SCREAMING_SNAKE_CASE__   =   batch_size
       SCREAMING_SNAKE_CASE__   =   num_channels
       SCREAMING_SNAKE_CASE__   =   image_size
       SCREAMING_SNAKE_CASE__   =   min_resolution
       SCREAMING_SNAKE_CASE__   =   max_resolution
       SCREAMING_SNAKE_CASE__   =   do_resize
       SCREAMING_SNAKE_CASE__   =   size
       SCREAMING_SNAKE_CASE__   =   do_center_crop
       SCREAMING_SNAKE_CASE__   =   crop_size
       SCREAMING_SNAKE_CASE__   =   do_normalize
       SCREAMING_SNAKE_CASE__   =   image_mean
       SCREAMING_SNAKE_CASE__   =   image_std
       SCREAMING_SNAKE_CASE__   =   do_reduce_labels







  def 				lowercase_		(							self						:		int )		->							Tuple:
       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_reduce_labels": self.do_reduce_labels,
       }



def     UpperCAmelCase_       (						):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__   =   load_dataset('''hf-internal-testing/fixtures_ade20k'''				,		split='''test'''    )

     SCREAMING_SNAKE_CASE__   =   Image.open(dataset[0]['''file''']    )
     SCREAMING_SNAKE_CASE__   =   Image.open(dataset[1]['''file''']    )

     return image, map
def     UpperCAmelCase_       (						):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__   =   load_dataset('''hf-internal-testing/fixtures_ade20k'''				,		split='''test'''    )

     SCREAMING_SNAKE_CASE__   =   Image.open(ds[0]['''file''']    )
     SCREAMING_SNAKE_CASE__   =   Image.open(ds[1]['''file''']    )
     SCREAMING_SNAKE_CASE__   =   Image.open(ds[2]['''file''']    )
     SCREAMING_SNAKE_CASE__   =   Image.open(ds[3]['''file''']    )

     return [imagea, imagea], [mapa, mapa]







@require_torch
@require_vision
class 	UpperCAmelCase__		(	A__						,					unittest.TestCase	):






  """simple docstring"""


  a									= BeitImageProcessor if is_vision_available() else None






  def 				lowercase_		(							self						:		List[Any] )		->							Tuple:
       SCREAMING_SNAKE_CASE__   =   BeitImageProcessingTester(self )






  @property
  def 				lowercase_		(							self						:		Optional[int] )		->							Optional[int]:
       return self.image_processor_tester.prepare_image_processor_dict()






  def 				lowercase_		(							self						:		int )		->							Union[str, Any]:
       SCREAMING_SNAKE_CASE__   =   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''' ) )






  def 				lowercase_		(							self						:		Tuple )		->							int:
       SCREAMING_SNAKE_CASE__   =   self.image_processing_class.from_dict(self.image_processor_dict )
       self.assertEqual(image_processor.size     ,       {'''height''': 20, '''width''': 20} )
       self.assertEqual(image_processor.crop_size     ,       {'''height''': 18, '''width''': 18} )
       self.assertEqual(image_processor.do_reduce_labels     ,       __lowerCamelCase )

       SCREAMING_SNAKE_CASE__   =   self.image_processing_class.from_dict(
           self.image_processor_dict     ,       size=42     ,       crop_size=84     ,       reduce_labels=__lowerCamelCase )
       self.assertEqual(image_processor.size     ,       {'''height''': 42, '''width''': 42} )
       self.assertEqual(image_processor.crop_size     ,       {'''height''': 84, '''width''': 84} )
       self.assertEqual(image_processor.do_reduce_labels     ,       __lowerCamelCase )






  def 				lowercase_		(							self						:		Optional[Any] )		->							Any:
       pass






  def 				lowercase_		(							self						:		List[Any] )		->							List[Any]:
       # Initialize image_processing
       SCREAMING_SNAKE_CASE__   =   self.image_processing_class(**self.image_processor_dict )
       # create random PIL images
       SCREAMING_SNAKE_CASE__   =   prepare_image_inputs(self.image_processor_tester     ,       equal_resolution=__lowerCamelCase )
       for image in image_inputs:
            self.assertIsInstance(__lowerCamelCase     ,       Image.Image )

       # Test not batched input
       SCREAMING_SNAKE_CASE__   =   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
       SCREAMING_SNAKE_CASE__   =   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 				lowercase_		(							self						:		List[Any] )		->							List[Any]:
       # Initialize image_processing
       SCREAMING_SNAKE_CASE__   =   self.image_processing_class(**self.image_processor_dict )
       # create random numpy tensors
       SCREAMING_SNAKE_CASE__   =   prepare_image_inputs(self.image_processor_tester     ,       equal_resolution=__lowerCamelCase     ,       numpify=__lowerCamelCase )
       for image in image_inputs:
            self.assertIsInstance(__lowerCamelCase     ,       np.ndarray )

       # Test not batched input
       SCREAMING_SNAKE_CASE__   =   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
       SCREAMING_SNAKE_CASE__   =   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 				lowercase_		(							self						:		int )		->							str:
       # Initialize image_processing
       SCREAMING_SNAKE_CASE__   =   self.image_processing_class(**self.image_processor_dict )
       # create random PyTorch tensors
       SCREAMING_SNAKE_CASE__   =   prepare_image_inputs(self.image_processor_tester     ,       equal_resolution=__lowerCamelCase     ,       torchify=__lowerCamelCase )
       for image in image_inputs:
            self.assertIsInstance(__lowerCamelCase     ,       torch.Tensor )

       # Test not batched input
       SCREAMING_SNAKE_CASE__   =   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
       SCREAMING_SNAKE_CASE__   =   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 				lowercase_		(							self						:		str )		->							List[Any]:
       # Initialize image_processing
       SCREAMING_SNAKE_CASE__   =   self.image_processing_class(**self.image_processor_dict )
       # create random PyTorch tensors
       SCREAMING_SNAKE_CASE__   =   prepare_image_inputs(self.image_processor_tester     ,       equal_resolution=__lowerCamelCase     ,       torchify=__lowerCamelCase )
       SCREAMING_SNAKE_CASE__   =   []
       for image in image_inputs:
            self.assertIsInstance(__lowerCamelCase     ,       torch.Tensor )
            maps.append(torch.zeros(image.shape[-2:] ).long() )

       # Test not batched input
       SCREAMING_SNAKE_CASE__   =   image_processing(image_inputs[0]     ,       maps[0]     ,       return_tensors='''pt''' )
       self.assertEqual(
           encoding['''pixel_values'''].shape     ,       (
               1,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size['''height'''],
               self.image_processor_tester.crop_size['''width'''],
           )     ,       )
       self.assertEqual(
           encoding['''labels'''].shape     ,       (
               1,
               self.image_processor_tester.crop_size['''height'''],
               self.image_processor_tester.crop_size['''width'''],
           )     ,       )
       self.assertEqual(encoding['''labels'''].dtype     ,       torch.long )
       self.assertTrue(encoding['''labels'''].min().item() >= 0 )
       self.assertTrue(encoding['''labels'''].max().item() <= 255 )

       # Test batched
       SCREAMING_SNAKE_CASE__   =   image_processing(__lowerCamelCase     ,       __lowerCamelCase     ,       return_tensors='''pt''' )
       self.assertEqual(
           encoding['''pixel_values'''].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'''],
           )     ,       )
       self.assertEqual(
           encoding['''labels'''].shape     ,       (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.crop_size['''height'''],
               self.image_processor_tester.crop_size['''width'''],
           )     ,       )
       self.assertEqual(encoding['''labels'''].dtype     ,       torch.long )
       self.assertTrue(encoding['''labels'''].min().item() >= 0 )
       self.assertTrue(encoding['''labels'''].max().item() <= 255 )

       # Test not batched input (PIL images)
       SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__   =   prepare_semantic_single_inputs()

       SCREAMING_SNAKE_CASE__   =   image_processing(__lowerCamelCase     ,       __lowerCamelCase     ,       return_tensors='''pt''' )
       self.assertEqual(
           encoding['''pixel_values'''].shape     ,       (
               1,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size['''height'''],
               self.image_processor_tester.crop_size['''width'''],
           )     ,       )
       self.assertEqual(
           encoding['''labels'''].shape     ,       (
               1,
               self.image_processor_tester.crop_size['''height'''],
               self.image_processor_tester.crop_size['''width'''],
           )     ,       )
       self.assertEqual(encoding['''labels'''].dtype     ,       torch.long )
       self.assertTrue(encoding['''labels'''].min().item() >= 0 )
       self.assertTrue(encoding['''labels'''].max().item() <= 255 )

       # Test batched input (PIL images)
       SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__   =   prepare_semantic_batch_inputs()

       SCREAMING_SNAKE_CASE__   =   image_processing(__lowerCamelCase     ,       __lowerCamelCase     ,       return_tensors='''pt''' )
       self.assertEqual(
           encoding['''pixel_values'''].shape     ,       (
               2,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size['''height'''],
               self.image_processor_tester.crop_size['''width'''],
           )     ,       )
       self.assertEqual(
           encoding['''labels'''].shape     ,       (
               2,
               self.image_processor_tester.crop_size['''height'''],
               self.image_processor_tester.crop_size['''width'''],
           )     ,       )
       self.assertEqual(encoding['''labels'''].dtype     ,       torch.long )
       self.assertTrue(encoding['''labels'''].min().item() >= 0 )
       self.assertTrue(encoding['''labels'''].max().item() <= 255 )







  def 				lowercase_		(							self						:		List[Any] )		->							Union[str, Any]:
       # Initialize image_processing
       SCREAMING_SNAKE_CASE__   =   self.image_processing_class(**self.image_processor_dict )

       # ADE20k has 150 classes, and the background is included, so labels should be between 0 and 150
       SCREAMING_SNAKE_CASE__,SCREAMING_SNAKE_CASE__   =   prepare_semantic_single_inputs()
       SCREAMING_SNAKE_CASE__   =   image_processing(__lowerCamelCase     ,       __lowerCamelCase     ,       return_tensors='''pt''' )
       self.assertTrue(encoding['''labels'''].min().item() >= 0 )
       self.assertTrue(encoding['''labels'''].max().item() <= 150 )

       SCREAMING_SNAKE_CASE__   =   True
       SCREAMING_SNAKE_CASE__   =   image_processing(__lowerCamelCase     ,       __lowerCamelCase     ,       return_tensors='''pt''' )
       self.assertTrue(encoding['''labels'''].min().item() >= 0 )
       self.assertTrue(encoding['''labels'''].max().item() <= 255 )





def     UpperCAmelCase_       (						_A    ):





     '''simple docstring'''




     if divisor % 5 == 0 or divisor % 2 == 0:
          return 0
     SCREAMING_SNAKE_CASE__   =   1
     SCREAMING_SNAKE_CASE__   =   1
     while repunit:
          SCREAMING_SNAKE_CASE__   =   (10 * repunit + 1) % divisor
          repunit_index += 1
     return repunit_index
def     UpperCAmelCase_       (						_A = 1_00_00_00    ):





     '''simple docstring'''




     SCREAMING_SNAKE_CASE__   =   limit - 1
     if divisor % 2 == 0:
          divisor += 1
     while least_divisible_repunit(_A    ) <= limit:
          divisor += 2
     return divisor


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


