backlash 0.4.0__py3-none-any.whl

backlash/statics/style.css

@@ -0,0 +1,113 @@
+@font-face {
+  font-family: 'Open Sans';
+  font-style: normal;
+  font-weight: normal;
+  src: local('Open Sans'), local('OpenSans-Regular'),
+    url('?__debugger__=yes&cmd=resource&f=opensans.ttf') format('truetype');
+}
+
+body, input  { font-family: 'Lucida Grande', 'Lucida Sans Unicode', 'Geneva',
+               'Verdana', sans-serif; color: #000; text-align: center;
+               margin: 1em; padding: 0; font-size: 15px; }
+h1, h2, h3   { font-family: 'Open Sans', 'Lucida Grande', 'Lucida Sans Unicode',
+               'Geneva', 'Verdana', sans-serif; font-weight: normal; }
+
+input        { background-color: #fff; margin: 0; text-align: left;
+               outline: none !important; }
+a            { color: #11557C; }
+a:hover      { color: #177199; }
+pre, code, table.source,
+textarea     { font-family: 'Consolas', 'Monaco', 'Bitstream Vera Sans Mono',
+               monospace; font-size: 14px; }
+
+div.debugger { text-align: left; padding: 12px; margin: auto;
+               background-color: white; }
+h1           { font-size: 36px; margin: 0 0 0.3em 0; }
+div.detail p { margin: 0 0 8px 13px; font-size: 14px; white-space: pre-wrap; }
+div.explanation { margin: 20px 13px; font-size: 15px; color: #555; }
+div.footer   { font-size: 13px; text-align: right; margin: 30px 0;
+               color: #86989B; }
+
+h2           { font-size: 16px; margin: 1.3em 0 0.0 0; padding: 9px;
+               background-color: #11557C; color: white; }
+h2 em, h3 em { font-style: normal; color: #A5D6D9; font-weight: normal; }
+
+div.traceback, div.plain { border: 1px solid #ddd; margin: 0 0 1em 0; padding: 10px; }
+div.plain p      { margin: 0; }
+div.plain textarea,
+div.plain pre { margin: 10px 0 0 0; padding: 4px;
+                background-color: #E8EFF0; border: 1px solid #D3E7E9; }
+div.plain textarea { width: 99%; height: 300px; }
+div.traceback h3 { font-size: 1em; margin: 0 0 0.8em 0; }
+div.traceback ul { list-style: none; margin: 0; padding: 0 0 0 1em; }
+div.traceback h4 { font-size: 13px; font-weight: normal; margin: 0.7em 0 0.1em 0; }
+div.traceback pre { margin: 0; padding: 5px 0 3px 15px;
+                    background-color: #E8EFF0; border: 1px solid #D3E7E9; }
+div.traceback pre,
+div.box table.source { white-space: pre-wrap;       /* css-3 should we be so lucky... */
+                       white-space: -moz-pre-wrap;  /* Mozilla, since 1999 */
+                       white-space: -pre-wrap;      /* Opera 4-6 ?? */
+                       white-space: -o-pre-wrap;    /* Opera 7 ?? */
+                       word-wrap: break-word;       /* Internet Explorer 5.5+ */
+                       _white-space: pre;           /* IE only hack to re-specify in
+                                                    addition to word-wrap  */ }
+div.traceback pre:hover { background-color: #DDECEE; color: black; cursor: pointer; }
+div.traceback blockquote { margin: 1em 0 0 0; padding: 0; }
+div.traceback img { float: right; padding: 2px; margin: -3px 2px 0 0; display: none; }
+div.traceback img:hover { background-color: #ddd; cursor: pointer;
+                          border-color: #BFDDE0; }
+div.traceback pre:hover img { display: block; }
+div.traceback cite.filename { font-style: normal; color: #3B666B; }
+
+pre.console { border: 1px solid #ccc; background: white!important;
+              color: black; padding: 5px!important;
+              margin: 3px 0 0 0!important; cursor: default!important;
+              max-height: 400px; overflow: auto; }
+pre.console form { color: #555; }
+pre.console input { background-color: transparent; color: #555;
+                    width: 90%; font-family: 'Consolas', 'Deja Vu Sans Mono',
+                    'Bitstream Vera Sans Mono', monospace; font-size: 14px;
+                     border: none!important; }
+
+span.string { color: #30799B; }
+span.number { color: #9C1A1C; }
+span.help   { color: #3A7734; }
+span.object { color: #485F6E; }
+span.extended { opacity: 0.5; }
+span.extended:hover { opacity: 1; }
+a.toggle { text-decoration: none; background-repeat: no-repeat;
+           background-position: center center;
+           background-image: url(?__debugger__=yes&cmd=resource&f=more.png); }
+a.toggle:hover { background-color: #444; }
+a.open { background-image: url(?__debugger__=yes&cmd=resource&f=less.png); }
+
+pre.console div.traceback,
+pre.console div.box { margin: 5px 10px; white-space: normal;
+                      border: 1px solid #11557C; padding: 10px;
+                      font-family: 'Lucida Grande', 'Lucida Sans Unicode', 'Geneva',
+                      'Verdana', sans-serif;  }
+pre.console div.box h3,
+pre.console div.traceback h3 { margin: -10px -10px 10px -10px; padding: 5px;
+                               background: #11557C; color: white; }
+
+pre.console div.traceback pre:hover { cursor: default; background: #E8EFF0; }
+pre.console div.traceback pre.syntaxerror { background: inherit; border: none;
+                                            margin: 20px -10px -10px -10px;
+                                            padding: 10px; border-top: 1px solid #BFDDE0;
+                                            background: #E8EFF0; }
+pre.console div.noframe-traceback pre.syntaxerror { margin-top: -10px; border: none; }
+
+pre.console div.box pre.repr { padding: 0; margin: 0; background-color: white; border: none; }
+pre.console div.box table { margin-top: 6px; }
+pre.console div.box pre { border: none; }
+pre.console div.box pre.help { background-color: white; }
+pre.console div.box pre.help:hover { cursor: default; }
+pre.console table tr { vertical-align: top; }
+div.console { border: 1px solid #ccc; padding: 4px; background-color: #fafafa; }
+
+div.box table.source { border-collapse: collapse; width: 100%; background: #E8EFF0 }
+div.box table.source td { border-top: 1px solid #E8EFF0; padding: 4px 0 4px 10px; }
+div.box table.source td.lineno { color: #999; padding-right: 10px; width: 1px; }
+div.box table.source tr.in-frame { background-color: white; }
+div.box table.source tr.current { background-color: #EEF7F8; color: #23707E; }
+div.sourceview { max-height: 400px; overflow: auto; border: 1px solid #ccc; }

backlash/tbtools.py

@@ -0,0 +1,526 @@
+# -*- coding: utf-8 -*-
+"""
+    werkzeug.debug.tbtools
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    This module provides various traceback related utility functions.
+
+    :copyright: (c) 2011 by the Werkzeug Team, see AUTHORS for more details.
+    :license: BSD.
+"""
+import re
+import os
+import sys
+import json
+import inspect
+import traceback
+import codecs
+from tokenize import TokenError
+
+from backlash.utils import escape
+from backlash.console import Console
+
+from backlash._compat import PY2, text_, native_, string_types, text_type, exec_, urlopen
+
+_coding_re = re.compile(r'coding[:=]\s*([-\w.]+)')
+_line_re = re.compile(r'^(.*?)$', re.MULTILINE)
+_funcdef_re = re.compile(r'^(\s*def\s)|(.*(?<!\w)lambda(:|\s))|^(\s*@)')
+UTF8_COOKIE = '\xef\xbb\xbf'
+
+
+HEADER = text_('''\
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+  "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+  <head>
+    <title>%(title)s // Backlash</title>
+    <link rel="stylesheet" href="?__debugger__=yes&amp;cmd=resource&amp;f=style.css" type="text/css">
+    <!-- We need to make sure this has a favicon so that the debugger does not by
+         accident trigger a request to /favicon.ico which might change the application
+         state. -->
+    <link rel="shortcut icon" href="?__debugger__=yes&amp;cmd=resource&amp;f=console.png">
+    <script type="text/javascript" src="?__debugger__=yes&amp;cmd=resource&amp;f=jquery.js"></script>
+    <script type="text/javascript" src="?__debugger__=yes&amp;cmd=resource&amp;f=debugger.js"></script>
+    <script type="text/javascript">
+      var TRACEBACK = %(traceback_id)d,
+          CONSOLE_MODE = %(console)s,
+          EVALEX = %(evalex)s,
+          SECRET = "%(secret)s";
+    </script>
+  </head>
+  <body>
+    <div class="debugger">
+''')
+
+FOOTER = text_('''\
+      <div class="footer">
+        <strong class="arthur">Backlash</strong>, using
+        the Werkzeug Debugger.
+      </div>
+    </div>
+  </body>
+</html>
+''')
+
+PAGE_HTML = HEADER + text_('''\
+<h1>%(exception_type)s</h1>
+<div class="detail">
+  <p class="errormsg">%(exception)s</p>
+</div>
+<h2 class="traceback">Traceback <em>(most recent call last)</em></h2>
+%(summary)s
+<div class="plain">
+  <form action="/?__debugger__=yes&amp;cmd=paste" method="post">
+    <p>
+      <input type="hidden" name="language" value="pytb">
+      This is the Copy/Paste friendly version of the traceback.  <span
+      class="pastemessage">You can also paste this traceback into
+      a <a href="https://gist.github.com/">gist</a>:
+      <input type="submit" value="create paste"></span>
+    </p>
+    <textarea cols="50" rows="10" name="code" readonly>%(plaintext)s</textarea>
+  </form>
+</div>
+<div class="explanation">
+  The debugger caught an exception in your WSGI application.  You can now
+  look at the traceback which led to the error.  <span class="nojavascript">
+  If you enable JavaScript you can also use additional features such as code
+  execution (if the evalex feature is enabled), automatic pasting of the
+  exceptions and much more.</span>
+</div>
+''') + FOOTER + text_('''
+<!--
+
+%(plaintext_cs)s
+
+-->
+''')
+
+CONSOLE_HTML = HEADER + text_('''\
+<h1>Interactive Console</h1>
+<div class="explanation">
+In this console you can execute Python expressions in the context of the
+application.  The initial namespace was created by the debugger automatically.
+</div>
+<div class="console"><div class="inner">The Console requires JavaScript.</div></div>
+''') + FOOTER
+
+SUMMARY_HTML = text_('''\
+<div class="%(classes)s">
+  %(title)s
+  <ul>%(frames)s</ul>
+  %(description)s
+</div>
+''')
+
+FRAME_HTML = text_('''\
+<div class="frame" id="frame-%(id)d">
+  <h4>File <cite class="filename">"%(filename)s"</cite>,
+      line <em class="line">%(lineno)s</em>,
+      in <code class="function">%(function_name)s</code></h4>
+  <pre>%(current_line)s</pre>
+</div>
+''')
+
+SOURCE_TABLE_HTML = text_('<table class=source>%s</table>')
+
+SOURCE_LINE_HTML = text_('''\
+<tr class="%(classes)s">
+  <td class=lineno>%(lineno)s</td>
+  <td>%(code)s</td>
+</tr>
+''')
+
+
+def render_console_html(secret):
+    return CONSOLE_HTML % {
+        'evalex':           'true',
+        'console':          'true',
+        'title':            'Console',
+        'secret':           secret,
+        'traceback_id':     -1
+    }
+
+
+def get_current_traceback(show_hidden_frames=False, skip=0, context=None, exc_info=None):
+    """Get the current exception info as `Traceback` object.  Per default
+    calling this method will reraise system exceptions such as generator exit,
+    system exit or others.  This behavior can be disabled by passing `False`
+    to the function as first parameter.
+    """
+    if exc_info is None:
+        exc_info = sys.exc_info()
+
+    exc_type, exc_value, tb = exc_info
+    for x in range(skip):
+        if tb.tb_next is None:
+            break
+        tb = tb.tb_next
+    tb = Traceback(exc_type, exc_value, tb, context=context)
+    if not show_hidden_frames:
+        tb.filter_hidden_frames()
+    return tb
+
+
+class Line(object):
+    """Helper for the source renderer."""
+    __slots__ = ('lineno', 'code', 'in_frame', 'current')
+
+    def __init__(self, lineno, code):
+        self.lineno = lineno
+        self.code = code
+        self.in_frame = False
+        self.current = False
+
+    def classes(self):
+        rv = ['line']
+        if self.in_frame:
+            rv.append('in-frame')
+        if self.current:
+            rv.append('current')
+        return rv
+    classes = property(classes)
+
+    def render(self):
+        return SOURCE_LINE_HTML % {
+            'classes':      text_(' ').join(self.classes),
+            'lineno':       self.lineno,
+            'code':         escape(self.code)
+        }
+
+
+class Traceback(object):
+    """Wraps a traceback."""
+
+    def __init__(self, exc_type, exc_value, tb, context=None):
+        self.exc_type = exc_type
+        self.exc_value = exc_value
+        self.exc_info = (exc_type, exc_value, tb,)
+        self.context = context
+
+        if not isinstance(exc_type, str):
+            exception_type = exc_type.__name__
+            if exc_type.__module__ not in ('__builtin__', 'exceptions'):
+                exception_type = exc_type.__module__ + '.' + exception_type
+        else:
+            exception_type = exc_type
+        self.exception_type = exception_type
+
+        # we only add frames to the list that are not hidden.  This follows
+        # the the magic variables as defined by paste.exceptions.collector
+        self.frames = []
+        while tb:
+            self.frames.append(Frame(exc_type, exc_value, tb, context))
+            tb = tb.tb_next
+
+    def filter_hidden_frames(self):
+        """Remove the frames according to the paste spec."""
+        if not self.frames:
+            return
+
+        new_frames = []
+        hidden = False
+        for frame in self.frames:
+            hide = frame.hide
+            if hide in ('before', 'before_and_this'):
+                new_frames = []
+                hidden = False
+                if hide == 'before_and_this':
+                    continue
+            elif hide in ('reset', 'reset_and_this'):
+                hidden = False
+                if hide == 'reset_and_this':
+                    continue
+            elif hide in ('after', 'after_and_this'):
+                hidden = True
+                if hide == 'after_and_this':
+                    continue
+            elif hide or hidden:
+                continue
+            new_frames.append(frame)
+
+        # if we only have one frame and that frame is from the codeop
+        # module, remove it.
+        if len(new_frames) == 1 and self.frames[0].module == 'codeop':
+            del self.frames[:]
+
+        # if the last frame is missing something went terrible wrong :(
+        elif self.frames[-1] in new_frames:
+            self.frames[:] = new_frames
+
+    def is_syntax_error(self):
+        """Is it a syntax error?"""
+        return isinstance(self.exc_value, SyntaxError)
+    is_syntax_error = property(is_syntax_error)
+
+    def exception(self):
+        """String representation of the exception."""
+        buf = traceback.format_exception_only(self.exc_type, self.exc_value)
+        return native_(''.join(buf).strip(), 'utf-8', 'replace')
+    exception = property(exception)
+
+    def log(self, logfile=None):
+        """Log the ASCII traceback into a file object."""
+        if logfile is None:
+            logfile = sys.stderr
+        tb = self.plaintext.rstrip() + '\n'
+        if PY2:
+            tb = tb.encode('utf-8')
+        logfile.write(tb)
+
+    def paste(self):
+        """Create a paste and return the paste id."""
+        data = json.dumps({
+            'description': 'Backlash Internal Server Error',
+            'public': False,
+            'files': {
+                'traceback.txt': {
+                    'content': self.plaintext
+                }
+            }
+        }).encode('utf-8')
+
+        rv = urlopen('https://api.github.com/gists', data=data)
+        resp = json.loads(rv.read().decode('utf-8'))
+        rv.close()
+        return {
+            'url': resp['html_url'],
+            'id': resp['id']
+        }
+
+    def render_summary(self, include_title=True):
+        """Render the traceback for the interactive console."""
+        title = ''
+        description = ''
+        frames = []
+        classes = ['traceback']
+        if not self.frames:
+            classes.append('noframe-traceback')
+
+        if include_title:
+            if self.is_syntax_error:
+                title = text_('Syntax Error')
+            else:
+                title = text_('Traceback <em>(most recent call last)</em>:')
+
+        for frame in self.frames:
+            frames.append(text_('<li%s>%s') % (
+                frame.info and text_(' title="%s"') % escape(frame.info) or text_(''),
+                frame.render()
+                ))
+
+        if self.is_syntax_error:
+            description_wrapper = text_('<pre class=syntaxerror>%s</pre>')
+        else:
+            description_wrapper = text_('<blockquote>%s</blockquote>')
+
+        return SUMMARY_HTML % {
+            'classes':      text_(' '.join(classes)),
+            'title':        title and text_('<h3>%s</h3>' % title) or text_(''),
+            'frames':       text_('\n'.join(frames)),
+            'description':  description_wrapper % escape(self.exception)
+        }
+
+    def render_full(self, evalex=False, secret=None):
+        """Render the Full HTML page with the traceback info."""
+        exc = escape(self.exception)
+        return PAGE_HTML % {
+            'evalex':           evalex and 'true' or 'false',
+            'console':          'false',
+            'title':            exc,
+            'exception':        exc,
+            'exception_type':   escape(self.exception_type),
+            'summary':          self.render_summary(include_title=False),
+            'plaintext':        self.plaintext,
+            'plaintext_cs':     re.sub('-{2,}', '-', self.plaintext),
+            'traceback_id':     self.id,
+            'secret':           secret
+        }
+
+    def generate_plaintext_traceback(self):
+        """Like the plaintext attribute but returns a generator"""
+        yield text_('Traceback (most recent call last):')
+        for frame in self.frames:
+            yield text_('  File "%s", line %s, in %s' % (
+                frame.filename,
+                frame.lineno,
+                frame.function_name
+                ))
+            yield text_('    ' + frame.current_line.strip())
+        yield text_(self.exception)
+
+    def plaintext(self):
+        return text_('\n'.join(self.generate_plaintext_traceback()))
+    plaintext = property(plaintext)
+
+    id = property(lambda x: id(x))
+
+
+class Frame(object):
+    """A single frame in a traceback."""
+
+    def __init__(self, exc_type, exc_value, tb, context=None):
+        if inspect.isframe(tb):
+            self.lineno = tb.f_lineno
+            tb_frame = tb
+        else:
+            self.lineno = tb.tb_lineno
+            tb_frame = tb.tb_frame
+
+        self.function_name = tb_frame.f_code.co_name
+        self.locals = tb_frame.f_locals
+        self.globals = tb_frame.f_globals
+        self.context = context
+
+        fn = inspect.getsourcefile(tb) or inspect.getfile(tb)
+        if fn[-4:] in ('.pyo', '.pyc'):
+            fn = fn[:-1]
+            # if it's a file on the file system resolve the real filename.
+        if os.path.isfile(fn):
+            fn = os.path.realpath(fn)
+        self.filename = fn
+        self.module = self.globals.get('__name__')
+        self.loader = self.globals.get('__loader__')
+        self.code = tb_frame.f_code
+
+        # support for paste's traceback extensions
+        self.hide = self.locals.get('__traceback_hide__', False)
+        info = self.locals.get('__traceback_info__')
+        if info is not None:
+            try:
+                info = text_(info)
+            except UnicodeError:
+                info = str(info).decode('utf-8', 'replace')
+        self.info = info
+
+    def __getattr__(self, item):
+        # Make it look like a plain python frame/traceback object.
+        if item in ('tb_lineno', 'f_lineno'):
+            return self.lineno
+        elif item in ('f_locals', ):
+            return self.locals
+        elif item in ('tb_frame', ):
+            return self
+        elif item in ('f_globals', ):
+            return self.globals
+        elif item in ('f_code', ):
+            return self.code
+
+        raise AttributeError("'Frame' object has no attribute '%s'" % item)
+
+    def render(self):
+        """Render a single frame in a traceback."""
+        return FRAME_HTML % {
+            'id':               self.id,
+            'filename':         escape(self.filename),
+            'lineno':           self.lineno,
+            'function_name':    escape(self.function_name),
+            'current_line':     escape(self.current_line.strip())
+        }
+
+    def get_annotated_lines(self):
+        """Helper function that returns lines with extra information."""
+        lines = [Line(idx + 1, x) for idx, x in enumerate(self.sourcelines)]
+
+        # find function definition and mark lines
+        if hasattr(self.code, 'co_firstlineno'):
+            lineno = self.code.co_firstlineno - 1
+            while lineno > 0:
+                if _funcdef_re.match(lines[lineno].code):
+                    break
+                lineno -= 1
+            try:
+                offset = len(inspect.getblock([x.code + '\n' for x
+                                               in lines[lineno:]]))
+            except TokenError:
+                offset = 0
+            for line in lines[lineno:lineno + offset]:
+                line.in_frame = True
+
+        # mark current line
+        try:
+            lines[self.lineno - 1].current = True
+        except IndexError:
+            pass
+
+        return lines
+
+    def render_source(self):
+        """Render the sourcecode."""
+        return SOURCE_TABLE_HTML % text_('\n'.join(line.render() for line in
+            self.get_annotated_lines()))
+
+    def eval(self, code, mode='single'):
+        """Evaluate code in the context of the frame."""
+        if isinstance(code, string_types):
+            if isinstance(code, text_type):
+                code = UTF8_COOKIE + code.encode('utf-8')
+            code = compile(code, '<interactive>', mode)
+        if mode != 'exec':
+            return eval(code, self.globals, self.locals)
+        exec_(code, self.globals, self.locals)
+
+    @property
+    def sourcelines(self):
+        """The sourcecode of the file as list of unicode strings."""
+        # get sourcecode from loader or file
+        source = None
+        if self.loader is not None:
+            try:
+                if hasattr(self.loader, 'get_source'):
+                    source = self.loader.get_source(self.module)
+                elif hasattr(self.loader, 'get_source_by_code'):
+                    source = self.loader.get_source_by_code(self.code)
+            except Exception:
+                # we munch the exception so that we don't cause troubles
+                # if the loader is broken.
+                pass
+
+        if source is None:
+            try:
+                f = open(self.filename)
+            except IOError:
+                return []
+            try:
+                source = f.read()
+            finally:
+                f.close()
+
+        # already unicode?  return right away
+        if isinstance(source, text_type):
+            return source.splitlines()
+
+        # yes. it should be ascii, but we don't want to reject too many
+        # characters in the debugger if something breaks
+        charset = 'utf-8'
+        if source.startswith(UTF8_COOKIE):
+            source = source[3:]
+        else:
+            for idx, match in enumerate(_line_re.finditer(source)):
+                match = _line_re.search(match.group())
+                if match is not None:
+                    charset = match.group(1)
+                    break
+                if idx > 1:
+                    break
+
+        # on broken cookies we fall back to utf-8 too
+        try:
+            codecs.lookup(charset)
+        except LookupError:
+            charset = 'utf-8'
+
+        return source.decode(charset, 'replace').splitlines()
+
+    @property
+    def current_line(self):
+        try:
+            return self.sourcelines[self.lineno - 1]
+        except IndexError:
+            return text_('')
+
+    @property
+    def console(self):
+        return Console(self.globals, self.locals, self.context)
+
+    id = property(lambda x: id(x))

backlash/trace_errors/__init__.py

@@ -0,0 +1,8 @@
+# HERE JUST FOR BACKWARD COMPATIBILITY
+from backlash.tracing.errors import TraceErrorsMiddleware
+from backlash.tracing.reporters.mail import EmailReporter
+
+import warnings
+warnings.warn(
+    'backlash.trace_errors is deprecated. Please use backlash.tracing.errors instead',
+    DeprecationWarning)

backlash/trace_errors/sentry.py

@@ -0,0 +1,6 @@
+from backlash.tracing.reporters.sentry import SentryReporter
+
+import warnings
+warnings.warn(
+    'backlash.trace_errors is deprecated. Please use backlash.tracing.reporters.sentry instead',
+    DeprecationWarning)

backlash/tracing/__init__.py

@@ -0,0 +1 @@
+  

backlash/tracing/errors/__init__.py

@@ -0,0 +1 @@
+from .middleware import TraceErrorsMiddleware