




import enum
import inspect
import warnings
from functools import wraps
from typing import Callable, Optional

from .logging import get_logger


snake_case_					:					Tuple       						=			set()
snake_case_					:					Any       						=			get_logger(__name__)


def   A		(__A  :       Optional[str] = None			)  -> Dict:







     """simple docstring"""


     def decorator(__A  :       Callable			):
          global _emitted_deprecation_warnings

          if inspect.isclass(__A			):
               UpperCAmelCase_		=				deprecated_class_or_function.__init__
               UpperCAmelCase_		=				deprecated_class_or_function.__name__
          else:
               UpperCAmelCase_		=				deprecated_class_or_function
               UpperCAmelCase_		=				deprecated_function.__name__
               # Support deprecating __init__ class method: class name instead
               UpperCAmelCase_		=				name if name != '''__init__''' else deprecated_function.__qualname__.split('''.'''			)[-2]

          UpperCAmelCase_		=				(
              F"""{name} is deprecated and will be removed in the next major version of datasets.""" + F""" {help_message}"""
              if help_message
              else ''''''
          )

          @wraps(__A			)
          def wrapper(*__A  :       Any  ,							**__A  :       int			):
               UpperCAmelCase_		=				hash(__A			)
               if func_hash not in _emitted_deprecation_warnings:
                    warnings.warn(__A  ,							category=__A  ,							stacklevel=2			)
                    _emitted_deprecation_warnings.add(__A			)
               return deprecated_function(*__A  ,							**__A			)

          UpperCAmelCase_		=				'''deprecated'''

          if inspect.isclass(__A			):
               UpperCAmelCase_		=				wrapper
               return deprecated_class_or_function
          else:
               return wrapper

     return decorator







class __snake_case     (     enum.EnumMeta						):







   def __getattribute__( cls						:		str   ,		_snake_case						:		Tuple):

        """simple docstring"""


        UpperCAmelCase_		=				super().__getattribute__(_snake_case)
        if isinstance(_snake_case   ,		enum.Enum) and obj._on_access:
             obj._on_access()
        return obj







   def __getitem__( cls						:		Optional[int]   ,		_snake_case						:		Union[str, Any]):

        """simple docstring"""


        UpperCAmelCase_		=				super().__getitem__(_snake_case)
        if member._on_access:
             member._on_access()
        return member







   def __call__( cls						:		int   ,		_snake_case						:		Any   ,		_snake_case						:		Optional[Any]=None   ,		*, _snake_case						:		str=None   ,		_snake_case						:		Tuple=None   ,		_snake_case						:		int=None   ,		_snake_case						:		List[Any]=1):

        """simple docstring"""


        UpperCAmelCase_		=				super().__call__(_snake_case   ,		_snake_case   ,		module=_snake_case   ,		qualname=_snake_case   ,		type=_snake_case   ,		start=_snake_case)
        if isinstance(_snake_case   ,		enum.Enum) and obj._on_access:
             obj._on_access()
        return obj







class __snake_case     (     enum.Enum					,    metaclass=a						):







   def __new__( cls						:		Optional[int]   ,		_snake_case						:		Optional[int]):

        """simple docstring"""


        UpperCAmelCase_		=				object.__new__(cls)
        UpperCAmelCase_		=				value
        UpperCAmelCase_		=				member.deprecate
        return member







   @property
   def lowerCamelCase		( self						:		int):

        """simple docstring"""


        return ""







   def lowerCamelCase		( self						:		Union[str, Any]):

        """simple docstring"""


        UpperCAmelCase_		=				F""" {self.help_message}""" if self.help_message else ''''''
        warnings.warn(
            F"""'{self.__objclass__.__name__}' is deprecated and will be removed in the next major version of datasets."""
            + help_message   ,		_snake_case   ,		stacklevel=3   ,		)












def   A		(__A  :       float  ,							__A  :       int = 2			)  -> float:







     """simple docstring"""


     return round((float(__A			) * 9 / 5) + 32  ,							__A			)


def   A		(__A  :       float  ,							__A  :       int = 2			)  -> float:







     """simple docstring"""


     return round(float(__A			) + 273.15  ,							__A			)


def   A		(__A  :       float  ,							__A  :       int = 2			)  -> float:







     """simple docstring"""


     return round((float(__A			) * 9 / 5) + 491.67  ,							__A			)


def   A		(__A  :       float  ,							__A  :       int = 2			)  -> float:







     """simple docstring"""


     return round((float(__A			) - 32) * 5 / 9  ,							__A			)


def   A		(__A  :       float  ,							__A  :       int = 2			)  -> float:







     """simple docstring"""


     return round(((float(__A			) - 32) * 5 / 9) + 273.15  ,							__A			)


def   A		(__A  :       float  ,							__A  :       int = 2			)  -> float:







     """simple docstring"""


     return round(float(__A			) + 459.67  ,							__A			)


def   A		(__A  :       float  ,							__A  :       int = 2			)  -> float:







     """simple docstring"""


     return round(float(__A			) - 273.15  ,							__A			)


def   A		(__A  :       float  ,							__A  :       int = 2			)  -> float:







     """simple docstring"""


     return round(((float(__A			) - 273.15) * 9 / 5) + 32  ,							__A			)


def   A		(__A  :       float  ,							__A  :       int = 2			)  -> float:







     """simple docstring"""


     return round((float(__A			) * 9 / 5)  ,							__A			)


def   A		(__A  :       float  ,							__A  :       int = 2			)  -> float:







     """simple docstring"""


     return round((float(__A			) - 491.67) * 5 / 9  ,							__A			)


def   A		(__A  :       float  ,							__A  :       int = 2			)  -> float:







     """simple docstring"""


     return round(float(__A			) - 459.67  ,							__A			)


def   A		(__A  :       float  ,							__A  :       int = 2			)  -> float:







     """simple docstring"""


     return round((float(__A			) * 5 / 9)  ,							__A			)


def   A		(__A  :       float  ,							__A  :       int = 2			)  -> float:







     """simple docstring"""


     return round((float(__A			) * 1.25 + 273.15)  ,							__A			)


def   A		(__A  :       float  ,							__A  :       int = 2			)  -> float:







     """simple docstring"""


     return round((float(__A			) * 2.25 + 32)  ,							__A			)


def   A		(__A  :       float  ,							__A  :       int = 2			)  -> float:







     """simple docstring"""


     return round((float(__A			) * 1.25)  ,							__A			)


def   A		(__A  :       float  ,							__A  :       int = 2			)  -> float:







     """simple docstring"""


     return round((float(__A			) * 2.25 + 32 + 459.67)  ,							__A			)


if __name__ == "__main__":
    import doctest

    doctest.testmod()






