





import math
import os

import cva
import numpy as np

_SCREAMING_SNAKE_CASE   						=		2_5_5.0


def 				SCREAMING_SNAKE_CASE__    (     __a ,			__a ):
	snake_case_		:      Optional[Any]           =						np.mean((original - contrast) ** 2 )
	if mse == 0:
		return 1_00

	return 20 * math.logaa(PIXEL_MAX / math.sqrt(__a ) )


def 				SCREAMING_SNAKE_CASE__    (     ):
	snake_case_		:      Any           =						os.path.dirname(os.path.realpath(__a ) )
	# Loading images (original image and compressed image)
	snake_case_		:      int           =						cva.imread(os.path.join(__a ,			'image_data/original_image.png' ) )
	snake_case_		:      Tuple           =						cva.imread(os.path.join(__a ,			'image_data/compressed_image.png' ) ,			1 )

	snake_case_		:      Dict           =						cva.imread(os.path.join(__a ,			'image_data/PSNR-example-base.png' ) )
	snake_case_		:      Optional[Any]           =						cva.imread(
	    os.path.join(__a ,			'image_data/PSNR-example-comp-10.jpg' ) ,			1 )

	# Value expected: 29.73dB
	print('-- First Test --' )
	print(f"""PSNR value is {peak_signal_to_noise_ratio(__a ,			__a )} dB""" )

	# # Value expected: 31.53dB (Wikipedia Example)
	print('\n-- Second Test --' )
	print(f"""PSNR value is {peak_signal_to_noise_ratio(__a ,			__a )} dB""" )


if __name__ == "__main__":
						main()





from collections import OrderedDict
from dataclasses import fields
from typing import Any, Tuple

import numpy as np

from .import_utils import is_torch_available






def 			__lowerCAmelCase       (SCREAMING_SNAKE_CASE   )->    Union[str, Any]:




      """simple docstring"""

      if is_torch_available():
            import torch

            if isinstance(SCREAMING_SNAKE_CASE   ,   torch.Tensor   ):
                  return True

      return isinstance(SCREAMING_SNAKE_CASE   ,   np.ndarray   )







class lowerCAmelCase_		(					lowerCamelCase__			):

 '''simple docstring'''

 def 		UpperCamelCase__	(      self   ):
       snake_case_			= fields(self   )

       # Safety and consistency checks
       if not len(_UpperCAmelCase   ):
             raise ValueError(F'''{self.__class__.__name__} has no fields.'''   )

       snake_case_			= getattr(self						, class_fields[0].name   )
       snake_case_			= all(getattr(self						, field.name   ) is None for field in class_fields[1:]   )

       if other_fields_are_none and isinstance(_UpperCAmelCase						, _UpperCAmelCase   ):
             for key, value in first_field.items():
                   snake_case_			= value
       else:
             for field in class_fields:
                   snake_case_			= getattr(self						, field.name   )
                   if v is not None:
                         snake_case_			= v



 def __delitem__(      self						, *_UpperCAmelCase						, **_UpperCAmelCase   ):
       raise Exception(F'''You cannot use ``__delitem__`` on a {self.__class__.__name__} instance.'''   )



 def 		UpperCamelCase__	(      self						, *_UpperCAmelCase						, **_UpperCAmelCase   ):
       raise Exception(F'''You cannot use ``setdefault`` on a {self.__class__.__name__} instance.'''   )



 def 		UpperCamelCase__	(      self						, *_UpperCAmelCase						, **_UpperCAmelCase   ):
       raise Exception(F'''You cannot use ``pop`` on a {self.__class__.__name__} instance.'''   )



 def 		UpperCamelCase__	(      self						, *_UpperCAmelCase						, **_UpperCAmelCase   ):
       raise Exception(F'''You cannot use ``update`` on a {self.__class__.__name__} instance.'''   )



 def __getitem__(      self						, _UpperCAmelCase   ):
       if isinstance(_UpperCAmelCase						, _UpperCAmelCase   ):
             snake_case_			= dict(self.items()   )
             return inner_dict[k]
       else:
             return self.to_tuple()[k]



 def __setattr__(      self						, _UpperCAmelCase						, _UpperCAmelCase   ):
       if name in self.keys() and value is not None:
             # Don't call self.__setitem__ to avoid recursion errors
             super().__setitem__(_UpperCAmelCase						, _UpperCAmelCase   )
       super().__setattr__(_UpperCAmelCase						, _UpperCAmelCase   )



 def __setitem__(      self						, _UpperCAmelCase						, _UpperCAmelCase   ):
       # Will raise a KeyException if needed
       super().__setitem__(_UpperCAmelCase						, _UpperCAmelCase   )
       # Don't call self.__setattr__ to avoid recursion errors
       super().__setattr__(_UpperCAmelCase						, _UpperCAmelCase   )





 def 		UpperCamelCase__	(      self   ):
       return tuple(self[k] for k in self.keys()   )