def process_response(self, response):
        # If the body is HTML, then we add the toolbar to the response.
        request = self.request

        if isinstance(response, WSGIHTTPException):
            # the body of a WSGIHTTPException needs to be "prepared"
            response.prepare(request.environ)

        for panel in self.panels:
            panel.process_response(response)

        if response.content_type in self.html_types:
            static_path = request.static_url(STATIC_PATH)
            root_path = request.route_url(ROOT_ROUTE_NAME)
            button_style = get_setting(request.registry.settings,
                    'button_style', '')
            vars = {'panels': self.panels, 'static_path': static_path,
                    'root_path': root_path, 'button_style': button_style}
            toolbar_html = render(
                    'pyramid_debugtoolbar:templates/toolbar.dbtmako',
                    vars, request=request)
            response_html = response.body
            toolbar_html = toolbar_html.encode(response.charset or 'utf-8')
            body = replace_insensitive(
                response_html, bytes_('</body>'),
                toolbar_html + bytes_('</body>')
                )
            response.app_iter = [body]
            response.content_length = len(body)

    def process_response(self, response):
        data = []
        for query in self.queries:
            stmt = query['statement']

            is_select = stmt.strip().lower().startswith('select')
            params = ''
            try:
                params = url_quote(json.dumps(query['parameters']))
            except TypeError:
                pass # object not JSON serializable
            except UnicodeDecodeError:
                pass # parameters contain non-utf8 (probably binary) data

            need = self.token + stmt + params
            hash = hashlib.sha1(bytes_(need)).hexdigest()

            data.append({
                'engine_id': query['engine_id'],
                'duration': query['duration'],
                'sql': format_sql(stmt),
                'raw_sql': stmt,
                'hash': hash,
                'parameters': query['parameters'],
                'params': params,
                'is_select': is_select,
                'context': query['context'],
            })

        self.data = {
            'queries':data,
            'text':text,
            }

    def sql_select(self):
        stmt = self.request.params['sql']
        params = self.request.params['params']
        engine_id = self.request.params['engine_id']

        # Validate hash
        hash = hashlib.sha1(
            bytes_(self.request.exc_history.token + stmt + params)).hexdigest()
        if hash != self.request.params['hash']:
            raise HTTPBadRequest('Bad token in request')
 
        # Make sure it is a select statement
        if not stmt.lower().strip().startswith('select'):
            raise HTTPBadRequest('Not a SELECT SQL statement')

        if not engine_id:
            raise HTTPBadRequest('No valid database engine')

        engine = getattr(self.request.registry, 'pdtb_sqla_engines')\
                      [int(engine_id)]()
        params = json.loads(params)
        result = engine.execute(stmt, params)

        return {
            'result': result.fetchall(),
            'headers': result.keys(),
            'sql': format_sql(stmt),
            'duration': float(self.request.params['duration']),
        }

 def test_execute(self):
     request = self._makeRequest()
     request.params['cmd'] = 'doit'
     view = self._makeOne(request)
     response = view.execute()
     self.assertEqual(response.body, bytes_('evaled'))
     self.assertEqual(response.content_type, 'text/html')

 def test_source(self):
     request = self._makeRequest()
     request.params['frm'] = '0'
     view = self._makeOne(request)
     response = view.source()
     self.assertEqual(response.body, bytes_('source'))
     self.assertEqual(response.content_type, 'text/html')

    def sql_select(self):
        stmt = self.request.params["sql"]
        params = self.request.params["params"]
        engine_id = self.request.params["engine_id"]

        # Validate hash
        hash = hashlib.sha1(bytes_(self.request.exc_history.token + stmt + params)).hexdigest()
        if hash != self.request.params["hash"]:
            raise HTTPBadRequest("Bad token in request")

        # Make sure it is a select statement
        if not stmt.lower().strip().startswith("select"):
            raise HTTPBadRequest("Not a SELECT SQL statement")

        if not engine_id:
            raise HTTPBadRequest("No valid database engine")

        engine = getattr(self.request.registry, "pdtb_sqla_engines")[int(engine_id)]()
        params = json.loads(params)
        result = engine.execute(stmt, params)

        return {
            "result": result.fetchall(),
            "headers": result.keys(),
            "sql": format_sql(stmt),
            "duration": float(self.request.params["duration"]),
        }

 def test_execute(self):
     request = self._makeRequest()
     request.params["frm"] = "0"
     request.params["cmd"] = "doit"
     view = self._makeOne(request)
     response = view.execute()
     self.assertEqual(response.body, bytes_("evaled"))
     self.assertEqual(response.content_type, "text/html")

 def inject(self, request, response):
     """
     Inject the debug toolbar iframe into an HTML response.
     """
     # called in host app
     response_html = response.body
     toolbar_url = debug_toolbar_url(request, request.id)
     button_style = get_setting(request.registry.settings,
             'button_style', '')
     css_path = request.static_url(STATIC_PATH + 'css/toolbar_button.css')
     toolbar_html = toolbar_html_template % {
         'button_style': button_style,
         'css_path': css_path,
         'toolbar_url': toolbar_url}
     toolbar_html = toolbar_html.encode(response.charset or 'utf-8')
     response.body = replace_insensitive(
         response_html, bytes_('</body>'),
         toolbar_html + bytes_('</body>')
         )

    def validate(self):
        stmt = self.request.params["sql"]
        params = self.request.params["params"]

        # Validate hash
        need = self.request.exc_history.token + stmt + url_quote(params)

        hash = hashlib.sha1(bytes_(need)).hexdigest()
        if hash != self.request.params["hash"]:
            raise HTTPBadRequest("Bad token in request")
        return stmt, params

    def validate(self):
        stmt = self.request.params['sql']
        params = self.request.params['params']

        # Validate hash
        need = self.token + stmt + url_quote(params)

        hash = hashlib.sha1(bytes_(need)).hexdigest()
        if hash != self.request.params['hash']:
            raise HTTPBadRequest('Bad token in request')
        return stmt, params

 def test_inject_html(self):
     from pyramid_debugtoolbar.utils import STATIC_PATH
     self.config.add_static_view('_debugtoolbar/static', STATIC_PATH)
     self.config.add_route('debugtoolbar', '/_debugtoolbar/*subpath')
     response = Response('<body></body>')
     response.content_type = 'text/html'
     request = Request.blank('/')
     request.pdtb_id = 'abc'
     request.registry = self.config.registry
     toolbar = self._makeOne(request, [DummyPanel], [DummyPanel], [])
     toolbar.inject(request, response)
     self.assertTrue(bytes_('div id="pDebug"') in response.app_iter[0])
     self.assertEqual(response.content_length, len(response.app_iter[0]))

 def test_process_response_html(self):
     from pyramid_debugtoolbar.utils import ROOT_ROUTE_NAME
     from pyramid_debugtoolbar.utils import STATIC_PATH
     self.config.add_static_view('_debugtoolbar/static',
                                 STATIC_PATH)
     self.config.add_route(ROOT_ROUTE_NAME, '/_debugtoolbar')
     response = Response('<body></body>')
     response.content_type = 'text/html'
     request = Request.blank('/')
     request.registry = self.config.registry
     toolbar = self._makeOne(request, [DummyPanel])
     toolbar.process_response(response)
     self.assertTrue(response.processed)
     self.assertTrue(bytes_('div id="pDebug"') in response.app_iter[0])

 def test_passing_of_button_style(self):
     from pyramid_debugtoolbar.utils import STATIC_PATH
     self.config.add_static_view('_debugtoolbar/static', STATIC_PATH)
     self.config.add_route('debugtoolbar', '/_debugtoolbar/*subpath')
     self.config.registry.settings['debugtoolbar.button_style'] = \
         'top:120px;zoom:50%'
     response = Response('<body></body>')
     response.content_type = 'text/html'
     request = Request.blank('/')
     request.pdtb_id = 'abc'
     request.registry = self.config.registry
     toolbar = self._makeOne(request, [DummyPanel], [DummyPanel], [])
     toolbar.inject(request, response)
     self.assertTrue(bytes_('top:120px;zoom:50%') in response.app_iter[0])

 def inject(self, request, response):
     """
     Inject the debug toolbar iframe into an HTML response.
     """
     # called in host app
     response_html = response.body
     toolbar_url = debug_toolbar_url(request, request.id)
     button_style = get_setting(request.registry.settings, "button_style", "")
     css_path = request.static_url(STATIC_PATH + "css/toolbar.css")
     toolbar_html = toolbar_html_template % {
         "button_style": button_style,
         "css_path": css_path,
         "toolbar_url": toolbar_url,
     }
     toolbar_html = toolbar_html.encode(response.charset or "utf-8")
     response.body = replace_insensitive(response_html, bytes_("</body>"), toolbar_html + bytes_("</body>"))

 def test_passing_of_button_style(self):
     from pyramid_debugtoolbar.utils import ROOT_ROUTE_NAME
     from pyramid_debugtoolbar.utils import STATIC_PATH
     self.config.include('pyramid_jinja2')
     self.config.add_static_view('_debugtoolbar/static',
                                 STATIC_PATH)
     self.config.add_route(ROOT_ROUTE_NAME, '/_debugtoolbar')
     self.config.registry.settings['debugtoolbar.button_style'] = \
         'top:120px;zoom:50%'
     response = Response('<body></body>')
     response.content_type = 'text/html'
     request = Request.blank('/')
     request.registry = self.config.registry
     toolbar = self._makeOne(request, [DummyPanel])
     toolbar.process_response(response)
     self.assertTrue(response.processed)
     self.failUnless(bytes_('top:120px;zoom:50%') in response.app_iter[0])

    def content(self):
        if not self.queries:
            return 'No queries in executed in request.'

        data = []
        for query in self.queries:
            stmt = query['statement']

            is_select = stmt.strip().lower().startswith('select')
            params = ''
            try:
                params = url_quote(json.dumps(query['parameters']))
            except TypeError:
                pass # object not JSON serializable
            except UnicodeDecodeError:
                pass # parameters contain non-utf8 (probably binary) data

            need = self.request.exc_history.token + stmt + params
            hash = hashlib.sha1(bytes_(need)).hexdigest()

            data.append({
                'engine_id': query['engine_id'],
                'duration': query['duration'],
                'sql': format_sql(stmt),
                'raw_sql': stmt,
                'hash': hash,
                'parameters': query['parameters'],
                'params': params,
                'is_select': is_select,
                'context': query['context'],
            })

        vars = {
            'static_path': self.request.static_url(STATIC_PATH),
            'root_path': self.request.route_url(ROOT_ROUTE_NAME),
            'queries':data,
            'text':text,
            }

        delattr(self.request, 'pdtb_sqla_queries')

        return self.render(
            'pyramid_debugtoolbar.panels:templates/sqlalchemy.dbtmako',
            vars, self.request)

    def content(self):
        if not self.queries:
            return "No queries in executed in request."

        data = []
        for query in self.queries:
            stmt = query["statement"]

            is_select = stmt.strip().lower().startswith("select")
            params = ""
            try:
                params = url_quote(json.dumps(query["parameters"]))
            except TypeError:
                pass  # object not JSON serializable
            except UnicodeDecodeError:
                pass  # parameters contain non-utf8 (probably binary) data

            need = self.request.exc_history.token + stmt + params
            hash = hashlib.sha1(bytes_(need)).hexdigest()

            data.append(
                {
                    "engine_id": query["engine_id"],
                    "duration": query["duration"],
                    "sql": format_sql(stmt),
                    "raw_sql": stmt,
                    "hash": hash,
                    "parameters": query["parameters"],
                    "params": params,
                    "is_select": is_select,
                    "context": query["context"],
                }
            )

        vars = {
            "static_path": self.request.static_url(STATIC_PATH),
            "root_path": self.request.route_url(ROOT_ROUTE_NAME),
            "queries": data,
            "text": text,
        }

        delattr(self.request, "pdtb_sqla_queries")

        return self.render("pyramid_debugtoolbar.panels:templates/sqlalchemy.dbtmako", vars, self.request)

    def content(self):
        if not self.queries:
            return 'No queries in executed in request.'

        data = []
        for query in self.queries:
            is_select = query['statement'].strip().lower().startswith('select')
            params = ''
            try:
                params = json.dumps(query['parameters'])
            except TypeError:
                pass # object not JSON serializable

            hash = hashlib.sha1(
                bytes_(self.request.exc_history.token +
                       query['statement'] + params)).hexdigest()

            data.append({
                'engine_id': query['engine_id'],
                'duration': query['duration'],
                'sql': format_sql(query['statement']),
                'raw_sql': query['statement'],
                'hash': hash,
                'params': params,
                'is_select': is_select,
                'context': query['context'],
            })

        vars = {
            'static_path': self.request.static_url(STATIC_PATH),
            'root_path': self.request.route_url(ROOT_ROUTE_NAME),
            'queries':data,
            }

        delattr(self.request, 'pdtb_sqla_queries')

        return self.render(
            'pyramid_debugtoolbar.panels:templates/sqlalchemy.jinja2',
            vars, self.request)

def hexlify(value):
    """Hexlify int, str then returns native str type."""
    # If integer
    str_ = str(value)
    hexified = text_(binascii.hexlify(bytes_(str_)))
    return hexified

    def test_debug_repr(self):
        assert debug_repr([]) == '[]'
        assert debug_repr([1, 2]) == \
            '[<span class="number">1</span>, <span class="number">2</span>]'
        assert debug_repr([1, 'test']) == \
            '[<span class="number">1</span>, <span class="string">\'test\'</span>]'
        assert debug_repr([None]) == \
            '[<span class="object">None</span>]'
        assert debug_repr(list(range(20))) == (
            '[<span class="number">0</span>, <span class="number">1</span>, '
            '<span class="number">2</span>, <span class="number">3</span>, '
            '<span class="number">4</span>, <span class="number">5</span>, '
            '<span class="number">6</span>, <span class="number">7</span>, '
            '<span class="number">8</span>, <span class="number">9</span>, '
            '<span class="number">10</span>, <span class="number">11</span>, '
            '<span class="number">12</span>, <span class="number">13</span>, '
            '<span class="number">14</span>, <span class="number">15</span>, '
            '<span class="number">16</span>, <span class="number">17</span>, '
            '<span class="number">18</span>, <span class="number">19</span>]'
        )
        assert debug_repr({}) == '{}'
        assert debug_repr({'foo': 42}) == \
            '{<span class="pair"><span class="key"><span class="string">\'foo\''\
            '</span></span>: <span class="value"><span class="number">42' \
            '</span></span></span>}'
        result = debug_repr((1, bytes_('zwei'), text_('drei')))
        if PY3: # pragma: no cover
            expected = (
                '(<span class="number">1</span>, <span class="string">b\''
                'zwei\'</span>, <span class="string">\'drei\'</span>)')
        else:
            expected = (
                '(<span class="number">1</span>, <span class="string">\''
                'zwei\'</span>, <span class="string">u\'drei\'</span>)')
        assert result == expected

        class Foo(object):
            def __repr__(self):
                return '<Foo 42>'
        assert debug_repr(Foo()) == '<span class="object">&lt;Foo 42&gt;</span>'

        class MyList(list):
            pass
        tmp = debug_repr(MyList([1, 2]))
        assert tmp == \
            '<span class="module">pyramid_debugtoolbar.tests.test_debug.</span>MyList([' \
            '<span class="number">1</span>, <span class="number">2</span>])'

        result = debug_repr(re.compile(r'foo\d'))
        assert result == \
            're.compile(<span class="string regex">r\'foo\\d\'</span>)'
        result = debug_repr(re.compile(text_(r'foo\d')))
        if PY3: # pragma: no cover
            assert result == \
                   're.compile(<span class="string regex">r\'foo\\d\'</span>)'
        else:
            assert result == \
                   're.compile(<span class="string regex">ur\'foo\\d\'</span>)'


        assert debug_repr(frozenset('x')) == \
            'frozenset([<span class="string">\'x\'</span>])'
        assert debug_repr(set('x')) == \
            'set([<span class="string">\'x\'</span>])'

        a = [1]
        a.append(a)
        assert debug_repr(a) == '[<span class="number">1</span>, [...]]'

        class Foo(object):
            def __repr__(self):
                1/0

        result = debug_repr(Foo())

        assert 'division' in result