6 |
7 |
4 |
5 |
6 |
7 |
9 | 🐞A debug toolbar for FastAPI based on the original django-debug-toolbar.🐞
10 |
Swagger UI & GraphQL are supported.
11 |
13 |
14 | 
15 |
16 |
17 | 
21 |
22 |
23 |
{html.escape(content)}
" 18 | scripts = [] 19 | else: 20 | panel = toolbar.get_panel_by_id(panel_id) 21 | content, scripts = panel.content, panel.scripts 22 | 23 | return {"content": content, "scripts": scripts} 24 | -------------------------------------------------------------------------------- /debug_toolbar/dependencies.py: -------------------------------------------------------------------------------- 1 | from __future__ import annotations 2 | 3 | import typing as t 4 | from contextlib import AsyncExitStack 5 | 6 | from fastapi import HTTPException, Request 7 | from fastapi.dependencies.utils import solve_dependencies 8 | 9 | 10 | async def get_dependencies(request: Request) -> dict[str, t.Any] | None: 11 | route = request["route"] 12 | 13 | if hasattr(route, "dependant"): 14 | try: 15 | solved_result = await solve_dependencies( 16 | request=request, 17 | dependant=route.dependant, 18 | dependency_overrides_provider=route.dependency_overrides_provider, 19 | async_exit_stack=AsyncExitStack(), 20 | ) 21 | except HTTPException: 22 | pass 23 | else: 24 | return solved_result[0] 25 | return None 26 | -------------------------------------------------------------------------------- /debug_toolbar/middleware.py: -------------------------------------------------------------------------------- 1 | import functools 2 | import json 3 | import re 4 | import typing as t 5 | from urllib import parse 6 | 7 | from anyio import CapacityLimiter 8 | from anyio.lowlevel import RunVar 9 | from fastapi import APIRouter, HTTPException, Request, Response, status 10 | from fastapi.responses import StreamingResponse 11 | from fastapi.staticfiles import StaticFiles 12 | from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint 13 | from starlette.routing import NoMatchFound 14 | from starlette.types import ASGIApp 15 | 16 | from debug_toolbar.api import render_panel 17 | from debug_toolbar.settings import DebugToolbarSettings 18 | from debug_toolbar.toolbar import DebugToolbar 19 | from debug_toolbar.utils import import_string, matched_route 20 | 21 | 22 | def show_toolbar(request: Request, settings: DebugToolbarSettings) -> bool: 23 | if request.client is not None and settings.ALLOWED_HOSTS is not None: 24 | return request.app.debug and request.client.host in settings.ALLOWED_HOSTS 25 | return request.app.debug 26 | 27 | 28 | class DebugToolbarMiddleware(BaseHTTPMiddleware): 29 | def __init__(self, app: ASGIApp, **settings: t.Any) -> None: 30 | super().__init__(app) 31 | self.settings = DebugToolbarSettings(**settings) 32 | self.show_toolbar = import_string(self.settings.SHOW_TOOLBAR_CALLBACK) 33 | self.router: APIRouter = app # type: ignore[assignment] 34 | 35 | while not isinstance(self.router, APIRouter): 36 | self.router = self.router.app 37 | try: 38 | self.router.url_path_for("debug_toolbar.render_panel") 39 | except NoMatchFound: 40 | self.init_toolbar() 41 | 42 | def init_toolbar(self) -> None: 43 | self.router.get( 44 | self.settings.API_URL, 45 | name="debug_toolbar.render_panel", 46 | include_in_schema=False, 47 | )(self.require_show_toolbar(render_panel)) 48 | 49 | self.router.mount( 50 | self.settings.STATIC_URL, 51 | StaticFiles(packages=[__package__]), 52 | name="debug_toolbar.static", 53 | ) 54 | 55 | _default_thread_limiter: RunVar[CapacityLimiter] = RunVar( 56 | "_default_thread_limiter" 57 | ) 58 | _default_thread_limiter.set(CapacityLimiter(1)) 59 | 60 | async def dispatch( 61 | self, 62 | request: Request, 63 | call_next: RequestResponseEndpoint, 64 | ) -> Response: 65 | request.scope["route"] = matched_route(request) 66 | 67 | if ( 68 | not request["route"] 69 | or not self.show_toolbar(request, self.settings) 70 | or self.settings.API_URL in request.url.path 71 | ): 72 | return await call_next(request) 73 | 74 | toolbar = DebugToolbar(request, call_next, self.settings) 75 | response = t.cast(StreamingResponse, await toolbar.process_request(request)) 76 | content_type = response.headers.get("Content-Type", "") 77 | is_html = content_type.startswith("text/html") 78 | 79 | if not (is_html or content_type == "application/json") or ( 80 | "gzip" in response.headers.get("Accept-Encoding", "") 81 | ): 82 | return response 83 | 84 | await toolbar.record_stats(response) 85 | await toolbar.record_server_timing(response) 86 | toolbar.generate_server_timing_header(response) 87 | 88 | if is_html: 89 | body = b"" 90 | 91 | async for chunk in response.body_iterator: 92 | if not isinstance(chunk, bytes): 93 | chunk = chunk.encode(response.charset) 94 | body += chunk 95 | 96 | decoded = body.decode(response.charset) 97 | pattern = re.escape(self.settings.INSERT_BEFORE) 98 | bits = re.split(pattern, decoded, flags=re.IGNORECASE) 99 | 100 | if len(bits) > 1: 101 | bits[-2] += toolbar.render_toolbar() 102 | body = self.settings.INSERT_BEFORE.join(bits).encode(response.charset) 103 | response.headers["Content-Length"] = str(len(body)) 104 | 105 | async def stream() -> t.AsyncGenerator[bytes, None]: 106 | yield body 107 | 108 | response.body_iterator = stream() 109 | else: 110 | data = parse.quote(json.dumps(toolbar.refresh())) 111 | response.set_cookie(key="dtRefresh", value=data) 112 | 113 | return response 114 | 115 | def require_show_toolbar( 116 | self, 117 | f: t.Callable[..., t.Any], 118 | ) -> t.Callable[[t.Any], t.Any]: 119 | @functools.wraps(f) 120 | def decorator(request: Request, *args: t.Any, **kwargs: t.Any) -> t.Any: 121 | if not self.show_toolbar(request, self.settings): 122 | raise HTTPException(status_code=status.HTTP_404_NOT_FOUND) 123 | return f(request, *args, **kwargs) 124 | 125 | return decorator 126 | -------------------------------------------------------------------------------- /debug_toolbar/panels/__init__.py: -------------------------------------------------------------------------------- 1 | from __future__ import annotations 2 | 3 | import typing as t 4 | 5 | from fastapi import Request, Response 6 | from starlette.middleware.base import RequestResponseEndpoint 7 | 8 | from debug_toolbar.types import ServerTiming, Stats 9 | from debug_toolbar.utils import get_name_from_obj 10 | 11 | if t.TYPE_CHECKING: 12 | from debug_toolbar.toolbar import DebugToolbar 13 | 14 | 15 | class Panel: 16 | has_content: bool = True 17 | 18 | def __init__( 19 | self, 20 | toolbar: "DebugToolbar", 21 | call_next: RequestResponseEndpoint, 22 | ) -> None: 23 | self.toolbar = toolbar 24 | self.call_next = call_next 25 | 26 | @property 27 | def panel_id(self) -> str: 28 | return self.__class__.__name__ 29 | 30 | @property 31 | def enabled(self) -> bool: 32 | disabled_panels = self.toolbar.settings.DISABLE_PANELS 33 | panel_path = get_name_from_obj(self) 34 | 35 | disable_panel = ( 36 | panel_path in disabled_panels 37 | or panel_path.replace(".panel.", ".") in disabled_panels 38 | ) 39 | if disable_panel: 40 | default = "off" 41 | else: 42 | default = "on" 43 | 44 | return self.toolbar.request.cookies.get(f"dt{self.panel_id}", default) == "on" 45 | 46 | @property 47 | def nav_title(self) -> str: 48 | return self.title 49 | 50 | @property 51 | def nav_subtitle(self) -> str: 52 | return "" 53 | 54 | @property 55 | def title(self) -> str: 56 | raise NotImplementedError 57 | 58 | @property 59 | def template(self) -> str: 60 | raise NotImplementedError 61 | 62 | @property 63 | def content(self) -> str: 64 | if self.has_content: 65 | return self.render(**self.get_stats()) 66 | return "" 67 | 68 | def render(self, **context: t.Any) -> str: 69 | return self.toolbar.render(self.template, **context) 70 | 71 | def url_for(self, name: str, **path_params: t.Any) -> str: 72 | return str(self.toolbar.request.url_for(name, **path_params)) 73 | 74 | @property 75 | def scripts(self) -> list[str]: 76 | return [] 77 | 78 | async def process_request(self, request: Request) -> Response: 79 | return await self.call_next(request) 80 | 81 | async def generate_stats(self, request: Request, response: Response) -> Stats: 82 | return {} 83 | 84 | def get_stats(self) -> Stats: 85 | return self.toolbar.stats.get(self.panel_id, {}) 86 | 87 | async def record_stats(self, request: Request, response: Response) -> None: 88 | stats = await self.generate_stats(request, response) 89 | 90 | if stats is not None: 91 | self.toolbar.stats.setdefault(self.panel_id, {}).update(stats) 92 | 93 | async def generate_server_timing( 94 | self, 95 | request: Request, 96 | response: Response, 97 | ) -> ServerTiming: 98 | return [] 99 | 100 | def get_server_timing_stats(self) -> ServerTiming: 101 | return self.toolbar.server_timing_stats.get(self.panel_id, []) 102 | 103 | async def record_server_timing(self, request: Request, response: Response) -> None: 104 | stats = await self.generate_server_timing(request, response) 105 | 106 | if stats is not None: 107 | st_stats = self.toolbar.server_timing_stats.setdefault(self.panel_id, []) 108 | st_stats += list(stats) 109 | -------------------------------------------------------------------------------- /debug_toolbar/panels/headers.py: -------------------------------------------------------------------------------- 1 | from fastapi import Request, Response 2 | 3 | from debug_toolbar.panels import Panel 4 | from debug_toolbar.types import Stats 5 | 6 | 7 | class HeadersPanel(Panel): 8 | title = "Headers" 9 | template = "panels/headers.html" 10 | 11 | async def generate_stats(self, request: Request, response: Response) -> Stats: 12 | if "cookie" in (request_headers := dict(request.headers)): 13 | request_headers["cookie"] = "=> see Request panel" 14 | 15 | return { 16 | "request_headers": request_headers, 17 | "environ": request.scope.get("asgi", {}), 18 | "response_headers": response.headers, 19 | } 20 | -------------------------------------------------------------------------------- /debug_toolbar/panels/logging.py: -------------------------------------------------------------------------------- 1 | from __future__ import annotations 2 | 3 | import datetime 4 | import logging 5 | import typing as t 6 | 7 | from fastapi import Request, Response 8 | from starlette.concurrency import run_in_threadpool 9 | 10 | from debug_toolbar.panels import Panel 11 | from debug_toolbar.types import Stats 12 | from debug_toolbar.utils import is_coroutine, pluralize 13 | 14 | try: 15 | import threading 16 | except ImportError: 17 | threading = None # type: ignore[assignment] 18 | 19 | 20 | class LogCollector: 21 | def __init__(self) -> None: 22 | if threading is None: 23 | raise NotImplementedError( 24 | "threading module is not available, " 25 | "this panel cannot be used without it" 26 | ) 27 | self.collections: dict[int, list[dict[str, t.Any]]] = {} 28 | 29 | def get_collection(self, thread_id: int | None = None) -> list[dict[str, t.Any]]: 30 | if thread_id is None: 31 | thread_id = threading.get_ident() 32 | if thread_id not in self.collections: 33 | self.collections[thread_id] = [] 34 | return self.collections[thread_id] 35 | 36 | def clear_collection(self, thread_id: int | None = None) -> None: 37 | if thread_id is None: 38 | thread_id = threading.get_ident() 39 | if thread_id in self.collections: 40 | del self.collections[thread_id] 41 | 42 | def collect(self, item: dict[str, t.Any], thread_id: int | None = None) -> None: 43 | self.get_collection(thread_id).append(item) 44 | 45 | 46 | class ThreadTrackingHandler(logging.Handler): 47 | def __init__(self, collector: LogCollector) -> None: 48 | logging.Handler.__init__(self) 49 | self.collector = collector 50 | 51 | def emit(self, record: logging.LogRecord) -> None: 52 | try: 53 | message = record.getMessage() 54 | except Exception: 55 | message = "[Could not get log message]" 56 | 57 | self.collector.collect( 58 | { 59 | "message": message, 60 | "time": datetime.datetime.fromtimestamp(record.created), 61 | "level": record.levelname, 62 | "file": record.pathname, 63 | "line": record.lineno, 64 | "channel": record.name, 65 | } 66 | ) 67 | 68 | 69 | collector = LogCollector() 70 | logging_handler = ThreadTrackingHandler(collector) 71 | logging.root.addHandler(logging_handler) 72 | 73 | 74 | class LoggingPanel(Panel): 75 | nav_title = "Logging" 76 | title = "Log messages" 77 | template = "panels/logging.html" 78 | 79 | def __init__(self, *args: t.Any, **kwargs: t.Any) -> None: 80 | super().__init__(*args, **kwargs) 81 | self._records: dict[t.Any, list[dict[str, t.Any]]] = {} 82 | 83 | @property 84 | def nav_subtitle(self) -> str: 85 | stats = self.get_stats() 86 | record_count = len(stats["records"]) 87 | return f"{record_count} message{pluralize(record_count)}" 88 | 89 | async def process_request(self, request: Request) -> Response: 90 | if is_coroutine(request["route"].endpoint): 91 | self.thread_id = threading.get_ident() 92 | else: 93 | self.thread_id = await run_in_threadpool(threading.get_ident) 94 | 95 | collector.clear_collection(thread_id=self.thread_id) 96 | return await super().process_request(request) 97 | 98 | async def generate_stats(self, request: Request, response: Response) -> Stats: 99 | records = collector.get_collection(thread_id=self.thread_id) 100 | self._records[self.thread_id] = records 101 | collector.clear_collection(thread_id=self.thread_id) 102 | return {"records": records} 103 | -------------------------------------------------------------------------------- /debug_toolbar/panels/profiling.py: -------------------------------------------------------------------------------- 1 | import typing as t 2 | 3 | from fastapi import Request, Response 4 | from pyinstrument import Profiler 5 | from starlette.concurrency import run_in_threadpool 6 | 7 | from debug_toolbar.panels import Panel 8 | from debug_toolbar.types import Stats 9 | from debug_toolbar.utils import is_coroutine 10 | 11 | 12 | class ProfilingPanel(Panel): 13 | title = "Profiling" 14 | template = "panels/profiling.html" 15 | 16 | async def process_request(self, request: Request) -> Response: 17 | self.profiler = Profiler(**self.toolbar.settings.PROFILER_OPTIONS) 18 | is_async = is_coroutine(request["route"].endpoint) 19 | 20 | async def call(f: t.Callable) -> None: 21 | await run_in_threadpool(f) if not is_async else f() 22 | 23 | await call(self.profiler.start) 24 | 25 | try: 26 | response = await super().process_request(request) 27 | finally: 28 | await call(self.profiler.stop) 29 | return response 30 | 31 | async def generate_stats(self, request: Request, response: Response) -> Stats: 32 | return {"content": self.profiler.output_html()} 33 | -------------------------------------------------------------------------------- /debug_toolbar/panels/redirects.py: -------------------------------------------------------------------------------- 1 | import typing as t 2 | 3 | from fastapi import Request, Response, status 4 | 5 | from debug_toolbar.panels import Panel 6 | from debug_toolbar.responses import StreamingHTMLResponse 7 | 8 | 9 | class RedirectsPanel(Panel): 10 | has_content = False 11 | nav_title = "Intercept redirects" 12 | template = "redirect.html" 13 | 14 | async def process_request(self, request: Request) -> Response: 15 | response = await super().process_request(request) 16 | 17 | if 300 <= response.status_code < 400: 18 | if redirect_to := response.headers.get("Location"): 19 | 20 | async def content() -> t.AsyncGenerator[str, None]: 21 | yield self.render( 22 | redirect_to=redirect_to, 23 | status_code=response.status_code, 24 | ) 25 | 26 | response = StreamingHTMLResponse( 27 | content=content(), 28 | status_code=status.HTTP_200_OK, 29 | ) 30 | return response 31 | -------------------------------------------------------------------------------- /debug_toolbar/panels/request.py: -------------------------------------------------------------------------------- 1 | from __future__ import annotations 2 | 3 | import typing as t 4 | 5 | from fastapi import Request, Response 6 | 7 | from debug_toolbar.panels import Panel 8 | from debug_toolbar.types import Stats 9 | from debug_toolbar.utils import get_name_from_obj 10 | 11 | 12 | class RequestPanel(Panel): 13 | title = "Request" 14 | template = "panels/request.html" 15 | 16 | @property 17 | def nav_subtitle(self) -> str: 18 | return get_name_from_obj(self.endpoint) 19 | 20 | async def generate_stats(self, request: Request, response: Response) -> Stats: 21 | self.endpoint = request["endpoint"] 22 | stats: dict[str, t.Any] = {"request": request} 23 | 24 | if hasattr(self, "_form"): 25 | stats["form"] = await request.form() 26 | 27 | if "session" in request.scope: 28 | stats["session"] = request.session 29 | return stats 30 | -------------------------------------------------------------------------------- /debug_toolbar/panels/routes.py: -------------------------------------------------------------------------------- 1 | from fastapi import Request, Response 2 | 3 | from debug_toolbar.panels import Panel 4 | from debug_toolbar.types import Stats 5 | 6 | 7 | class RoutesPanel(Panel): 8 | title = "Routes" 9 | template = "panels/routes.html" 10 | 11 | async def generate_stats(self, request: Request, response: Response) -> Stats: 12 | return { 13 | "routes": request.app.routes, 14 | "endpoint": request["endpoint"], 15 | } 16 | -------------------------------------------------------------------------------- /debug_toolbar/panels/settings.py: -------------------------------------------------------------------------------- 1 | from debug_toolbar.panels import Panel 2 | 3 | 4 | class SettingsPanel(Panel): 5 | title = "Settings" 6 | template = "panels/settings.html" 7 | -------------------------------------------------------------------------------- /debug_toolbar/panels/sql.py: -------------------------------------------------------------------------------- 1 | from __future__ import annotations 2 | 3 | import html 4 | import json 5 | import re 6 | import typing as t 7 | from collections import defaultdict 8 | 9 | import sqlparse 10 | from fastapi import Request, Response 11 | from fastapi.encoders import jsonable_encoder 12 | from pydantic_extra_types.color import Color 13 | from sqlparse import tokens as T 14 | 15 | from debug_toolbar.panels import Panel 16 | from debug_toolbar.types import ServerTiming, Stats 17 | from debug_toolbar.utils import color_generator 18 | 19 | __all__ = ["SQLPanel", "parse_sql", "raw_sql"] 20 | 21 | Stream = t.Generator[t.Tuple[T._TokenType, str], None, None] 22 | 23 | 24 | class BoldKeywordFilter: 25 | def process(self, stream: Stream) -> Stream: 26 | for token_type, value in stream: 27 | if is_keyword := token_type in T.Keyword: 28 | yield T.Text, "" 29 | yield token_type, html.escape(value) 30 | if is_keyword: 31 | yield T.Text, "" 32 | 33 | 34 | class RawFilter: 35 | def process(self, stream: Stream) -> Stream: 36 | for token_type, value in stream: 37 | if token_type not in T.Number and token_type != T.String.Single: 38 | yield token_type, value 39 | 40 | 41 | def simplify(sql: str) -> str: 42 | expr = r"SELECT (...........*?) FROM" 43 | return re.sub(expr, "SELECT ••• FROM", sql) 44 | 45 | 46 | class FilterStack(sqlparse.engine.FilterStack): 47 | def run(self, sql: str) -> str: 48 | self.postprocess.append(sqlparse.filters.SerializerUnicode()) 49 | return "".join(super().run(sql)) 50 | 51 | 52 | def parse_sql(sql: str, aligned_indent: bool = False) -> str: 53 | stack = FilterStack() 54 | 55 | if aligned_indent: 56 | stack.enable_grouping() 57 | stack.stmtprocess.append( 58 | sqlparse.filters.AlignedIndentFilter(char=" ", n="${version}
9 |
10 | ${new Date(releases[version]).toLocaleDateString()}
11 | `;
12 | }
13 | function link(url) {
14 | return `
15 |
16 | ${$$.truncatechars(url, 40)}
17 | `;
18 | }
19 | function render(rowVersion, data) {
20 | if (rowVersion.textContent !== data.version) {
21 | rowVersion.parentNode.style.backgroundColor = loader.nextElementSibling.dataset.warningColor;
22 | }
23 | if (data.releases[rowVersion.textContent] !== null) {
24 | rowVersion.innerHTML = versionInfo(data.releases, rowVersion.textContent);
25 | }
26 | const lastVersion = rowVersion.nextElementSibling;
27 | lastVersion.innerHTML = versionInfo(data.releases, data.version);
28 |
29 | const python = lastVersion.nextElementSibling;
30 | python.innerHTML = data.requires_python;
31 |
32 | const status = python.nextElementSibling;
33 | status.innerHTML = data.status ? data.status.slice(26) : "";
34 |
35 | if (data.home_page) {
36 | status.nextElementSibling.innerHTML = link(data.home_page);
37 | }
38 | }
39 | function getData(pypi) {
40 | return {
41 | version: pypi.info.version,
42 | requires_python: pypi.info.requires_python,
43 | home_page: pypi.info.home_page,
44 | releases: Object.fromEntries(
45 | Object.entries(pypi.releases).map(function ([k, v], i) {
46 | return [k, v.length ? v[0].upload_time : null];
47 | }),
48 | ),
49 | status: pypi.info.classifiers.find(function (classifier) {
50 | return classifier.startsWith("Development Status");
51 | }),
52 | };
53 | }
54 | function updateRow(row) {
55 | return new Promise((resolve) => {
56 | const name = row.firstElementChild.textContent.trim();
57 | const data = JSON.parse(localStorage.getItem(`pypi-${name}`));
58 | const rowVersion = row.children.item(1);
59 |
60 | if (data === null || !(rowVersion.textContent in data.releases)) {
61 | fetch(`https://pypi.org/pypi/${name}/json`).then(function (response) {
62 | if (response.ok) {
63 | response.json().then(function (pypi) {
64 | const data = getData(pypi);
65 |
66 | if (!(rowVersion.textContent in data.releases)) {
67 | data.releases[rowVersion.textContent] = null;
68 | }
69 | localStorage.setItem(`pypi-${name}`, JSON.stringify(data));
70 | render(rowVersion, data);
71 | resolve();
72 | });
73 | }
74 | });
75 | } else {
76 | render(rowVersion, data);
77 | resolve();
78 | }
79 | });
80 | }
81 | if (loader && !loader.getAttribute("lock")) {
82 | loader.setAttribute("lock", true);
83 |
84 | const table = loader.nextElementSibling;
85 | const queryResult = table.querySelectorAll("tbody > tr");
86 | const promises = [];
87 |
88 | for (let i = 0; i < queryResult.length; i++) {
89 | promises.push(updateRow(queryResult[i]));
90 | }
91 | Promise.all(promises).then(() => {
92 | loader.remove();
93 | table.classList.remove("fastdt-hidden");
94 | });
95 | }
96 | }
97 |
98 | const fastDebug = document.getElementById("fastDebug");
99 | pypiIndex();
100 | $$.onPanelRender(fastDebug, "VersionsPanel", pypiIndex);
101 |
--------------------------------------------------------------------------------
/debug_toolbar/templates/base.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |  }}){kind=icon}
24 |
25 | DT
26 | | Key | 11 |Value | 12 |
|---|---|
| {{ key|escape }} | 18 |{{ value|escape }} | 19 |
| Key | 34 |Value | 35 |
|---|---|
| {{ key|escape }} | 41 |{{ value|escape }} | 42 |
| Key | 53 |Value | 54 |
|---|---|
| {{ key|escape }} | 60 |{{ value|escape }} | 61 |
| Level | 6 |Time | 7 |Channel | 8 |Message | 9 |Location | 10 |
|---|---|---|---|---|
| {{ record.level }} | 16 |{{ record.time.strftime('%H:%M:%S %m/%d/%Y') }} | 17 |{{ record.channel|default('-') }} | 18 |{{ record.message }} |
19 | {{ record.file }}:{{ record.line }} | 20 |
No messages logged.
26 | {% endif %} 27 | -------------------------------------------------------------------------------- /debug_toolbar/templates/panels/profiling.html: -------------------------------------------------------------------------------- 1 | 5 | 6 | 12 | -------------------------------------------------------------------------------- /debug_toolbar/templates/panels/request.html: -------------------------------------------------------------------------------- 1 || Name | 7 |Endpoint | 8 |Path params | 9 |
|---|---|---|
| {{ request.route.name }} | 14 |{{ get_name_from_obj(request.endpoint) }} | 15 |16 | {% if request.path_params %} 17 | {% for k, v in request.path_params.items() %} 18 | {{ k }}={{ v }}{% if not loop.last %}, {% endif %} 19 | {% endfor %} 20 | {% else %} 21 | - 22 | {% endif %} 23 | | 24 |
| Variable | 37 |Value | 38 |
|---|---|
{{ key|pprint }} |
44 | {{ value|pprint }} |
45 |
No cookies
57 | {% endif %} 58 | 59 |No session data
64 | {% endif %} 65 | 66 |No GET data
71 | {% endif %} 72 | 73 |No POST data
78 | {% endif %} 79 | -------------------------------------------------------------------------------- /debug_toolbar/templates/panels/routes.html: -------------------------------------------------------------------------------- 1 || Name | 5 |Methods | 6 |Path | 7 |Endpoint | 8 |Description | 9 |{{ route.name|default('', true) }} | 15 |{% if route.methods %}{{ route.methods|sort|join(', ') }}{% endif %} | 16 |{{ route.path }} | 17 |{{ get_name_from_obj(route.endpoint) }} | 18 |{{ route.description }} |
19 |
20 | {% endfor %}
21 |
|---|
| Key | 8 |Value | 9 |
|---|---|
| {{ key|escape }} | 15 |{{ value|pprint|escape }} |
16 |
| 27 | | Query | 28 |Timeline | 29 |Time (ms) | 30 | {# TODO:Action | #} 31 ||
|---|---|---|---|---|---|
| 37 | | 38 | 39 | | 40 |
41 |
42 | {{ query.sql_formatted|safe }}
43 | {{ query.sql_simple|safe }}
44 |
45 | {% if query.sim_count %}
46 |
47 |
48 | {{ query.sim_count }} similar queries.
49 |
50 | {% endif %}
51 | {% if query.dup_count %}
52 |
53 |
54 | Duplicated {{ query.dup_count }} times.
55 |
56 | {% endif %}
57 | |
58 | 59 | 62 | | 63 |64 | {{ '%0.2f'|format(query.duration|float) }} 65 | | 66 ||
| 69 | |
70 |
71 | {% if query.params %}
74 | Params: Connection: {{ alias }} 73 | |
75 | ||||
No SQL queries were recorded during this request.
81 | {% endif %} 82 | -------------------------------------------------------------------------------- /debug_toolbar/templates/panels/timer.html: -------------------------------------------------------------------------------- 1 || Resource | 10 |Value | 11 |
|---|---|
| {{ key|escape }} | 17 |{{ value|escape }} | 18 |
| Timing attribute | 34 |Timeline | 35 |Milliseconds since navigation start (+length) | 36 |
|---|
| Package | 7 |Version | 8 |Latest version | 9 |Python | 10 |Status | 11 |Home page | 12 |
|---|---|---|---|---|---|
| 18 | 19 | {{ package.metadata.name }} 20 | 21 | | 22 |{{ package.version }} |
23 | 24 | | 25 | | 26 | | 27 | |
11 | The Debug Toolbar has intercepted a redirect to the above URL for debug viewing purposes. You can click the above link to continue with the redirect as normal. 12 |
13 |