code: 
  '''simple docstring'''
  
  
  
  
  
  import enum
  import inspect
  import warnings
  from functools import wraps
  from typing import Callable, Optional
  
  from .logging import get_logger
  
  
  A           =   set()
  A           =   get_logger(__name__)
  def   snake_case_       (							_a     :							Optional[str] = None			):
  
        def decorator(_a     :							Callable			):
              global _emitted_deprecation_warnings
  
              if inspect.isclass(_a			):
                    snake_case_						       =							deprecated_class_or_function.__init__
                    snake_case_						       =							deprecated_class_or_function.__name__
              else:
                    snake_case_						       =							deprecated_class_or_function
                    snake_case_						       =							deprecated_function.__name__
                    # Support deprecating __init__ class method: class name instead
                    snake_case_						       =							name if name != "__init__" else deprecated_function.__qualname__.split("."			)[-2]
  
              snake_case_						       =							(
                  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     :							str ,					**_a     :							Optional[Any]			):
                    snake_case_						       =							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			)
  
              snake_case_						       =							"deprecated"
  
              if inspect.isclass(_a			):
                    snake_case_						       =							wrapper
                    return deprecated_class_or_function
              else:
                    return wrapper
  
        return decorator
  
  
  
  class  lowerCAmelCase__   (       enum.EnumMeta			):
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
    def __getattribute__(cls  : List[str]	, lowerCAmelCase_  : str    )   ->       Optional[int]:
          snake_case_						       =							super().__getattribute__(lowerCAmelCase_    )
          if isinstance(lowerCAmelCase_	, enum.Enum    ) and obj._on_access:
                obj._on_access()
          return obj
  
    def __getitem__(cls  : Tuple	, lowerCAmelCase_  : Tuple    )   ->       str:
          snake_case_						       =							super().__getitem__(lowerCAmelCase_    )
          if member._on_access:
                member._on_access()
          return member
  
  
    def __call__(cls  : Tuple	, lowerCAmelCase_  : List[str]	, lowerCAmelCase_  : Dict=None	, *, lowerCAmelCase_  : int=None	, lowerCAmelCase_  : Optional[Any]=None	, lowerCAmelCase_  : Union[str, Any]=None	, lowerCAmelCase_  : Optional[Any]=1    )   ->       Union[str, Any]:
          snake_case_						       =							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=UpperCamelCase			):
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
    def __new__(cls  : List[Any]	, lowerCAmelCase_  : Optional[int]    )   ->       List[Any]:
          snake_case_						       =							object.__new__(cls    )
          snake_case_						       =							value
          snake_case_						       =							member.deprecate
          return member
  
    @property
    def 		_lowerCamelCase	(self  : List[Any]    )   ->       List[Any]:
          return ""
  
  
    def 		_lowerCamelCase	(self  : Any    )   ->       List[str]:
          snake_case_						       =							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: 
  '''simple docstring'''
  
  
  
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available
  
  
  A           =   {
      "configuration_deta": ["DETA_PRETRAINED_CONFIG_ARCHIVE_MAP", "DetaConfig"],
  }
  
  try:
       if not is_vision_available():
            raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
       pass
  else:
       A           =   ["DetaImageProcessor"]
  
  try:
       if not is_torch_available():
            raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
       pass
  else:
       A           =   [
           "DETA_PRETRAINED_MODEL_ARCHIVE_LIST",
           "DetaForObjectDetection",
           "DetaModel",
           "DetaPreTrainedModel",
       ]
  
  
  if TYPE_CHECKING:
       from .configuration_deta import DETA_PRETRAINED_CONFIG_ARCHIVE_MAP, DetaConfig
  
       try:
            if not is_vision_available():
                 raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
            pass
       else:
            from .image_processing_deta import DetaImageProcessor
  
       try:
            if not is_torch_available():
                 raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
            pass
       else:
            from .modeling_deta import (
                DETA_PRETRAINED_MODEL_ARCHIVE_LIST,
                DetaForObjectDetection,
                DetaModel,
                DetaPreTrainedModel,
            )
  
  else:
       import sys
  
       A           =   _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
  
  