

import unittest

from diffusers import __version__
from diffusers.utils import deprecate







class 					__lowerCamelCase							(      unittest.TestCase      ):
      lowerCamelCase_      : Optional[int]  			=   '.'.join([str(int(__version__.split('.'      )[0]      ) + 1      )] + __version__.split('.'      )[1:]      )
      lowerCamelCase_      : List[Any]  			=   '0.0.1'







      def       lowerCAmelCase_       (	self  )		->			Dict:
        snake_case_					= {'deprecated_arg': 4}

        with self.assertWarns(lowerCamelCase  ) as warning:
          snake_case_					= deprecate("""deprecated_arg"""				,    self.higher_version				,    """message"""				,    take_from=lowerCamelCase  )

        assert output == 4
        assert (
            str(warning.warning  )
            == f'''The `deprecated_arg` argument is deprecated and will be removed in version {self.higher_version}.'''
            " message"
        )







      def       lowerCAmelCase_       (	self  )		->			str:
        snake_case_					= {'deprecated_arg': 4}

        with self.assertWarns(lowerCamelCase  ) as warning:
          snake_case_					= deprecate(("""deprecated_arg""", self.higher_version, """message""")				,    take_from=lowerCamelCase  )

        assert output == 4
        assert (
            str(warning.warning  )
            == f'''The `deprecated_arg` argument is deprecated and will be removed in version {self.higher_version}.'''
            " message"
        )







      def       lowerCAmelCase_       (	self  )		->			List[Any]:
        snake_case_					= {'deprecated_arg_1': 4, 'deprecated_arg_2': 8}
        with self.assertWarns(lowerCamelCase  ) as warning:
          snake_case_					= deprecate(
              ("""deprecated_arg_1""", self.higher_version, """Hey""")				,    ("""deprecated_arg_2""", self.higher_version, """Hey""")				,    take_from=lowerCamelCase				,    )
        assert output_a == 4
        assert output_a == 8
        assert (
            str(warning.warnings[0].message  )
            == "The `deprecated_arg_1` argument is deprecated and will be removed in version"
            f''' {self.higher_version}. Hey'''
        )
        assert (
            str(warning.warnings[1].message  )
            == "The `deprecated_arg_2` argument is deprecated and will be removed in version"
            f''' {self.higher_version}. Hey'''
        )







      def       lowerCAmelCase_       (	self  )		->			List[Any]:
        snake_case_					= {'deprecated_arg': 4}

        with self.assertRaises(lowerCamelCase  ) as error:
          deprecate(("""wrong_arg""", self.higher_version, """message""")				,    take_from=lowerCamelCase  )

        assert "test_deprecate_function_incorrect_arg in" in str(error.exception  )
        assert "line" in str(error.exception  )
        assert "got an unexpected keyword argument `deprecated_arg`" in str(error.exception  )







      def       lowerCAmelCase_       (	self  )		->			List[str]:
        with self.assertWarns(lowerCamelCase  ) as warning:
          deprecate(("""deprecated_arg""", self.higher_version, """message""")  )

        assert (
            str(warning.warning  )
            == f'''`deprecated_arg` is deprecated and will be removed in version {self.higher_version}. message'''
        )







      def       lowerCAmelCase_       (	self  )		->			int:
        with self.assertWarns(lowerCamelCase  ) as warning:
          deprecate(
              ("""deprecated_arg_1""", self.higher_version, """Hey""")				,    ("""deprecated_arg_2""", self.higher_version, """Hey""")				,    )
        assert (
            str(warning.warnings[0].message  )
            == f'''`deprecated_arg_1` is deprecated and will be removed in version {self.higher_version}. Hey'''
        )
        assert (
            str(warning.warnings[1].message  )
            == f'''`deprecated_arg_2` is deprecated and will be removed in version {self.higher_version}. Hey'''
        )







      def       lowerCAmelCase_       (	self  )		->			Any:







        class 					__lowerCamelCase							:
              lowerCamelCase_      : Optional[int]  			=   5

        with self.assertWarns(lowerCamelCase  ) as warning:
          snake_case_					= deprecate(("""arg""", self.higher_version, """message""")				,    take_from=Args()  )

        assert arg == 5
        assert (
            str(warning.warning  )
            == f'''The `arg` attribute is deprecated and will be removed in version {self.higher_version}. message'''
        )







      def       lowerCAmelCase_       (	self  )		->			int:







        class 					__lowerCamelCase							:
              lowerCamelCase_      : int  			=   5
              lowerCamelCase_      : int  			=   7

        with self.assertWarns(lowerCamelCase  ) as warning:
          snake_case_					= deprecate(
              ("""arg""", self.higher_version, """message""")				,    ("""foo""", self.higher_version, """message""")				,    ("""does not exist""", self.higher_version, """message""")				,    take_from=Args()				,    )

        assert arg_a == 5
        assert arg_a == 7
        assert (
            str(warning.warning  )
            == f'''The `arg` attribute is deprecated and will be removed in version {self.higher_version}. message'''
        )
        assert (
            str(warning.warnings[0].message  )
            == f'''The `arg` attribute is deprecated and will be removed in version {self.higher_version}. message'''
        )
        assert (
            str(warning.warnings[1].message  )
            == f'''The `foo` attribute is deprecated and will be removed in version {self.higher_version}. message'''
        )







      def       lowerCAmelCase_       (	self  )		->			int:
        snake_case_					= {'deprecated_arg': 4}

        with self.assertRaises(lowerCamelCase  ) as error:
          deprecate(("""wrong_arg""", self.lower_version, """message""")				,    take_from=lowerCamelCase  )

        assert (
            str(error.exception  )
            == "The deprecation tuple ('wrong_arg', '0.0.1', 'message') should be removed since diffusers' version"
            f''' {__version__} is >= {self.lower_version}'''
        )







      def       lowerCAmelCase_       (	self  )		->			List[str]:
        with self.assertWarns(lowerCamelCase  ) as warning:
          deprecate(("""deprecated_arg""", self.higher_version, """This message is better!!!""")				,    standard_warn=lowerCamelCase  )

        assert str(warning.warning  ) == "This message is better!!!"







      def       lowerCAmelCase_       (	self  )		->			Optional[int]:
        with self.assertWarns(lowerCamelCase  ) as warning:
          deprecate(("""deprecated_arg""", self.higher_version, """This message is better!!!""")				,    standard_warn=lowerCamelCase  )
        assert str(warning.warning  ) == "This message is better!!!"
        assert "diffusers/tests/others/test_utils.py" in warning.filename
import unittest
from dataclasses import dataclass
from typing import List, Union

import numpy as np
import PIL.Image

from diffusers.utils.outputs import BaseOutput




@dataclass
class  __lowerCAmelCase	(							a_    ):



 '''simple docstring'''
 _lowerCamelCase    :						Union[List[PIL.Image.Image], np.ndarray]







class  __lowerCAmelCase	(							unittest.TestCase    ):



 '''simple docstring'''

 def        __snake_case       (      self							:		int	)			->				Tuple:
        _UpperCamelCase  :							str	    =	CustomOutput(images=np.random.rand(1							,      3							,      4							,      4	)	)

        # check every way of getting the attribute
        assert isinstance(outputs.images							,      np.ndarray	)
        assert outputs.images.shape == (1, 3, 4, 4)
        assert isinstance(outputs['images']							,      np.ndarray	)
        assert outputs["images"].shape == (1, 3, 4, 4)
        assert isinstance(outputs[0]							,      np.ndarray	)
        assert outputs[0].shape == (1, 3, 4, 4)

        # test with a non-tensor attribute
        _UpperCamelCase  :							str	    =	CustomOutput(images=[PIL.Image.new('RGB'							,      (4, 4)	)]	)

        # check every way of getting the attribute
        assert isinstance(outputs.images							,      lowerCamelCase	)
        assert isinstance(outputs.images[0]							,      PIL.Image.Image	)
        assert isinstance(outputs['images']							,      lowerCamelCase	)
        assert isinstance(outputs['images'][0]							,      PIL.Image.Image	)
        assert isinstance(outputs[0]							,      lowerCamelCase	)
        assert isinstance(outputs[0][0]							,      PIL.Image.Image	)

 def        __snake_case       (      self							:		Any	)			->				Dict:
        # test output reinitialization with a `dict` for compatibility with `accelerate`
        _UpperCamelCase  :							Tuple	    =	CustomOutput({'images': np.random.rand(1							,      3							,      4							,      4	)}	)

        # check every way of getting the attribute
        assert isinstance(outputs.images							,      np.ndarray	)
        assert outputs.images.shape == (1, 3, 4, 4)
        assert isinstance(outputs['images']							,      np.ndarray	)
        assert outputs["images"].shape == (1, 3, 4, 4)
        assert isinstance(outputs[0]							,      np.ndarray	)
        assert outputs[0].shape == (1, 3, 4, 4)

        # test with a non-tensor attribute
        _UpperCamelCase  :							int	    =	CustomOutput({'images': [PIL.Image.new('RGB'							,      (4, 4)	)]}	)

        # check every way of getting the attribute
        assert isinstance(outputs.images							,      lowerCamelCase	)
        assert isinstance(outputs.images[0]							,      PIL.Image.Image	)
        assert isinstance(outputs['images']							,      lowerCamelCase	)
        assert isinstance(outputs['images'][0]							,      PIL.Image.Image	)
        assert isinstance(outputs[0]							,      lowerCamelCase	)
        assert isinstance(outputs[0][0]							,      PIL.Image.Image	)



