python part of the warnings subsystem import sys all warn warnexplicit showwarning formatwarning filterwarnings simplefilter resetwarnings catchwarnings deprecated def showwarningmessage category filename lineno filenone linenone function to format a warning the standard way msg warningmessagemessage category filename lineno none line return formatwarnmsgimplmsg def showwarnmsgimplmsg file msg file if file is none file sys stderr if file is none sys stderr is none when run with pythonw exe warnings get lost return text formatwarnmsgmsg try file writetext except oserror the file probably stderr is invalid this warning gets lost pass def formatwarnmsgimplmsg category msg category name s fmsg filename msg lineno category msg messagen if msg line is none try import linecache line linecache getlinemsg filename msg lineno except exception when a warning is logged during python shutdown linecache and the import machinery don t work anymore line none linecache none else line msg line if line line line strip s sn line if msg source is not none try import tracemalloc logging a warning should not raise a new exception catch exception not only importerror and recursionerror except exception don t suggest to enable tracemalloc if it s not available tracing true tb none else tracing tracemalloc istracing try tb tracemalloc getobjecttracebackmsg source except exception when a warning is logged during python shutdown tracemalloc and the import machinery don t work anymore tb none if tb is not none s object allocated at most recent call last n for frame in tb s file s lineno sn frame filename frame lineno try if linecache is not none line linecache getlineframe filename frame lineno else line none except exception line none if line line line strip s sn line elif not tracing s f category enable tracemalloc to get the object f allocation tracebackn return s keep a reference to check if the function was replaced showwarningorig showwarning def showwarnmsgmsg warnings showwarning was replaced keep a reference to check if the function was replaced function to format a warning the standard way try fw formatwarning except nameerror pass else if fw is not formatwarningorig warnings formatwarning was replaced return fwmsg message msg category msg filename msg lineno msg line return formatwarnmsgimplmsg def filterwarningsaction message categorywarning module lineno0 appendfalse if action not in error ignore always default module once raise valueerrorfinvalid action action r if not isinstancemessage str raise typeerrormessage must be a string if not isinstancecategory type or not issubclasscategory warning raise typeerrorcategory must be a warning subclass if not isinstancemodule str raise typeerrormodule must be a string if not isinstancelineno int raise typeerrorlineno must be an int if lineno 0 raise valueerrorlineno must be an int 0 if message or module import re if message message re compilemessage re i else message none if module module re compilemodule else module none addfilteraction message category module lineno appendappend def simplefilteraction categorywarning lineno0 appendfalse if action not in error ignore always default module once raise valueerrorfinvalid action action r if not isinstancelineno int raise typeerrorlineno must be an int if lineno 0 raise valueerrorlineno must be an int 0 addfilteraction none category none lineno appendappend def addfilteritem append remove possible duplicate filters so new one will be placed in correct place if appendtrue and duplicate exists do nothing if not append try filters removeitem except valueerror pass filters insert0 item else if item not in filters filters appenditem filtersmutated def resetwarnings exception used by option processing helpers pass helper to process w options passed via sys warnoptions def processoptionsargs for arg in args try setoptionarg except optionerror as msg printinvalid w option ignored msg filesys stderr helper for processoptions def setoptionarg parts arg split if lenparts 5 raise optionerrortoo many fields max 5 r arg while lenparts 5 parts append action message category module lineno s strip for s in parts action getactionaction category getcategorycategory if message or module import re if message message re escapemessage if module module re escapemodule r z if lineno try lineno intlineno if lineno 0 raise valueerror except valueerror overflowerror raise optionerrorinvalid lineno r lineno from none else lineno 0 filterwarningsaction message category module lineno helper for setoption def getactionaction if not action return default if action all return always alias for a in default always ignore module once error if a startswithaction return a raise optionerrorinvalid action r action helper for setoption def getcategorycategory if not category return warning if not in category import builtins as m klass category else module klass category rpartition try m importmodule none none klass except importerror raise optionerrorinvalid module name r module from none try cat getattrm klass except attributeerror raise optionerrorunknown warning category r category from none if not issubclasscat warning raise optionerrorinvalid warning category r category return cat def isinternalfilenamefilename return importlib in filename and bootstrap in filename def isfilenametoskipfilename skipfileprefixes return anyfilename startswithprefix for prefix in skipfileprefixes def isinternalframeframe find the next frame that doesn t involve python or user internals frame frame fback while frame is not none and isinternalfilenamefilename frame fcode cofilename or isfilenametoskipfilename skipfileprefixes frame frame fback return frame code typically replaced by warnings def warnmessage categorynone stacklevel1 sourcenone skipfileprefixes check if message is already a warning object check category argument the c version demands a tuple for implementation performance get context information if frame is too small to care or if the warning originated in internal code then do not try to hide any frames look for one frame less since the above line starts us off quick test for common case search the filters early exit actions prime the linecache for formatting in case the file is actually in a zipfile or something other actions unrecognized actions are errors print message and context a context manager that copies and restores the warnings filter upon exiting the context the record argument specifies whether warnings should be captured by a custom implementation of warnings showwarning and be appended to a list returned by the context manager otherwise none is returned by the context manager the objects appended to the list are arguments whose attributes mirror the arguments to showwarning the module argument is to specify an alternative module to the module named warnings and imported under that name this argument is only useful when testing the warnings module itself if the action argument is not none the remaining arguments are passed to warnings simplefilter as if it were called immediately on entering the context specify whether to record warnings and if an alternative module should be used other than sys modules warnings for compatibility with python 3 0 please consider all arguments to be keywordonly reset showwarning to the default implementation to make sure that showwarnmsg calls showwarnmsgimpl indicate that a class function or overload is deprecated when this decorator is applied to an object the type checker will generate a diagnostic on usage of the deprecated object usage deprecateduse b instead class a pass deprecateduse g instead def f pass overload deprecatedint support is deprecated def gx int int overload def gx str int the warning specified by category will be emitted at runtime on use of deprecated objects for functions that happens on calls for classes on instantiation and on creation of subclasses if the category is none no warning is emitted at runtime the stacklevel determines where the warning is emitted if it is 1 the default the warning is emitted at the direct caller of the deprecated object if it is higher it is emitted further up the stack static type checker behavior is not affected by the category and stacklevel arguments the deprecation message passed to the decorator is saved in the deprecated attribute on the decorated object if applied to an overload the decorator must be after the overload decorator for the attribute to exist on the overload as returned by getoverloads see pep 702 for details make sure the inner functions created below don t retain a reference to self mirrors a similar check in object new we need slightly different behavior if initsubclass is a bound method likely if it was implemented in python or otherwise which likely means it s a builtin such as object s implementation of initsubclass warn that name is deprecated or should be removed runtimeerror is raised if remove specifies a majorminor tuple older than the current python version or the same version but past the alpha the message argument is formatted with name and remove as a python version tuple e g 3 11 private utility function called by pyerrwarnunawaitedcoroutine passing source here means that if the user happens to have tracemalloc enabled and tracking where the coroutine was created the warning will contain that traceback this does mean that if they have both coroutine origin tracking and tracemalloc enabled they ll get two partiallyredundant tracebacks if we wanted to be clever we could probably detect this case and avoid it but for now we don t bother filters contains a sequence of filter 5tuples the components of the 5tuple are an action error ignore always default module or once a compiled regex that must match the warning message a class representing the warning category a compiled regex that must match the module that is being warned a line number for the line being warning or 0 to mean any line if either if the compiled regexs are none match anything module initialization several warning categories are ignored by default in regular builds hook to write a warning to a file replace if you like function to format a warning the standard way sys stderr is none when run with pythonw exe warnings get lost the file probably stderr is invalid this warning gets lost when a warning is logged during python shutdown linecache and the import machinery don t work anymore logging a warning should not raise a new exception catch exception not only importerror and recursionerror don t suggest to enable tracemalloc if it s not available when a warning is logged during python shutdown tracemalloc and the import machinery don t work anymore keep a reference to check if the function was replaced hook to write a warning to a file replace if you like warnings showwarning was replaced keep a reference to check if the function was replaced function to format a warning the standard way warnings formatwarning was replaced insert an entry into the list of warnings filters at the front action one of error ignore always default module or once message a regex that the warning message must match category a class that the warning must be a subclass of module a regex that the module name must match lineno an integer line number 0 matches all warnings append if true append to the list of filters insert a simple entry into the list of warnings filters at the front a simple filter matches all modules and messages action one of error ignore always default module or once category a class that the warning must be a subclass of lineno an integer line number 0 matches all warnings append if true append to the list of filters remove possible duplicate filters so new one will be placed in correct place if append true and duplicate exists do nothing clear the list of warning filters so that no filters are active exception used by option processing helpers helper to process w options passed via sys warnoptions helper for _processoptions helper for _setoption alias helper for _setoption signal whether the frame is an internal cpython implementation detail find the next frame that doesn t involve python or user internals code typically replaced by _warnings issue a warning or maybe ignore it or raise an exception check if message is already a warning object check category argument the c version demands a tuple for implementation performance get context information if frame is too small to care or if the warning originated in internal code then do not try to hide any frames look for one frame less since the above line starts us off xxx what about leading pathname quick test for common case search the filters early exit actions prime the linecache for formatting in case the file is actually in a zipfile or something other actions unrecognized actions are errors print message and context a context manager that copies and restores the warnings filter upon exiting the context the record argument specifies whether warnings should be captured by a custom implementation of warnings showwarning and be appended to a list returned by the context manager otherwise none is returned by the context manager the objects appended to the list are arguments whose attributes mirror the arguments to showwarning the module argument is to specify an alternative module to the module named warnings and imported under that name this argument is only useful when testing the warnings module itself if the action argument is not none the remaining arguments are passed to warnings simplefilter as if it were called immediately on entering the context specify whether to record warnings and if an alternative module should be used other than sys modules warnings for compatibility with python 3 0 please consider all arguments to be keyword only reset showwarning to the default implementation to make sure that _showwarnmsg calls _showwarnmsg_impl indicate that a class function or overload is deprecated when this decorator is applied to an object the type checker will generate a diagnostic on usage of the deprecated object usage deprecated use b instead class a pass deprecated use g instead def f pass overload deprecated int support is deprecated def g x int int overload def g x str int the warning specified by category will be emitted at runtime on use of deprecated objects for functions that happens on calls for classes on instantiation and on creation of subclasses if the category is none no warning is emitted at runtime the stacklevel determines where the warning is emitted if it is 1 the default the warning is emitted at the direct caller of the deprecated object if it is higher it is emitted further up the stack static type checker behavior is not affected by the category and stacklevel arguments the deprecation message passed to the decorator is saved in the __deprecated__ attribute on the decorated object if applied to an overload the decorator must be after the overload decorator for the attribute to exist on the overload as returned by get_overloads see pep 702 for details make sure the inner functions created below don t retain a reference to self mirrors a similar check in object __new__ we need slightly different behavior if __init_subclass__ is a bound method likely if it was implemented in python or otherwise which likely means it s a builtin such as object s implementation of __init_subclass__ warn that name is deprecated or should be removed runtimeerror is raised if remove specifies a major minor tuple older than the current python version or the same version but past the alpha the message argument is formatted with name and remove as a python version tuple e g 3 11 private utility function called by _pyerr_warnunawaitedcoroutine passing source here means that if the user happens to have tracemalloc enabled and tracking where the coroutine was created the warning will contain that traceback this does mean that if they have both coroutine origin tracking and tracemalloc enabled they ll get two partially redundant tracebacks if we wanted to be clever we could probably detect this case and avoid it but for now we don t bother filters contains a sequence of filter 5 tuples the components of the 5 tuple are an action error ignore always default module or once a compiled regex that must match the warning message a class representing the warning category a compiled regex that must match the module that is being warned a line number for the line being warning or 0 to mean any line if either if the compiled regexs are none match anything module initialization several warning categories are ignored by default in regular builds
import sys


__all__ = ["warn", "warn_explicit", "showwarning",
           "formatwarning", "filterwarnings", "simplefilter",
           "resetwarnings", "catch_warnings", "deprecated"]

def showwarning(message, category, filename, lineno, file=None, line=None):
    
    msg = WarningMessage(message, category, filename, lineno, file, line)
    _showwarnmsg_impl(msg)

def formatwarning(message, category, filename, lineno, line=None):
    
    msg = WarningMessage(message, category, filename, lineno, None, line)
    return _formatwarnmsg_impl(msg)

def _showwarnmsg_impl(msg):
    file = msg.file
    if file is None:
        file = sys.stderr
        if file is None:
            
            
            return
    text = _formatwarnmsg(msg)
    try:
        file.write(text)
    except OSError:
        
        pass

def _formatwarnmsg_impl(msg):
    category = msg.category.__name__
    s =  f"{msg.filename}:{msg.lineno}: {category}: {msg.message}\n"

    if msg.line is None:
        try:
            import linecache
            line = linecache.getline(msg.filename, msg.lineno)
        except Exception:
            
            
            line = None
            linecache = None
    else:
        line = msg.line
    if line:
        line = line.strip()
        s += "  %s\n" % line

    if msg.source is not None:
        try:
            import tracemalloc
        
        
        except Exception:
            
            tracing = True
            tb = None
        else:
            tracing = tracemalloc.is_tracing()
            try:
                tb = tracemalloc.get_object_traceback(msg.source)
            except Exception:
                
                
                tb = None

        if tb is not None:
            s += 'Object allocated at (most recent call last):\n'
            for frame in tb:
                s += ('  File "%s", lineno %s\n'
                      % (frame.filename, frame.lineno))

                try:
                    if linecache is not None:
                        line = linecache.getline(frame.filename, frame.lineno)
                    else:
                        line = None
                except Exception:
                    line = None
                if line:
                    line = line.strip()
                    s += '    %s\n' % line
        elif not tracing:
            s += (f'{category}: Enable tracemalloc to get the object '
                  f'allocation traceback\n')
    return s


_showwarning_orig = showwarning

def _showwarnmsg(msg):
    
    try:
        sw = showwarning
    except NameError:
        pass
    else:
        if sw is not _showwarning_orig:
            
            if not callable(sw):
                raise TypeError("warnings.showwarning() must be set to a "
                                "function or method")

            sw(msg.message, msg.category, msg.filename, msg.lineno,
               msg.file, msg.line)
            return
    _showwarnmsg_impl(msg)


_formatwarning_orig = formatwarning

def _formatwarnmsg(msg):
    
    try:
        fw = formatwarning
    except NameError:
        pass
    else:
        if fw is not _formatwarning_orig:
            
            return fw(msg.message, msg.category,
                      msg.filename, msg.lineno, msg.line)
    return _formatwarnmsg_impl(msg)

def filterwarnings(action, message="", category=Warning, module="", lineno=0,
                   append=False):
    
    if action not in {"error", "ignore", "always", "default", "module", "once"}:
        raise ValueError(f"invalid action: {action!r}")
    if not isinstance(message, str):
        raise TypeError("message must be a string")
    if not isinstance(category, type) or not issubclass(category, Warning):
        raise TypeError("category must be a Warning subclass")
    if not isinstance(module, str):
        raise TypeError("module must be a string")
    if not isinstance(lineno, int):
        raise TypeError("lineno must be an int")
    if lineno < 0:
        raise ValueError("lineno must be an int >= 0")

    if message or module:
        import re

    if message:
        message = re.compile(message, re.I)
    else:
        message = None
    if module:
        module = re.compile(module)
    else:
        module = None

    _add_filter(action, message, category, module, lineno, append=append)

def simplefilter(action, category=Warning, lineno=0, append=False):
    
    if action not in {"error", "ignore", "always", "default", "module", "once"}:
        raise ValueError(f"invalid action: {action!r}")
    if not isinstance(lineno, int):
        raise TypeError("lineno must be an int")
    if lineno < 0:
        raise ValueError("lineno must be an int >= 0")
    _add_filter(action, None, category, None, lineno, append=append)

def _add_filter(*item, append):
    
    
    if not append:
        try:
            filters.remove(item)
        except ValueError:
            pass
        filters.insert(0, item)
    else:
        if item not in filters:
            filters.append(item)
    _filters_mutated()

def resetwarnings():
    
    filters[:] = []
    _filters_mutated()

class _OptionError(Exception):
    
    pass


def _processoptions(args):
    for arg in args:
        try:
            _setoption(arg)
        except _OptionError as msg:
            print("Invalid -W option ignored:", msg, file=sys.stderr)


def _setoption(arg):
    parts = arg.split(':')
    if len(parts) > 5:
        raise _OptionError("too many fields (max 5): %r" % (arg,))
    while len(parts) < 5:
        parts.append('')
    action, message, category, module, lineno = [s.strip()
                                                 for s in parts]
    action = _getaction(action)
    category = _getcategory(category)
    if message or module:
        import re
    if message:
        message = re.escape(message)
    if module:
        module = re.escape(module) + r'\Z'
    if lineno:
        try:
            lineno = int(lineno)
            if lineno < 0:
                raise ValueError
        except (ValueError, OverflowError):
            raise _OptionError("invalid lineno %r" % (lineno,)) from None
    else:
        lineno = 0
    filterwarnings(action, message, category, module, lineno)


def _getaction(action):
    if not action:
        return "default"
    if action == "all": return "always" 
    for a in ('default', 'always', 'ignore', 'module', 'once', 'error'):
        if a.startswith(action):
            return a
    raise _OptionError("invalid action: %r" % (action,))


def _getcategory(category):
    if not category:
        return Warning
    if '.' not in category:
        import builtins as m
        klass = category
    else:
        module, _, klass = category.rpartition('.')
        try:
            m = __import__(module, None, None, [klass])
        except ImportError:
            raise _OptionError("invalid module name: %r" % (module,)) from None
    try:
        cat = getattr(m, klass)
    except AttributeError:
        raise _OptionError("unknown warning category: %r" % (category,)) from None
    if not issubclass(cat, Warning):
        raise _OptionError("invalid warning category: %r" % (category,))
    return cat


def _is_internal_filename(filename):
    return 'importlib' in filename and '_bootstrap' in filename


def _is_filename_to_skip(filename, skip_file_prefixes):
    return any(filename.startswith(prefix) for prefix in skip_file_prefixes)


def _is_internal_frame(frame):
    
    return _is_internal_filename(frame.f_code.co_filename)


def _next_external_frame(frame, skip_file_prefixes):
    
    frame = frame.f_back
    while frame is not None and (
            _is_internal_filename(filename := frame.f_code.co_filename) or
            _is_filename_to_skip(filename, skip_file_prefixes)):
        frame = frame.f_back
    return frame



def warn(message, category=None, stacklevel=1, source=None,
         *, skip_file_prefixes=()):
    
    
    if isinstance(message, Warning):
        category = message.__class__
    
    if category is None:
        category = UserWarning
    if not (isinstance(category, type) and issubclass(category, Warning)):
        raise TypeError("category must be a Warning subclass, "
                        "not '{:s}'".format(type(category).__name__))
    if not isinstance(skip_file_prefixes, tuple):
        
        raise TypeError('skip_file_prefixes must be a tuple of strs.')
    if skip_file_prefixes:
        stacklevel = max(2, stacklevel)
    
    try:
        if stacklevel <= 1 or _is_internal_frame(sys._getframe(1)):
            
            
            frame = sys._getframe(stacklevel)
        else:
            frame = sys._getframe(1)
            
            for x in range(stacklevel-1):
                frame = _next_external_frame(frame, skip_file_prefixes)
                if frame is None:
                    raise ValueError
    except ValueError:
        globals = sys.__dict__
        filename = "sys"
        lineno = 1
    else:
        globals = frame.f_globals
        filename = frame.f_code.co_filename
        lineno = frame.f_lineno
    if '__name__' in globals:
        module = globals['__name__']
    else:
        module = "<string>"
    registry = globals.setdefault("__warningregistry__", {})
    warn_explicit(message, category, filename, lineno, module, registry,
                  globals, source)

def warn_explicit(message, category, filename, lineno,
                  module=None, registry=None, module_globals=None,
                  source=None):
    lineno = int(lineno)
    if module is None:
        module = filename or "<unknown>"
        if module[-3:].lower() == ".py":
            module = module[:-3] 
    if registry is None:
        registry = {}
    if registry.get('version', 0) != _filters_version:
        registry.clear()
        registry['version'] = _filters_version
    if isinstance(message, Warning):
        text = str(message)
        category = message.__class__
    else:
        text = message
        message = category(message)
    key = (text, category, lineno)
    
    if registry.get(key):
        return
    
    for item in filters:
        action, msg, cat, mod, ln = item
        if ((msg is None or msg.match(text)) and
            issubclass(category, cat) and
            (mod is None or mod.match(module)) and
            (ln == 0 or lineno == ln)):
            break
    else:
        action = defaultaction
    
    if action == "ignore":
        return

    
    
    import linecache
    linecache.getlines(filename, module_globals)

    if action == "error":
        raise message
    
    if action == "once":
        registry[key] = 1
        oncekey = (text, category)
        if onceregistry.get(oncekey):
            return
        onceregistry[oncekey] = 1
    elif action == "always":
        pass
    elif action == "module":
        registry[key] = 1
        altkey = (text, category, 0)
        if registry.get(altkey):
            return
        registry[altkey] = 1
    elif action == "default":
        registry[key] = 1
    else:
        
        raise RuntimeError(
              "Unrecognized action (%r) in warnings.filters:\n %s" %
              (action, item))
    
    msg = WarningMessage(message, category, filename, lineno, source)
    _showwarnmsg(msg)


class WarningMessage(object):

    _WARNING_DETAILS = ("message", "category", "filename", "lineno", "file",
                        "line", "source")

    def __init__(self, message, category, filename, lineno, file=None,
                 line=None, source=None):
        self.message = message
        self.category = category
        self.filename = filename
        self.lineno = lineno
        self.file = file
        self.line = line
        self.source = source
        self._category_name = category.__name__ if category else None

    def __str__(self):
        return ("{message : %r, category : %r, filename : %r, lineno : %s, "
                    "line : %r}" % (self.message, self._category_name,
                                    self.filename, self.lineno, self.line))


class catch_warnings(object):

    

    def __init__(self, *, record=False, module=None,
                 action=None, category=Warning, lineno=0, append=False):
        
        self._record = record
        self._module = sys.modules['warnings'] if module is None else module
        self._entered = False
        if action is None:
            self._filter = None
        else:
            self._filter = (action, category, lineno, append)

    def __repr__(self):
        args = []
        if self._record:
            args.append("record=True")
        if self._module is not sys.modules['warnings']:
            args.append("module=%r" % self._module)
        name = type(self).__name__
        return "%s(%s)" % (name, ", ".join(args))

    def __enter__(self):
        if self._entered:
            raise RuntimeError("Cannot enter %r twice" % self)
        self._entered = True
        self._filters = self._module.filters
        self._module.filters = self._filters[:]
        self._module._filters_mutated()
        self._showwarning = self._module.showwarning
        self._showwarnmsg_impl = self._module._showwarnmsg_impl
        if self._filter is not None:
            simplefilter(*self._filter)
        if self._record:
            log = []
            self._module._showwarnmsg_impl = log.append
            
            
            self._module.showwarning = self._module._showwarning_orig
            return log
        else:
            return None

    def __exit__(self, *exc_info):
        if not self._entered:
            raise RuntimeError("Cannot exit %r without entering first" % self)
        self._module.filters = self._filters
        self._module._filters_mutated()
        self._module.showwarning = self._showwarning
        self._module._showwarnmsg_impl = self._showwarnmsg_impl


class deprecated:
    
    def __init__(
        self,
        message: str,
        /,
        *,
        category: type[Warning] | None = DeprecationWarning,
        stacklevel: int = 1,
    ) -> None:
        if not isinstance(message, str):
            raise TypeError(
                f"Expected an object of type str for 'message', not {type(message).__name__!r}"
            )
        self.message = message
        self.category = category
        self.stacklevel = stacklevel

    def __call__(self, arg, /):
        
        
        msg = self.message
        category = self.category
        stacklevel = self.stacklevel
        if category is None:
            arg.__deprecated__ = msg
            return arg
        elif isinstance(arg, type):
            import functools
            from types import MethodType

            original_new = arg.__new__

            @functools.wraps(original_new)
            def __new__(cls, *args, **kwargs):
                if cls is arg:
                    warn(msg, category=category, stacklevel=stacklevel + 1)
                if original_new is not object.__new__:
                    return original_new(cls, *args, **kwargs)
                
                elif cls.__init__ is object.__init__ and (args or kwargs):
                    raise TypeError(f"{cls.__name__}() takes no arguments")
                else:
                    return original_new(cls)

            arg.__new__ = staticmethod(__new__)

            original_init_subclass = arg.__init_subclass__
            
            
            if isinstance(original_init_subclass, MethodType):
                original_init_subclass = original_init_subclass.__func__

                @functools.wraps(original_init_subclass)
                def __init_subclass__(*args, **kwargs):
                    warn(msg, category=category, stacklevel=stacklevel + 1)
                    return original_init_subclass(*args, **kwargs)

                arg.__init_subclass__ = classmethod(__init_subclass__)
            
            
            else:
                @functools.wraps(original_init_subclass)
                def __init_subclass__(*args, **kwargs):
                    warn(msg, category=category, stacklevel=stacklevel + 1)
                    return original_init_subclass(*args, **kwargs)

                arg.__init_subclass__ = __init_subclass__

            arg.__deprecated__ = __new__.__deprecated__ = msg
            __init_subclass__.__deprecated__ = msg
            return arg
        elif callable(arg):
            import functools

            @functools.wraps(arg)
            def wrapper(*args, **kwargs):
                warn(msg, category=category, stacklevel=stacklevel + 1)
                return arg(*args, **kwargs)

            arg.__deprecated__ = wrapper.__deprecated__ = msg
            return wrapper
        else:
            raise TypeError(
                "@deprecated decorator with non-None category must be applied to "
                f"a class or callable, not {arg!r}"
            )


_DEPRECATED_MSG = "{name!r} is deprecated and slated for removal in Python {remove}"

def _deprecated(name, message=_DEPRECATED_MSG, *, remove, _version=sys.version_info):
    
    remove_formatted = f"{remove[0]}.{remove[1]}"
    if (_version[:2] > remove) or (_version[:2] == remove and _version[3] != "alpha"):
        msg = f"{name!r} was slated for removal after Python {remove_formatted} alpha"
        raise RuntimeError(msg)
    else:
        msg = message.format(name=name, remove=remove_formatted)
        warn(msg, DeprecationWarning, stacklevel=3)



def _warn_unawaited_coroutine(coro):
    msg_lines = [
        f"coroutine '{coro.__qualname__}' was never awaited\n"
    ]
    if coro.cr_origin is not None:
        import linecache, traceback
        def extract():
            for filename, lineno, funcname in reversed(coro.cr_origin):
                line = linecache.getline(filename, lineno)
                yield (filename, lineno, funcname, line)
        msg_lines.append("Coroutine created at (most recent call last)\n")
        msg_lines += traceback.format_list(list(extract()))
    msg = "".join(msg_lines).rstrip("\n")
    
    
    
    
    
    
    warn(msg, category=RuntimeWarning, stacklevel=2, source=coro)










try:
    from _warnings import (filters, _defaultaction, _onceregistry,
                           warn, warn_explicit, _filters_mutated)
    defaultaction = _defaultaction
    onceregistry = _onceregistry
    _warnings_defaults = True
except ImportError:
    filters = []
    defaultaction = "default"
    onceregistry = {}

    _filters_version = 1

    def _filters_mutated():
        global _filters_version
        _filters_version += 1

    _warnings_defaults = False



_processoptions(sys.warnoptions)
if not _warnings_defaults:
    
    if not hasattr(sys, 'gettotalrefcount'):
        filterwarnings("default", category=DeprecationWarning,
                       module="__main__", append=1)
        simplefilter("ignore", category=DeprecationWarning, append=1)
        simplefilter("ignore", category=PendingDeprecationWarning, append=1)
        simplefilter("ignore", category=ImportWarning, append=1)
        simplefilter("ignore", category=ResourceWarning, append=1)

del _warnings_defaults