panel package#

Subpackages#

Submodules#

Module contents#

Panel is a high level app and dashboarding framework#

Panel is an open-source Python library that lets you create custom interactive web apps and dashboards by connecting user-defined widgets to plots, images, tables, or text.

Panel works with the tools you know and ❤️.

Check out https://panel.holoviz.org/

How to develop a Panel app in 3 simple steps#

Write the app

>>> import panel as pn
>>> pn.extension(sizing_mode="stretch_width", template="fast")
>>> pn.state.template.param.update(title="My Data App")
>>> pn.panel(some_python_object).servable()

Run your app

$ panel serve my_script.py –dev –show

or

$ panel serve my_notebook.ipynb –dev –show

The app will be available in your browser!

Change your code and save it

The app will reload with your changes!

You can also add automatic reload to jupyterlab. Check out https://blog.holoviz.org/panel_0.12.0.html#JupyterLab-previews

To learn more about Panel check out https://panel.holoviz.org/getting_started/index.html

class panel.Accordion(*objects, **params)[source]#

Bases: NamedListPanel

The Accordion layout is a type of Card layout that allows switching between multiple objects by clicking on the corresponding card header.

The labels for each card will default to the name parameter of the card’s contents, but may also be defined explicitly as part of a tuple.

Like Column and Row, Accordion has a list-like API that allows interactively updating and modifying the cards using the methods append, extend, clear, insert, pop, remove and __setitem__.

Reference: https://panel.holoviz.org/reference/layouts/Accordion.html

Example:

>>> pn.Accordion(some_pane_with_a_name, ("Plot", some_plot))

Methods

select([selector])

Iterates over the Viewable and any potential children in the applying the Selector.

Parameter Definitions

Parameters inherited from:

panel.viewable.Layoutable: align, aspect_ratio, css_classes, design, height, min_width, min_height, max_width, max_height, margin, styles, stylesheets, tags, width, width_policy, height_policy, sizing_mode, visible

panel.viewable.Viewable: loading

panel.layout.base.NamedListLike: objects

panel.layout.base.NamedListPanel: scroll

active = List(bounds=(0, None), default=[], label='Active'): List of indexes of active cards.
active_header_background = String(allow_None=True, label='Active header background'): Color for currently active headers.
header_color = String(default='', label='Header color'): A valid CSS color to apply to the expand button.
header_background = String(default='', label='Header background'): A valid CSS color for the header background.
toggle = Boolean(default=False, label='Toggle'): Whether to toggle between active cards or allow multiple cards

select(selector: type | Callable[[Viewable], bool] | None = None) → list[Viewable][source]#

Iterates over the Viewable and any potential children in the applying the Selector.

Parameters:

selector: type or callable or None: The selector allows selecting a subset of Viewables by declaring a type or callable function to filter by.

Returns:

viewables: list(Viewable)

class panel.Card(*objects, **params)[source]#

Bases: Column

A Card layout allows arranging multiple panel objects in a collapsible, vertical container with a header bar.

Reference: https://panel.holoviz.org/reference/layouts/Card.html

Example:

>>> pn.Card(
...     some_widget, some_pane, some_python_object,
...     title='Card', styles=dict(background='WhiteSmoke'),
... )

Methods

select([selector])

Iterates over the Viewable and any potential children in the applying the Selector.

Parameter Definitions

Parameters inherited from:

panel.viewable.Layoutable: align, aspect_ratio, design, height, min_width, min_height, max_width, max_height, margin, styles, stylesheets, tags, width, width_policy, height_policy, sizing_mode, visible

panel.viewable.Viewable: loading

panel.layout.base.ListLike: objects

panel.layout.base.ListPanel: scroll

panel.layout.base.Column: auto_scroll_limit, scroll_button_threshold, scroll_position, view_latest

css_classes = List(bounds=(0, None), default=['card'], label='Css classes', nested_refs=True): CSS classes to apply to the overall Card.
active_header_background = String(allow_None=True, label='Active header background'): A valid CSS color for the header background when not collapsed.
button_css_classes = List(bounds=(0, None), default=['card-button'], label='Button css classes'): CSS classes to apply to the button element.
collapsible = Boolean(default=True, label='Collapsible'): Whether the Card should be expandable and collapsible.
collapsed = Boolean(default=False, label='Collapsed'): Whether the contents of the Card are collapsed.
header = Parameter(allow_None=True, label='Header'): A Panel component to display in the header bar of the Card. Will override the given title if defined.
header_background = String(default='', label='Header background'): A valid CSS color for the header background.
header_color = String(default='', label='Header color'): A valid CSS color to apply to the header text.
header_css_classes = List(bounds=(0, None), default=['card-header'], label='Header css classes'): CSS classes to apply to the header element.
hide_header = Boolean(default=False, label='Hide header'): Whether to skip rendering the header.
title_css_classes = List(bounds=(0, None), default=['card-title'], label='Title css classes'): CSS classes to apply to the header title.
title = String(default='', label='Title'): A title to be displayed in the Card header, will be overridden by the header if defined.

select(selector: type | Callable[[Viewable], bool] | None = None) → list[Viewable][source]#

Iterates over the Viewable and any potential children in the applying the Selector.

Parameters:

selector: type or callable or None: The selector allows selecting a subset of Viewables by declaring a type or callable function to filter by.

Returns:

viewables: list(Viewable)

class panel.Column(*objects: Any, **params: Any)[source]#

Bases: ListPanel

The Column layout allows arranging multiple panel objects in a vertical container.

It has a list-like API with methods to append, extend, clear, insert, pop, remove and __setitem__, which makes it possible to interactively update and modify the layout.

Reference: https://panel.holoviz.org/reference/layouts/Column.html

Example:

>>> pn.Column(some_widget, some_pane, some_python_object)

Methods

scroll_to(index)

Scrolls to the child at the provided index.

Parameter Definitions

Parameters inherited from:

panel.viewable.Layoutable: align, aspect_ratio, css_classes, design, height, min_width, min_height, max_width, max_height, margin, styles, stylesheets, tags, width, width_policy, height_policy, sizing_mode, visible

panel.viewable.Viewable: loading

panel.layout.base.ListLike: objects

panel.layout.base.ListPanel: scroll

auto_scroll_limit = Integer(bounds=(0, None), default=0, inclusive_bounds=(True, True), label='Auto scroll limit'): Max pixel distance from the latest object in the Column to activate automatic scrolling upon update. Setting to 0 disables auto-scrolling.
scroll_button_threshold = Integer(bounds=(0, None), default=0, inclusive_bounds=(True, True), label='Scroll button threshold'): Min pixel distance from the latest object in the Column to display the scroll button. Setting to 0 disables the scroll button.
scroll_position = Integer(default=0, inclusive_bounds=(True, True), label='Scroll position'): Current scroll position of the Column. Setting this value will update the scroll position of the Column. Setting to 0 will scroll to the top.
view_latest = Boolean(default=False, label='View latest'): Whether to scroll to the latest object on init. If not enabled the view will be on the first object.

scroll_to(index: int)[source]#

Scrolls to the child at the provided index.

Parameters:

index: int: Index of the child object to scroll to.

class panel.Feed(*objects, **params)[source]#

Bases: Column

The Feed class inherits from the Column layout, thereby enabling the arrangement of multiple panel objects within a vertical container. However, it restrictively manages the number of objects displayed at any moment. This layout is particularly useful for efficiently rendering a substantial number of objects.

Similar to Column, the Feed provides a list-like API, including methods such as append, extend, clear, insert, pop, remove, and __setitem__. These methods facilitate interactive updates and modifications to the layout.

Reference: https://panel.holoviz.org/reference/layouts/Feed.html

Example:

>>> pn.Feed(some_widget, some_pane, some_python_object, ..., python_object_1002)

Methods

scroll_to_latest([scroll_limit])

Scrolls the Feed to the latest entry.

Parameter Definitions

Parameters inherited from:

panel.viewable.Layoutable: align, aspect_ratio, css_classes, design, height, min_width, min_height, max_width, max_height, margin, styles, stylesheets, tags, width, width_policy, height_policy, sizing_mode, visible

panel.viewable.Viewable: loading

panel.layout.base.ListLike: objects

panel.layout.base.Column: auto_scroll_limit, scroll_button_threshold, scroll_position, view_latest

scroll = Selector(default='y', label='Scroll', names={}, objects=[False, True, 'both-auto', 'y-auto', 'x-auto', 'both', 'x', 'y']): Whether to add scrollbars if the content overflows the size of the container. If “both-auto”, will only add scrollbars if the content overflows in either directions. If “x-auto” or “y-auto”, will only add scrollbars if the content overflows in the respective direction. If “both”, will always add scrollbars. If “x” or “y”, will always add scrollbars in the respective direction. If False, overflowing content will be clipped. If True, will only add scrollbars in the direction of the container, (e.g. Column: vertical, Row: horizontal).
load_buffer = Integer(bounds=(0, None), default=50, inclusive_bounds=(True, True), label='Load buffer'): The number of objects loaded on each side of the visible objects. When scrolled halfway into the buffer, the feed will automatically load additional objects while unloading objects on the opposite side.
visible_range = Range(allow_None=True, constant=True, inclusive_bounds=(True, True), label='Visible range', length=2, readonly=True): Read-only upper and lower bounds of the currently visible feed objects. This list is automatically updated based on scrolling.

scroll_to_latest(scroll_limit: float | None = None) → None[source]#

Scrolls the Feed to the latest entry.

Parameters:

scroll_limitfloat, optional: Maximum pixel distance from the latest object in the Feed to trigger scrolling. If the distance exceeds this limit, scrolling will not occur. If this is not set, it will always scroll to the latest while setting this to 0 disables scrolling.

class panel.FlexBox(*objects, **params)[source]#

Bases: ListLike, ReactiveHTML

The FlexBox is a list-like layout (unlike GridSpec) that wraps objects into a CSS flex container.

It has a list-like API with methods to append, extend, clear, insert, pop, remove and __setitem__, which makes it possible to interactively update and modify the layout. It exposes all the CSS options for controlling the behavior and layout of the flex box.

Reference: https://panel.holoviz.org/reference/layouts/FlexBox.html

Example:

>>> pn.FlexBox(
...    some_python_object, another_python_object, ...,
...    the_last_python_object
... )

Methods

select([selector])

Iterates over the Viewable and any potential children in the applying the Selector.

Parameter Definitions

Parameters inherited from:

panel.viewable.Layoutable: align, aspect_ratio, css_classes, design, height, min_width, min_height, max_width, max_height, margin, styles, stylesheets, tags, width, width_policy, height_policy, sizing_mode, visible

panel.viewable.Viewable: loading

panel.layout.base.ListLike: objects

align_content = Selector(default='flex-start', label='Align content', names={}, objects=['normal', 'flex-start', 'flex-end', 'center', 'space-between', 'space-around', 'space-evenly', 'stretch', 'start', 'end', 'baseline', 'first baseline', 'last baseline']): Defines how a flex container’s lines align when there is extra space in the cross-axis.
align_items = Selector(default='flex-start', label='Align items', names={}, objects=['stretch', 'flex-start', 'flex-end', 'center', 'baseline', 'first baseline', 'last baseline', 'start', 'end', 'self-start', 'self-end']): Defines the default behavior for how flex items are laid out along the cross axis on the current line.
flex_direction = Selector(default='row', label='Flex direction', names={}, objects=['row', 'row-reverse', 'column', 'column-reverse']): This establishes the main-axis, thus defining the direction flex items are placed in the flex container.
flex_wrap = Selector(default='wrap', label='Flex wrap', names={}, objects=['nowrap', 'wrap', 'wrap-reverse']): Whether and how to wrap items in the flex container.
gap = String(default='', label='Gap'): Defines the spacing between flex items, supporting various units (px, em, rem, %, vw/vh).
justify_content = Selector(default='flex-start', label='Justify content', names={}, objects=['flex-start', 'flex-end', 'center', 'space-between', 'space-around', 'space-evenly', 'start', 'end', 'left', 'right']): Defines the alignment along the main axis.

select(selector=None)[source]#

Iterates over the Viewable and any potential children in the applying the Selector.

Parameters:

selector: type or callable or None: The selector allows selecting a subset of Viewables by declaring a type or callable function to filter by.

Returns:

viewables: list(Viewable)

class panel.FloatPanel(*objects, name='', **params)[source]#

Bases: ListLike, ReactiveHTML

Float provides a floating panel layout.

Reference: https://panel.holoviz.org/reference/layouts/FloatPanel.html

Example:

>>> import panel as pn
>>> pn.extension("floatpanel")
>>> pn.layout.FloatPanel("**I can float**!", position="center", width=300).servable()

Methods

select([selector])

Iterates over the Viewable and any potential children in the applying the Selector.

Parameter Definitions

Parameters inherited from:

panel.viewable.Layoutable: align, aspect_ratio, css_classes, design, height, min_width, min_height, max_width, max_height, margin, styles, stylesheets, tags, width, width_policy, height_policy, sizing_mode, visible

panel.viewable.Viewable: loading

panel.layout.base.ListLike: objects

config = Dict(class_=<class 'dict'>, default={}, label='Config'): Additional jsPanel configuration with precedence over parameter values.
contained = Boolean(default=True, label='Contained'): Whether the component is contained within parent container or completely free floating.
position = Selector(default='right-top', label='Position', names={}, objects=['center', 'left-top', 'center-top', 'right-top', 'right-center', 'right-bottom', 'center-bottom', 'left-bottom', 'left-center']): The initial position if the container is free-floating.
offsetx = Integer(allow_None=True, bounds=(0, None), inclusive_bounds=(True, True), label='Offsetx'): Horizontal offset in pixels.
offsety = Integer(allow_None=True, bounds=(0, None), inclusive_bounds=(True, True), label='Offsety'): Vertical offset in pixels.
theme = String(default='primary', label='Theme'): The theme which can be one of: - Built-ins: ‘default’, ‘primary’, ‘secondary’, ‘info’, ‘success’, ‘warning’, ‘danger’, ‘light’, ‘dark’ and ‘none’ - HEX, RGB and HSL color values like ‘#123456’ Any standardized color name like ‘forestgreen’ and color names from the Material Design Color System like ‘purple900’ - Additionally a theme string may include one of the modifiers ‘filled’, ‘filledlight’, ‘filleddark’ or ‘fillcolor’ separated from the theme color by a space like ‘primary
status = Selector(default='normalized', label='Status', names={}, objects=['normalized', 'maximized', 'minimized', 'smallified', 'smallifiedmax', 'closed']): The current status of the panel.

select(selector=None)[source]#

Iterates over the Viewable and any potential children in the applying the Selector.

Parameters:

selector: type or callable or None: The selector allows selecting a subset of Viewables by declaring a type or callable function to filter by.

Returns:

viewables: list(Viewable)

class panel.GridBox(*objects: Any, **params: Any)[source]#

Bases: ListPanel

The GridBox is a list-like layout (unlike GridSpec) that wraps objects into a grid according to the specified nrows and ncols parameters.

It has a list-like API with methods to append, extend, clear, insert, pop, remove and __setitem__, which makes it possible to interactively update and modify the layout.

Reference: https://panel.holoviz.org/reference/layouts/GridBox.html

Example:

>>> pn.GridBox(
...    python_object_1, python_object_2, ...,
...    python_object_24, ncols=6
... )

Parameter Definitions

Parameters inherited from:

panel.viewable.Layoutable: align, aspect_ratio, css_classes, design, height, min_width, min_height, max_width, max_height, margin, styles, stylesheets, tags, width, width_policy, height_policy, sizing_mode, visible

panel.viewable.Viewable: loading

panel.layout.base.ListLike: objects

panel.layout.base.ListPanel: scroll

nrows = Integer(allow_None=True, bounds=(0, None), inclusive_bounds=(True, True), label='Nrows'): Number of rows to reflow the layout into.
ncols = Integer(allow_None=True, bounds=(0, None), inclusive_bounds=(True, True), label='Ncols'): Number of columns to reflow the layout into.

class panel.GridSpec(*, mode, ncols, nrows, objects, loading, align, aspect_ratio, css_classes, design, height, height_policy, margin, max_height, max_width, min_height, min_width, sizing_mode, styles, stylesheets, tags, visible, width, width_policy, name)[source]#

Bases: Panel

The GridSpec is an array like layout that allows arranging multiple Panel objects in a grid using a simple API to assign objects to individual grid cells or to a grid span.

Other layout containers function like lists, but a GridSpec has an API similar to a 2D array, making it possible to use 2D assignment to populate, index, and slice the grid.

See GridStack for a similar layout that allows the user to resize and drag the cells.

Reference: https://panel.holoviz.org/reference/layouts/GridSpec.html

Example:

>>> import panel as pn
>>> gspec = pn.GridSpec(width=800, height=600)
>>> gspec[:,   0  ] = pn.Spacer(styles=dict(background='red'))
>>> gspec[0,   1:3] = pn.Spacer(styles=dict(background='green'))
>>> gspec[1,   2:4] = pn.Spacer(styles=dict(background='orange'))
>>> gspec[2,   1:4] = pn.Spacer(styles=dict(background='blue'))
>>> gspec[0:1, 3:4] = pn.Spacer(styles=dict(background='purple'))
>>> gspec

Attributes:

grid

Methods

clone(**params)

Makes a copy of the GridSpec sharing the same parameters.

Parameter Definitions

Parameters inherited from:

panel.viewable.Layoutable: align, aspect_ratio, css_classes, design, height, min_width, min_height, max_width, max_height, margin, styles, stylesheets, tags, width, width_policy, height_policy, sizing_mode, visible

panel.viewable.Viewable: loading

objects = ChildDict(class_=<class 'dict'>, default={}, label='Objects'): The dictionary of child objects that make up the grid.
mode = Selector(default='warn', label='Mode', names={}, objects=['warn', 'error', 'override']): Whether to warn, error or simply override on overlapping assignment.
ncols = Integer(allow_None=True, bounds=(0, None), inclusive_bounds=(True, True), label='Ncols'): Limits the number of columns that can be assigned.
nrows = Integer(allow_None=True, bounds=(0, None), inclusive_bounds=(True, True), label='Nrows'): Limits the number of rows that can be assigned.

clone(**params)[source]#

Makes a copy of the GridSpec sharing the same parameters.

Parameters:

params: Keyword arguments override the parameters on the clone.

Returns:

Cloned GridSpec object

class panel.GridStack(*, allow_drag, allow_resize, state, mode, ncols, nrows, objects, loading, align, aspect_ratio, css_classes, design, height, height_policy, margin, max_height, max_width, min_height, min_width, sizing_mode, styles, stylesheets, tags, visible, width, width_policy, name)[source]#

Bases: ReactiveHTML, GridSpec

The GridStack layout allows arranging multiple Panel objects in a grid using a simple API to assign objects to individual grid cells or to a grid span.

Other layout containers function like lists, but a GridSpec has an API similar to a 2D array, making it possible to use 2D assignment to populate, index, and slice the grid.

Reference: https://panel.holoviz.org/reference/layouts/GridStack.html

Example:

>>> pn.extension('gridstack')
>>> gstack = GridStack(sizing_mode='stretch_both')
>>> gstack[ : , 0: 3] = pn.Spacer(styles=dict(background='red'))
>>> gstack[0:2, 3: 9] = pn.Spacer(styles=dict(background='green'))
>>> gstack[2:4, 6:12] = pn.Spacer(styles=dict(background='orange'))
>>> gstack[4:6, 3:12] = pn.Spacer(styles=dict(background='blue'))
>>> gstack[0:2, 9:12] = pn.Spacer(styles=dict(background='purple'))

Parameter Definitions

Parameters inherited from:

panel.viewable.Layoutable: align, aspect_ratio, css_classes, design, min_width, min_height, max_width, max_height, margin, styles, stylesheets, tags, width_policy, height_policy, sizing_mode, visible

panel.viewable.Viewable: loading

panel.layout.grid.GridSpec: objects, mode, ncols, nrows

height = Integer(allow_None=True, bounds=(0, None), inclusive_bounds=(True, True), label='Height'): The height of the component (in pixels). This can be either fixed or preferred height, depending on height sizing policy.
width = Integer(allow_None=True, bounds=(0, None), inclusive_bounds=(True, True), label='Width'): The width of the component (in pixels). This can be either fixed or preferred width, depending on width sizing policy.
allow_resize = Boolean(default=True, label='Allow resize'): Allow resizing the grid cells.
allow_drag = Boolean(default=True, label='Allow drag'): Allow dragging the grid cells.
state = List(bounds=(0, None), default=[], label='State'): Current state of the grid (updated as items are resized and dragged).

class panel.HSpacer(refs=None, **params)[source]#

Bases: Spacer

The HSpacer layout provides responsive horizontal spacing.

Using this component we can space objects equidistantly in a layout and allow the empty space to shrink when the browser is resized.

How-to: https://panel.holoviz.org/how_to/layout/spacing.html#spacer-components

Example:

>>> pn.Row(
...     pn.layout.HSpacer(), 'Item 1',
...     pn.layout.HSpacer(), 'Item 2',
...     pn.layout.HSpacer()
... )

Parameter Definitions

Parameters inherited from:

panel.viewable.Layoutable: align, aspect_ratio, css_classes, design, height, min_width, min_height, max_width, max_height, margin, styles, stylesheets, tags, width, width_policy, height_policy, visible

panel.viewable.Viewable: loading

sizing_mode = Parameter(constant=True, default='stretch_width', label='Sizing mode', readonly=True): How the component should size itself. This is a high-level setting for maintaining width and height of the component. To gain more fine grained control over sizing, use width_policy, height_policy and aspect_ratio instead (those take precedence over sizing_mode). "fixed" Component is not responsive. It will retain its original width and height regardless of any subsequent browser window resize events. "stretch_width" Component will responsively resize to stretch to the available width, without maintaining any aspect ratio. The height of the component depends on the type of the component and may be fixed or fit to component’s contents. "stretch_height" Component will responsively resize to stretch to the available height, without maintaining any aspect ratio. The width of the component depends on the type of the component and may be fixed or fit to component’s contents. "stretch_both" Component is completely responsive, independently in width and height, and will occupy all the available horizontal and vertical space, even if this changes the aspect ratio of the component. "scale_width" Component will responsively resize to stretch to the available width, while maintaining the original or provided aspect ratio. "scale_height" Component will responsively resize to stretch to the available height, while maintaining the original or provided aspect ratio. "scale_both" Component will responsively resize to both the available width and height, while maintaining the original or provided aspect ratio.

class panel.Modal(*objects: Any, **params: Any)[source]#

Bases: ListPanel

Create a modal dialog that can be opened and closed.

Methods

`create_button`(action, **kwargs)	Create a button to show, hide or toggle the modal.
`show`()	Starts a Bokeh server and displays the Viewable in a new tab.

hide
toggle

Parameter Definitions

Parameters inherited from:

panel.viewable.Layoutable: align, aspect_ratio, css_classes, design, height, min_width, min_height, max_width, max_height, margin, styles, stylesheets, tags, width, width_policy, height_policy, sizing_mode, visible

panel.viewable.Viewable: loading

panel.layout.base.ListLike: objects

panel.layout.base.ListPanel: scroll

open = Boolean(default=False, label='Open'): Whether to open the modal.
show_close_button = Boolean(default=True, label='Show close button'): Whether to show a close button in the modal.
background_close = Boolean(default=True, label='Background close'): Whether to enable closing the modal when clicking the background.

create_button(action: Literal['show', 'hide', 'toggle'], **kwargs)[source]#: Create a button to show, hide or toggle the modal.

show()[source]#

Starts a Bokeh server and displays the Viewable in a new tab.

Parameters:

titlestr | None: A string title to give the Document (if served as an app)
port: int (optional, default=0): Allows specifying a specific port
addressstr: The address the server should listen on for HTTP requests.
websocket_origin: str or list(str) (optional): A list of hosts that can connect to the websocket. This is typically required when embedding a server app in an external web site. If None, “localhost” is used.
threaded: boolean (optional, default=False): Whether to launch the Server on a separate thread, allowing interactive use.
verbose: boolean (optional, default=True): Whether to print the address and port
openboolean (optional, default=True): Whether to open the server in a new browser tab
locationboolean or panel.io.location.Location: Whether to create a Location component to observe and set the URL location.

Returns:

server: bokeh.server.Server or panel.io.server.StoppableThread: Returns the Bokeh server instance or the thread the server was launched on (if threaded=True)

class panel.Param(object=None, **params)[source]#

Bases: Pane

Param panes render a Parameterized class into a set of interactive widgets that are dynamically linked to the parameter values of the class.

Reference: https://panel.holoviz.org/reference/panes/Param.html

Example:

>>> import param
>>> import panel as pn
>>> pn.extension()

>>> class App(param.Parameterized):
>>>     some_text = param.String(default="Hello")
>>>     some_float = param.Number(default=1, bounds=(0, 10), step=0.1)
>>>     some_boolean = param.Boolean(default=True)

>>> app = App()

>>> pn.Param(app, parameters=["some_text", "some_float"], show_name=False).servable()

Attributes:

widgets

Methods

`applies`(obj)	Returns boolean or float indicating whether the Pane can render the object.
`get_root`([doc, comm, preprocess])	Returns the root model and applies pre-processing hooks
`select`([selector])	Iterates over the Viewable and any potential children in the applying the Selector.
`widget`(p_name)	Get widget for param_name

widget_type

Parameter Definitions

Parameters inherited from:

panel.viewable.Layoutable: align, aspect_ratio, css_classes, design, min_width, min_height, max_width, max_height, styles, stylesheets, tags, width_policy, height_policy, sizing_mode, visible

panel.viewable.Viewable: loading

panel.pane.base.PaneBase: margin

height = Integer(allow_None=True, bounds=(0, None), inclusive_bounds=(True, True), label='Height'): Height of widgetbox the parameter widgets are displayed in.
width = Integer(allow_None=True, bounds=(0, None), inclusive_bounds=(True, True), label='Width'): Width of widgetbox the parameter widgets are displayed in.
default_layout = ClassSelector(class_=<class 'panel.layout.base.Panel'>, default=<class 'panel.layout.base.Column'>, label='Default layout'): Defines the layout the model(s) returned by the pane will be placed in.
object = Parameter(allow_None=True, label='Object'): The object being wrapped, which will be converted to a Bokeh model.
display_threshold = Number(default=0, inclusive_bounds=(True, True), label='Display threshold'): Parameters with precedence below this value are not displayed.
default_precedence = Number(default=1e-08, inclusive_bounds=(True, True), label='Default precedence'): Precedence value to use for parameters with no declared precedence. By default, zero predecence is available for forcing some parameters to the top of the list, and other values above the default_precedence values can be used to sort or group parameters arbitrarily.
expand = Boolean(default=False, label='Expand'): Whether parameterized subobjects are expanded or collapsed on instantiation.
expand_button = Boolean(allow_None=True, label='Expand button'): Whether to add buttons to expand and collapse sub-objects.
expand_layout = Parameter(default=<class 'panel.layout.base.Column'>, label='Expand layout'): Layout to expand sub-objects into.
hide_constant = Boolean(default=False, label='Hide constant'): Whether to hide widgets of constant parameters.
initializer = Callable(allow_None=True, label='Initializer'): User-supplied function that will be called on initialization, usually to update the default Parameter values of the underlying parameterized object.
parameters = List(allow_None=True, bounds=(0, None), default=[], label='Parameters'): If set this serves as a allowlist of parameters to display on the supplied Parameterized object.
show_labels = Boolean(default=True, label='Show labels'): Whether to show labels for each widget
show_name = Boolean(default=True, label='Show name'): Whether to show the parameterized object’s name
sort = ClassSelector(class_=(<class 'bool'>, <class 'collections.abc.Callable'>), default=False, label='Sort'): If True the widgets will be sorted alphabetically by label. If a callable is provided it will be used to sort the Parameters, for example lambda x: x[1].label[::-1] will sort by the reversed label.
widgets = Dict(allow_None=True, class_=<class 'dict'>, label='Widgets'): Dictionary of widget overrides, mapping from parameter name to widget class.

classmethod applies(obj: Any) → float | bool | None[source]#

Returns boolean or float indicating whether the Pane can render the object.

If the priority of the pane is set to None, this method may also be used to define a float priority depending on the object being rendered.

default_layout[source]#: alias of Column

expand_layout[source]#: alias of Column

get_root(doc: Document | None = None, comm: Comm | None = None, preprocess: bool = True) → Model[source]#

Returns the root model and applies pre-processing hooks

Parameters:

doc: bokeh.document.Document: Optional Bokeh document the bokeh model will be attached to.
comm: pyviz_comms.Comm: Optional pyviz_comms when working in notebook
preprocess: bool (default=True): Whether to run preprocessing hooks

Returns:

Returns the bokeh model corresponding to this panel object

select(selector=None)[source]#

Iterates over the Viewable and any potential children in the applying the Selector.

Parameters:

selector: type or callable or None: The selector allows selecting a subset of Viewables by declaring a type or callable function to filter by.

Returns:

viewables: list(Viewable)

widget(p_name)[source]#: Get widget for param_name

class panel.ReactiveExpr(object=None, **params)[source]#

Bases: Pane

ReactiveExpr generates a UI for param.rx objects by rendering the widgets and outputs.

Attributes:

widgets

Methods

applies(object)

Returns boolean or float indicating whether the Pane can render the object.

Parameter Definitions

Parameters inherited from:

panel.viewable.Layoutable: align, aspect_ratio, css_classes, design, height, min_width, min_height, max_width, max_height, styles, stylesheets, tags, width, width_policy, height_policy, sizing_mode, visible

panel.viewable.Viewable: loading

panel.pane.base.PaneBase: margin, default_layout

object = Parameter(allow_None=True, label='Object'): The object being wrapped, which will be converted to a Bokeh model.
center = Boolean(default=False, label='Center'): Whether to center the output.
show_widgets = Boolean(default=True, label='Show widgets'): Whether to display the widget inputs.
widget_layout = Selector(constant=True, default=<class 'panel.layout.base.WidgetBox'>, label='Widget layout', names={}, objects=[<class 'panel.layout.base.WidgetBox'>, <class 'panel.layout.base.Row'>, <class 'panel.layout.base.Column'>]): The layout object to display the widgets in.
widget_location = Selector(default='left_top', label='Widget location', names={}, objects=['left', 'right', 'top', 'bottom', 'top_left', 'top_right', 'bottom_left', 'bottom_right', 'left_top', 'right_top', 'right_bottom']): The location of the widgets relative to the output of the reactive expression.

classmethod applies(object)[source]#

Returns boolean or float indicating whether the Pane can render the object.

If the priority of the pane is set to None, this method may also be used to define a float priority depending on the object being rendered.

widget_layout[source]#: alias of WidgetBox

class panel.Row(*objects: Any, **params: Any)[source]#

Bases: ListPanel

The Row layout allows arranging multiple panel objects in a horizontal container.

It has a list-like API with methods to append, extend, clear, insert, pop, remove and __setitem__, which makes it possible to interactively update and modify the layout.

Reference: https://panel.holoviz.org/reference/layouts/Row.html

Example:

>>> pn.Row(some_widget, some_pane, some_python_object)

Parameter Definitions

Parameters inherited from:

panel.viewable.Layoutable: align, aspect_ratio, css_classes, design, height, min_width, min_height, max_width, max_height, margin, styles, stylesheets, tags, width, width_policy, height_policy, sizing_mode, visible

panel.viewable.Viewable: loading

panel.layout.base.ListLike: objects

panel.layout.base.ListPanel: scroll

class panel.Spacer(refs=None, **params)[source]#

Bases: Reactive

The Spacer layout is a very versatile component which makes it easy to put fixed or responsive spacing between objects.

Like all other components spacers support both absolute and responsive sizing modes.

How-to: https://panel.holoviz.org/how_to/layout/spacing.html#spacer-components

Example:

>>> pn.Row(
...    1, pn.Spacer(width=200),
...    2, pn.Spacer(width=100),
...    3
... )

Parameter Definitions

Parameters inherited from:

panel.viewable.Layoutable: align, aspect_ratio, css_classes, design, height, min_width, min_height, max_width, max_height, margin, styles, stylesheets, tags, width, width_policy, height_policy, sizing_mode, visible

panel.viewable.Viewable: loading

class panel.Swipe(*objects, **params)[source]#

Bases: ListLike, ReactiveHTML

The Swipe layout enables you to quickly compare two panels laid out on top of each other with a part of the before panel shown on one side of a slider and a part of the after panel shown on the other side.

Attributes:

after
before

Methods

select([selector])

Iterates over the Viewable and any potential children in the applying the Selector.

Parameter Definitions

Parameters inherited from:

panel.viewable.Layoutable: align, aspect_ratio, css_classes, design, height, min_width, min_height, max_width, max_height, margin, styles, stylesheets, tags, width, width_policy, height_policy, sizing_mode, visible

panel.viewable.Viewable: loading

objects = List(bounds=(0, 2), default=[], item_type=<class 'panel.viewable.Viewable'>, label='Objects'): The list of child objects that make up the layout.
slider_width = Integer(bounds=(0, 25), default=5, inclusive_bounds=(True, True), label='Slider width'): The width of the slider in pixels
slider_color = Color(allow_named=True, default='black', label='Slider color'): The color of the slider
value = Integer(bounds=(0, 100), default=50, inclusive_bounds=(True, True), label='Value'): The percentage of the after panel to show.

_before = Parameter(allow_None=True, label=' before')

_after = Parameter(allow_None=True, label=' after')

select(selector=None)[source]#

Iterates over the Viewable and any potential children in the applying the Selector.

Parameters:

selector: type or callable or None: The selector allows selecting a subset of Viewables by declaring a type or callable function to filter by.

Returns:

viewables: list(Viewable)

class panel.Tabs(*objects, **params)[source]#

Bases: NamedListPanel

The Tabs layout allows switching between multiple objects by clicking on the corresponding tab header.

Tab labels may be defined explicitly as part of a tuple or will be inferred from the name parameter of the tab’s contents.

Like Column and Row, Tabs has a list-like API with methods to append, extend, clear, insert, pop, remove and __setitem__, which make it possible to interactively update and modify the tabs.

Reference: https://panel.holoviz.org/reference/layouts/Tabs.html

Example:

>>> pn.Tabs(('Scatter', plot1), some_pane_with_a_name)

Parameter Definitions

Parameters inherited from:

panel.viewable.Layoutable: align, aspect_ratio, css_classes, design, min_width, min_height, max_width, max_height, margin, styles, stylesheets, tags, width_policy, height_policy, sizing_mode, visible

panel.viewable.Viewable: loading

panel.layout.base.NamedListLike: objects

panel.layout.base.NamedListPanel: active, scroll

height = Integer(allow_None=True, bounds=(0, None), inclusive_bounds=(True, True), label='Height'): The height of the component (in pixels). This can be either fixed or preferred height, depending on height sizing policy.
width = Integer(allow_None=True, bounds=(0, None), inclusive_bounds=(True, True), label='Width'): The width of the component (in pixels). This can be either fixed or preferred width, depending on width sizing policy.
closable = Boolean(default=False, label='Closable'): Whether it should be possible to close tabs.
dynamic = Boolean(default=False, label='Dynamic'): Dynamically populate only the active tab.
tabs_location = Selector(default='above', label='Tabs location', names={}, objects=['above', 'below', 'left', 'right']): The location of the tabs relative to the tab contents.

class panel.Template(template: str | _Template, nb_template: str | _Template | None = None, items: dict[str, Any] | None = None, **params)[source]#

Bases: BaseTemplate

A Template is a high-level component to render multiple Panel objects into a single HTML document defined through a Jinja2 template. The Template object is given a Jinja2 template and then allows populating this template by adding Panel objects, which are given unique names. These unique names may then be referenced in the template to insert the rendered Panel object at a specific location. For instance, given a Jinja2 template that defines roots A and B like this:

<div> {{ embed(roots.A) }} </div> <div> {{ embed(roots.B) }} </div>

We can then populate the template by adding panel ‘A’ and ‘B’ to the Template object:

template.add_panel(‘A’, pn.panel(‘A’)) template.add_panel(‘B’, pn.panel(‘B’))

Once a template has been fully populated it can be rendered using the same API as other Panel objects. Note that all roots that have been declared using the {{ embed(roots.A) }} syntax in the Jinja2 template must be defined when rendered.

Since embedding complex CSS frameworks inside a notebook can have undesirable side-effects and a notebook does not afford the same amount of screen space a Template may given separate template and nb_template objects. This allows for different layouts when served as a standalone server and when used in the notebook.

Methods

`add_panel`(name, panel[, tags])	Add panels to the Template, which may then be referenced by the given name using the jinja2 embed macro.
`add_variable`(name, value)	Add parameters to the template, which may then be referenced by the given name in the Jinja2 template.

Parameter Definitions

Parameters inherited from:

panel.template.base.BaseTemplate: config, design, location, theme

add_panel(name: str, panel: Any, tags: list[str] = []) → None[source]#

Add panels to the Template, which may then be referenced by the given name using the jinja2 embed macro.

Parameters:

namestr: The name to refer to the panel by in the template
panelpanel.Viewable: A Panel component to embed in the template.

add_variable(name: str, value: Any) → None[source]#

Add parameters to the template, which may then be referenced by the given name in the Jinja2 template.

Parameters:

namestr: The name to refer to the panel by in the template
valueobject: Any valid Jinja2 variable type.

class panel.VSpacer(refs=None, **params)[source]#

Bases: Spacer

The VSpacer layout provides responsive vertical spacing.

Using this component we can space objects equidistantly in a layout and allow the empty space to shrink when the browser is resized.

Reference: https://panel.holoviz.org/how_to/layout/spacing.html#spacer-components

Example:

>>> pn.Column(
...     pn.layout.VSpacer(), 'Item 1',
...     pn.layout.VSpacer(), 'Item 2',
...     pn.layout.VSpacer()
... )

Parameter Definitions

Parameters inherited from:

panel.viewable.Layoutable: align, aspect_ratio, css_classes, design, height, min_width, min_height, max_width, max_height, margin, styles, stylesheets, tags, width, width_policy, height_policy, visible

panel.viewable.Viewable: loading

sizing_mode = Parameter(constant=True, default='stretch_height', label='Sizing mode', readonly=True): How the component should size itself. This is a high-level setting for maintaining width and height of the component. To gain more fine grained control over sizing, use width_policy, height_policy and aspect_ratio instead (those take precedence over sizing_mode). "fixed" Component is not responsive. It will retain its original width and height regardless of any subsequent browser window resize events. "stretch_width" Component will responsively resize to stretch to the available width, without maintaining any aspect ratio. The height of the component depends on the type of the component and may be fixed or fit to component’s contents. "stretch_height" Component will responsively resize to stretch to the available height, without maintaining any aspect ratio. The width of the component depends on the type of the component and may be fixed or fit to component’s contents. "stretch_both" Component is completely responsive, independently in width and height, and will occupy all the available horizontal and vertical space, even if this changes the aspect ratio of the component. "scale_width" Component will responsively resize to stretch to the available width, while maintaining the original or provided aspect ratio. "scale_height" Component will responsively resize to stretch to the available height, while maintaining the original or provided aspect ratio. "scale_both" Component will responsively resize to both the available width and height, while maintaining the original or provided aspect ratio.

class panel.WidgetBox(*objects: Any, **params: Any)[source]#

Bases: ListPanel

The WidgetBox layout allows arranging multiple panel objects in a vertical (or horizontal) container.

It is largely identical to the Column layout, but has some default styling that makes widgets be clearly grouped together visually.

It has a list-like API with methods to append, extend, clear, insert, pop, remove and __setitem__, which make it possible to interactively update and modify the layout.

Reference: https://panel.holoviz.org/reference/layouts/WidgetBox.html

Example:

>>> pn.WidgetBox(some_widget, another_widget)

Parameter Definitions

Parameters inherited from:

panel.viewable.Layoutable: align, aspect_ratio, design, height, min_width, min_height, max_width, max_height, margin, styles, stylesheets, tags, width, width_policy, height_policy, sizing_mode, visible

panel.viewable.Viewable: loading

panel.layout.base.ListLike: objects

panel.layout.base.ListPanel: scroll

css_classes = List(bounds=(0, None), default=['panel-widget-box'], label='Css classes', nested_refs=True): CSS classes to apply to the layout.
disabled = Boolean(default=False, label='Disabled'): Whether the widget is disabled.
horizontal = Boolean(default=False, label='Horizontal'): Whether to lay out the widgets in a Row layout as opposed to a Column layout.

panel.bind(function, *args, watch=False, **kwargs)[source]#

Given a function, returns a wrapper function that binds the values of some or all arguments to Parameter values and expresses Param dependencies on those values, so that the function can be invoked whenever the underlying values change and the output will reflect those updated values.

As for functools.partial, arguments can also be bound to constants, which allows all of the arguments to be bound, leaving a simple callable object.

Arguments:#

function: callable: The function to bind constant or dynamic args and kwargs to.
args: object, param.Parameter: Positional arguments to bind to the function.
watch: boolean: Whether to evaluate the function automatically whenever one of the bound parameters changes.
kwargs: object, param.Parameter: Keyword arguments to bind to the function.

Returns:

Returns a new function with the args and kwargs bound to it and
annotated with all dependencies.

panel.cache(func: Callable[_P, _R] | None = None, hash_funcs: dict[type[Any], Callable[[Any], bytes]] | None = None, max_items: int | None = None, policy: Literal['FIFO', 'LRU', 'LFU'] = 'LRU', ttl: float | None = None, to_disk: bool = False, cache_path: str | os.PathLike = './cache', per_session: bool = False) → _CachedFunc[Callable[_P, _R]] | Callable[[Callable[_P, _R]], _CachedFunc[Callable[_P, _R]]][source]#

Memoizes functions for a user session. Can be used as function annotation or just directly.

For global caching across user sessions use pn.state.as_cached.

Parameters:

func: callable

The function to cache.

hash_funcs: dict or None

A dictionary mapping from a type to a function which returns a hash for an object of that type. If provided this will override the default hashing function provided by Panel.

max_items: int or None

The maximum items to keep in the cache. Default is None, which does not limit number of items stored in the cache.

policy: str

A caching policy when max_items is set, must be one of:

FIFO: First in - First out
LRU: Least recently used
LFU: Least frequently used

ttl: float or None

The number of seconds to keep an item in the cache, or None if the cache should not expire. The default is None.

to_disk: bool

Whether to cache to disk using diskcache.

cache_path: str

Directory to cache to on disk.

per_session: bool

Whether to cache data only for the current session.

panel.depends(func: CallableT, /, *dependencies: Dependency, watch: bool = False, on_init: bool = False, **kw: Parameter) → Callable[[CallableT], DependsFunc[CallableT]][source]#

Annotates a function or Parameterized method to express its dependencies.

The specified dependencies can be either be Parameter instances or if a method is supplied they can be defined as strings referring to Parameters of the class, or Parameters of subobjects (Parameterized objects that are values of this object’s parameters). Dependencies can either be on Parameter values, or on other metadata about the Parameter.

Parameters:

watchbool, optional: Whether to invoke the function/method when the dependency is updated, by default False
on_initbool, optional: Whether to invoke the function/method when the instance is created, by default False

panel.extension[source]#: alias of panel_extension

panel.ipywidget(obj: Any, doc=None, **kwargs: Any)[source]#

Returns an ipywidget model which renders the Panel object.

Requires jupyter_bokeh to be installed.

Parameters:

obj: object: Any Panel object or object which can be rendered with Panel
doc: bokeh.Document: Bokeh document the bokeh model will be attached to.
**kwargs: dict: Keyword arguments passed to the pn.panel utility function

Returns:

Returns an ipywidget model which renders the Panel object.

panel.panel(obj: Any, **kwargs) → Viewable | ServableMixin[source]#

Creates a displayable Panel object given any valid Python object.

The appropriate Pane to render a specific object is determined by iterating over all defined Pane types and querying it’s .applies method for a priority value.

Any keyword arguments are passed down to the applicable Pane.

Setting loading_indicator=True will display a loading indicator while the function is being evaluated.

To lazily render components when the application loads, you may also provide a Python function, with or without bound parameter dependencies and set defer_load=True.

Reference: https://panel.holoviz.org/explanation/components/components_overview.html#panes

>>> pn.panel(some_python_object, width=500)

Parameters:

obj: object: Any object to be turned into a Panel
**kwargs: dict: Any keyword arguments to be passed to the applicable Pane

Returns:

layout: Viewable: A Viewable representation of the input object

class panel.rx(obj=None, **kwargs)[source]#

Bases: object

rx allows wrapping objects and then operating on them interactively while recording any operations applied to them. By recording all arguments or operands in the operations the recorded pipeline can be replayed if an operand represents a dynamic value.

Parameters:

obj: any: A supported data structure object

Examples

Instantiate it from an object:

>>> ifloat = rx(3.14)
>>> ifloat * 2
6.28

Then update the original value and see the new result: >>> ifloat.value = 1 2

classmethod register_accessor(name: str, accessor: Callable[[rx], Any], predicate: Callable[[Any], bool] | None = None)[source]#

Registers an accessor that extends rx with custom behavior.

Arguments:#

name: str: The name of the accessor will be attribute-accessible under.
accessor: Callable[[rx], any]: A callable that will return the accessor namespace object given the rx object it is registered on.

predicate: Callable[[Any], bool] | None

classmethod register_display_handler(obj_type, handler, **kwargs)[source]#

Registers a display handler for a specific type of object, making it possible to define custom display options for specific objects.

Arguments:#

obj_type: type | callable: The type to register a custom display handler on.
handler: Viewable | callable: A Viewable or callable that is given the object to be displayed and the custom keyword arguments.
kwargs: dict[str, Any]: Additional display options to register for this type.

classmethod register_method_handler(method, handler)[source]#: Registers a handler that is called when a specific method on an object is called.

property rx: reactive_ops#

The reactive namespace.

Provides reactive versions of operations that cannot be made reactive through operator overloading, such as .rx.and_ and .rx.bool. Calling this namespace (()) returns a reactive expression.

Returns:

Reactive expression: The result of calling the reactive namespace is a reactive expression.

Examples

Create a Parameterized instance:

>>> import param
>>> class P(param.Parameterized):
...     a = param.Number()
>>> p = P(a=1)

Get the current value:

>>> a = p.param.a.rx.value

Call it to get a reactive expression:

>>> rx_value = p.param.a.rx()

panel.serve(panels: TViewableFuncOrPath | dict[str, TViewableFuncOrPath], port: int = 0, address: str | None = None, websocket_origin: str | list[str] | None = None, loop: IOLoop | None = None, show: bool = True, start: bool = True, title: str | None = None, verbose: bool = True, location: bool = True, threaded: bool = False, admin: bool = False, **kwargs) → StoppableThread | Server[source]#

Allows serving one or more panel objects on a single server. The panels argument should be either a Panel object or a function returning a Panel object or a dictionary of these two. If a dictionary is supplied the keys represent the slugs at which each app is served, e.g. serve({‘app’: panel1, ‘app2’: panel2}) will serve apps at /app and /app2 on the server.

Reference: https://panel.holoviz.org/user_guide/Server_Configuration.html#serving-multiple-apps

Parameters:

panels: Viewable, function or {str: Viewable or function}

A Panel object, a function returning a Panel object or a dictionary mapping from the URL slug to either.

port: int (optional, default=0)

Allows specifying a specific port

addressstr

The address the server should listen on for HTTP requests.

websocket_origin: str or list(str) (optional)

A list of hosts that can connect to the websocket.

This is typically required when embedding a server app in an external web site.

If None, “localhost” is used.

looptornado.ioloop.IOLoop (optional, default=IOLoop.current())

The tornado IOLoop to run the Server on

showboolean (optional, default=True)

Whether to open the server in a new browser tab on start

startboolean(optional, default=True)

Whether to start the Server

title: str or {str: str} (optional, default=None)

An HTML title for the application or a dictionary mapping from the URL slug to a customized title

verbose: boolean (optional, default=True)

Whether to print the address and port

locationboolean or panel.io.location.Location

Whether to create a Location component to observe and set the URL location.

threaded: boolean (default=False)

Whether to start the server on a new Thread

admin: boolean (default=False)

Whether to enable the admin panel

kwargs: dict

Additional keyword arguments to pass to Server instance

class panel.widget(*, name)[source]#

Bases: ParameterizedFunction

Attempts to find a widget appropriate for a given value.

Parameters:

name: str: The name of the resulting widget.
value: Any: The value to deduce a widget from.
default: Any: The default value for the resulting widget.
**params: Any: Additional keyword arguments to pass to the widget.

Methods

`widget_from_iterable`(o, name)	Make widgets from an iterable.
`widget_from_single_value`(o, name)	Make widgets from single values, which can be used as parameter defaults.
`widget_from_tuple`(o, name, default)	Make widgets from a tuple abbreviation.

Returns:

Widget

Parameter Definitions

static widget_from_iterable(o, name)[source]#: Make widgets from an iterable. This should not be done for a string or tuple.

static widget_from_single_value(o, name)[source]#: Make widgets from single values, which can be used as parameter defaults.

static widget_from_tuple(o, name, default)[source]#: Make widgets from a tuple abbreviation.