code: 
  
  
  import numpy as np
  from cva import destroyAllWindows, imread, imshow, waitKey
  
  
  class 		_SCREAMING_SNAKE_CASE    :
  
  
       def __init__(     self       ,				A_       ,				A_						):
         _UpperCAmelCase		:       Optional[Any]       =    0
         # max greyscale value for #FFFFFF
         _UpperCAmelCase		:       Any       =    int(self.get_greyscale(2_55       ,				2_55       ,				2_55						)						)
  
         if not self.min_threshold < threshold < self.max_threshold:
           _UpperCAmelCase		:       List[Any]       =    F'''Factor value should be from 0 to {self.max_threshold}'''
           raise ValueError(A_						)
  
         _UpperCAmelCase		:       Any       =    input_img
         _UpperCAmelCase		:       List[Any]       =    threshold
         _UpperCAmelCase,_UpperCAmelCase		:       Tuple       =    self.input_img.shape[1], self.input_img.shape[0]
  
         # error table size (+4 columns and +1 row) greater than input image because of
         # lack of if statements
         _UpperCAmelCase		:       List[str]       =    [
             [0 for _ in range(self.height + 4						)] for __ in range(self.width + 1						)
         ]
         _UpperCAmelCase		:       Optional[Any]       =    np.ones((self.width, self.height, 3)       ,				np.uinta						) * 2_55
  
  
       @classmethod
       def 					__snake_case(     cls       ,				A_       ,				A_       ,				A_						):
         return 0.1_1_4 * blue + 0.5_8_7 * green + 0.2_1_2_6 * red
  
  
  
  
       def 					__snake_case(     self						):
         for y in range(self.height						):
           for x in range(self.width						):
             _UpperCAmelCase		:       Tuple       =    int(self.get_greyscale(*self.input_img[y][x]						)						)
             if self.threshold > greyscale + self.error_table[y][x]:
               _UpperCAmelCase		:       Tuple       =    (0, 0, 0)
               _UpperCAmelCase		:       Union[str, Any]       =    greyscale + self.error_table[x][y]
             else:
               _UpperCAmelCase		:       int       =    (2_55, 2_55, 2_55)
               _UpperCAmelCase		:       List[Any]       =    greyscale + self.error_table[x][y] - 2_55
             self.error_table[y][x + 1] += int(8 / 32 * current_error						)
             self.error_table[y][x + 2] += int(4 / 32 * current_error						)
             self.error_table[y + 1][x] += int(8 / 32 * current_error						)
             self.error_table[y + 1][x + 1] += int(4 / 32 * current_error						)
             self.error_table[y + 1][x + 2] += int(2 / 32 * current_error						)
             self.error_table[y + 1][x - 1] += int(4 / 32 * current_error						)
             self.error_table[y + 1][x - 2] += int(2 / 32 * current_error						)
  
  
  if __name__ == "__main__":
   # create Burke's instances with original images in greyscale
   SCREAMING_SNAKE_CASE__				:    Any         =    [
       Burkes(imread('image_data/lena.jpg', 1), threshold)
       for threshold in (1, 126, 130, 140)
   ]
  
   for burkes in burkes_instances:
    burkes.process()
  
   for burkes in burkes_instances:
    imshow(
        F'Original image with dithering threshold: {burkes.threshold}',
        burkes.output_img,
    )
  
   waitKey(0)
   destroyAllWindows()
  
  
  
  
  
  
style_context: 
  
  
  from dataclasses import dataclass
  from enum import Enum
  from typing import List, Optional, Union
  
  import numpy as np
  import PIL
  from PIL import Image
  
  from ...utils import BaseOutput, is_torch_available, is_transformers_available
  
  
  @dataclass
  class 		_SCREAMING_SNAKE_CASE    (	A    ):
       __SCREAMING_SNAKE_CASE    				=						{
           '''sld_warmup_steps''': 1_5,
           '''sld_guidance_scale''': 2_0,
           '''sld_threshold''': 0.0,
           '''sld_momentum_scale''': 0.0,
           '''sld_mom_beta''': 0.0,
       }
       __SCREAMING_SNAKE_CASE    				=						{
           '''sld_warmup_steps''': 1_0,
           '''sld_guidance_scale''': 1_0_0_0,
           '''sld_threshold''': 0.01,
           '''sld_momentum_scale''': 0.3,
           '''sld_mom_beta''': 0.4,
       }
       __SCREAMING_SNAKE_CASE    				=						{
           '''sld_warmup_steps''': 7,
           '''sld_guidance_scale''': 2_0_0_0,
           '''sld_threshold''': 0.025,
           '''sld_momentum_scale''': 0.5,
           '''sld_mom_beta''': 0.7,
       }
       __SCREAMING_SNAKE_CASE    				=						{
           '''sld_warmup_steps''': 0,
           '''sld_guidance_scale''': 5_0_0_0,
           '''sld_threshold''': 1.0,
           '''sld_momentum_scale''': 0.5,
           '''sld_mom_beta''': 0.7,
       }
  
  
  @dataclass
  class 		_SCREAMING_SNAKE_CASE    (	A    ):
       __SCREAMING_SNAKE_CASE    				=						42
       __SCREAMING_SNAKE_CASE    				=						42
       __SCREAMING_SNAKE_CASE    				=						42
       __SCREAMING_SNAKE_CASE    				=						42
  
  
  if is_transformers_available() and is_torch_available():
   from .pipeline_stable_diffusion_safe import StableDiffusionPipelineSafe
   from .safety_checker import SafeStableDiffusionSafetyChecker
  
  
  
  
  
  