code: import enum
  import inspect
  import warnings
  from functools import wraps
  from typing import Callable, Optional
  
  from .logging import get_logger
  
  
  UpperCAmelCase					=				set()
  UpperCAmelCase					=				get_logger(__name__)
  
  
  def SCREAMING_SNAKE_CASE				(     lowercase_:	Optional[str] = None				):
  
         def decorator(lowercase_:	Callable				):
                global _emitted_deprecation_warnings
  
                if inspect.isclass(lowercase_				):
                       _UpperCamelCase     :       Optional[Any]  						=  deprecated_class_or_function.__init__
                       _UpperCamelCase     :       Union[str, Any]  						=  deprecated_class_or_function.__name__
                else:
                       _UpperCamelCase     :       Union[str, Any]  						=  deprecated_class_or_function
                       _UpperCamelCase     :       Optional[Any]  						=  deprecated_function.__name__
                       # Support deprecating __init__ class method: class name instead
                       _UpperCamelCase     :       List[Any]  						=  name if name != '__init__' else deprecated_function.__qualname__.split('.'				)[-2]
  
                _UpperCamelCase     :       Dict  						=  (
                    F"{name} is deprecated and will be removed in the next major version of datasets." + F" {help_message}"
                    if help_message
                    else ''
                )
  
                @wraps(lowercase_				)
                def wrapper(*lowercase_:	Dict		,						**lowercase_:	List[str]				):
                       _UpperCamelCase     :       List[str]  						=  hash(lowercase_				)
                       if func_hash not in _emitted_deprecation_warnings:
                              warnings.warn(lowercase_		,						category=lowercase_		,						stacklevel=2				)
                              _emitted_deprecation_warnings.add(lowercase_				)
                       return deprecated_function(*lowercase_		,						**lowercase_				)
  
                _UpperCamelCase     :       List[Any]  						=  'deprecated'
  
                if inspect.isclass(lowercase_				):
                       _UpperCamelCase     :       Any  						=  wrapper
                       return deprecated_class_or_function
                else:
                       return wrapper
  
         return decorator
  
  
  
  
  class    __lowerCAmelCase  (       enum.EnumMeta						):
  
  
  
   '''simple docstring'''
  
   def __getattribute__(			cls       :		Dict       ,			lowerCamelCase       :		int  ) ->							Any:
          _UpperCamelCase     :       Dict  						=  super().__getattribute__(lowerCamelCase  )
          if isinstance(lowerCamelCase       ,			enum.Enum  ) and obj._on_access:
                 obj._on_access()
          return obj
  
   def __getitem__(			cls       :		Optional[Any]       ,			lowerCamelCase       :		str  ) ->							List[Any]:
          _UpperCamelCase     :       Dict  						=  super().__getitem__(lowerCamelCase  )
          if member._on_access:
                 member._on_access()
          return member
  
   def __call__(			cls       :		List[str]       ,			lowerCamelCase       :		Any       ,			lowerCamelCase       :		Any=None       ,			*, lowerCamelCase       :		str=None       ,			lowerCamelCase       :		List[str]=None       ,			lowerCamelCase       :		int=None       ,			lowerCamelCase       :		List[str]=1  ) ->							Optional[Any]:
          _UpperCamelCase     :       str  						=  super().__call__(lowerCamelCase       ,			lowerCamelCase       ,			module=lowerCamelCase       ,			qualname=lowerCamelCase       ,			type=lowerCamelCase       ,			start=lowerCamelCase  )
          if isinstance(lowerCamelCase       ,			enum.Enum  ) and obj._on_access:
                 obj._on_access()
          return obj
  
  
  
  
  
  
  
  class    __lowerCAmelCase  (       enum.Enum,	metaclass=a_						):
  
  
  
   '''simple docstring'''
  
   def __new__(			cls       :		Any       ,			lowerCamelCase       :		str  ) ->							str:
          _UpperCamelCase     :       Optional[Any]  						=  object.__new__(cls  )
          _UpperCamelCase     :       Optional[Any]  						=  value
          _UpperCamelCase     :       Union[str, Any]  						=  member.deprecate
          return member
  
   @property
   def 					__snake_case					(			self       :		Optional[int]  ) ->							Tuple:
          return ""
  
   def 					__snake_case					(			self       :		Any  ) ->							str:
          _UpperCamelCase     :       List[str]  						=  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       ,			lowerCamelCase       ,			stacklevel=3       ,			)
  
  
  
  
style_context: from ..utils import requires_backends
  
  
  UpperCAmelCase					=				None
  
  
  
  
  class    __lowerCAmelCase  :
  
  
  
   '''simple docstring'''
  
   def __init__(			self       :		Optional[int]       ,			*lowerCamelCase       :		Dict       ,			**lowerCamelCase       :		int  ) ->							Tuple:
          requires_backends(self       ,			['detectron2']  )
  
   @classmethod
   def 					__snake_case					(			cls       :		Optional[Any]       ,			*lowerCamelCase       :		Optional[int]       ,			**lowerCamelCase       :		Tuple  ) ->							List[str]:
          requires_backends(cls       ,			['detectron2']  )
  
  
  
  