code: 
  
  import json
  import os
  import tempfile
  
  from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_vision
  from transformers.utils import is_torch_available, is_vision_available
  
  
  if is_torch_available():
   import numpy as np
   import torch
  
  if is_vision_available():
   from PIL import Image
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			int  ,						SCREAMING_SNAKE_CASE__						:			Optional[int]=False  ,						SCREAMING_SNAKE_CASE__						:			int=False  ,						SCREAMING_SNAKE_CASE__						:			int=False ):
      assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"
  
      UpperCamelCase :int										=     []
      for i in range(image_processor_tester.batch_size ):
          if equal_resolution:
              UpperCamelCase :Any										=     image_processor_tester.max_resolution
          else:
              # To avoid getting image width/height 0
              UpperCamelCase :List[str]										=     image_processor_tester.min_resolution
              if getattr(SCREAMING_SNAKE_CASE__  ,						'''size_divisor'''  ,						SCREAMING_SNAKE_CASE__ ):
                  # If `size_divisor` is defined, the image needs to have width/size >= `size_divisor`
                  UpperCamelCase :str										=     max(image_processor_tester.size_divisor  ,						SCREAMING_SNAKE_CASE__ )
              UpperCamelCase :Optional[int]										=     np.random.choice(np.arange(SCREAMING_SNAKE_CASE__  ,						image_processor_tester.max_resolution )  ,						2 )
          image_inputs.append(
              np.random.randint(255  ,						size=(image_processor_tester.num_channels, width, height)  ,						dtype=np.uinta ) )
  
      if not numpify and not torchify:
          # PIL expects the channel dimension as last dimension
          UpperCamelCase :Tuple										=     [Image.fromarray(np.moveaxis(SCREAMING_SNAKE_CASE__  ,						0  ,						-1 ) ) for image in image_inputs]
  
      if torchify:
          UpperCamelCase :Dict										=     [torch.from_numpy(SCREAMING_SNAKE_CASE__ ) for image in image_inputs]
  
      return image_inputs
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			int  ,						SCREAMING_SNAKE_CASE__						:			List[str]=10  ,						SCREAMING_SNAKE_CASE__						:			str=10  ,						SCREAMING_SNAKE_CASE__						:			List[Any]=False  ,						SCREAMING_SNAKE_CASE__						:			List[Any]=False ):
      UpperCamelCase :Dict										=     []
      for i in range(image_processor_tester.num_frames ):
          video.append(np.random.randint(255  ,						size=(image_processor_tester.num_channels, width, height)  ,						dtype=np.uinta ) )
  
      if not numpify and not torchify:
          # PIL expects the channel dimension as last dimension
          UpperCamelCase :Union[str, Any]										=     [Image.fromarray(np.moveaxis(SCREAMING_SNAKE_CASE__  ,						0  ,						-1 ) ) for frame in video]
  
      if torchify:
          UpperCamelCase :Dict										=     [torch.from_numpy(SCREAMING_SNAKE_CASE__ ) for frame in video]
  
      return video
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			List[str]  ,						SCREAMING_SNAKE_CASE__						:			Tuple=False  ,						SCREAMING_SNAKE_CASE__						:			Union[str, Any]=False  ,						SCREAMING_SNAKE_CASE__						:			int=False ):
      assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"
  
      UpperCamelCase :str										=     []
      for i in range(image_processor_tester.batch_size ):
          if equal_resolution:
              UpperCamelCase :Union[str, Any]										=     image_processor_tester.max_resolution
          else:
              UpperCamelCase :Union[str, Any]										=     np.random.choice(
                  np.arange(image_processor_tester.min_resolution  ,						image_processor_tester.max_resolution )  ,						2 )
              UpperCamelCase :List[str]										=     prepare_video(
                  image_processor_tester=SCREAMING_SNAKE_CASE__  ,						width=SCREAMING_SNAKE_CASE__  ,						height=SCREAMING_SNAKE_CASE__  ,						numpify=SCREAMING_SNAKE_CASE__  ,						torchify=SCREAMING_SNAKE_CASE__  ,						)
          video_inputs.append(SCREAMING_SNAKE_CASE__ )
  
      return video_inputs
  
  
  
  
  
  
  
  class     UpperCAmelCase_		:
  
  
  
        """simple docstring"""
        UpperCamelCase_       :      int     =None
        def 					UpperCAmelCase		(       self				)       ->   int:
            UpperCamelCase :Optional[Any]										=     self.image_processing_class(**self.image_processor_dict				)
            UpperCamelCase :Union[str, Any]										=     json.loads(image_processor.to_json_string()				)
            for key, value in self.image_processor_dict.items():
                self.assertEqual(obj[key]					,       SCREAMING_SNAKE_CASE_				)
        def 					UpperCAmelCase		(       self				)       ->   List[Any]:
            UpperCamelCase :List[str]										=     self.image_processing_class(**self.image_processor_dict				)
  
            with tempfile.TemporaryDirectory() as tmpdirname:
                UpperCamelCase :Any										=     os.path.join(SCREAMING_SNAKE_CASE_					,       '''image_processor.json'''				)
                image_processor_first.to_json_file(SCREAMING_SNAKE_CASE_				)
                UpperCamelCase :Dict										=     self.image_processing_class.from_json_file(SCREAMING_SNAKE_CASE_				)
  
            self.assertEqual(image_processor_second.to_dict()					,       image_processor_first.to_dict()				)
        def 					UpperCAmelCase		(       self				)       ->   List[str]:
            UpperCamelCase :Any										=     self.image_processing_class(**self.image_processor_dict				)
  
            with tempfile.TemporaryDirectory() as tmpdirname:
                UpperCamelCase :List[Any]										=     image_processor_first.save_pretrained(SCREAMING_SNAKE_CASE_				)[0]
                check_json_file_has_correct_format(SCREAMING_SNAKE_CASE_				)
                UpperCamelCase :str										=     self.image_processing_class.from_pretrained(SCREAMING_SNAKE_CASE_				)
  
            self.assertEqual(image_processor_second.to_dict()					,       image_processor_first.to_dict()				)
        def 					UpperCAmelCase		(       self				)       ->   Optional[int]:
            UpperCamelCase :Union[str, Any]										=     self.image_processing_class()
            self.assertIsNotNone(SCREAMING_SNAKE_CASE_				)
  
  
  
  
        @require_torch
        @require_vision
        def 					UpperCAmelCase		(       self				)       ->   Union[str, Any]:
            if self.test_cast_dtype is not None:
                # Initialize image_processor
                UpperCamelCase :str										=     self.image_processing_class(**self.image_processor_dict				)
  
                # create random PyTorch tensors
                UpperCamelCase :Any										=     prepare_image_inputs(self.image_processor_tester					,       equal_resolution=SCREAMING_SNAKE_CASE_					,       torchify=SCREAMING_SNAKE_CASE_				)
  
                UpperCamelCase :List[Any]										=     image_processor(SCREAMING_SNAKE_CASE_					,       return_tensors='''pt'''				)
                # for layoutLM compatiblity
                self.assertEqual(encoding.pixel_values.device					,       torch.device('''cpu'''				)				)
                self.assertEqual(encoding.pixel_values.dtype					,       torch.floataa				)
  
                UpperCamelCase :List[str]										=     image_processor(SCREAMING_SNAKE_CASE_					,       return_tensors='''pt'''				).to(torch.floataa				)
                self.assertEqual(encoding.pixel_values.device					,       torch.device('''cpu'''				)				)
                self.assertEqual(encoding.pixel_values.dtype					,       torch.floataa				)
  
                UpperCamelCase :int										=     image_processor(SCREAMING_SNAKE_CASE_					,       return_tensors='''pt'''				).to('''cpu'''					,       torch.bfloataa				)
                self.assertEqual(encoding.pixel_values.device					,       torch.device('''cpu'''				)				)
                self.assertEqual(encoding.pixel_values.dtype					,       torch.bfloataa				)
  
                with self.assertRaises(SCREAMING_SNAKE_CASE_				):
                    UpperCamelCase :List[str]										=     image_processor(SCREAMING_SNAKE_CASE_					,       return_tensors='''pt'''				).to(torch.bfloataa					,       '''cpu'''				)
  
                # Try with text + image feature
                UpperCamelCase :Tuple										=     image_processor(SCREAMING_SNAKE_CASE_					,       return_tensors='''pt'''				)
                encoding.update({'''input_ids''': torch.LongTensor([[1, 2, 3], [4, 5, 6]]				)}				)
                UpperCamelCase :Optional[Any]										=     encoding.to(torch.floataa				)
  
                self.assertEqual(encoding.pixel_values.device					,       torch.device('''cpu'''				)				)
                self.assertEqual(encoding.pixel_values.dtype					,       torch.floataa				)
                self.assertEqual(encoding.input_ids.dtype					,       torch.long				)
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  from __future__ import annotations
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			int ):
      UpperCamelCase :int										=     {1}
      UpperCamelCase :Optional[int]										=     [1]
      for _ in range(2  ,						depth + 1 ):
          UpperCamelCase :Union[str, Any]										=     [*previous_coefficients, 0]
          UpperCamelCase :List[str]										=     [0, *previous_coefficients]
          UpperCamelCase :List[str]										=     []
          for x, y in zip(SCREAMING_SNAKE_CASE__  ,						SCREAMING_SNAKE_CASE__ ):
              coefficients.add(x + y )
              previous_coefficients.append(x + y )
      return coefficients
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			set[int] ):
      UpperCamelCase :Union[str, Any]										=     set()
      for number in unique_coefficients:
          UpperCamelCase :Optional[int]										=     2
          UpperCamelCase :List[Any]										=     number
          while divisor**2 <= copy_number:
              UpperCamelCase :List[Any]										=     0
              while copy_number % divisor == 0:
                  copy_number //= divisor
                  multiplicity += 1
              if multiplicity >= 2:
                  non_squarefrees.add(SCREAMING_SNAKE_CASE__ )
                  break
              divisor += 1
  
      return unique_coefficients.difference(SCREAMING_SNAKE_CASE__ )
  
  
  def 						_A     (       SCREAMING_SNAKE_CASE__						:			int = 51 ):
      UpperCamelCase :Any										=     get_pascal_triangle_unique_coefficients(SCREAMING_SNAKE_CASE__ )
      UpperCamelCase :str										=     get_squarefrees(SCREAMING_SNAKE_CASE__ )
      return sum(SCREAMING_SNAKE_CASE__ )
  
  
  if __name__ == "__main__":
   print(f'''{solution() = }''')
  
  
  
  
  
  