




import copy
import os

import cva
import numpy as np
from matplotlib import pyplot as plt




class    _A					:






		def __init__(     self      ):
								_UpperCAmelCase	     =      """"""
								_UpperCAmelCase	     =      """"""
								_UpperCAmelCase	     =      []
								_UpperCAmelCase	     =      0
								_UpperCAmelCase	     =      256
								_UpperCAmelCase	     =      0
								_UpperCAmelCase	     =      0
								_UpperCAmelCase	     =      0
								_UpperCAmelCase	     =      0






		def 					UpperCAmelCase			(     self    ,		_SCREAMING_SNAKE_CASE      ):
								_UpperCAmelCase	     =      cva.imread(_SCREAMING_SNAKE_CASE    ,		0      )
								_UpperCAmelCase	     =      copy.deepcopy(self.img      )
								_UpperCAmelCase     ,       _UpperCAmelCase     ,       _UpperCAmelCase	     =      plt.hist(self.img.ravel()    ,		256    ,		[0, 256]    ,		label="""x"""      )
								_UpperCAmelCase	     =      np.sum(_SCREAMING_SNAKE_CASE      )
								for i in range(len(_SCREAMING_SNAKE_CASE      )      ):
														_UpperCAmelCase	     =      x[i] / self.k
														self.sk += prk
														_UpperCAmelCase	     =      (self.L - 1) * self.sk
														if self.rem != 0:
																				_UpperCAmelCase	     =      int(last % last      )
														_UpperCAmelCase	     =      int(last + 1 if self.rem >= 0.5 else last      )
														self.last_list.append(_SCREAMING_SNAKE_CASE      )
														_UpperCAmelCase	     =      int(np.ma.count(self.img      ) / self.img[1].size      )
														_UpperCAmelCase	     =      self.img[1].size
								for i in range(self.number_of_cols      ):
														for j in range(self.number_of_rows      ):
																				_UpperCAmelCase	     =      self.img[j][i]
																				if num != self.last_list[num]:
																										_UpperCAmelCase	     =      self.last_list[num]
								cva.imwrite("""output_data/output.jpg"""    ,		self.img      )






		def 					UpperCAmelCase			(     self      ):
								plt.hist(self.img.ravel()    ,		256    ,		[0, 256]      )






		def 					UpperCAmelCase			(     self      ):
								cva.imshow("""Output-Image"""    ,		self.img      )
								cva.imshow("""Input-Image"""    ,		self.original_image      )
								cva.waitKey(5000      )
								cva.destroyAllWindows()


if __name__ == "__main__":
				a    				=      os.path.join(os.path.basename(__file__), "image_data/input.jpg")
				a    				=      ConstantStretch()
				stretcher.stretch(file_path)
				stretcher.plot_histogram()
				stretcher.show_image()
'''simple docstring'''




import unittest
from typing import Tuple

import torch

from diffusers.utils import floats_tensor, randn_tensor, torch_all_close, torch_device
from diffusers.utils.testing_utils import require_torch




@require_torch
class        a__ :






     @property
     def   SCREAMING_SNAKE_CASE__  (					self						:						str       ):





         """simple docstring"""



         return self.get_dummy_input()






     @property
     def   SCREAMING_SNAKE_CASE__  (					self						:						str       ):





         """simple docstring"""



         if self.block_type == "down":
             return (4, 32, 16, 16)
         elif self.block_type == "mid":
             return (4, 32, 32, 32)
         elif self.block_type == "up":
             return (4, 32, 64, 64)

         raise ValueError(f"""'{self.block_type}' is not a supported block_type. Set it to 'up', 'mid', or 'down'."""       )






     def   SCREAMING_SNAKE_CASE__  (					self						:						Optional[Any]    ,							a						:						List[Any]=True    ,							a						:						Dict=False    ,							a						:						Optional[Any]=False    ,							a						:						List[Any]=False    ,							):





         """simple docstring"""



         __lowerCamelCase            =    4
         __lowerCamelCase            =    32
         __lowerCamelCase            =    (32, 32)

         __lowerCamelCase            =    torch.manual_seed(0       )
         __lowerCamelCase            =    torch.device(a       )
         __lowerCamelCase            =    (batch_size, num_channels) + sizes
         __lowerCamelCase            =    randn_tensor(a    ,							generator=a    ,							device=a       )
         __lowerCamelCase            =    {'''hidden_states''': hidden_states}

         if include_temb:
             __lowerCamelCase            =    1_28
             __lowerCamelCase            =    randn_tensor((batch_size, temb_channels)    ,							generator=a    ,							device=a       )

         if include_res_hidden_states_tuple:
             __lowerCamelCase            =    torch.manual_seed(1       )
             __lowerCamelCase            =    (randn_tensor(a    ,							generator=a    ,							device=a       ),)

         if include_encoder_hidden_states:
             __lowerCamelCase            =    floats_tensor((batch_size, 32, 32)       ).to(a       )

         if include_skip_sample:
             __lowerCamelCase            =    randn_tensor(((batch_size, 3) + sizes)    ,							generator=a    ,							device=a       )

         return dummy_input






     def   SCREAMING_SNAKE_CASE__  (					self						:						Optional[int]       ):





         """simple docstring"""



         __lowerCamelCase            =    {
             '''in_channels''': 32,
             '''out_channels''': 32,
             '''temb_channels''': 1_28,
         }
         if self.block_type == "up":
             __lowerCamelCase            =    32

         if self.block_type == "mid":
             init_dict.pop('''out_channels'''       )

         __lowerCamelCase            =    self.dummy_input
         return init_dict, inputs_dict






     def   SCREAMING_SNAKE_CASE__  (					self						:						Optional[Any]    ,							a						:						List[str]       ):





         """simple docstring"""



         __lowerCamelCase      ,    __lowerCamelCase            =    self.prepare_init_args_and_inputs_for_common()
         __lowerCamelCase            =    self.block_class(**a       )
         unet_block.to(a       )
         unet_block.eval()

         with torch.no_grad():
             __lowerCamelCase            =    unet_block(**a       )

         if isinstance(a    ,							a       ):
             __lowerCamelCase            =    output[0]

         self.assertEqual(output.shape    ,							self.output_shape       )

         __lowerCamelCase            =    output[0, -1, -3:, -3:]
         __lowerCamelCase            =    torch.tensor(a       ).to(a       )
         assert torch_all_close(output_slice.flatten()    ,							a    ,							atol=5e-3       )






     @unittest.skipIf(torch_device == '''mps'''    ,							'''Training is not supported in mps'''       )
     def   SCREAMING_SNAKE_CASE__  (					self						:						Any       ):





         """simple docstring"""



         __lowerCamelCase      ,    __lowerCamelCase            =    self.prepare_init_args_and_inputs_for_common()
         __lowerCamelCase            =    self.block_class(**a       )
         model.to(a       )
         model.train()
         __lowerCamelCase            =    model(**a       )

         if isinstance(a    ,							a       ):
             __lowerCamelCase            =    output[0]

         __lowerCamelCase            =    torch.device(a       )
         __lowerCamelCase            =    randn_tensor(output.shape    ,							device=a       )
         __lowerCamelCase            =    torch.nn.functional.mse_loss(a    ,							a       )
         loss.backward()
