backlash 0.3.0__tar.gz → 0.3.2__tar.gz

backlash-0.3.2/AUTHORS

@@ -0,0 +1,15 @@
+Backlash is written and maintained by the TurboGears Team and various contributors:
+
+
+Project Core Developers:
+
+Alessandro Molina <amol@turbogears.org>
+
+
+Contributions:
+
+
+The tbtools module and the stylesheet are taken from the Werkzeug project
+which is originally licensed under the BSD license, please refer to
+the AUTHORS file of the Werkzeug project for additional informations on its
+contributors.

backlash-0.3.2/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.1
+Name: backlash
+Version: 0.3.2
+Summary: Standalone WebOb port of the Werkzeug Debugger with Python3 support meant to replace WebError in future TurboGears2
+Home-page: https://github.com/TurboGears/backlash
+Author: Alessandro Molina
+Author-email: amol@turbogears.org
+License: MIT
+Keywords: wsgi
+Platform: UNKNOWN
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Middleware
+Classifier: Topic :: Internet :: WWW/HTTP :: WSGI
+License-File: LICENSE
+License-File: AUTHORS
+
+About backlash
+-------------------------
+
+backlash is a swiss army knife for web applications debugging, which provides:
+
+    - An Interactive In Browser Debugger based on a Werkzeug Debugger fork ported to WebOb
+    - Crash reporting by email and on Sentry
+    - Slow requests reporting by email and on Sentry.
+
+Backlash was born as a replacement for WebError in TurboGears2.3 versions.
+
+Installing
+-------------------------------
+
+backlash can be installed from pypi::
+
+    pip install backlash
+
+should just work for most of the users
+
+Debugging and Console
+----------------------------------
+
+Backlash supports both debugging applications on crash and realtime console,
+both are based on the Werkzeug Debugger and adapted to work with WebOb.
+
+The debugging function is provided by the ``DebuggedApplication`` middleware,
+wrapping your application with this middleware will intercept any exception
+and display the traceback and an interactive console in your browser.
+
+An interactive console will also be always available at ``/__console__`` path.
+
+Context Injectors
++++++++++++++++++++++++++++++
+
+The ``DebuggedApplication`` middleware also makes possible to provide one or more
+``context injectors``, those are simple python functions that will be called when
+an exception is raised to retrieve the context to store and make back available during
+debugging.
+
+Context injectors have to return a dictionary which will be merged into the current
+request context, the request context itself will be made available inside the debugger
+as the ``ctx`` object.
+
+This feature is used for example by TurboGears to provide back some of the objects
+which were available during execution like the current request.
+
+Example
++++++++++++++++++++++++++++++++
+
+The DebuggedApplication middleware is used by TurboGears in the following way::
+
+    def _turbogears_backlash_context(environ):
+        tgl = environ.get('tg.locals')
+        return {'request':getattr(tgl, 'request', None)}
+
+    app = backlash.DebuggedApplication(app, context_injectors=[_turbogears_backlash_context])
+
+
+Exception Tracing
+---------------------------------------
+
+The ``TraceErrorsMiddleware`` provides a WSGI middleware that intercepts any exception
+raised during execution, retrieves a traceback object and provides it to one or more
+``reporters`` to log the error.
+
+By default the ``EmailReporter`` and ``SentryReporter`` are provided to send error
+reports by email and on Sentry.
+
+The ``EmailReporter`` supports most of the options WebError ErrorMiddleware to provide some
+kind of backward compatibility and make possible a quick transition.
+
+While this function is easily replicable using the python logging SMTPHandler, the
+TraceErrorsMiddleware is explicitly meant for web applications crash reporting
+which has the benefit of being able to provide more complete information and keep a clear
+and separate process in managing errors.
+
+Example
+++++++++++++++++++++++++++++++++
+
+The TraceErrorsMiddleware is used by TurboGears in the following way::
+
+    from backlash.trace_errors import EmailReporter
+
+    def _turbogears_backlash_context(environ):
+       tgl = environ.get('tg.locals')
+       return {'request':getattr(tgl, 'request', None)}
+
+    app = backlash.TraceErrorsMiddleware(app, [EmailReporter(**errorware)],
+                                         context_injectors=[_turbogears_backlash_context])
+
+Slow Requests Tracing
+---------------------------------------
+
+The ``TraceSlowRequestsMiddleware`` provides a WSGI middleware that tracks requests
+execution time and reports requests that took more than a specified interval to complete
+(by default 25 seconds).
+
+It is also possible to exclude a list of paths that start with a specified string
+to avoid reporting long polling connections or other kind of requests that are
+expected to have a long life spawn.
+
+Example
+++++++++++++++++++++++++++++++++
+
+The TraceSlowRequestsMiddleware is used by TurboGears in the following way::
+
+    from backlash.trace_errors import EmailReporter
+
+    def _turbogears_backlash_context(environ):
+       tgl = environ.get('tg.locals')
+       return {'request':getattr(tgl, 'request', None)}
+
+    app = backlash.TraceSlowRequestsMiddleware(app, [EmailReporter(**errorware)],
+                                               interval=25, exclude_paths=None,
+                                               context_injectors=[_turbogears_backlash_context])
+
+

{backlash-0.3.0 → backlash-0.3.2}/backlash/_compat.py

@@ -3,6 +3,7 @@ import types
 
 # True if we are running on Python 3.
 PY3 = sys.version_info[0] == 3
+PY2 = sys.version_info[0] == 2
 
 if PY3: # pragma: no cover
     string_types = str,

{backlash-0.3.0 → backlash-0.3.2}/backlash/tbtools.py

@@ -20,7 +20,7 @@ from tokenize import TokenError
 from backlash.utils import escape
 from backlash.console import Console
 
-from backlash._compat import text_, native_, string_types, text_type, exec_, urlopen
+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)
@@ -264,6 +264,8 @@ class Traceback(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):

{backlash-0.3.0 → backlash-0.3.2}/backlash/tracing/slowrequests/middleware.py

@@ -22,7 +22,7 @@ class TraceSlowRequestsMiddleware(object):
         self.exclude_paths = exclude_paths or []
 
         self.timer = Timer()
-        self.timer.setDaemon(True)
+        self.timer.daemon = True
         self.timer.start()
 
     def _stream_response(self, environ, data):

backlash-0.3.2/backlash.egg-info/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.1
+Name: backlash
+Version: 0.3.2
+Summary: Standalone WebOb port of the Werkzeug Debugger with Python3 support meant to replace WebError in future TurboGears2
+Home-page: https://github.com/TurboGears/backlash
+Author: Alessandro Molina
+Author-email: amol@turbogears.org
+License: MIT
+Keywords: wsgi
+Platform: UNKNOWN
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Middleware
+Classifier: Topic :: Internet :: WWW/HTTP :: WSGI
+License-File: LICENSE
+License-File: AUTHORS
+
+About backlash
+-------------------------
+
+backlash is a swiss army knife for web applications debugging, which provides:
+
+    - An Interactive In Browser Debugger based on a Werkzeug Debugger fork ported to WebOb
+    - Crash reporting by email and on Sentry
+    - Slow requests reporting by email and on Sentry.
+
+Backlash was born as a replacement for WebError in TurboGears2.3 versions.
+
+Installing
+-------------------------------
+
+backlash can be installed from pypi::
+
+    pip install backlash
+
+should just work for most of the users
+
+Debugging and Console
+----------------------------------
+
+Backlash supports both debugging applications on crash and realtime console,
+both are based on the Werkzeug Debugger and adapted to work with WebOb.
+
+The debugging function is provided by the ``DebuggedApplication`` middleware,
+wrapping your application with this middleware will intercept any exception
+and display the traceback and an interactive console in your browser.
+
+An interactive console will also be always available at ``/__console__`` path.
+
+Context Injectors
++++++++++++++++++++++++++++++
+
+The ``DebuggedApplication`` middleware also makes possible to provide one or more
+``context injectors``, those are simple python functions that will be called when
+an exception is raised to retrieve the context to store and make back available during
+debugging.
+
+Context injectors have to return a dictionary which will be merged into the current
+request context, the request context itself will be made available inside the debugger
+as the ``ctx`` object.
+
+This feature is used for example by TurboGears to provide back some of the objects
+which were available during execution like the current request.
+
+Example
++++++++++++++++++++++++++++++++
+
+The DebuggedApplication middleware is used by TurboGears in the following way::
+
+    def _turbogears_backlash_context(environ):
+        tgl = environ.get('tg.locals')
+        return {'request':getattr(tgl, 'request', None)}
+
+    app = backlash.DebuggedApplication(app, context_injectors=[_turbogears_backlash_context])
+
+
+Exception Tracing
+---------------------------------------
+
+The ``TraceErrorsMiddleware`` provides a WSGI middleware that intercepts any exception
+raised during execution, retrieves a traceback object and provides it to one or more
+``reporters`` to log the error.
+
+By default the ``EmailReporter`` and ``SentryReporter`` are provided to send error
+reports by email and on Sentry.
+
+The ``EmailReporter`` supports most of the options WebError ErrorMiddleware to provide some
+kind of backward compatibility and make possible a quick transition.
+
+While this function is easily replicable using the python logging SMTPHandler, the
+TraceErrorsMiddleware is explicitly meant for web applications crash reporting
+which has the benefit of being able to provide more complete information and keep a clear
+and separate process in managing errors.
+
+Example
+++++++++++++++++++++++++++++++++
+
+The TraceErrorsMiddleware is used by TurboGears in the following way::
+
+    from backlash.trace_errors import EmailReporter
+
+    def _turbogears_backlash_context(environ):
+       tgl = environ.get('tg.locals')
+       return {'request':getattr(tgl, 'request', None)}
+
+    app = backlash.TraceErrorsMiddleware(app, [EmailReporter(**errorware)],
+                                         context_injectors=[_turbogears_backlash_context])
+
+Slow Requests Tracing
+---------------------------------------
+
+The ``TraceSlowRequestsMiddleware`` provides a WSGI middleware that tracks requests
+execution time and reports requests that took more than a specified interval to complete
+(by default 25 seconds).
+
+It is also possible to exclude a list of paths that start with a specified string
+to avoid reporting long polling connections or other kind of requests that are
+expected to have a long life spawn.
+
+Example
+++++++++++++++++++++++++++++++++
+
+The TraceSlowRequestsMiddleware is used by TurboGears in the following way::
+
+    from backlash.trace_errors import EmailReporter
+
+    def _turbogears_backlash_context(environ):
+       tgl = environ.get('tg.locals')
+       return {'request':getattr(tgl, 'request', None)}
+
+    app = backlash.TraceSlowRequestsMiddleware(app, [EmailReporter(**errorware)],
+                                               interval=25, exclude_paths=None,
+                                               context_injectors=[_turbogears_backlash_context])
+
+

{backlash-0.3.0 → backlash-0.3.2}/backlash.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+AUTHORS
 LICENSE
 MANIFEST.in
 README.rst

{backlash-0.3.0 → backlash-0.3.2}/setup.py

@@ -7,7 +7,7 @@ try:
 except IOError:
     README = ''
 
-version = "0.3.0"
+version = "0.3.2"
 
 setup(name='backlash',
       version=version,

backlash-0.3.0/PKG-INFO

@@ -1,134 +0,0 @@
-Metadata-Version: 1.1
-Name: backlash
-Version: 0.3.0
-Summary: Standalone WebOb port of the Werkzeug Debugger with Python3 support meant to replace WebError in future TurboGears2
-Home-page: https://github.com/TurboGears/backlash
-Author: Alessandro Molina
-Author-email: amol@turbogears.org
-License: MIT
-Description: About backlash
-        -------------------------
-        
-        backlash is a swiss army knife for web applications debugging, which provides:
-        
-            - An Interactive In Browser Debugger based on a Werkzeug Debugger fork ported to WebOb
-            - Crash reporting by email and on Sentry
-            - Slow requests reporting by email and on Sentry.
-        
-        Backlash was born as a replacement for WebError in TurboGears2.3 versions.
-        
-        Installing
-        -------------------------------
-        
-        backlash can be installed from pypi::
-        
-            pip install backlash
-        
-        should just work for most of the users
-        
-        Debugging and Console
-        ----------------------------------
-        
-        Backlash supports both debugging applications on crash and realtime console,
-        both are based on the Werkzeug Debugger and adapted to work with WebOb.
-        
-        The debugging function is provided by the ``DebuggedApplication`` middleware,
-        wrapping your application with this middleware will intercept any exception
-        and display the traceback and an interactive console in your browser.
-        
-        An interactive console will also be always available at ``/__console__`` path.
-        
-        Context Injectors
-        +++++++++++++++++++++++++++++
-        
-        The ``DebuggedApplication`` middleware also makes possible to provide one or more
-        ``context injectors``, those are simple python functions that will be called when
-        an exception is raised to retrieve the context to store and make back available during
-        debugging.
-        
-        Context injectors have to return a dictionary which will be merged into the current
-        request context, the request context itself will be made available inside the debugger
-        as the ``ctx`` object.
-        
-        This feature is used for example by TurboGears to provide back some of the objects
-        which were available during execution like the current request.
-        
-        Example
-        +++++++++++++++++++++++++++++++
-        
-        The DebuggedApplication middleware is used by TurboGears in the following way::
-        
-            def _turbogears_backlash_context(environ):
-                tgl = environ.get('tg.locals')
-                return {'request':getattr(tgl, 'request', None)}
-        
-            app = backlash.DebuggedApplication(app, context_injectors=[_turbogears_backlash_context])
-        
-        
-        Exception Tracing
-        ---------------------------------------
-        
-        The ``TraceErrorsMiddleware`` provides a WSGI middleware that intercepts any exception
-        raised during execution, retrieves a traceback object and provides it to one or more
-        ``reporters`` to log the error.
-        
-        By default the ``EmailReporter`` and ``SentryReporter`` are provided to send error
-        reports by email and on Sentry.
-        
-        The ``EmailReporter`` supports most of the options WebError ErrorMiddleware to provide some
-        kind of backward compatibility and make possible a quick transition.
-        
-        While this function is easily replicable using the python logging SMTPHandler, the
-        TraceErrorsMiddleware is explicitly meant for web applications crash reporting
-        which has the benefit of being able to provide more complete information and keep a clear
-        and separate process in managing errors.
-        
-        Example
-        ++++++++++++++++++++++++++++++++
-        
-        The TraceErrorsMiddleware is used by TurboGears in the following way::
-        
-            from backlash.trace_errors import EmailReporter
-        
-            def _turbogears_backlash_context(environ):
-               tgl = environ.get('tg.locals')
-               return {'request':getattr(tgl, 'request', None)}
-        
-            app = backlash.TraceErrorsMiddleware(app, [EmailReporter(**errorware)],
-                                                 context_injectors=[_turbogears_backlash_context])
-        
-        Slow Requests Tracing
-        ---------------------------------------
-        
-        The ``TraceSlowRequestsMiddleware`` provides a WSGI middleware that tracks requests
-        execution time and reports requests that took more than a specified interval to complete
-        (by default 25 seconds).
-        
-        It is also possible to exclude a list of paths that start with a specified string
-        to avoid reporting long polling connections or other kind of requests that are
-        expected to have a long life spawn.
-        
-        Example
-        ++++++++++++++++++++++++++++++++
-        
-        The TraceSlowRequestsMiddleware is used by TurboGears in the following way::
-        
-            from backlash.trace_errors import EmailReporter
-        
-            def _turbogears_backlash_context(environ):
-               tgl = environ.get('tg.locals')
-               return {'request':getattr(tgl, 'request', None)}
-        
-            app = backlash.TraceSlowRequestsMiddleware(app, [EmailReporter(**errorware)],
-                                                       interval=25, exclude_paths=None,
-                                                       context_injectors=[_turbogears_backlash_context])
-        
-Keywords: wsgi
-Platform: UNKNOWN
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Middleware
-Classifier: Topic :: Internet :: WWW/HTTP :: WSGI

backlash-0.3.0/backlash.egg-info/PKG-INFO

@@ -1,134 +0,0 @@
-Metadata-Version: 1.1
-Name: backlash
-Version: 0.3.0
-Summary: Standalone WebOb port of the Werkzeug Debugger with Python3 support meant to replace WebError in future TurboGears2
-Home-page: https://github.com/TurboGears/backlash
-Author: Alessandro Molina
-Author-email: amol@turbogears.org
-License: MIT
-Description: About backlash
-        -------------------------
-        
-        backlash is a swiss army knife for web applications debugging, which provides:
-        
-            - An Interactive In Browser Debugger based on a Werkzeug Debugger fork ported to WebOb
-            - Crash reporting by email and on Sentry
-            - Slow requests reporting by email and on Sentry.
-        
-        Backlash was born as a replacement for WebError in TurboGears2.3 versions.
-        
-        Installing
-        -------------------------------
-        
-        backlash can be installed from pypi::
-        
-            pip install backlash
-        
-        should just work for most of the users
-        
-        Debugging and Console
-        ----------------------------------
-        
-        Backlash supports both debugging applications on crash and realtime console,
-        both are based on the Werkzeug Debugger and adapted to work with WebOb.
-        
-        The debugging function is provided by the ``DebuggedApplication`` middleware,
-        wrapping your application with this middleware will intercept any exception
-        and display the traceback and an interactive console in your browser.
-        
-        An interactive console will also be always available at ``/__console__`` path.
-        
-        Context Injectors
-        +++++++++++++++++++++++++++++
-        
-        The ``DebuggedApplication`` middleware also makes possible to provide one or more
-        ``context injectors``, those are simple python functions that will be called when
-        an exception is raised to retrieve the context to store and make back available during
-        debugging.
-        
-        Context injectors have to return a dictionary which will be merged into the current
-        request context, the request context itself will be made available inside the debugger
-        as the ``ctx`` object.
-        
-        This feature is used for example by TurboGears to provide back some of the objects
-        which were available during execution like the current request.
-        
-        Example
-        +++++++++++++++++++++++++++++++
-        
-        The DebuggedApplication middleware is used by TurboGears in the following way::
-        
-            def _turbogears_backlash_context(environ):
-                tgl = environ.get('tg.locals')
-                return {'request':getattr(tgl, 'request', None)}
-        
-            app = backlash.DebuggedApplication(app, context_injectors=[_turbogears_backlash_context])
-        
-        
-        Exception Tracing
-        ---------------------------------------
-        
-        The ``TraceErrorsMiddleware`` provides a WSGI middleware that intercepts any exception
-        raised during execution, retrieves a traceback object and provides it to one or more
-        ``reporters`` to log the error.
-        
-        By default the ``EmailReporter`` and ``SentryReporter`` are provided to send error
-        reports by email and on Sentry.
-        
-        The ``EmailReporter`` supports most of the options WebError ErrorMiddleware to provide some
-        kind of backward compatibility and make possible a quick transition.
-        
-        While this function is easily replicable using the python logging SMTPHandler, the
-        TraceErrorsMiddleware is explicitly meant for web applications crash reporting
-        which has the benefit of being able to provide more complete information and keep a clear
-        and separate process in managing errors.
-        
-        Example
-        ++++++++++++++++++++++++++++++++
-        
-        The TraceErrorsMiddleware is used by TurboGears in the following way::
-        
-            from backlash.trace_errors import EmailReporter
-        
-            def _turbogears_backlash_context(environ):
-               tgl = environ.get('tg.locals')
-               return {'request':getattr(tgl, 'request', None)}
-        
-            app = backlash.TraceErrorsMiddleware(app, [EmailReporter(**errorware)],
-                                                 context_injectors=[_turbogears_backlash_context])
-        
-        Slow Requests Tracing
-        ---------------------------------------
-        
-        The ``TraceSlowRequestsMiddleware`` provides a WSGI middleware that tracks requests
-        execution time and reports requests that took more than a specified interval to complete
-        (by default 25 seconds).
-        
-        It is also possible to exclude a list of paths that start with a specified string
-        to avoid reporting long polling connections or other kind of requests that are
-        expected to have a long life spawn.
-        
-        Example
-        ++++++++++++++++++++++++++++++++
-        
-        The TraceSlowRequestsMiddleware is used by TurboGears in the following way::
-        
-            from backlash.trace_errors import EmailReporter
-        
-            def _turbogears_backlash_context(environ):
-               tgl = environ.get('tg.locals')
-               return {'request':getattr(tgl, 'request', None)}
-        
-            app = backlash.TraceSlowRequestsMiddleware(app, [EmailReporter(**errorware)],
-                                                       interval=25, exclude_paths=None,
-                                                       context_injectors=[_turbogears_backlash_context])
-        
-Keywords: wsgi
-Platform: UNKNOWN
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Middleware
-Classifier: Topic :: Internet :: WWW/HTTP :: WSGI