

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: warnings.py</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'>&quot;&quot;&quot;Python part of the warnings subsystem.&quot;&quot;&quot;

# Note: function level imports should *not* be used
# in this module as it may cause import lock deadlock.
# See bug 683658.
import linecache
import sys
import types

__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 warnpy3k(message, category=None, stacklevel=1):
    &quot;&quot;&quot;Issue a deprecation warning for Python 3.x related changes.

    Warnings are omitted unless Python is started with the -3 option.
    &quot;&quot;&quot;
    if sys.py3kwarning:
        if category is None:
            category = DeprecationWarning
        warn(message, category, stacklevel+1)

def _show_warning(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;
    if file is None:
        file = sys.stderr
        if file is None:
            # sys.stderr is None - warnings get lost
            return
    try:
        file.write(formatwarning(message, category, filename, lineno, line))
    except (IOError, UnicodeError):
        pass # the file (probably stderr) is invalid - this warning gets lost.
# Keep a working version around in case the deprecation of the old API is
# triggered.
showwarning = _show_warning

def formatwarning(message, category, filename, lineno, line=None):
    &quot;&quot;&quot;Function to format a warning the standard way.&quot;&quot;&quot;
    try:
        unicodetype = unicode
    except NameError:
        unicodetype = ()
    try:
        message = str(message)
    except UnicodeEncodeError:
        pass
    s =  &quot;%s: %s: %s\n&quot; % (lineno, category.__name__, message)
    line = linecache.getline(filename, lineno) if line is None else line
    if line:
        line = line.strip()
        if isinstance(s, unicodetype) and isinstance(line, str):
            line = unicode(line, &#039;latin1&#039;)
        s += &quot;  %s\n&quot; % line
    if isinstance(s, unicodetype) and isinstance(filename, str):
        enc = sys.getfilesystemencoding()
        if enc:
            try:
                filename = unicode(filename, enc)
            except UnicodeDecodeError:
                pass
    s = &quot;%s:%s&quot; % (filename, s)
    return s

def filterwarnings(action, message=&quot;&quot;, category=Warning, module=&quot;&quot;, lineno=0,
                   append=0):
    &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;
    import re
    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, basestring), &quot;message must be a string&quot;
    assert isinstance(category, (type, types.ClassType)), \
           &quot;category must be a class&quot;
    assert issubclass(category, Warning), &quot;category must be a Warning subclass&quot;
    assert isinstance(module, basestring), &quot;module must be a string&quot;
    assert isinstance(lineno, (int, long)) and lineno &gt;= 0, \
           &quot;lineno must be an int &gt;= 0&quot;
    item = (action, re.compile(message, re.I), category,
            re.compile(module), int(lineno))
    if append:
        filters.append(item)
    else:
        filters.insert(0, item)

def simplefilter(action, category=Warning, lineno=0, append=0):
    &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, long)) and lineno &gt;= 0, \
           &quot;lineno must be an int &gt;= 0&quot;
    item = (action, None, category, None, int(lineno))
    if append:
        filters.append(item)
    else:
        filters.insert(0, item)

def resetwarnings():
    &quot;&quot;&quot;Clear the list of warning filters, so that no filters are active.&quot;&quot;&quot;
    filters[:] = []

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, msg:
            print &gt;&gt;sys.stderr, &quot;Invalid -W option ignored:&quot;, msg

# Helper for _processoptions()
def _setoption(arg):
    import re
    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)
    message = re.escape(message)
    category = _getcategory(category)
    module = re.escape(module)
    if module:
        module = module + &#039;$&#039;
    if lineno:
        try:
            lineno = int(lineno)
            if lineno &lt; 0:
                raise ValueError
        except (ValueError, OverflowError):
            raise _OptionError(&quot;invalid lineno %r&quot; % (lineno,))
    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):
    import re
    if not category:
        return Warning
    if re.match(&quot;^[a-zA-Z0-9_]+$&quot;, category):
        try:
            cat = eval(category)
        except NameError:
            raise _OptionError(&quot;unknown warning category: %r&quot; % (category,))
    else:
        i = category.rfind(&quot;.&quot;)
        module = category[:i]
        klass = category[i+1:]
        try:
            m = __import__(module, None, None, [klass])
        except ImportError:
            raise _OptionError(&quot;invalid module name: %r&quot; % (module,))
        try:
            cat = getattr(m, klass)
        except AttributeError:
            raise _OptionError(&quot;unknown warning category: %r&quot; % (category,))
    if not issubclass(cat, Warning):
        raise _OptionError(&quot;invalid warning category: %r&quot; % (category,))
    return cat


# Code typically replaced by _warnings
def warn(message, category=None, stacklevel=1):
    &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
    assert issubclass(category, Warning)
    # Get context information
    try:
        caller = sys._getframe(stacklevel)
    except ValueError:
        globals = sys.__dict__
        lineno = 1
    else:
        globals = caller.f_globals
        lineno = caller.f_lineno
    if &#039;__name__&#039; in globals:
        module = globals[&#039;__name__&#039;]
    else:
        module = &quot;&lt;string&gt;&quot;
    filename = globals.get(&#039;__file__&#039;)
    if filename:
        fnl = filename.lower()
        if fnl.endswith((&quot;.pyc&quot;, &quot;.pyo&quot;)):
            filename = filename[:-1]
    else:
        if module == &quot;__main__&quot;:
            try:
                filename = sys.argv[0]
            except AttributeError:
                # embedded interpreters don&#039;t have sys.argv, see bug #839151
                filename = &#039;__main__&#039;
        if not filename:
            filename = module
    registry = globals.setdefault(&quot;__warningregistry__&quot;, {})
    warn_explicit(message, category, filename, lineno, module, registry,
                  globals)

def warn_explicit(message, category, filename, lineno,
                  module=None, registry=None, module_globals=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 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;:
        registry[key] = 1
        return

    # Prime the linecache for formatting, in case the
    # &quot;file&quot; is actually in a zipfile or something.
    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
    showwarning(message, category, filename, lineno)


class WarningMessage(object):

    &quot;&quot;&quot;Holds the result of a single showwarning() call.&quot;&quot;&quot;

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

    def __init__(self, message, category, filename, lineno, file=None,
                    line=None):
        self.message = message
        self.category = category
        self.filename = filename
        self.lineno = lineno
        self.file = file
        self.line = line
        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._showwarning = self._module.showwarning
        if self._record:
            log = []
            def showwarning(*args, **kwargs):
                log.append(WarningMessage(*args, **kwargs))
            self._module.showwarning = showwarning
            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.showwarning = self._showwarning


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


# Module initialization
_processoptions(sys.warnoptions)
if not _warnings_defaults:
    silence = [ImportWarning, PendingDeprecationWarning]
    # Don&#039;t silence DeprecationWarning if -3 or -Q was used.
    if not sys.py3kwarning and not sys.flags.division_warning:
        silence.append(DeprecationWarning)
    for cls in silence:
        simplefilter(&quot;ignore&quot;, category=cls)
    bytes_warning = sys.flags.bytes_warning
    if bytes_warning &gt; 1:
        bytes_action = &quot;error&quot;
    elif bytes_warning:
        bytes_action = &quot;default&quot;
    else:
        bytes_action = &quot;ignore&quot;
    simplefilter(bytes_action, category=BytesWarning, append=1)
del _warnings_defaults
</textarea><br><br><input type='hidden' name='archivo_editar' value='/lib64/python2.7/warnings.py'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Flib64%2Fpython2.7' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>