





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

from .logging import get_logger


a__							:							str			=set()
a__							:							Tuple			=get_logger(__name__)
def     lowercase__       (       __lowercase						:  Optional[Any] = None					)			->				List[str]:



       """simple docstring"""






       def decorator(__lowercase						:  Dict					):
              global _emitted_deprecation_warnings

              if inspect.isclass(__lowercase					):
                     __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(__lowercase					)
              def wrapper(*__lowercase						:  Any    ,  **__lowercase						:  Optional[int]					):
                     __UpperCamelCase	=  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	=  'deprecated'

              if inspect.isclass(__lowercase					):
                     __UpperCamelCase	=  wrapper
                     return deprecated_class_or_function
              else:
                     return wrapper

       return decorator

class 					snake_case					(   enum.EnumMeta	):




 """simple docstring"""



 def __getattribute__(	cls	:							List[str]							,     __A	:							str     ):
        __UpperCamelCase	=  super().__getattribute__(lowerCAmelCase__     )
        if isinstance(lowerCAmelCase__							,     enum.Enum     ) and obj._on_access:
               obj._on_access()
        return obj






 def __getitem__(	cls	:							Optional[Any]							,     __A	:							Union[str, Any]     ):
        __UpperCamelCase	=  super().__getitem__(lowerCAmelCase__     )
        if member._on_access:
               member._on_access()
        return member






 def __call__(	cls	:							Union[str, Any]							,     __A	:							Optional[Any]							,     __A	:							str=None							,     *, __A	:							Optional[int]=None							,     __A	:							int=None							,     __A	:							Optional[int]=None							,     __A	:							int=1     ):
        __UpperCamelCase	=  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 					snake_case					(   enum.Enum      ,	metaclass=_UpperCAmelCase	):




 """simple docstring"""



 def __new__(	cls	:							Dict							,     __A	:							List[Any]     ):
        __UpperCamelCase	=  object.__new__(cls     )
        __UpperCamelCase	=  value
        __UpperCamelCase	=  member.deprecate
        return member






 @property
 def 	_lowerCamelCase (	self	:							List[Any]     ):
        return ""






 def 	_lowerCamelCase (	self	:							str     ):
        __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							,     lowerCAmelCase__							,     stacklevel=3							,     )







'''simple docstring'''
def     lowercase__       (       __lowercase						:  str    ,  __lowercase						:  Tuple					)			->				str:



       """simple docstring"""






       sequence.append(__lowercase					)

       __UpperCamelCase	=  0
       while sequence[index] != target:
              index += 1

       sequence.pop()

       if index == len(__lowercase					):
              return None

       return index


if __name__ == "__main__":
    a__							:							Any			=input('''Enter numbers separated by comma:\n''').strip()
    a__							:							Any			=[int(item) for item in user_input.split(''',''')]

    a__							:							Tuple			=input('''Enter a single number to be found in the list:\n''')
    a__							:							List[Any]			=int(target_input)
    a__							:							List[Any]			=sentinel_linear_search(sequence, target)
    if result is not None:
        print(f'{target} found at positions: {result}')
    else:
        print('''Not found''')
