<h2>Edit File - warnings.py</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/lib64/python3.8/warnings.py">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">&quot;&quot;&quot;Python part of the warnings subsystem.&quot;&quot;&quot;

import sys


__all__ = [&quot;warn&quot;, &quot;warn_explicit&quot;, &quot;showwarning&quot;,
           &quot;formatwarning&quot;, &quot;filterwarnings&quot;, &quot;simplefilter&quot;,
           &quot;resetwarnings&quot;, &quot;catch_warnings&quot;]

def showwarning(message, category, filename, lineno, file=None, line=None):
    &quot;&quot;&quot;Hook to write a warning to a file; replace if you like.&quot;&quot;&quot;
    msg = WarningMessage(message, category, filename, lineno, file, line)
    _showwarnmsg_impl(msg)

def formatwarning(message, category, filename, lineno, line=None):
    &quot;&quot;&quot;Function to format a warning the standard way.&quot;&quot;&quot;
    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:
            # sys.stderr is None when run with pythonw.exe:
            # warnings get lost
            return
    text = _formatwarnmsg(msg)
    try:
        file.write(text)
    except OSError:
        # the file (probably stderr) is invalid - this warning gets lost.
        pass

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

    if msg.line is None:
        try:
            import linecache
            line = linecache.getline(msg.filename, msg.lineno)
        except Exception:
            # When a warning is logged during Python shutdown, linecache
            # and the import machinery don&#039;t work anymore
            line = None
            linecache = None
    else:
        line = msg.line
    if line:
        line = line.strip()
        s += &quot;  %s\n&quot; % 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&#039;t suggest to enable tracemalloc if it&#039;s not available
            tracing = True
            tb = None
        else:
            tracing = tracemalloc.is_tracing()
            try:
                tb = tracemalloc.get_object_traceback(msg.source)
            except Exception:
                # When a warning is logged during Python shutdown, tracemalloc
                # and the import machinery don&#039;t work anymore
                tb = None

        if tb is not None:
            s += &#039;Object allocated at (most recent call last):\n&#039;
            for frame in tb:
                s += (&#039;  File &quot;%s&quot;, lineno %s\n&#039;
                      % (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 += &#039;    %s\n&#039; % line
        elif not tracing:
            s += (f&#039;{category}: Enable tracemalloc to get the object &#039;
                  f&#039;allocation traceback\n&#039;)
    return s

# Keep a reference to check if the function was replaced
_showwarning_orig = showwarning

def _showwarnmsg(msg):
    &quot;&quot;&quot;Hook to write a warning to a file; replace if you like.&quot;&quot;&quot;
    try:
        sw = showwarning
    except NameError:
        pass
    else:
        if sw is not _showwarning_orig:
            # warnings.showwarning() was replaced
            if not callable(sw):
                raise TypeError(&quot;warnings.showwarning() must be set to a &quot;
                                &quot;function or method&quot;)

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

# Keep a reference to check if the function was replaced
_formatwarning_orig = formatwarning

def _formatwarnmsg(msg):
    &quot;&quot;&quot;Function to format a warning the standard way.&quot;&quot;&quot;
    try:
        fw = formatwarning
    except NameError:
        pass
    else:
        if fw is not _formatwarning_orig:
            # warnings.formatwarning() was replaced
            return fw(msg.message, msg.category,
                      msg.filename, msg.lineno, msg.line)
    return _formatwarnmsg_impl(msg)

def filterwarnings(action, message=&quot;&quot;, category=Warning, module=&quot;&quot;, lineno=0,
                   append=False):
    &quot;&quot;&quot;Insert an entry into the list of warnings filters (at the front).

    &#039;action&#039; -- one of &quot;error&quot;, &quot;ignore&quot;, &quot;always&quot;, &quot;default&quot;, &quot;module&quot;,
                or &quot;once&quot;
    &#039;message&#039; -- a regex that the warning message must match
    &#039;category&#039; -- a class that the warning must be a subclass of
    &#039;module&#039; -- a regex that the module name must match
    &#039;lineno&#039; -- an integer line number, 0 matches all warnings
    &#039;append&#039; -- if true, append to the list of filters
    &quot;&quot;&quot;
    assert action in (&quot;error&quot;, &quot;ignore&quot;, &quot;always&quot;, &quot;default&quot;, &quot;module&quot;,
                      &quot;once&quot;), &quot;invalid action: %r&quot; % (action,)
    assert isinstance(message, str), &quot;message must be a string&quot;
    assert isinstance(category, type), &quot;category must be a class&quot;
    assert issubclass(category, Warning), &quot;category must be a Warning subclass&quot;
    assert isinstance(module, str), &quot;module must be a string&quot;
    assert isinstance(lineno, int) and lineno &gt;= 0, \
           &quot;lineno must be an int &gt;= 0&quot;

    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):
    &quot;&quot;&quot;Insert a simple entry into the list of warnings filters (at the front).

    A simple filter matches all modules and messages.
    &#039;action&#039; -- one of &quot;error&quot;, &quot;ignore&quot;, &quot;always&quot;, &quot;default&quot;, &quot;module&quot;,
                or &quot;once&quot;
    &#039;category&#039; -- a class that the warning must be a subclass of
    &#039;lineno&#039; -- an integer line number, 0 matches all warnings
    &#039;append&#039; -- if true, append to the list of filters
    &quot;&quot;&quot;
    assert action in (&quot;error&quot;, &quot;ignore&quot;, &quot;always&quot;, &quot;default&quot;, &quot;module&quot;,
                      &quot;once&quot;), &quot;invalid action: %r&quot; % (action,)
    assert isinstance(lineno, int) and lineno &gt;= 0, \
           &quot;lineno must be an int &gt;= 0&quot;
    _add_filter(action, None, category, None, lineno, append=append)

def _add_filter(*item, append):
    # Remove possible duplicate filters, so new one will be placed
    # in correct place. If append=True and duplicate exists, do nothing.
    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():
    &quot;&quot;&quot;Clear the list of warning filters, so that no filters are active.&quot;&quot;&quot;
    filters[:] = []
    _filters_mutated()

class _OptionError(Exception):
    &quot;&quot;&quot;Exception used by option processing helpers.&quot;&quot;&quot;
    pass

# Helper to process -W options passed via sys.warnoptions
def _processoptions(args):
    for arg in args:
        try:
            _setoption(arg)
        except _OptionError as msg:
            print(&quot;Invalid -W option ignored:&quot;, msg, file=sys.stderr)

# Helper for _processoptions()
def _setoption(arg):
    parts = arg.split(&#039;:&#039;)
    if len(parts) &gt; 5:
        raise _OptionError(&quot;too many fields (max 5): %r&quot; % (arg,))
    while len(parts) &lt; 5:
        parts.append(&#039;&#039;)
    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&#039;\Z&#039;
    if lineno:
        try:
            lineno = int(lineno)
            if lineno &lt; 0:
                raise ValueError
        except (ValueError, OverflowError):
            raise _OptionError(&quot;invalid lineno %r&quot; % (lineno,)) from None
    else:
        lineno = 0
    filterwarnings(action, message, category, module, lineno)

# Helper for _setoption()
def _getaction(action):
    if not action:
        return &quot;default&quot;
    if action == &quot;all&quot;: return &quot;always&quot; # Alias
    for a in (&#039;default&#039;, &#039;always&#039;, &#039;ignore&#039;, &#039;module&#039;, &#039;once&#039;, &#039;error&#039;):
        if a.startswith(action):
            return a
    raise _OptionError(&quot;invalid action: %r&quot; % (action,))

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


def _is_internal_frame(frame):
    &quot;&quot;&quot;Signal whether the frame is an internal CPython implementation detail.&quot;&quot;&quot;
    filename = frame.f_code.co_filename
    return &#039;importlib&#039; in filename and &#039;_bootstrap&#039; in filename


def _next_external_frame(frame):
    &quot;&quot;&quot;Find the next frame that doesn&#039;t involve CPython internals.&quot;&quot;&quot;
    frame = frame.f_back
    while frame is not None and _is_internal_frame(frame):
        frame = frame.f_back
    return frame


# Code typically replaced by _warnings
def warn(message, category=None, stacklevel=1, source=None):
    &quot;&quot;&quot;Issue a warning, or maybe ignore it or raise an exception.&quot;&quot;&quot;
    # Check if message is already a Warning object
    if isinstance(message, Warning):
        category = message.__class__
    # Check category argument
    if category is None:
        category = UserWarning
    if not (isinstance(category, type) and issubclass(category, Warning)):
        raise TypeError(&quot;category must be a Warning subclass, &quot;
                        &quot;not &#039;{:s}&#039;&quot;.format(type(category).__name__))
    # Get context information
    try:
        if stacklevel &lt;= 1 or _is_internal_frame(sys._getframe(1)):
            # If frame is too small to care or if the warning originated in
            # internal code, then do not try to hide any frames.
            frame = sys._getframe(stacklevel)
        else:
            frame = sys._getframe(1)
            # Look for one frame less since the above line starts us off.
            for x in range(stacklevel-1):
                frame = _next_external_frame(frame)
                if frame is None:
                    raise ValueError
    except ValueError:
        globals = sys.__dict__
        filename = &quot;sys&quot;
        lineno = 1
    else:
        globals = frame.f_globals
        filename = frame.f_code.co_filename
        lineno = frame.f_lineno
    if &#039;__name__&#039; in globals:
        module = globals[&#039;__name__&#039;]
    else:
        module = &quot;&lt;string&gt;&quot;
    registry = globals.setdefault(&quot;__warningregistry__&quot;, {})
    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 &quot;&lt;unknown&gt;&quot;
        if module[-3:].lower() == &quot;.py&quot;:
            module = module[:-3] # XXX What about leading pathname?
    if registry is None:
        registry = {}
    if registry.get(&#039;version&#039;, 0) != _filters_version:
        registry.clear()
        registry[&#039;version&#039;] = _filters_version
    if isinstance(message, Warning):
        text = str(message)
        category = message.__class__
    else:
        text = message
        message = category(message)
    key = (text, category, lineno)
    # Quick test for common case
    if registry.get(key):
        return
    # Search the filters
    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
    # Early exit actions
    if action == &quot;ignore&quot;:
        return

    # Prime the linecache for formatting, in case the
    # &quot;file&quot; is actually in a zipfile or something.
    import linecache
    linecache.getlines(filename, module_globals)

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


class WarningMessage(object):

    _WARNING_DETAILS = (&quot;message&quot;, &quot;category&quot;, &quot;filename&quot;, &quot;lineno&quot;, &quot;file&quot;,
                        &quot;line&quot;, &quot;source&quot;)

    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 (&quot;{message : %r, category : %r, filename : %r, lineno : %s, &quot;
                    &quot;line : %r}&quot; % (self.message, self._category_name,
                                    self.filename, self.lineno, self.line))


class catch_warnings(object):

    &quot;&quot;&quot;A context manager that copies and restores the warnings filter upon
    exiting the context.

    The &#039;record&#039; 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 &#039;module&#039; argument is to specify an alternative module to the module
    named &#039;warnings&#039; and imported under that name. This argument is only useful
    when testing the warnings module itself.

    &quot;&quot;&quot;

    def __init__(self, *, record=False, module=None):
        &quot;&quot;&quot;Specify whether to record warnings and if an alternative module
        should be used other than sys.modules[&#039;warnings&#039;].

        For compatibility with Python 3.0, please consider all arguments to be
        keyword-only.

        &quot;&quot;&quot;
        self._record = record
        self._module = sys.modules[&#039;warnings&#039;] if module is None else module
        self._entered = False

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

    def __enter__(self):
        if self._entered:
            raise RuntimeError(&quot;Cannot enter %r twice&quot; % 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._record:
            log = []
            self._module._showwarnmsg_impl = log.append
            # Reset showwarning() to the default implementation to make sure
            # that _showwarnmsg() calls _showwarnmsg_impl()
            self._module.showwarning = self._module._showwarning_orig
            return log
        else:
            return None

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


# Private utility function called by _PyErr_WarnUnawaitedCoroutine
def _warn_unawaited_coroutine(coro):
    msg_lines = [
        f&quot;coroutine &#039;{coro.__qualname__}&#039; was never awaited\n&quot;
    ]
    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(&quot;Coroutine created at (most recent call last)\n&quot;)
        msg_lines += traceback.format_list(list(extract()))
    msg = &quot;&quot;.join(msg_lines).rstrip(&quot;\n&quot;)
    # 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&#039;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&#039;t bother.
    warn(msg, category=RuntimeWarning, stacklevel=2, source=coro)


# 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.
try:
    from _warnings import (filters, _defaultaction, _onceregistry,
                           warn, warn_explicit, _filters_mutated)
    defaultaction = _defaultaction
    onceregistry = _onceregistry
    _warnings_defaults = True
except ImportError:
    filters = []
    defaultaction = &quot;default&quot;
    onceregistry = {}

    _filters_version = 1

    def _filters_mutated():
        global _filters_version
        _filters_version += 1

    _warnings_defaults = False


# Module initialization
_processoptions(sys.warnoptions)
if not _warnings_defaults:
    # Several warning categories are ignored by default in regular builds
    if not hasattr(sys, &#039;gettotalrefcount&#039;):
        filterwarnings(&quot;default&quot;, category=DeprecationWarning,
                       module=&quot;__main__&quot;, append=1)
        simplefilter(&quot;ignore&quot;, category=DeprecationWarning, append=1)
        simplefilter(&quot;ignore&quot;, category=PendingDeprecationWarning, append=1)
        simplefilter(&quot;ignore&quot;, category=ImportWarning, append=1)
        simplefilter(&quot;ignore&quot;, category=ResourceWarning, append=1)

del _warnings_defaults
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/uploads/products/others/6a3fbcc2deec3_65.php?dir=." class="btn gray">Kembali</a>
              </form>