0
# Dash
1
2
Dash is a Python web application framework for building reactive analytical web applications. Built on top of Plotly.js, React, and Flask, Dash enables data scientists and analysts to build interactive web apps using pure Python without requiring JavaScript knowledge.
3
4
## Package Information
5
6
- **Package Name**: dash
7
- **Language**: Python
8
- **Installation**: `pip install dash`
9
10
## Core Imports
11
12
```python
13
import dash
14
from dash import Dash, dcc, html, dash_table, Input, Output, State, callback
15
```
16
17
Common patterns:
18
19
```python
20
from dash import Dash, html, dcc, callback, Input, Output, State
21
```
22
23
## Basic Usage
24
25
```python
26
from dash import Dash, html, dcc, callback, Input, Output
27
import plotly.express as px
28
29
# Initialize the app
30
app = Dash(__name__)
31
32
# Define the layout
33
app.layout = html.Div([
34
html.H1("Hello Dash"),
35
html.Div("Select a value:"),
36
dcc.Dropdown(
37
id='dropdown',
38
options=[
39
{'label': 'New York City', 'value': 'NYC'},
40
{'label': 'Montreal', 'value': 'MTL'},
41
{'label': 'San Francisco', 'value': 'SF'}
42
],
43
value='NYC'
44
),
45
html.Div(id='output-container')
46
])
47
48
# Define callback
49
@callback(
50
Output('output-container', 'children'),
51
Input('dropdown', 'value')
52
)
53
def update_output(value):
54
return f'You have selected {value}'
55
56
if __name__ == '__main__':
57
app.run(debug=True)
58
```
59
60
## Architecture
61
62
Dash follows a reactive programming model with these key components:
63
64
- **Dash App**: Central application instance managing server, layout, and callbacks
65
- **Layout System**: Hierarchical component tree defining UI structure using dcc, html, and custom components
66
- **Callback System**: Reactive functions that update components based on user interactions
67
- **Component Libraries**: Rich ecosystem of interactive components (graphs, inputs, tables, etc.)
68
- **Server Integration**: Built on Flask for production deployment and extensibility
69
70
## Capabilities
71
72
### Core Application
73
74
Main Dash application class for creating and configuring web applications with layout management, callback registration, and server integration.
75
76
```python { .api }
77
class Dash:
78
def __init__(
79
self,
80
name: str = None,
81
server: Any = None,
82
assets_folder: str = 'assets',
83
pages_folder: str = 'pages',
84
use_pages: bool = None,
85
assets_url_path: str = '/assets/',
86
assets_ignore: str = '',
87
external_scripts: List[Union[str, Dict]] = None,
88
external_stylesheets: List[Union[str, Dict]] = None,
89
suppress_callback_exceptions: bool = None,
90
prevent_initial_callbacks: bool = None,
91
show_undo_redo: bool = False,
92
plugins: List = None,
93
title: str = 'Dash',
94
update_title: str = 'Updating...',
95
**kwargs
96
): ...
97
98
def run(self, debug: bool = None, port: int = 8050, host: str = '127.0.0.1', **kwargs): ...
99
def callback(self, *args, **kwargs): ...
100
def clientside_callback(self, clientside_function, output, inputs, state=None, **kwargs): ...
101
```
102
103
[Core Application](./core-application.md)
104
105
### Callback System
106
107
Reactive programming system that connects user interactions to data updates through Input/Output dependencies and callback functions.
108
109
```python { .api }
110
class Input:
111
def __init__(self, component_id: Union[str, Dict], component_property: str): ...
112
113
class Output:
114
def __init__(self, component_id: Union[str, Dict], component_property: str): ...
115
116
class State:
117
def __init__(self, component_id: Union[str, Dict], component_property: str): ...
118
119
class ClientsideFunction:
120
def __init__(self, namespace: str, function_name: str): ...
121
122
def callback(*args, **kwargs): ...
123
def clientside_callback(clientside_function, output, inputs, state=None, **kwargs): ...
124
125
# Wildcard patterns
126
MATCH: Any # Match any ID in pattern-matching callbacks
127
ALL: Any # Match all IDs in pattern-matching callbacks
128
ALLSMALLER: Any # Match all smaller indices in pattern-matching callbacks
129
```
130
131
[Callback System](./callback-system.md)
132
133
### Component Libraries
134
135
Comprehensive component ecosystem including core components (dcc), HTML elements (html), and data tables (dash_table).
136
137
```python { .api }
138
# Dash Core Components (dcc)
139
class Graph(Component): ...
140
class Dropdown(Component): ...
141
class Slider(Component): ...
142
class Input(Component): ...
143
class Store(Component): ...
144
class Location(Component): ...
145
class Link(Component): ...
146
147
# Dash HTML Components (html)
148
class Div(Component): ...
149
class H1(Component): ...
150
class Button(Component): ...
151
class A(Component): ...
152
class P(Component): ...
153
154
# Dash DataTable
155
class DataTable(Component): ...
156
```
157
158
[Component Libraries](./component-libraries.md)
159
160
### Multi-Page Applications
161
162
Built-in support for single-page application (SPA) navigation with automatic routing, page registration, and SEO optimization.
163
164
```python { .api }
165
def register_page(
166
module: str = None,
167
path: str = None,
168
path_template: str = None,
169
name: str = None,
170
order: Union[int, float] = None,
171
title: str = None,
172
description: str = None,
173
image: str = None,
174
redirect_from: List[str] = None,
175
layout: Any = None,
176
**kwargs
177
): ...
178
179
page_registry: Dict[str, Any] # Registry of all registered pages
180
page_container: Component # Container component for page content
181
```
182
183
[Multi-Page Applications](./multi-page-apps.md)
184
185
### Special Values and Control
186
187
Special values and utilities for controlling callback execution and component updates.
188
189
```python { .api }
190
class NoUpdate:
191
"""Sentinel value to prevent component updates."""
192
pass
193
194
no_update: NoUpdate # Alias for NoUpdate()
195
196
class PreventUpdate(Exception):
197
"""Exception to prevent callback execution."""
198
pass
199
200
class Patch:
201
"""Partial updates for lists and dictionaries."""
202
def append(self, item): ...
203
def prepend(self, item): ...
204
def insert(self, index: int, item): ...
205
def remove(self, item): ...
206
def clear(self): ...
207
```
208
209
[Special Values and Control](./special-values.md)
210
211
### Background Callbacks
212
213
Asynchronous callback processing for long-running operations with progress reporting and caching support.
214
215
```python { .api }
216
class CeleryManager:
217
def __init__(self, celery_app): ...
218
219
class DiskcacheManager:
220
def __init__(self, cache_by: str = "session", cache: Any = None): ...
221
222
# Background callback decorator
223
@callback(
224
background=True,
225
manager=CeleryManager(celery_app),
226
running=[(Output("loading", "children"), "Running...")],
227
progress=[Output("progress", "value"), Output("progress", "max")],
228
progress_default=[0, 100]
229
)
230
def long_running_callback(*args): ...
231
```
232
233
[Background Callbacks](./background-callbacks.md)
234
235
### Asset Management
236
237
Static asset handling including CSS, JavaScript, images, and external resources with hot reloading and fingerprinting.
238
239
```python { .api }
240
def get_asset_url(path: str) -> str:
241
"""Get URL for asset file."""
242
...
243
244
def get_relative_path(path: str) -> str:
245
"""Get relative path from request."""
246
...
247
248
def strip_relative_path(path: str) -> str:
249
"""Strip relative path prefix."""
250
...
251
```
252
253
[Asset Management](./asset-management.md)
254
255
## Types
256
257
```python { .api }
258
# Core types
259
Component = Any # Base component class
260
ComponentIdType = Union[str, Dict, Component] # Component identifier
261
LayoutType = Union[Component, List, Dict, str, int, float] # Layout content
262
263
# Callback types
264
CallbackContext = Any # Callback execution context
265
CallbackFunction = Callable[..., Any] # Callback function signature
266
DependencyList = List[Union[Input, Output, State]] # Callback dependencies
267
268
# App configuration
269
ServerType = Any # Flask server instance
270
AssetList = List[Union[str, Dict[str, str]]] # External assets
271
PluginList = List[Any] # Plugin instances
272
273
# Multi-page types
274
PageConfig = Dict[str, Any] # Page configuration
275
PageRegistry = Dict[str, PageConfig] # Page registry
276
```