holoviews.mpl Package


mpl Package

holoviews.plotting.mpl.set_style(key)[source]

Select a style by name, e.g. set_style(‘default’). To revert to the previous style use the key ‘unset’ or False.


annotation Module

digraph inheritancecd48cde56d { fontsize=18; rankdir=LR; size="12.0, 12.0"; "holoviews.plotting.mpl.annotation.ABLine2D" [URL="#holoviews.plotting.mpl.annotation.ABLine2D",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Draw a line based on its slope and y-intercept. Additional arguments are"]; "matplotlib.lines.Line2D" -> "holoviews.plotting.mpl.annotation.ABLine2D" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.annotation.AnnotationPlot" [URL="#holoviews.plotting.mpl.annotation.AnnotationPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="AnnotationPlot handles the display of all annotation elements."]; "holoviews.plotting.mpl.element.ElementPlot" -> "holoviews.plotting.mpl.annotation.AnnotationPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.annotation.ArrowPlot" [URL="#holoviews.plotting.mpl.annotation.ArrowPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Draw an arrow using the information supplied to the Arrow annotation"]; "holoviews.plotting.mpl.annotation.AnnotationPlot" -> "holoviews.plotting.mpl.annotation.ArrowPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.annotation.HLinePlot" [URL="#holoviews.plotting.mpl.annotation.HLinePlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Draw a horizontal line on the axis"]; "holoviews.plotting.mpl.annotation.AnnotationPlot" -> "holoviews.plotting.mpl.annotation.HLinePlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.annotation.HSpanPlot" [URL="#holoviews.plotting.mpl.annotation.HSpanPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Draw a horizontal span on the axis"]; "holoviews.plotting.mpl.annotation.AnnotationPlot" -> "holoviews.plotting.mpl.annotation.HSpanPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.annotation.LabelsPlot" [URL="#holoviews.plotting.mpl.annotation.LabelsPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top"]; "holoviews.plotting.mpl.element.ColorbarPlot" -> "holoviews.plotting.mpl.annotation.LabelsPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.annotation.SlopePlot" [URL="#holoviews.plotting.mpl.annotation.SlopePlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top"]; "holoviews.plotting.mpl.annotation.AnnotationPlot" -> "holoviews.plotting.mpl.annotation.SlopePlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.annotation.SplinePlot" [URL="#holoviews.plotting.mpl.annotation.SplinePlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Draw the supplied Spline annotation (see Spline docstring)"]; "holoviews.plotting.mpl.annotation.AnnotationPlot" -> "holoviews.plotting.mpl.annotation.SplinePlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.annotation.TextPlot" [URL="#holoviews.plotting.mpl.annotation.TextPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Draw the Text annotation object"]; "holoviews.plotting.mpl.annotation.AnnotationPlot" -> "holoviews.plotting.mpl.annotation.TextPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.annotation.VLinePlot" [URL="#holoviews.plotting.mpl.annotation.VLinePlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Draw a vertical line on the axis"]; "holoviews.plotting.mpl.annotation.AnnotationPlot" -> "holoviews.plotting.mpl.annotation.VLinePlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.annotation.VSpanPlot" [URL="#holoviews.plotting.mpl.annotation.VSpanPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Draw a vertical span on the axis"]; "holoviews.plotting.mpl.annotation.AnnotationPlot" -> "holoviews.plotting.mpl.annotation.VSpanPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.element.ColorbarPlot" [URL="#holoviews.plotting.mpl.element.ColorbarPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top"]; "holoviews.plotting.mpl.element.ElementPlot" -> "holoviews.plotting.mpl.element.ColorbarPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.element.ElementPlot" [URL="#holoviews.plotting.mpl.element.ElementPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top"]; "holoviews.plotting.plot.GenericElementPlot" -> "holoviews.plotting.mpl.element.ElementPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.plot.MPLPlot" -> "holoviews.plotting.mpl.element.ElementPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.plot.MPLPlot" [URL="#holoviews.plotting.mpl.plot.MPLPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="An MPLPlot object draws a matplotlib figure object when called or"]; "holoviews.plotting.plot.DimensionedPlot" -> "holoviews.plotting.mpl.plot.MPLPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.plot.DimensionedPlot" [URL="holoviews.plotting.html#holoviews.plotting.plot.DimensionedPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="DimensionedPlot implements a number of useful methods"]; "holoviews.plotting.plot.Plot" -> "holoviews.plotting.plot.DimensionedPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.plot.GenericElementPlot" [URL="holoviews.plotting.html#holoviews.plotting.plot.GenericElementPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Plotting baseclass to render contents of an Element. Implements"]; "holoviews.plotting.plot.DimensionedPlot" -> "holoviews.plotting.plot.GenericElementPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.plot.Plot" [URL="holoviews.plotting.html#holoviews.plotting.plot.Plot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Base class of all Plot classes in HoloViews, designed to be"]; "param.parameterized.Parameterized" -> "holoviews.plotting.plot.Plot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "matplotlib.artist.Artist" [fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",tooltip="Abstract base class for someone who renders into a"]; "matplotlib.lines.Line2D" [fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",tooltip="A line - the line can have both a solid linestyle connecting all"]; "matplotlib.artist.Artist" -> "matplotlib.lines.Line2D" [arrowsize=0.5,style="setlinewidth(0.5)"]; "param.parameterized.Parameterized" [fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",tooltip="params(name=String)"]; }
class holoviews.plotting.mpl.annotation.ABLine2D(slope, intercept, *args, **kwargs)[source]

Bases: matplotlib.lines.Line2D

Draw a line based on its slope and y-intercept. Additional arguments are passed to the <matplotlib.lines.Line2D> constructor.

add_callback(func)

Adds a callback function that will be called whenever one of the Artist’s properties changes.

Returns an id that is useful for removing the callback with remove_callback() later.

property axes

The Axes instance the artist resides in, or None.

contains(mouseevent)

Test whether the mouse event occurred on the line. The pick radius determines the precision of the location test (usually within five points of the value). Use get_pickradius() or set_pickradius() to view or modify it.

Returns True if any values are within the radius along with {'ind': pointlist}, where pointlist is the set of points within the radius.

TODO: sort returned indices by distance

convert_xunits(x)

For artists in an axes, if the xaxis has units support, convert x using xaxis unit type

convert_yunits(y)

For artists in an axes, if the yaxis has units support, convert y using yaxis unit type

draw(renderer)

draw the Line with renderer unless visibility is False

findobj(match=None, include_self=True)

Find artist objects.

Recursively find all Artist instances contained in self.

match can be

  • None: return all objects contained in artist.

  • function with signature boolean = match(artist) used to filter matches

  • class instance: e.g., Line2D. Only return artists of class type.

If include_self is True (default), include self in the list to be checked for a match.

format_cursor_data(data)

Return cursor data string formatted.

get_aa(*args, **kwargs)

alias for get_antialiased

get_agg_filter()

Return filter function to be used for agg filter.

get_alpha()

Return the alpha value used for blending - not supported on all backends

get_animated()

Return the artist’s animated state

get_c(*args, **kwargs)

alias for get_color

get_children()

Return a list of the child Artist`s this :class:`Artist contains.

get_clip_box()

Return artist clipbox

get_clip_on()

Return whether artist uses clipping

get_clip_path()

Return artist clip path

get_contains()

Return the _contains test used by the artist, or None for default.

get_cursor_data(event)

Get the cursor data for a given event.

get_dash_capstyle()

Get the cap style for dashed linestyles

get_dash_joinstyle()

Get the join style for dashed linestyles

get_data(orig=True)

Return the xdata, ydata.

If orig is True, return the original data.

get_figure()

Return the .Figure instance the artist belongs to.

get_fillstyle()

return the marker fillstyle

get_gid()

Returns the group id.

get_in_layout()

Return boolean flag, True if artist is included in layout calculations.

E.g. /tutorials/intermediate/constrainedlayout_guide, .Figure.tight_layout(), and fig.savefig(fname, bbox_inches='tight').

get_label()

Get the label used for this artist in the legend.

get_ls(*args, **kwargs)

alias for get_linestyle

get_lw(*args, **kwargs)

alias for get_linewidth

get_markevery()

return the markevery setting

get_mec(*args, **kwargs)

alias for get_markeredgecolor

get_mew(*args, **kwargs)

alias for get_markeredgewidth

get_mfc(*args, **kwargs)

alias for get_markerfacecolor

get_mfcalt(*args, **kwargs)

alias for get_markerfacecoloralt

get_ms(*args, **kwargs)

alias for get_markersize

get_path()

Return the Path object associated with this line.

get_picker()

Return the picker object used by this artist.

get_pickradius()

return the pick radius used for containment tests

get_rasterized()

Return whether the artist is to be rasterized.

get_sketch_params()

Returns the sketch parameters for the artist.

sketch_params : tuple or None

A 3-tuple with the following elements:

  • scale: The amplitude of the wiggle perpendicular to the source line.

  • length: The length of the wiggle along the line.

  • randomness: The scale factor by which the length is shrunken or expanded.

May return None if no sketch parameters were set.

get_snap()

Returns the snap setting which may be:

  • True: snap vertices to the nearest pixel center

  • False: leave vertices as-is

  • None: (auto) If the path contains only rectilinear line segments, round to the nearest pixel center

Only supported by the Agg and MacOSX backends.

get_solid_capstyle()

Get the cap style for solid linestyles

get_solid_joinstyle()

Get the join style for solid linestyles

get_tightbbox(renderer)

Like Artist.get_window_extent, but includes any clipping.

renderer.RendererBase instance

renderer that will be used to draw the figures (i.e. fig.canvas.get_renderer())

bbox.BboxBase

containing the bounding box (in figure pixel co-ordinates).

get_transform()

Return the Transform instance used by this artist.

get_transformed_clip_path_and_affine()

Return the clip path with the non-affine part of its transformation applied, and the remaining affine part of its transformation.

get_url()

Returns the url.

get_visible()

Return the artist’s visiblity

get_window_extent(renderer)

Get the axes bounding box in display space. Subclasses should override for inclusion in the bounding box “tight” calculation. Default is to return an empty bounding box at 0, 0.

Be careful when using this function, the results will not update if the artist window extent of the artist changes. The extent can change due to any changes in the transform stack, such as changing the axes limits, the figure size, or the canvas used (as is done when saving a figure). This can lead to unexpected behavior where interactive figures will look fine on the screen, but will save incorrectly.

get_xdata(orig=True)

Return the xdata.

If orig is True, return the original data, else the processed data.

get_xydata()

Return the xy data as a Nx2 numpy array.

get_ydata(orig=True)

Return the ydata.

If orig is True, return the original data, else the processed data.

get_zorder()

Return the artist’s zorder.

have_units()

Return True if units are set on the x or y axes

hitlist(event)

Deprecated since version 2.2: The hitlist function was deprecated in Matplotlib 2.2 and will be removed in 3.1.

List the children of the artist which contain the mouse event event.

is_dashed()

return True if line is dashstyle

is_figure_set()

Deprecated since version 2.2: artist.figure is not None

Returns whether the artist is assigned to a .Figure.

is_transform_set()

Returns True if Artist has a transform explicitly set.

pchanged()

Fire an event when property changed, calling all of the registered callbacks.

pick(mouseevent)

Process pick event

each child artist will fire a pick event if mouseevent is over the artist and the artist has picker set

pickable()

Return True if Artist is pickable.

properties()

return a dictionary mapping property name -> value for all Artist props

remove()

Remove the artist from the figure if possible. The effect will not be visible until the figure is redrawn, e.g., with matplotlib.axes.Axes.draw_idle(). Call matplotlib.axes.Axes.relim() to update the axes limits if desired.

Note: relim() will not see collections even if the collection was added to axes with autolim = True.

Note: there is no support for removing the artist’s legend entry.

remove_callback(oid)

Remove a callback based on its id.

See also

add_callback()

For adding callbacks

set(**kwargs)

A property batch setter. Pass kwargs to set properties.

set_aa(*args, **kwargs)

alias for set_antialiased

set_agg_filter(filter_func)

Set the agg filter.

filter_funccallable

A filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array.

set_alpha(alpha)

Set the alpha value used for blending - not supported on all backends.

alpha : float

set_animated(b)

Set the artist’s animation state.

b : bool

set_antialiased(b)

Set whether to use antialiased rendering.

b : bool

set_c(*args, **kwargs)

alias for set_color

set_clip_box(clipbox)

Set the artist’s clip .Bbox.

clipbox : .Bbox

set_clip_on(b)

Set whether artist uses clipping.

When False artists will be visible out side of the axes which can lead to unexpected results.

b : bool

set_clip_path(path, transform=None)

Set the artist’s clip path, which may be:

  • a Patch (or subclass) instance; or

  • a Path instance, in which case a Transform instance, which will be applied to the path before using it for clipping, must be provided; or

  • None, to remove a previously set clipping path.

For efficiency, if the path happens to be an axis-aligned rectangle, this method will set the clipping box to the corresponding rectangle and set the clipping path to None.

ACCEPTS: [(~matplotlib.path.Path, .Transform) | .Patch | None]

set_color(color)

Set the color of the line

color : color

set_contains(picker)

Replace the contains test used by this artist. The new picker should be a callable function which determines whether the artist is hit by the mouse event:

hit, props = picker(artist, mouseevent)

If the mouse event is over the artist, return hit = True and props is a dictionary of properties you want returned with the contains test.

picker : callable

set_dash_capstyle(s)

Set the cap style for dashed linestyles.

s : {‘butt’, ‘round’, ‘projecting’}

set_dash_joinstyle(s)

Set the join style for dashed linestyles.

s : {‘miter’, ‘round’, ‘bevel’}

set_dashes(seq)

Set the dash sequence, sequence of dashes with on off ink in points. If seq is empty or if seq = (None, None), the linestyle will be set to solid.

seq : sequence of floats (on/off ink in points) or (None, None)

set_data(*args)

Set the x and y data

ACCEPTS: 2D array (rows are x, y) or two 1D arrays

set_drawstyle(drawstyle)

Set the drawstyle of the plot

‘default’ connects the points with lines. The steps variants produce step-plots. ‘steps’ is equivalent to ‘steps-pre’ and is maintained for backward-compatibility.

drawstyle : {‘default’, ‘steps’, ‘steps-pre’, ‘steps-mid’, ‘steps-post’}

set_figure(fig)

Set the .Figure instance the artist belongs to.

fig : .Figure

set_fillstyle(fs)

Set the marker fill style; ‘full’ means fill the whole marker. ‘none’ means no filling; other options are for half-filled markers.

fs : {‘full’, ‘left’, ‘right’, ‘bottom’, ‘top’, ‘none’}

set_gid(gid)

Sets the (group) id for the artist.

gid : str

set_in_layout(in_layout)

Set if artist is to be included in layout calculations, E.g. /tutorials/intermediate/constrainedlayout_guide, .Figure.tight_layout(), and fig.savefig(fname, bbox_inches='tight').

in_layout : bool

set_label(s)

Set the label to s for auto legend.

sobject

s will be converted to a string by calling str.

set_linestyle(ls)

Set the linestyle of the line (also accepts drawstyles, e.g., 'steps--')

linestyle

description

'-' or 'solid'

solid line

'--' or 'dashed'

dashed line

'-.' or 'dashdot'

dash-dotted line

':' or 'dotted'

dotted line

'None'

draw nothing

' '

draw nothing

''

draw nothing

‘steps’ is equivalent to ‘steps-pre’ and is maintained for backward-compatibility.

Alternatively a dash tuple of the following form can be provided:

(offset, onoffseq),

where onoffseq is an even length tuple of on and off ink in points.

See also

set_drawstyle()

To set the drawing style (stepping) of the plot.

ls{‘-‘, ‘–’, ‘-.’, ‘:’, ‘’, (offset, on-off-seq), …}

The line style.

set_linewidth(w)

Set the line width in points

w : float

set_ls(*args, **kwargs)

alias for set_linestyle

set_lw(*args, **kwargs)

alias for set_linewidth

set_marker(marker)

Set the line marker.

marker: marker style

See ~matplotlib.markers for full description of possible arguments.

set_markeredgecolor(ec)

Set the marker edge color.

ec : color

set_markeredgewidth(ew)

Set the marker edge width in points.

ew : float

set_markerfacecolor(fc)

Set the marker face color.

fc : color

set_markerfacecoloralt(fc)

Set the alternate marker face color.

fc : color

set_markersize(sz)

Set the marker size in points.

sz : float

set_markevery(every)

Set the markevery property to subsample the plot when using markers.

e.g., if every=5, every 5-th marker will be plotted.

every: None or int or (int, int) or slice or List[int] or float or (float, float)

Which markers to plot.

  • every=None, every point will be plotted.

  • every=N, every N-th marker will be plotted starting with marker 0.

  • every=(start, N), every N-th marker, starting at point start, will be plotted.

  • every=slice(start, end, N), every N-th marker, starting at point start, up to but not including point end, will be plotted.

  • every=[i, j, m, n], only markers at points i, j, m, and n will be plotted.

  • every=0.1, (i.e. a float) then markers will be spaced at approximately equal distances along the line; the distance along the line between markers is determined by multiplying the display-coordinate distance of the axes bounding-box diagonal by the value of every.

  • every=(0.5, 0.1) (i.e. a length-2 tuple of float), the same functionality as every=0.1 is exhibited but the first marker will be 0.5 multiplied by the display-cordinate-diagonal-distance along the line.

Setting the markevery property will only show markers at actual data points. When using float arguments to set the markevery property on irregularly spaced data, the markers will likely not appear evenly spaced because the actual data points do not coincide with the theoretical spacing between markers.

When using a start offset to specify the first marker, the offset will be from the first data point which may be different from the first the visible data point if the plot is zoomed in.

If zooming in on a plot when using float arguments then the actual data points that have markers will change because the distance between markers is always determined from the display-coordinates axes-bounding-box-diagonal regardless of the actual axes data limits.

set_mec(*args, **kwargs)

alias for set_markeredgecolor

set_mew(*args, **kwargs)

alias for set_markeredgewidth

set_mfc(*args, **kwargs)

alias for set_markerfacecolor

set_mfcalt(*args, **kwargs)

alias for set_markerfacecoloralt

set_ms(*args, **kwargs)

alias for set_markersize

set_path_effects(path_effects)

Set the path effects.

path_effects : .AbstractPathEffect

set_picker(p)

Sets the event picker details for the line.

pfloat or callable[[Artist, Event], Tuple[bool, dict]]

If a float, it is used as the pick radius in points.

set_pickradius(d)

Set the pick radius used for containment tests.

dfloat

Pick radius, in points.

set_rasterized(rasterized)

Force rasterized (bitmap) drawing in vector backend output.

Defaults to None, which implies the backend’s default behavior.

rasterized : bool or None

set_sketch_params(scale=None, length=None, randomness=None)

Sets the sketch parameters.

scalefloat, optional

The amplitude of the wiggle perpendicular to the source line, in pixels. If scale is None, or not provided, no sketch filter will be provided.

lengthfloat, optional

The length of the wiggle along the line, in pixels (default 128.0)

randomnessfloat, optional

The scale factor by which the length is shrunken or expanded (default 16.0)

set_snap(snap)

Sets the snap setting which may be:

  • True: snap vertices to the nearest pixel center

  • False: leave vertices as-is

  • None: (auto) If the path contains only rectilinear line segments, round to the nearest pixel center

Only supported by the Agg and MacOSX backends.

snap : bool or None

set_solid_capstyle(s)

Set the cap style for solid linestyles.

s : {‘butt’, ‘round’, ‘projecting’}

set_solid_joinstyle(s)

Set the join style for solid linestyles.

s : {‘miter’, ‘round’, ‘bevel’}

set_transform(t)

set the Transformation instance used by this artist

t : matplotlib.transforms.Transform

set_url(url)

Sets the url for the artist.

url : str

set_visible(b)

Set the artist’s visibility.

b : bool

set_xdata(x)

Set the data array for x.

x : 1D array

set_ydata(y)

Set the data array for y.

y : 1D array

set_zorder(level)

Set the zorder for the artist. Artists with lower zorder values are drawn first.

level : float

property stale

If the artist is ‘stale’ and needs to be re-drawn for the output to match the internal state of the artist.

property sticky_edges

x and y sticky edge lists for autoscaling.

When performing autoscaling, if a data limit coincides with a value in the corresponding sticky_edges list, then no margin will be added–the view limit “sticks” to the edge. A typical usecase is histograms, where one usually expects no margin on the bottom edge (0) of the histogram.

This attribute cannot be assigned to; however, the x and y lists can be modified in place as needed.

>>> artist.sticky_edges.x[:] = (xmin, xmax)
>>> artist.sticky_edges.y[:] = (ymin, ymax)
update(props)

Update this artist’s properties from the dictionary prop.

update_from(other)

copy properties from other to self

class holoviews.plotting.mpl.annotation.AnnotationPlot(annotation, **params)[source]

Bases: holoviews.plotting.mpl.element.ElementPlot

AnnotationPlot handles the display of all annotation elements.

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=True)

Whether to display the plot title.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.ClassSelector(class_=(<class ‘str’>, <class ‘tuple’>))

If set bgcolor overrides the background color of the axis.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=0.1)

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=False)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Whether to show a Cartesian grid on the plot.

xaxis = param.ObjectSelector(default=’bottom’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None, True, False])

Whether and where to display the xaxis. The “bare” options allow suppressing all axis labels, including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’left’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None, True, False])

Whether and where to display the yaxis. The “bare” options allow suppressing all axis labels, including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’, ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’square’)

The aspect ratio mode of the plot. By default, a plot may select its own appropriate aspect ratio but sometimes it may be necessary to force a square aspect ratio (e.g. to display the plot as an element of a grid). The modes ‘auto’ and ‘equal’ correspond to the axis modes of the same name in matplotlib, a numeric value specifying the ratio between plot width and height may also be passed. To control the aspect ratio between the axis scales use the data_aspect option instead.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.AnnotationPlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

  • ‘data’: Just the data ranges

  • ‘extents’: Element.extents

  • ‘soft’: Dimension.soft_range values

  • ‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

  • ‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.AnnotationPlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.AnnotationPlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.AnnotationPlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.AnnotationPlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.AnnotationPlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.AnnotationPlot'>)
set_root(root)

Sets the root model on all subplots.

property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, annotation, ranges, style)[source]

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.plotting.mpl.annotation.ArrowPlot(annotation, **params)[source]

Bases: holoviews.plotting.mpl.annotation.AnnotationPlot

Draw an arrow using the information supplied to the Arrow annotation

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=True)

Whether to display the plot title.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.ClassSelector(class_=(<class ‘str’>, <class ‘tuple’>))

If set bgcolor overrides the background color of the axis.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=0.1)

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=False)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Whether to show a Cartesian grid on the plot.

xaxis = param.ObjectSelector(default=’bottom’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None, True, False])

Whether and where to display the xaxis. The “bare” options allow suppressing all axis labels, including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’left’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None, True, False])

Whether and where to display the yaxis. The “bare” options allow suppressing all axis labels, including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’, ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’square’)

The aspect ratio mode of the plot. By default, a plot may select its own appropriate aspect ratio but sometimes it may be necessary to force a square aspect ratio (e.g. to display the plot as an element of a grid). The modes ‘auto’ and ‘equal’ correspond to the axis modes of the same name in matplotlib, a numeric value specifying the ratio between plot width and height may also be passed. To control the aspect ratio between the axis scales use the data_aspect option instead.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.ArrowPlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

  • ‘data’: Just the data ranges

  • ‘extents’: Element.extents

  • ‘soft’: Dimension.soft_range values

  • ‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

  • ‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.ArrowPlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.ArrowPlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.ArrowPlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.ArrowPlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.ArrowPlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.ArrowPlot'>)
set_root(root)

Sets the root model on all subplots.

property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, annotation, ranges, style)

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.plotting.mpl.annotation.HLinePlot(annotation, **params)[source]

Bases: holoviews.plotting.mpl.annotation.AnnotationPlot

Draw a horizontal line on the axis

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=True)

Whether to display the plot title.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.ClassSelector(class_=(<class ‘str’>, <class ‘tuple’>))

If set bgcolor overrides the background color of the axis.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=0.1)

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=False)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Whether to show a Cartesian grid on the plot.

xaxis = param.ObjectSelector(default=’bottom’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None, True, False])

Whether and where to display the xaxis. The “bare” options allow suppressing all axis labels, including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’left’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None, True, False])

Whether and where to display the yaxis. The “bare” options allow suppressing all axis labels, including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’, ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’square’)

The aspect ratio mode of the plot. By default, a plot may select its own appropriate aspect ratio but sometimes it may be necessary to force a square aspect ratio (e.g. to display the plot as an element of a grid). The modes ‘auto’ and ‘equal’ correspond to the axis modes of the same name in matplotlib, a numeric value specifying the ratio between plot width and height may also be passed. To control the aspect ratio between the axis scales use the data_aspect option instead.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

draw_annotation(axis, position, opts)[source]

Draw a horizontal line on the axis

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.HLinePlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

  • ‘data’: Just the data ranges

  • ‘extents’: Element.extents

  • ‘soft’: Dimension.soft_range values

  • ‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

  • ‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.HLinePlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.HLinePlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.HLinePlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.HLinePlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.HLinePlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.HLinePlot'>)
set_root(root)

Sets the root model on all subplots.

property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, annotation, ranges, style)

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.plotting.mpl.annotation.HSpanPlot(annotation, **params)[source]

Bases: holoviews.plotting.mpl.annotation.AnnotationPlot

Draw a horizontal span on the axis

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=True)

Whether to display the plot title.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.ClassSelector(class_=(<class ‘str’>, <class ‘tuple’>))

If set bgcolor overrides the background color of the axis.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=0.1)

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=False)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Whether to show a Cartesian grid on the plot.

xaxis = param.ObjectSelector(default=’bottom’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None, True, False])

Whether and where to display the xaxis. The “bare” options allow suppressing all axis labels, including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’left’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None, True, False])

Whether and where to display the yaxis. The “bare” options allow suppressing all axis labels, including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’, ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’square’)

The aspect ratio mode of the plot. By default, a plot may select its own appropriate aspect ratio but sometimes it may be necessary to force a square aspect ratio (e.g. to display the plot as an element of a grid). The modes ‘auto’ and ‘equal’ correspond to the axis modes of the same name in matplotlib, a numeric value specifying the ratio between plot width and height may also be passed. To control the aspect ratio between the axis scales use the data_aspect option instead.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

draw_annotation(axis, positions, opts)[source]

Draw a horizontal span on the axis

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.HSpanPlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

  • ‘data’: Just the data ranges

  • ‘extents’: Element.extents

  • ‘soft’: Dimension.soft_range values

  • ‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

  • ‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.HSpanPlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.HSpanPlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.HSpanPlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.HSpanPlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.HSpanPlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.HSpanPlot'>)
set_root(root)

Sets the root model on all subplots.

property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, annotation, ranges, style)

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.plotting.mpl.annotation.LabelsPlot(*args, **kwargs)[source]

Bases: holoviews.plotting.mpl.element.ColorbarPlot

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=True)

Whether to display the plot title.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.ClassSelector(class_=(<class ‘str’>, <class ‘tuple’>))

If set bgcolor overrides the background color of the axis.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=0.1)

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=True)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Whether to show a Cartesian grid on the plot.

xaxis = param.ObjectSelector(default=’bottom’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None, True, False])

Whether and where to display the xaxis. The “bare” options allow suppressing all axis labels, including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’left’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None, True, False])

Whether and where to display the yaxis. The “bare” options allow suppressing all axis labels, including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’, ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’square’)

The aspect ratio mode of the plot. By default, a plot may select its own appropriate aspect ratio but sometimes it may be necessary to force a square aspect ratio (e.g. to display the plot as an element of a grid). The modes ‘auto’ and ‘equal’ correspond to the axis modes of the same name in matplotlib, a numeric value specifying the ratio between plot width and height may also be passed. To control the aspect ratio between the axis scales use the data_aspect option instead.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

clabel = param.String()

An explicit override of the color bar label, if set takes precedence over the title key in colorbar_opts.

clim = param.NumericTuple(default=(nan, nan), length=2)

User-specified colorbar axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

cformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the colorbar axis.

colorbar = param.Boolean(bounds=(0, 1), default=False)

Whether to draw a colorbar.

colorbar_opts = param.Dict(class_=<class ‘dict’>, default={})

Allows setting specific styling options for the colorbar.

color_levels = param.ClassSelector(class_=(<class ‘int’>, <class ‘list’>))

Number of discrete colors to use when colormapping or a set of color intervals defining the range of values to map each color to.

clipping_colors = param.Dict(class_=<class ‘dict’>, default={})

Dictionary to specify colors for clipped values, allows setting color for NaN values and for values above and below the min and max value. The min, max or NaN color may specify an RGB(A) color as a color hex string of the form #FFFFFF or #FFFFFFFF or a length 3 or length 4 tuple specifying values in the range 0-1 or a named HTML color.

cbar_padding = param.Number(default=0.01, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Padding between colorbar and other plots.

cbar_ticks = param.Parameter()

Ticks along colorbar-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

cbar_width = param.Number(default=0.05, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Width of the colorbar as a fraction of the main plot

cbar_extend = param.ObjectSelector(objects=[‘neither’, ‘both’, ‘min’, ‘max’])

If not ‘neither’, make pointed end(s) for out-of- range values.

symmetric = param.Boolean(bounds=(0, 1), default=False)

Whether to make the colormap symmetric around zero.

color_index = param.ClassSelector(class_=(<class ‘str’>, <class ‘int’>))

Index of the dimension from which the color will the drawn

xoffset = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Amount of offset to apply to labels along x-axis.

yoffset = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Amount of offset to apply to labels along x-axis.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.LabelsPlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

  • ‘data’: Just the data ranges

  • ‘extents’: Element.extents

  • ‘soft’: Dimension.soft_range values

  • ‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

  • ‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.LabelsPlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.LabelsPlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)[source]

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.LabelsPlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.LabelsPlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.LabelsPlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.LabelsPlot'>)
set_root(root)

Sets the root model on all subplots.

property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()[source]

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, element, ranges, style)

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.plotting.mpl.annotation.SlopePlot(annotation, **params)[source]

Bases: holoviews.plotting.mpl.annotation.AnnotationPlot

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=True)

Whether to display the plot title.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.ClassSelector(class_=(<class ‘str’>, <class ‘tuple’>))

If set bgcolor overrides the background color of the axis.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=0.1)

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=False)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Whether to show a Cartesian grid on the plot.

xaxis = param.ObjectSelector(default=’bottom’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None, True, False])

Whether and where to display the xaxis. The “bare” options allow suppressing all axis labels, including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’left’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None, True, False])

Whether and where to display the yaxis. The “bare” options allow suppressing all axis labels, including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’, ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’square’)

The aspect ratio mode of the plot. By default, a plot may select its own appropriate aspect ratio but sometimes it may be necessary to force a square aspect ratio (e.g. to display the plot as an element of a grid). The modes ‘auto’ and ‘equal’ correspond to the axis modes of the same name in matplotlib, a numeric value specifying the ratio between plot width and height may also be passed. To control the aspect ratio between the axis scales use the data_aspect option instead.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

draw_annotation(axis, position, opts)[source]

Draw a horizontal line on the axis

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.SlopePlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

  • ‘data’: Just the data ranges

  • ‘extents’: Element.extents

  • ‘soft’: Dimension.soft_range values

  • ‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

  • ‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.SlopePlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.SlopePlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.SlopePlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.SlopePlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.SlopePlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.SlopePlot'>)
set_root(root)

Sets the root model on all subplots.

property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, annotation, ranges, style)

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.plotting.mpl.annotation.SplinePlot(annotation, **params)[source]

Bases: holoviews.plotting.mpl.annotation.AnnotationPlot

Draw the supplied Spline annotation (see Spline docstring)

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=True)

Whether to display the plot title.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.ClassSelector(class_=(<class ‘str’>, <class ‘tuple’>))

If set bgcolor overrides the background color of the axis.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=0.1)

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=False)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Whether to show a Cartesian grid on the plot.

xaxis = param.ObjectSelector(default=’bottom’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None, True, False])

Whether and where to display the xaxis. The “bare” options allow suppressing all axis labels, including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’left’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None, True, False])

Whether and where to display the yaxis. The “bare” options allow suppressing all axis labels, including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’, ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’square’)

The aspect ratio mode of the plot. By default, a plot may select its own appropriate aspect ratio but sometimes it may be necessary to force a square aspect ratio (e.g. to display the plot as an element of a grid). The modes ‘auto’ and ‘equal’ correspond to the axis modes of the same name in matplotlib, a numeric value specifying the ratio between plot width and height may also be passed. To control the aspect ratio between the axis scales use the data_aspect option instead.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.SplinePlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

  • ‘data’: Just the data ranges

  • ‘extents’: Element.extents

  • ‘soft’: Dimension.soft_range values

  • ‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

  • ‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.SplinePlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.SplinePlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.SplinePlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.SplinePlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.SplinePlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.SplinePlot'>)
set_root(root)

Sets the root model on all subplots.

property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, annotation, ranges, style)

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.plotting.mpl.annotation.TextPlot(annotation, **params)[source]

Bases: holoviews.plotting.mpl.annotation.AnnotationPlot

Draw the Text annotation object

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=True)

Whether to display the plot title.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.ClassSelector(class_=(<class ‘str’>, <class ‘tuple’>))

If set bgcolor overrides the background color of the axis.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=0.1)

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=False)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Whether to show a Cartesian grid on the plot.

xaxis = param.ObjectSelector(default=’bottom’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None, True, False])

Whether and where to display the xaxis. The “bare” options allow suppressing all axis labels, including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’left’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None, True, False])

Whether and where to display the yaxis. The “bare” options allow suppressing all axis labels, including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’, ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’square’)

The aspect ratio mode of the plot. By default, a plot may select its own appropriate aspect ratio but sometimes it may be necessary to force a square aspect ratio (e.g. to display the plot as an element of a grid). The modes ‘auto’ and ‘equal’ correspond to the axis modes of the same name in matplotlib, a numeric value specifying the ratio between plot width and height may also be passed. To control the aspect ratio between the axis scales use the data_aspect option instead.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.TextPlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

  • ‘data’: Just the data ranges

  • ‘extents’: Element.extents

  • ‘soft’: Dimension.soft_range values

  • ‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

  • ‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.TextPlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.TextPlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.TextPlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.TextPlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.TextPlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.TextPlot'>)
set_root(root)

Sets the root model on all subplots.

property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, annotation, ranges, style)

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.plotting.mpl.annotation.VLinePlot(annotation, **params)[source]

Bases: holoviews.plotting.mpl.annotation.AnnotationPlot

Draw a vertical line on the axis

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=True)

Whether to display the plot title.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.ClassSelector(class_=(<class ‘str’>, <class ‘tuple’>))

If set bgcolor overrides the background color of the axis.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=0.1)

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=False)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Whether to show a Cartesian grid on the plot.

xaxis = param.ObjectSelector(default=’bottom’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None, True, False])

Whether and where to display the xaxis. The “bare” options allow suppressing all axis labels, including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’left’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None, True, False])

Whether and where to display the yaxis. The “bare” options allow suppressing all axis labels, including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’, ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’square’)

The aspect ratio mode of the plot. By default, a plot may select its own appropriate aspect ratio but sometimes it may be necessary to force a square aspect ratio (e.g. to display the plot as an element of a grid). The modes ‘auto’ and ‘equal’ correspond to the axis modes of the same name in matplotlib, a numeric value specifying the ratio between plot width and height may also be passed. To control the aspect ratio between the axis scales use the data_aspect option instead.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.VLinePlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

  • ‘data’: Just the data ranges

  • ‘extents’: Element.extents

  • ‘soft’: Dimension.soft_range values

  • ‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

  • ‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.VLinePlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.VLinePlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.VLinePlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.VLinePlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.VLinePlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.VLinePlot'>)
set_root(root)

Sets the root model on all subplots.

property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, annotation, ranges, style)

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.plotting.mpl.annotation.VSpanPlot(annotation, **params)[source]

Bases: holoviews.plotting.mpl.annotation.AnnotationPlot

Draw a vertical span on the axis

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=True)

Whether to display the plot title.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.ClassSelector(class_=(<class ‘str’>, <class ‘tuple’>))

If set bgcolor overrides the background color of the axis.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=0.1)

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=False)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Whether to show a Cartesian grid on the plot.

xaxis = param.ObjectSelector(default=’bottom’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None, True, False])

Whether and where to display the xaxis. The “bare” options allow suppressing all axis labels, including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’left’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None, True, False])

Whether and where to display the yaxis. The “bare” options allow suppressing all axis labels, including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’, ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’square’)

The aspect ratio mode of the plot. By default, a plot may select its own appropriate aspect ratio but sometimes it may be necessary to force a square aspect ratio (e.g. to display the plot as an element of a grid). The modes ‘auto’ and ‘equal’ correspond to the axis modes of the same name in matplotlib, a numeric value specifying the ratio between plot width and height may also be passed. To control the aspect ratio between the axis scales use the data_aspect option instead.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

draw_annotation(axis, positions, opts)[source]

Draw a vertical span on the axis

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.VSpanPlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

  • ‘data’: Just the data ranges

  • ‘extents’: Element.extents

  • ‘soft’: Dimension.soft_range values

  • ‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

  • ‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.VSpanPlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.VSpanPlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.VSpanPlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.VSpanPlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.VSpanPlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.annotation.VSpanPlot'>)
set_root(root)

Sets the root model on all subplots.

property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, annotation, ranges, style)

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring


chart Module

digraph inheritanceb5bf85e7cd { fontsize=18; rankdir=LR; size="12.0, 12.0"; "holoviews.plotting.mixins.AreaMixin" [fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)"]; "holoviews.plotting.mixins.BarsMixin" [fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)"]; "holoviews.plotting.mixins.SpikesMixin" [fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart.AreaPlot" [URL="#holoviews.plotting.mpl.chart.AreaPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top"]; "holoviews.plotting.mixins.AreaMixin" -> "holoviews.plotting.mpl.chart.AreaPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart.ChartPlot" -> "holoviews.plotting.mpl.chart.AreaPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart.BarPlot" [URL="#holoviews.plotting.mpl.chart.BarPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top"]; "holoviews.plotting.mixins.BarsMixin" -> "holoviews.plotting.mpl.chart.BarPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.element.ColorbarPlot" -> "holoviews.plotting.mpl.chart.BarPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.element.LegendPlot" -> "holoviews.plotting.mpl.chart.BarPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart.ChartPlot" [URL="#holoviews.plotting.mpl.chart.ChartPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Baseclass to plot Chart elements."]; "holoviews.plotting.mpl.element.ElementPlot" -> "holoviews.plotting.mpl.chart.ChartPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart.CurvePlot" [URL="#holoviews.plotting.mpl.chart.CurvePlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="CurvePlot can plot Curve and ViewMaps of Curve, which can be"]; "holoviews.plotting.mpl.chart.ChartPlot" -> "holoviews.plotting.mpl.chart.CurvePlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart.ErrorPlot" [URL="#holoviews.plotting.mpl.chart.ErrorPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="ErrorPlot plots the ErrorBar Element type and supporting"]; "holoviews.plotting.mpl.element.ColorbarPlot" -> "holoviews.plotting.mpl.chart.ErrorPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart.HistogramPlot" [URL="#holoviews.plotting.mpl.chart.HistogramPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="HistogramPlot can plot DataHistograms and ViewMaps of"]; "holoviews.plotting.mpl.element.ColorbarPlot" -> "holoviews.plotting.mpl.chart.HistogramPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart.PointPlot" [URL="#holoviews.plotting.mpl.chart.PointPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Note that the 'cmap', 'vmin' and 'vmax' style arguments control"]; "holoviews.plotting.mpl.chart.ChartPlot" -> "holoviews.plotting.mpl.chart.PointPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.element.ColorbarPlot" -> "holoviews.plotting.mpl.chart.PointPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart.SideAreaPlot" [URL="#holoviews.plotting.mpl.chart.SideAreaPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top"]; "holoviews.plotting.mpl.plot.AdjoinedPlot" -> "holoviews.plotting.mpl.chart.SideAreaPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart.AreaPlot" -> "holoviews.plotting.mpl.chart.SideAreaPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart.SideHistogramPlot" [URL="#holoviews.plotting.mpl.chart.SideHistogramPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top"]; "holoviews.plotting.mpl.plot.AdjoinedPlot" -> "holoviews.plotting.mpl.chart.SideHistogramPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart.HistogramPlot" -> "holoviews.plotting.mpl.chart.SideHistogramPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart.SideSpikesPlot" [URL="#holoviews.plotting.mpl.chart.SideSpikesPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top"]; "holoviews.plotting.mpl.plot.AdjoinedPlot" -> "holoviews.plotting.mpl.chart.SideSpikesPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart.SpikesPlot" -> "holoviews.plotting.mpl.chart.SideSpikesPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart.SpikesPlot" [URL="#holoviews.plotting.mpl.chart.SpikesPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top"]; "holoviews.plotting.mixins.SpikesMixin" -> "holoviews.plotting.mpl.chart.SpikesPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.path.PathPlot" -> "holoviews.plotting.mpl.chart.SpikesPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.element.ColorbarPlot" -> "holoviews.plotting.mpl.chart.SpikesPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart.SpreadPlot" [URL="#holoviews.plotting.mpl.chart.SpreadPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="SpreadPlot plots the Spread Element type."]; "holoviews.plotting.mpl.chart.AreaPlot" -> "holoviews.plotting.mpl.chart.SpreadPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart.VectorFieldPlot" [URL="#holoviews.plotting.mpl.chart.VectorFieldPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Renders vector fields in sheet coordinates. The vectors are"]; "holoviews.plotting.mpl.element.ColorbarPlot" -> "holoviews.plotting.mpl.chart.VectorFieldPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.element.ColorbarPlot" [URL="#holoviews.plotting.mpl.element.ColorbarPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top"]; "holoviews.plotting.mpl.element.ElementPlot" -> "holoviews.plotting.mpl.element.ColorbarPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.element.ElementPlot" [URL="#holoviews.plotting.mpl.element.ElementPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top"]; "holoviews.plotting.plot.GenericElementPlot" -> "holoviews.plotting.mpl.element.ElementPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.plot.MPLPlot" -> "holoviews.plotting.mpl.element.ElementPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.element.LegendPlot" [URL="#holoviews.plotting.mpl.element.LegendPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top"]; "holoviews.plotting.mpl.element.ElementPlot" -> "holoviews.plotting.mpl.element.LegendPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.path.PathPlot" [URL="#holoviews.plotting.mpl.path.PathPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top"]; "holoviews.plotting.mpl.element.ColorbarPlot" -> "holoviews.plotting.mpl.path.PathPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.plot.AdjoinedPlot" [URL="#holoviews.plotting.mpl.plot.AdjoinedPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top"]; "holoviews.plotting.plot.DimensionedPlot" -> "holoviews.plotting.mpl.plot.AdjoinedPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.plot.MPLPlot" [URL="#holoviews.plotting.mpl.plot.MPLPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="An MPLPlot object draws a matplotlib figure object when called or"]; "holoviews.plotting.plot.DimensionedPlot" -> "holoviews.plotting.mpl.plot.MPLPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.plot.DimensionedPlot" [URL="holoviews.plotting.html#holoviews.plotting.plot.DimensionedPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="DimensionedPlot implements a number of useful methods"]; "holoviews.plotting.plot.Plot" -> "holoviews.plotting.plot.DimensionedPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.plot.GenericElementPlot" [URL="holoviews.plotting.html#holoviews.plotting.plot.GenericElementPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Plotting baseclass to render contents of an Element. Implements"]; "holoviews.plotting.plot.DimensionedPlot" -> "holoviews.plotting.plot.GenericElementPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.plot.Plot" [URL="holoviews.plotting.html#holoviews.plotting.plot.Plot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Base class of all Plot classes in HoloViews, designed to be"]; "param.parameterized.Parameterized" -> "holoviews.plotting.plot.Plot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "param.parameterized.Parameterized" [fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",tooltip="params(name=String)"]; }
class holoviews.plotting.mpl.chart.AreaPlot(element, **params)[source]

Bases: holoviews.plotting.mixins.AreaMixin, holoviews.plotting.mpl.chart.ChartPlot

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=True)

Whether to display the plot title.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.ClassSelector(class_=(<class ‘str’>, <class ‘tuple’>))

If set bgcolor overrides the background color of the axis.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=(0, 0.1))

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=False)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Whether to show a Cartesian grid on the plot.

xaxis = param.ObjectSelector(default=’bottom’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None, True, False])

Whether and where to display the xaxis. The “bare” options allow suppressing all axis labels, including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’left’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None, True, False])

Whether and where to display the yaxis. The “bare” options allow suppressing all axis labels, including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’, ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’square’)

The aspect ratio mode of the plot. By default, a plot may select its own appropriate aspect ratio but sometimes it may be necessary to force a square aspect ratio (e.g. to display the plot as an element of a grid). The modes ‘auto’ and ‘equal’ correspond to the axis modes of the same name in matplotlib, a numeric value specifying the ratio between plot width and height may also be passed. To control the aspect ratio between the axis scales use the data_aspect option instead.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.AreaPlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.AreaPlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.AreaPlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_data, plot_kwargs)[source]

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.AreaPlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.AreaPlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.AreaPlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.AreaPlot'>)
set_root(root)

Sets the root model on all subplots.

property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, element, ranges, style)

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.plotting.mpl.chart.BarPlot(*args, **kwargs)[source]

Bases: holoviews.plotting.mixins.BarsMixin, holoviews.plotting.mpl.element.ColorbarPlot, holoviews.plotting.mpl.element.LegendPlot

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=True)

Whether to display the plot title.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.ClassSelector(class_=(<class ‘str’>, <class ‘tuple’>))

If set bgcolor overrides the background color of the axis.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=0.1)

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=True)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Whether to show a Cartesian grid on the plot.

xaxis = param.ObjectSelector(default=’bottom’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None, True, False])

Whether and where to display the xaxis. The “bare” options allow suppressing all axis labels, including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’left’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None, True, False])

Whether and where to display the yaxis. The “bare” options allow suppressing all axis labels, including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’, ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’square’)

The aspect ratio mode of the plot. By default, a plot may select its own appropriate aspect ratio but sometimes it may be necessary to force a square aspect ratio (e.g. to display the plot as an element of a grid). The modes ‘auto’ and ‘equal’ correspond to the axis modes of the same name in matplotlib, a numeric value specifying the ratio between plot width and height may also be passed. To control the aspect ratio between the axis scales use the data_aspect option instead.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

legend_cols = param.Integer(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Number of legend columns in the legend.

legend_position = param.ObjectSelector(default=’inner’, objects=[‘inner’, ‘right’, ‘bottom’, ‘top’, ‘left’, ‘best’, ‘top_right’, ‘top_left’, ‘bottom_left’, ‘bottom_right’])

Allows selecting between a number of predefined legend position options. The predefined options may be customized in the legend_specs class attribute. By default, ‘inner’, ‘right’, ‘bottom’, ‘top’, ‘left’, ‘best’, ‘top_right’, ‘top_left’, ‘bottom_right’ and ‘bottom_left’ are supported.

clabel = param.String()

An explicit override of the color bar label, if set takes precedence over the title key in colorbar_opts.

clim = param.NumericTuple(default=(nan, nan), length=2)

User-specified colorbar axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

cformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the colorbar axis.

colorbar = param.Boolean(bounds=(0, 1), default=False)

Whether to draw a colorbar.

colorbar_opts = param.Dict(class_=<class ‘dict’>, default={})

Allows setting specific styling options for the colorbar.

color_levels = param.ClassSelector(class_=(<class ‘int’>, <class ‘list’>))

Number of discrete colors to use when colormapping or a set of color intervals defining the range of values to map each color to.

clipping_colors = param.Dict(class_=<class ‘dict’>, default={})

Dictionary to specify colors for clipped values, allows setting color for NaN values and for values above and below the min and max value. The min, max or NaN color may specify an RGB(A) color as a color hex string of the form #FFFFFF or #FFFFFFFF or a length 3 or length 4 tuple specifying values in the range 0-1 or a named HTML color.

cbar_padding = param.Number(default=0.01, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Padding between colorbar and other plots.

cbar_ticks = param.Parameter()

Ticks along colorbar-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

cbar_width = param.Number(default=0.05, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Width of the colorbar as a fraction of the main plot

cbar_extend = param.ObjectSelector(objects=[‘neither’, ‘both’, ‘min’, ‘max’])

If not ‘neither’, make pointed end(s) for out-of- range values.

symmetric = param.Boolean(bounds=(0, 1), default=False)

Whether to make the colormap symmetric around zero.

bar_padding = param.Number(default=0.2, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the padding between groups.

multi_level = param.Boolean(bounds=(0, 1), default=True)

Whether the Bars should be grouped into a second categorical axis level.

stacked = param.Boolean(bounds=(0, 1), default=False)

Whether the bars should be stacked or grouped.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.BarPlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined')

Make adjustments to plot extents by computing stacked bar heights, adjusting the bar baseline and forcing the x-axis to be categorical.

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.BarPlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.BarPlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.BarPlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.BarPlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.BarPlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.BarPlot'>)
set_root(root)

Sets the root model on all subplots.

property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, element, ranges, style)

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.plotting.mpl.chart.ChartPlot(element, **params)[source]

Bases: holoviews.plotting.mpl.element.ElementPlot

Baseclass to plot Chart elements.

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=True)

Whether to display the plot title.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.ClassSelector(class_=(<class ‘str’>, <class ‘tuple’>))

If set bgcolor overrides the background color of the axis.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=0.1)

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=True)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Whether to show a Cartesian grid on the plot.

xaxis = param.ObjectSelector(default=’bottom’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None, True, False])

Whether and where to display the xaxis. The “bare” options allow suppressing all axis labels, including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’left’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None, True, False])

Whether and where to display the yaxis. The “bare” options allow suppressing all axis labels, including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’, ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’square’)

The aspect ratio mode of the plot. By default, a plot may select its own appropriate aspect ratio but sometimes it may be necessary to force a square aspect ratio (e.g. to display the plot as an element of a grid). The modes ‘auto’ and ‘equal’ correspond to the axis modes of the same name in matplotlib, a numeric value specifying the ratio between plot width and height may also be passed. To control the aspect ratio between the axis scales use the data_aspect option instead.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.ChartPlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

  • ‘data’: Just the data ranges

  • ‘extents’: Element.extents

  • ‘soft’: Dimension.soft_range values

  • ‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

  • ‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.ChartPlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.ChartPlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.ChartPlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.ChartPlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.ChartPlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.ChartPlot'>)
set_root(root)

Sets the root model on all subplots.

property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, element, ranges, style)

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.plotting.mpl.chart.CurvePlot(element, **params)[source]

Bases: holoviews.plotting.mpl.chart.ChartPlot

CurvePlot can plot Curve and ViewMaps of Curve, which can be displayed as a single frame or animation. Axes, titles and legends are automatically generated from dim_info.

If the dimension is set to cyclic in the dim_info it will rotate the curve so that minimum y values are at the minimum x value to make the plots easier to interpret.

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=True)

Whether to display the plot title.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.ClassSelector(class_=(<class ‘str’>, <class ‘tuple’>))

If set bgcolor overrides the background color of the axis.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=(0, 0.1))

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=True)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Enable axis grid.

xaxis = param.ObjectSelector(default=’bottom’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None, True, False])

Whether and where to display the xaxis. The “bare” options allow suppressing all axis labels, including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’left’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None, True, False])

Whether and where to display the yaxis. The “bare” options allow suppressing all axis labels, including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’, ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’square’)

The aspect ratio mode of the plot. By default, a plot may select its own appropriate aspect ratio but sometimes it may be necessary to force a square aspect ratio (e.g. to display the plot as an element of a grid). The modes ‘auto’ and ‘equal’ correspond to the axis modes of the same name in matplotlib, a numeric value specifying the ratio between plot width and height may also be passed. To control the aspect ratio between the axis scales use the data_aspect option instead.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

autotick = param.Boolean(bounds=(0, 1), default=False)

Whether to let matplotlib automatically compute tick marks or to allow the user to control tick marks.

interpolation = param.ObjectSelector(default=’linear’, objects=[‘linear’, ‘steps-mid’, ‘steps-pre’, ‘steps-post’])

Defines how the samples of the Curve are interpolated, default is ‘linear’, other options include ‘steps-mid’, ‘steps-pre’ and ‘steps-post’.

relative_labels = param.Boolean(bounds=(0, 1), default=False)

If plotted quantity is cyclic and center_cyclic is enabled, will compute tick labels relative to the center.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.CurvePlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

  • ‘data’: Just the data ranges

  • ‘extents’: Element.extents

  • ‘soft’: Dimension.soft_range values

  • ‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

  • ‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.CurvePlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.CurvePlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)[source]

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.CurvePlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.CurvePlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.CurvePlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.CurvePlot'>)
set_root(root)

Sets the root model on all subplots.

property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, element, ranges, style)[source]

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.plotting.mpl.chart.ErrorPlot(*args, **kwargs)[source]

Bases: holoviews.plotting.mpl.element.ColorbarPlot

ErrorPlot plots the ErrorBar Element type and supporting both horizontal and vertical error bars via the ‘horizontal’ plot option.

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=True)

Whether to display the plot title.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.ClassSelector(class_=(<class ‘str’>, <class ‘tuple’>))

If set bgcolor overrides the background color of the axis.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=0.1)

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=True)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Whether to show a Cartesian grid on the plot.

xaxis = param.ObjectSelector(default=’bottom’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None, True, False])

Whether and where to display the xaxis. The “bare” options allow suppressing all axis labels, including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’left’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None, True, False])

Whether and where to display the yaxis. The “bare” options allow suppressing all axis labels, including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’, ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’square’)

The aspect ratio mode of the plot. By default, a plot may select its own appropriate aspect ratio but sometimes it may be necessary to force a square aspect ratio (e.g. to display the plot as an element of a grid). The modes ‘auto’ and ‘equal’ correspond to the axis modes of the same name in matplotlib, a numeric value specifying the ratio between plot width and height may also be passed. To control the aspect ratio between the axis scales use the data_aspect option instead.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

clabel = param.String()

An explicit override of the color bar label, if set takes precedence over the title key in colorbar_opts.

clim = param.NumericTuple(default=(nan, nan), length=2)

User-specified colorbar axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

cformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the colorbar axis.

colorbar = param.Boolean(bounds=(0, 1), default=False)

Whether to draw a colorbar.

colorbar_opts = param.Dict(class_=<class ‘dict’>, default={})

Allows setting specific styling options for the colorbar.

color_levels = param.ClassSelector(class_=(<class ‘int’>, <class ‘list’>))

Number of discrete colors to use when colormapping or a set of color intervals defining the range of values to map each color to.

clipping_colors = param.Dict(class_=<class ‘dict’>, default={})

Dictionary to specify colors for clipped values, allows setting color for NaN values and for values above and below the min and max value. The min, max or NaN color may specify an RGB(A) color as a color hex string of the form #FFFFFF or #FFFFFFFF or a length 3 or length 4 tuple specifying values in the range 0-1 or a named HTML color.

cbar_padding = param.Number(default=0.01, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Padding between colorbar and other plots.

cbar_ticks = param.Parameter()

Ticks along colorbar-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

cbar_width = param.Number(default=0.05, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Width of the colorbar as a fraction of the main plot

cbar_extend = param.ObjectSelector(objects=[‘neither’, ‘both’, ‘min’, ‘max’])

If not ‘neither’, make pointed end(s) for out-of- range values.

symmetric = param.Boolean(bounds=(0, 1), default=False)

Whether to make the colormap symmetric around zero.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.ErrorPlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

  • ‘data’: Just the data ranges

  • ‘extents’: Element.extents

  • ‘soft’: Dimension.soft_range values

  • ‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

  • ‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.ErrorPlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.ErrorPlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_data, plot_kwargs)[source]

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.ErrorPlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.ErrorPlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.ErrorPlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.ErrorPlot'>)
set_root(root)

Sets the root model on all subplots.

property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, element, ranges, style)[source]

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.plotting.mpl.chart.HistogramPlot(histograms, **params)[source]

Bases: holoviews.plotting.mpl.element.ColorbarPlot

HistogramPlot can plot DataHistograms and ViewMaps of DataHistograms, which can be displayed as a single frame or animation.

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=True)

Whether to display the plot title.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.ClassSelector(class_=(<class ‘str’>, <class ‘tuple’>))

If set bgcolor overrides the background color of the axis.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=0.1)

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=True)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Whether to show a Cartesian grid on the plot.

xaxis = param.ObjectSelector(default=’bottom’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None, True, False])

Whether and where to display the xaxis. The “bare” options allow suppressing all axis labels, including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’left’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None, True, False])

Whether and where to display the yaxis. The “bare” options allow suppressing all axis labels, including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’, ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’square’)

The aspect ratio mode of the plot. By default, a plot may select its own appropriate aspect ratio but sometimes it may be necessary to force a square aspect ratio (e.g. to display the plot as an element of a grid). The modes ‘auto’ and ‘equal’ correspond to the axis modes of the same name in matplotlib, a numeric value specifying the ratio between plot width and height may also be passed. To control the aspect ratio between the axis scales use the data_aspect option instead.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

clabel = param.String()

An explicit override of the color bar label, if set takes precedence over the title key in colorbar_opts.

clim = param.NumericTuple(default=(nan, nan), length=2)

User-specified colorbar axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

cformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the colorbar axis.

colorbar = param.Boolean(bounds=(0, 1), default=False)

Whether to draw a colorbar.

colorbar_opts = param.Dict(class_=<class ‘dict’>, default={})

Allows setting specific styling options for the colorbar.

color_levels = param.ClassSelector(class_=(<class ‘int’>, <class ‘list’>))

Number of discrete colors to use when colormapping or a set of color intervals defining the range of values to map each color to.

clipping_colors = param.Dict(class_=<class ‘dict’>, default={})

Dictionary to specify colors for clipped values, allows setting color for NaN values and for values above and below the min and max value. The min, max or NaN color may specify an RGB(A) color as a color hex string of the form #FFFFFF or #FFFFFFFF or a length 3 or length 4 tuple specifying values in the range 0-1 or a named HTML color.

cbar_padding = param.Number(default=0.01, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Padding between colorbar and other plots.

cbar_ticks = param.Parameter()

Ticks along colorbar-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

cbar_width = param.Number(default=0.05, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Width of the colorbar as a fraction of the main plot

cbar_extend = param.ObjectSelector(objects=[‘neither’, ‘both’, ‘min’, ‘max’])

If not ‘neither’, make pointed end(s) for out-of- range values.

symmetric = param.Boolean(bounds=(0, 1), default=False)

Whether to make the colormap symmetric around zero.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.HistogramPlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined')[source]

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

  • ‘data’: Just the data ranges

  • ‘extents’: Element.extents

  • ‘soft’: Dimension.soft_range values

  • ‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

  • ‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.HistogramPlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.HistogramPlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.HistogramPlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.HistogramPlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.HistogramPlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.HistogramPlot'>)
set_root(root)

Sets the root model on all subplots.

property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, element, ranges, style)[source]

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.plotting.mpl.chart.PointPlot(*args, **kwargs)[source]

Bases: holoviews.plotting.mpl.chart.ChartPlot, holoviews.plotting.mpl.element.ColorbarPlot

Note that the ‘cmap’, ‘vmin’ and ‘vmax’ style arguments control how point magnitudes are rendered to different colors.

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=True)

Whether to display the plot title.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.ClassSelector(class_=(<class ‘str’>, <class ‘tuple’>))

If set bgcolor overrides the background color of the axis.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=0.1)

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=True)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Whether to draw grid lines at the tick positions.

xaxis = param.ObjectSelector(default=’bottom’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None, True, False])

Whether and where to display the xaxis. The “bare” options allow suppressing all axis labels, including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’left’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None, True, False])

Whether and where to display the yaxis. The “bare” options allow suppressing all axis labels, including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’, ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’square’)

The aspect ratio mode of the plot. By default, a plot may select its own appropriate aspect ratio but sometimes it may be necessary to force a square aspect ratio (e.g. to display the plot as an element of a grid). The modes ‘auto’ and ‘equal’ correspond to the axis modes of the same name in matplotlib, a numeric value specifying the ratio between plot width and height may also be passed. To control the aspect ratio between the axis scales use the data_aspect option instead.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

clabel = param.String()

An explicit override of the color bar label, if set takes precedence over the title key in colorbar_opts.

clim = param.NumericTuple(default=(nan, nan), length=2)

User-specified colorbar axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

cformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the colorbar axis.

colorbar = param.Boolean(bounds=(0, 1), default=False)

Whether to draw a colorbar.

colorbar_opts = param.Dict(class_=<class ‘dict’>, default={})

Allows setting specific styling options for the colorbar.

color_levels = param.ClassSelector(class_=(<class ‘int’>, <class ‘list’>))

Number of discrete colors to use when colormapping or a set of color intervals defining the range of values to map each color to.

clipping_colors = param.Dict(class_=<class ‘dict’>, default={})

Dictionary to specify colors for clipped values, allows setting color for NaN values and for values above and below the min and max value. The min, max or NaN color may specify an RGB(A) color as a color hex string of the form #FFFFFF or #FFFFFFFF or a length 3 or length 4 tuple specifying values in the range 0-1 or a named HTML color.

cbar_padding = param.Number(default=0.01, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Padding between colorbar and other plots.

cbar_ticks = param.Parameter()

Ticks along colorbar-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

cbar_width = param.Number(default=0.05, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Width of the colorbar as a fraction of the main plot

cbar_extend = param.ObjectSelector(objects=[‘neither’, ‘both’, ‘min’, ‘max’])

If not ‘neither’, make pointed end(s) for out-of- range values.

symmetric = param.Boolean(bounds=(0, 1), default=False)

Whether to make the colormap symmetric around zero.

color_index = param.ClassSelector(class_=(<class ‘str’>, <class ‘int’>))

Deprecated in favor of color style mapping, e.g. color=dim(‘color’)

size_index = param.ClassSelector(class_=(<class ‘str’>, <class ‘int’>))

Deprecated in favor of size style mapping, e.g. size=dim(‘size’)

scaling_method = param.ObjectSelector(default=’area’, objects=[‘width’, ‘area’])

Deprecated in favor of size style mapping, e.g. size=dim(‘size’)**2.

scaling_factor = param.Number(bounds=(0, None), default=1, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scaling factor which is applied to either the width or area of each point, depending on the value of scaling_method.

size_fn = param.Callable(default=<ufunc ‘absolute’>)

Function applied to size values before applying scaling, to remove values lower than zero.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.PointPlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

  • ‘data’: Just the data ranges

  • ‘extents’: Element.extents

  • ‘soft’: Dimension.soft_range values

  • ‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

  • ‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.PointPlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.PointPlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.PointPlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.PointPlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.PointPlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.PointPlot'>)
set_root(root)

Sets the root model on all subplots.

size_fn = <ufunc 'absolute'>
property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, element, ranges, style)[source]

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.plotting.mpl.chart.SideAreaPlot(element, **params)[source]

Bases: holoviews.plotting.mpl.plot.AdjoinedPlot, holoviews.plotting.mpl.chart.AreaPlot

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=False)

Titles should be disabled on all SidePlots to avoid clutter.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.Parameter(default=(1, 1, 1, 0))

Make plot background invisible.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=(0, 0.1))

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=False)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Whether to show a Cartesian grid on the plot.

xaxis = param.ObjectSelector(default=’bare’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None])

Whether and where to display the xaxis, bare options allow suppressing all axis labels including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’bare’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None])

Whether and where to display the yaxis, bare options allow suppressing all axis labels including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’ ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’auto’)

Aspect ratios on SideHistogramPlot should be determined by the AdjointLayoutPlot.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

border_size = param.Number(default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The size of the border expressed as a fraction of the main plot.

subplot_size = param.Number(default=0.25, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The size subplots as expressed as a fraction of the main plot.

show_xlabel = param.Boolean(bounds=(0, 1), default=False)

Whether to show the x-label of the plot. Disabled by default because plots are often too cramped to fit the title correctly.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SideAreaPlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SideAreaPlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SideAreaPlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_data, plot_kwargs)

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SideAreaPlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SideAreaPlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SideAreaPlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SideAreaPlot'>)
set_root(root)

Sets the root model on all subplots.

property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, element, ranges, style)

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.plotting.mpl.chart.SideHistogramPlot(histograms, **params)[source]

Bases: holoviews.plotting.mpl.plot.AdjoinedPlot, holoviews.plotting.mpl.chart.HistogramPlot

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=False)

Titles should be disabled on all SidePlots to avoid clutter.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.Parameter(default=(1, 1, 1, 0))

Make plot background invisible.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=0.1)

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=True)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Whether to overlay a grid on the axis.

xaxis = param.ObjectSelector(default=’bottom’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None, True, False])

Whether and where to display the xaxis. The “bare” options allow suppressing all axis labels, including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’left’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None, True, False])

Whether and where to display the yaxis. The “bare” options allow suppressing all axis labels, including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’, ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’auto’)

Aspect ratios on SideHistogramPlot should be determined by the AdjointLayoutPlot.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

clabel = param.String()

An explicit override of the color bar label, if set takes precedence over the title key in colorbar_opts.

clim = param.NumericTuple(default=(nan, nan), length=2)

User-specified colorbar axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

cformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the colorbar axis.

colorbar = param.Boolean(bounds=(0, 1), default=False)

Whether to draw a colorbar.

colorbar_opts = param.Dict(class_=<class ‘dict’>, default={})

Allows setting specific styling options for the colorbar.

color_levels = param.ClassSelector(class_=(<class ‘int’>, <class ‘list’>))

Number of discrete colors to use when colormapping or a set of color intervals defining the range of values to map each color to.

clipping_colors = param.Dict(class_=<class ‘dict’>, default={})

Dictionary to specify colors for clipped values, allows setting color for NaN values and for values above and below the min and max value. The min, max or NaN color may specify an RGB(A) color as a color hex string of the form #FFFFFF or #FFFFFFFF or a length 3 or length 4 tuple specifying values in the range 0-1 or a named HTML color.

cbar_padding = param.Number(default=0.01, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Padding between colorbar and other plots.

cbar_ticks = param.Parameter()

Ticks along colorbar-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

cbar_width = param.Number(default=0.05, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Width of the colorbar as a fraction of the main plot

cbar_extend = param.ObjectSelector(objects=[‘neither’, ‘both’, ‘min’, ‘max’])

If not ‘neither’, make pointed end(s) for out-of- range values.

symmetric = param.Boolean(bounds=(0, 1), default=False)

Whether to make the colormap symmetric around zero.

border_size = param.Number(default=0.25, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The size of the border expressed as a fraction of the main plot.

subplot_size = param.Number(default=0.25, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The size subplots as expressed as a fraction of the main plot.

show_xlabel = param.Boolean(bounds=(0, 1), default=False)

Whether to show the x-label of the plot. Disabled by default because plots are often too cramped to fit the title correctly.

offset = param.Number(bounds=(0, 1), default=0.2, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Histogram value offset for a colorbar.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SideHistogramPlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined')

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

  • ‘data’: Just the data ranges

  • ‘extents’: Element.extents

  • ‘soft’: Dimension.soft_range values

  • ‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

  • ‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SideHistogramPlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SideHistogramPlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SideHistogramPlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SideHistogramPlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SideHistogramPlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SideHistogramPlot'>)
set_root(root)

Sets the root model on all subplots.

property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, element, ranges, style)

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.plotting.mpl.chart.SideSpikesPlot(*args, **kwargs)[source]

Bases: holoviews.plotting.mpl.plot.AdjoinedPlot, holoviews.plotting.mpl.chart.SpikesPlot

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=False)

Titles should be disabled on all SidePlots to avoid clutter.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=True)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.Parameter(default=(1, 1, 1, 0))

Make plot background invisible.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=(0, 0.1))

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=False)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Whether to show a Cartesian grid on the plot.

xaxis = param.ObjectSelector(default=’bare’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None])

Whether and where to display the xaxis, bare options allow suppressing all axis labels including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’bare’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None])

Whether and where to display the yaxis, bare options allow suppressing all axis labels including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’ ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’auto’)

Aspect ratios on SideHistogramPlot should be determined by the AdjointLayoutPlot.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

clabel = param.String()

An explicit override of the color bar label, if set takes precedence over the title key in colorbar_opts.

clim = param.NumericTuple(default=(nan, nan), length=2)

User-specified colorbar axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

cformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the colorbar axis.

colorbar = param.Boolean(bounds=(0, 1), default=False)

Whether to draw a colorbar.

colorbar_opts = param.Dict(class_=<class ‘dict’>, default={})

Allows setting specific styling options for the colorbar.

color_levels = param.ClassSelector(class_=(<class ‘int’>, <class ‘list’>))

Number of discrete colors to use when colormapping or a set of color intervals defining the range of values to map each color to.

clipping_colors = param.Dict(class_=<class ‘dict’>, default={})

Dictionary to specify colors for clipped values, allows setting color for NaN values and for values above and below the min and max value. The min, max or NaN color may specify an RGB(A) color as a color hex string of the form #FFFFFF or #FFFFFFFF or a length 3 or length 4 tuple specifying values in the range 0-1 or a named HTML color.

cbar_padding = param.Number(default=0.01, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Padding between colorbar and other plots.

cbar_ticks = param.Parameter()

Ticks along colorbar-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

cbar_width = param.Number(default=0.05, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Width of the colorbar as a fraction of the main plot

cbar_extend = param.ObjectSelector(objects=[‘neither’, ‘both’, ‘min’, ‘max’])

If not ‘neither’, make pointed end(s) for out-of- range values.

symmetric = param.Boolean(bounds=(0, 1), default=False)

Whether to make the colormap symmetric around zero.

color_index = param.ClassSelector(class_=(<class ‘str’>, <class ‘int’>))

Index of the dimension from which the color will the drawn

spike_length = param.Number(default=1, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The length of each spike if Spikes object is one dimensional.

position = param.Number(default=0.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The position of the lower end of each spike.

border_size = param.Number(default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The size of the border expressed as a fraction of the main plot.

subplot_size = param.Number(default=0.1, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The size subplots as expressed as a fraction of the main plot.

show_xlabel = param.Boolean(bounds=(0, 1), default=False)

Whether to show the x-label of the plot. Disabled by default because plots are often too cramped to fit the title correctly.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SideSpikesPlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SideSpikesPlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SideSpikesPlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SideSpikesPlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SideSpikesPlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SideSpikesPlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SideSpikesPlot'>)
set_root(root)

Sets the root model on all subplots.

property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, element, ranges, style)

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.plotting.mpl.chart.SpikesPlot(*args, **kwargs)[source]

Bases: holoviews.plotting.mixins.SpikesMixin, holoviews.plotting.mpl.path.PathPlot, holoviews.plotting.mpl.element.ColorbarPlot

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=True)

Whether to display the plot title.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.ClassSelector(class_=(<class ‘str’>, <class ‘tuple’>))

If set bgcolor overrides the background color of the axis.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=(0, 0.1))

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=False)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Whether to show a Cartesian grid on the plot.

xaxis = param.ObjectSelector(default=’bottom’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None, True, False])

Whether and where to display the xaxis. The “bare” options allow suppressing all axis labels, including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’left’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None, True, False])

Whether and where to display the yaxis. The “bare” options allow suppressing all axis labels, including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’, ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’square’)

The aspect ratio mode of the plot. Allows setting an explicit aspect ratio as width/height as well as ‘square’ and ‘equal’ options.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

clabel = param.String()

An explicit override of the color bar label, if set takes precedence over the title key in colorbar_opts.

clim = param.NumericTuple(default=(nan, nan), length=2)

User-specified colorbar axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

cformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the colorbar axis.

colorbar = param.Boolean(bounds=(0, 1), default=False)

Whether to draw a colorbar.

colorbar_opts = param.Dict(class_=<class ‘dict’>, default={})

Allows setting specific styling options for the colorbar.

color_levels = param.ClassSelector(class_=(<class ‘int’>, <class ‘list’>))

Number of discrete colors to use when colormapping or a set of color intervals defining the range of values to map each color to.

clipping_colors = param.Dict(class_=<class ‘dict’>, default={})

Dictionary to specify colors for clipped values, allows setting color for NaN values and for values above and below the min and max value. The min, max or NaN color may specify an RGB(A) color as a color hex string of the form #FFFFFF or #FFFFFFFF or a length 3 or length 4 tuple specifying values in the range 0-1 or a named HTML color.

cbar_padding = param.Number(default=0.01, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Padding between colorbar and other plots.

cbar_ticks = param.Parameter()

Ticks along colorbar-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

cbar_width = param.Number(default=0.05, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Width of the colorbar as a fraction of the main plot

cbar_extend = param.ObjectSelector(objects=[‘neither’, ‘both’, ‘min’, ‘max’])

If not ‘neither’, make pointed end(s) for out-of- range values.

symmetric = param.Boolean(bounds=(0, 1), default=False)

Whether to make the colormap symmetric around zero.

color_index = param.ClassSelector(class_=(<class ‘str’>, <class ‘int’>))

Index of the dimension from which the color will the drawn

spike_length = param.Number(default=0.1, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The length of each spike if Spikes object is one dimensional.

position = param.Number(default=0.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

The position of the lower end of each spike.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SpikesPlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SpikesPlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SpikesPlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)[source]

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SpikesPlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SpikesPlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SpikesPlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SpikesPlot'>)
set_root(root)

Sets the root model on all subplots.

property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, element, ranges, style)[source]

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.plotting.mpl.chart.SpreadPlot(element, **params)[source]

Bases: holoviews.plotting.mpl.chart.AreaPlot

SpreadPlot plots the Spread Element type.

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=True)

Whether to display the plot title.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.ClassSelector(class_=(<class ‘str’>, <class ‘tuple’>))

If set bgcolor overrides the background color of the axis.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=(0, 0.1))

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=False)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Whether to show a Cartesian grid on the plot.

xaxis = param.ObjectSelector(default=’bottom’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None, True, False])

Whether and where to display the xaxis. The “bare” options allow suppressing all axis labels, including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’left’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None, True, False])

Whether and where to display the yaxis. The “bare” options allow suppressing all axis labels, including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’, ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’square’)

The aspect ratio mode of the plot. By default, a plot may select its own appropriate aspect ratio but sometimes it may be necessary to force a square aspect ratio (e.g. to display the plot as an element of a grid). The modes ‘auto’ and ‘equal’ correspond to the axis modes of the same name in matplotlib, a numeric value specifying the ratio between plot width and height may also be passed. To control the aspect ratio between the axis scales use the data_aspect option instead.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SpreadPlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined')[source]

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

  • ‘data’: Just the data ranges

  • ‘extents’: Element.extents

  • ‘soft’: Dimension.soft_range values

  • ‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

  • ‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SpreadPlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SpreadPlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_data, plot_kwargs)

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SpreadPlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SpreadPlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SpreadPlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.SpreadPlot'>)
set_root(root)

Sets the root model on all subplots.

property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, element, ranges, style)

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring

class holoviews.plotting.mpl.chart.VectorFieldPlot(*args, **kwargs)[source]

Bases: holoviews.plotting.mpl.element.ColorbarPlot

Renders vector fields in sheet coordinates. The vectors are expressed in polar coordinates and may be displayed according to angle alone (with some common, arbitrary arrow length) or may be true polar vectors.

The color or magnitude can be mapped onto any dimension using the color_index and size_index.

The length of the arrows is controlled by the ‘scale’ style option. The scaling of the arrows may also be controlled via the normalize_lengths and rescale_lengths plot option, which will normalize the lengths to a maximum of 1 and scale them according to the minimum distance respectively.

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=True)

Whether to display the plot title.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.Parameter()

The projection of the plot axis, default of None is equivalent to 2D plot, ‘3d’ and ‘polar’ are also supported by matplotlib by default. May also supply a custom projection that is either a matplotlib projection type or implements the _as_mpl_axes method.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.ClassSelector(class_=(<class ‘str’>, <class ‘tuple’>))

If set bgcolor overrides the background color of the axis.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=0.05)

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=True)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=False)

Whether to show a Cartesian grid on the plot.

xaxis = param.ObjectSelector(default=’bottom’, objects=[‘top’, ‘bottom’, ‘bare’, ‘top-bare’, ‘bottom-bare’, None, True, False])

Whether and where to display the xaxis. The “bare” options allow suppressing all axis labels, including ticks and xlabel. Valid options are ‘top’, ‘bottom’, ‘bare’, ‘top-bare’ and ‘bottom-bare’.

yaxis = param.ObjectSelector(default=’left’, objects=[‘left’, ‘right’, ‘bare’, ‘left-bare’, ‘right-bare’, None, True, False])

Whether and where to display the yaxis. The “bare” options allow suppressing all axis labels, including ticks and ylabel. Valid options are ‘left’, ‘right’, ‘bare’, ‘left-bare’ and ‘right-bare’.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’square’)

The aspect ratio mode of the plot. By default, a plot may select its own appropriate aspect ratio but sometimes it may be necessary to force a square aspect ratio (e.g. to display the plot as an element of a grid). The modes ‘auto’ and ‘equal’ correspond to the axis modes of the same name in matplotlib, a numeric value specifying the ratio between plot width and height may also be passed. To control the aspect ratio between the axis scales use the data_aspect option instead.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’])

Whether to plot the ‘x’ and ‘y’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.Boolean(bounds=(0, 1), default=True)

Whether to display the z-axis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

clabel = param.String()

An explicit override of the color bar label, if set takes precedence over the title key in colorbar_opts.

clim = param.NumericTuple(default=(nan, nan), length=2)

User-specified colorbar axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

cformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the colorbar axis.

colorbar = param.Boolean(bounds=(0, 1), default=False)

Whether to draw a colorbar.

colorbar_opts = param.Dict(class_=<class ‘dict’>, default={})

Allows setting specific styling options for the colorbar.

color_levels = param.ClassSelector(class_=(<class ‘int’>, <class ‘list’>))

Number of discrete colors to use when colormapping or a set of color intervals defining the range of values to map each color to.

clipping_colors = param.Dict(class_=<class ‘dict’>, default={})

Dictionary to specify colors for clipped values, allows setting color for NaN values and for values above and below the min and max value. The min, max or NaN color may specify an RGB(A) color as a color hex string of the form #FFFFFF or #FFFFFFFF or a length 3 or length 4 tuple specifying values in the range 0-1 or a named HTML color.

cbar_padding = param.Number(default=0.01, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Padding between colorbar and other plots.

cbar_ticks = param.Parameter()

Ticks along colorbar-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

cbar_width = param.Number(default=0.05, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Width of the colorbar as a fraction of the main plot

cbar_extend = param.ObjectSelector(objects=[‘neither’, ‘both’, ‘min’, ‘max’])

If not ‘neither’, make pointed end(s) for out-of- range values.

symmetric = param.Boolean(bounds=(0, 1), default=False)

Whether to make the colormap symmetric around zero.

arrow_heads = param.Boolean(bounds=(0, 1), default=True)

Whether or not to draw arrow heads. If arrowheads are enabled, they may be customized with the ‘headlength’ and ‘headaxislength’ style options.

magnitude = param.ClassSelector(class_=(<class ‘str’>, <class ‘holoviews.util.transform.dim’>))

Dimension or dimension value transform that declares the magnitude of each vector. Magnitude is expected to be scaled between 0-1, by default the magnitudes are rescaled relative to the minimum distance between vectors, this can be disabled with the rescale_lengths option.

rescale_lengths = param.Boolean(bounds=(0, 1), default=True)

Whether the lengths will be rescaled to take into account the smallest non-zero distance between two vectors.

color_index = param.ClassSelector(class_=(<class ‘str’>, <class ‘int’>))

Deprecated in favor of dimension value transform on color option, e.g. color=dim(‘Magnitude’).

size_index = param.ClassSelector(class_=(<class ‘str’>, <class ‘int’>))

Deprecated in favor of the magnitude option, e.g. magnitude=dim(‘Magnitude’).

normalize_lengths = param.Boolean(bounds=(0, 1), default=True)

Deprecated in favor of rescaling length using dimension value transforms using the magnitude option, e.g. dim(‘Magnitude’).norm().

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.

compute_ranges(obj, key, ranges)

Given an object, a specific key, and the normalization options, this method will find the specified normalization options on the appropriate OptionTree, group the elements according to the selected normalization option (i.e. either per frame or over the whole animation) and finally compute the dimension ranges in each group. The new set of ranges is returned.

debug(**kwargs)

Inspect .param.debug method for the full docstring

defaults(**kwargs)

Inspect .param.defaults method for the full docstring

force_new_dynamic_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.VectorFieldPlot'>)
get_aspect(xspan, yspan)

Computes the aspect ratio of the plot

get_extents(element, ranges, range_type='combined', xdim=None, ydim=None, zdim=None)

Gets the extents for the axes from the current Element. The globally computed ranges can optionally override the extents.

The extents are computed by combining the data ranges, extents and dimension ranges. Each of these can be obtained individually by setting the range_type to one of:

  • ‘data’: Just the data ranges

  • ‘extents’: Element.extents

  • ‘soft’: Dimension.soft_range values

  • ‘hard’: Dimension.range values

To obtain the combined range, which includes range padding the default may be used:

  • ‘combined’: All the range types combined and padding applied

This allows Overlay plots to obtain each range and combine them appropriately for all the objects in the overlay.

get_padding(obj, extents)

Computes padding along the axes taking into account the plot aspect.

get_param_values = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.VectorFieldPlot'>)
get_value_generator = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.VectorFieldPlot'>)
get_zorder(overlay, key, el)

Computes the z-order of element in the NdOverlay taking into account possible batching of elements.

init_artists(ax, plot_args, plot_kwargs)

Initializes the artist based on the plot method declared on the plot.

inspect_value = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.VectorFieldPlot'>)
matches(spec)

Matches a specification against the current Plot.

message(**kwargs)

Inspect .param.message method for the full docstring

params = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.VectorFieldPlot'>)
pprint(imports=None, prefix=' ', unknown_value='<?>', qualify=False, separator='')

(Experimental) Pretty printed representation that may be evaluated with eval. See pprint() function for more details.

classmethod print_param_defaults(*args, **kwargs)

Inspect .param.print_param_defaults method for the full docstring

print_param_values(**kwargs)

Inspect .param.print_param_values method for the full docstring

push()

Pushes plot updates to the frontend.

refresh(**kwargs)

Refreshes the plot by rerendering it and then pushing the updated data if the plot has an associated Comm.

script_repr(imports=[], prefix=' ')

Variant of __repr__ designed for generating a runnable script.

classmethod set_default(*args, **kwargs)

Inspect .param.set_default method for the full docstring

set_dynamic_time_fn = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.VectorFieldPlot'>)
set_param = functools.partial(<function Parameters.deprecate.<locals>.inner>, <class 'holoviews.plotting.mpl.chart.VectorFieldPlot'>)
set_root(root)

Sets the root model on all subplots.

property state

The plotting state that gets updated via the update method and used by the renderer to generate output.

state_pop()

Restore the most recently saved state.

See state_push() for more details.

state_push()

Save this instance’s state.

For Parameterized instances, this includes the state of dynamically generated values.

Subclasses that maintain short-term state should additionally save and restore that state using state_push() and state_pop().

Generally, this method is used by operations that need to test something without permanently altering the objects’ state.

teardown_handles()

If no custom update_handles method is supplied this method is called to tear down any previous handles before replacing them.

traverse(fn=None, specs=None, full_breadth=True)

Traverses any nested DimensionedPlot returning a list of all plots that match the specs. The specs should be supplied as a list of either Plot types or callables, which should return a boolean given the plot class.

update(key)

Update the internal state of the Plot to represent the given key tuple (where integers represent frames). Returns this state.

update_handles(key, axis, element, ranges, style)[source]

Update the elements of the plot.

verbose(**kwargs)

Inspect .param.verbose method for the full docstring

warning(**kwargs)

Inspect .param.warning method for the full docstring


chart3d Module

digraph inheritance40c19db063 { fontsize=18; rankdir=LR; size="12.0, 12.0"; "holoviews.plotting.mpl.chart.ChartPlot" [URL="#holoviews.plotting.mpl.chart.ChartPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Baseclass to plot Chart elements."]; "holoviews.plotting.mpl.element.ElementPlot" -> "holoviews.plotting.mpl.chart.ChartPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart.PointPlot" [URL="#holoviews.plotting.mpl.chart.PointPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Note that the 'cmap', 'vmin' and 'vmax' style arguments control"]; "holoviews.plotting.mpl.chart.ChartPlot" -> "holoviews.plotting.mpl.chart.PointPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.element.ColorbarPlot" -> "holoviews.plotting.mpl.chart.PointPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart3d.Path3DPlot" [URL="#holoviews.plotting.mpl.chart3d.Path3DPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Allows plotting paths on a 3D axis."]; "holoviews.plotting.mpl.chart3d.Plot3D" -> "holoviews.plotting.mpl.chart3d.Path3DPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.path.PathPlot" -> "holoviews.plotting.mpl.chart3d.Path3DPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart3d.Plot3D" [URL="#holoviews.plotting.mpl.chart3d.Plot3D",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Plot3D provides a common baseclass for mplot3d based"]; "holoviews.plotting.mpl.element.ColorbarPlot" -> "holoviews.plotting.mpl.chart3d.Plot3D" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart3d.Scatter3DPlot" [URL="#holoviews.plotting.mpl.chart3d.Scatter3DPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Subclass of PointPlot allowing plotting of Points"]; "holoviews.plotting.mpl.chart3d.Plot3D" -> "holoviews.plotting.mpl.chart3d.Scatter3DPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart.PointPlot" -> "holoviews.plotting.mpl.chart3d.Scatter3DPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart3d.SurfacePlot" [URL="#holoviews.plotting.mpl.chart3d.SurfacePlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Plots surfaces wireframes and contours in 3D space."]; "holoviews.plotting.mpl.chart3d.Plot3D" -> "holoviews.plotting.mpl.chart3d.SurfacePlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.chart3d.TriSurfacePlot" [URL="#holoviews.plotting.mpl.chart3d.TriSurfacePlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Plots a trisurface given a TriSurface element, containing"]; "holoviews.plotting.mpl.chart3d.Plot3D" -> "holoviews.plotting.mpl.chart3d.TriSurfacePlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.element.ColorbarPlot" [URL="#holoviews.plotting.mpl.element.ColorbarPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top"]; "holoviews.plotting.mpl.element.ElementPlot" -> "holoviews.plotting.mpl.element.ColorbarPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.element.ElementPlot" [URL="#holoviews.plotting.mpl.element.ElementPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top"]; "holoviews.plotting.plot.GenericElementPlot" -> "holoviews.plotting.mpl.element.ElementPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.plot.MPLPlot" -> "holoviews.plotting.mpl.element.ElementPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.path.PathPlot" [URL="#holoviews.plotting.mpl.path.PathPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top"]; "holoviews.plotting.mpl.element.ColorbarPlot" -> "holoviews.plotting.mpl.path.PathPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.mpl.plot.MPLPlot" [URL="#holoviews.plotting.mpl.plot.MPLPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="An MPLPlot object draws a matplotlib figure object when called or"]; "holoviews.plotting.plot.DimensionedPlot" -> "holoviews.plotting.mpl.plot.MPLPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.plot.DimensionedPlot" [URL="holoviews.plotting.html#holoviews.plotting.plot.DimensionedPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="DimensionedPlot implements a number of useful methods"]; "holoviews.plotting.plot.Plot" -> "holoviews.plotting.plot.DimensionedPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.plot.GenericElementPlot" [URL="holoviews.plotting.html#holoviews.plotting.plot.GenericElementPlot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Plotting baseclass to render contents of an Element. Implements"]; "holoviews.plotting.plot.DimensionedPlot" -> "holoviews.plotting.plot.GenericElementPlot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "holoviews.plotting.plot.Plot" [URL="holoviews.plotting.html#holoviews.plotting.plot.Plot",fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",target="_top",tooltip="Base class of all Plot classes in HoloViews, designed to be"]; "param.parameterized.Parameterized" -> "holoviews.plotting.plot.Plot" [arrowsize=0.5,style="setlinewidth(0.5)"]; "param.parameterized.Parameterized" [fontname="Vera Sans, DejaVu Sans, Liberation Sans, Arial, Helvetica, sans",fontsize=10,height=0.25,shape=box,style="setlinewidth(0.5)",tooltip="params(name=String)"]; }
class holoviews.plotting.mpl.chart3d.Path3DPlot(*args, **kwargs)[source]

Bases: holoviews.plotting.mpl.chart3d.Plot3D, holoviews.plotting.mpl.path.PathPlot

Allows plotting paths on a 3D axis.

fontsize = param.Parameter()

Specifies various font sizes of the displayed text. Finer control is available by supplying a dictionary where any unmentioned keys revert to the default sizes, e.g: {‘ticks’:20, ‘title’:15, ‘ylabel’:5, ‘xlabel’:5, ‘zlabel’:5, ‘legend’:8, ‘legend_title’:13} You can set the font size of ‘zlabel’, ‘ylabel’ and ‘xlabel’ together using the ‘labels’ key.

fontscale = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Scales the size of all fonts.

show_title = param.Boolean(bounds=(0, 1), default=True)

Whether to display the plot title.

title = param.String(default=’{label} {group}n{dimensions}’)

The formatting string for the title of this plot, allows defining a label group separator and dimension labels.

title_format = param.String()

Alias for title.

normalize = param.Boolean(bounds=(0, 1), default=True)

Whether to compute ranges across all Elements at this level of plotting. Allows selecting normalization at different levels for nested data containers.

projection = param.ObjectSelector(default=’3d’, objects=[‘3d’])

The projection of the matplotlib axis.

fig_alpha = param.Number(bounds=(0, 1), default=1.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Alpha of the overall figure background.

fig_bounds = param.NumericTuple(default=(0.15, 0.15, 0.85, 0.85), length=4)

The bounds of the overall figure as a 4-tuple of the form (left, bottom, right, top), defining the size of the border around the subplots.

fig_inches = param.Parameter(default=4)

The overall matplotlib figure size in inches. May be set as an integer in which case it will be used to autocompute a size. Alternatively may be set with an explicit tuple or list, in which case it will be applied directly after being scaled by fig_size. If either the width or height is set to None, it will be computed automatically.

fig_latex = param.Boolean(bounds=(0, 1), default=False)

Whether to use LaTeX text in the overall figure.

fig_rcparams = param.Dict(class_=<class ‘dict’>, default={})

matplotlib rc parameters to apply to the overall figure.

fig_size = param.Number(bounds=(1, None), default=100.0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size relative to the supplied overall fig_inches in percent.

initial_hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called before plotting the data onto the axis (now marked for deprecation). The hook is passed the plot object and the displayed object; other plotting handles can be accessed via plot.handles.

sublabel_format = param.String()

Allows labeling the subaxes in each plot with various formatters including {Alpha}, {alpha}, {numeric} and {roman}.

sublabel_position = param.NumericTuple(default=(-0.35, 0.85), length=2)

Position relative to the plot for placing the optional subfigure label.

sublabel_size = param.Number(default=18, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Size of optional subfigure label.

show_frame = param.Boolean(bounds=(0, 1), default=False)

Whether or not to show a complete frame around the plot.

apply_ranges = param.Boolean(bounds=(0, 1), default=True)

Whether to compute the plot bounds from the data itself.

apply_extents = param.Boolean(bounds=(0, 1), default=True)

Whether to apply extent overrides on the Elements

bgcolor = param.String(default=’white’)

Background color of the axis.

default_span = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=2.0)

Defines the span of an axis if the axis range is zero, i.e. if the lower and upper end of an axis are equal or no range is defined at all. For example if there is a single datapoint at 0 a default_span of 2.0 will result in axis ranges spanning from -1 to 1.

hooks = param.HookList(bounds=(0, None), default=[])

Optional list of hooks called when finalizing a plot. The hook is passed the plot object and the displayed element, and other plotting handles can be accessed via plot.handles.

invert_axes = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the x- and y-axis

invert_xaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot x-axis.

invert_yaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot y-axis.

finalize_hooks = param.HookList(bounds=(0, None), default=[])

Deprecated; use hooks options instead.

logx = param.Boolean(bounds=(0, 1), default=False)

Whether the x-axis of the plot will be a log axis.

logy = param.Boolean(bounds=(0, 1), default=False)

Whether the y-axis of the plot will be a log axis.

padding = param.ClassSelector(class_=(<class ‘int’>, <class ‘float’>, <class ‘tuple’>), default=0.1)

Fraction by which to increase auto-ranged extents to make datapoints more visible around borders. To compute padding, the axis whose screen size is largest is chosen, and the range of that axis is increased by the specified fraction along each axis. Other axes are then padded ensuring that the amount of screen space devoted to padding is equal for all axes. If specified as a tuple, the int or float values in the tuple will be used for padding in each axis, in order (x,y or x,y,z). For example, for padding=0.2 on a 800x800-pixel plot, an x-axis with the range [0,10] will be padded by 20% to be [-1,11], while a y-axis with a range [0,1000] will be padded to be [-100,1100], which should make the padding be approximately the same number of pixels. But if the same plot is changed to have a height of only 200, the y-range will then be [-400,1400] so that the y-axis padding will still match that of the x-axis. It is also possible to declare non-equal padding value for the lower and upper bound of an axis by supplying nested tuples, e.g. padding=(0.1, (0, 0.1)) will pad the x-axis lower and upper bound as well as the y-axis upper bound by a fraction of 0.1 while the y-axis lower bound is not padded at all.

show_legend = param.Boolean(bounds=(0, 1), default=False)

Whether to show legend for the plot.

show_grid = param.Boolean(bounds=(0, 1), default=True)

Whether to draw a grid in the figure.

xaxis = param.ObjectSelector(default=’fixed’, objects=[‘fixed’, None])

Whether and where to display the xaxis.

yaxis = param.ObjectSelector(default=’fixed’, objects=[‘fixed’, None])

Whether and where to display the yaxis.

xlabel = param.String()

An explicit override of the x-axis label, if set takes precedence over the dimension label.

ylabel = param.String()

An explicit override of the y-axis label, if set takes precedence over the dimension label.

xlim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

ylim = param.Tuple(default=(nan, nan), length=2)

User-specified x-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

zlim = param.Tuple(default=(nan, nan), length=2)

User-specified z-axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

xrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the xticks.

yrotation = param.Integer(bounds=(0, 360), inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the yticks.

xticks = param.Parameter()

Ticks along x-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

yticks = param.Parameter()

Ticks along y-axis specified as an integer, explicit list of tick locations, or bokeh Ticker object. If set to None default bokeh ticking behavior is applied.

apply_ticks = param.Boolean(bounds=(0, 1), default=True)

Whether to apply custom ticks.

aspect = param.Parameter(default=’square’)

PathPlots axes usually define single space so aspect of Paths follows aspect in data coordinates by default.

data_aspect = param.Number(inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Defines the aspect of the axis scaling, i.e. the ratio of y-unit to x-unit.

invert_zaxis = param.Boolean(bounds=(0, 1), default=False)

Whether to invert the plot z-axis.

labelled = param.List(bounds=(0, None), default=[‘x’, ‘y’, ‘z’])

Whether to plot the ‘x’, ‘y’ and ‘z’ labels.

logz = param.Boolean(bounds=(0, 1), default=False)

Whether to apply log scaling to the y-axis of the Chart.

xformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the x-axis.

yformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the y-axis.

zformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the z-axis.

zaxis = param.ObjectSelector(default=’fixed’, objects=[‘fixed’, None])

Whether and where to display the yaxis.

zlabel = param.String()

An explicit override of the z-axis label, if set takes precedence over the dimension label.

zrotation = param.Integer(bounds=(0, 360), default=0, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Rotation angle of the zticks.

zticks = param.Parameter()

Ticks along z-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

clabel = param.String()

An explicit override of the color bar label, if set takes precedence over the title key in colorbar_opts.

clim = param.NumericTuple(default=(nan, nan), length=2)

User-specified colorbar axis range limits for the plot, as a tuple (low,high). If specified, takes precedence over data and dimension ranges.

cformatter = param.ClassSelector(class_=(<class ‘str’>, <class ‘matplotlib.ticker.Formatter’>, <class ‘function’>))

Formatter for ticks along the colorbar axis.

colorbar = param.Boolean(bounds=(0, 1), default=False)

Whether to draw a colorbar.

colorbar_opts = param.Dict(class_=<class ‘dict’>, default={})

Allows setting specific styling options for the colorbar.

color_levels = param.ClassSelector(class_=(<class ‘int’>, <class ‘list’>))

Number of discrete colors to use when colormapping or a set of color intervals defining the range of values to map each color to.

clipping_colors = param.Dict(class_=<class ‘dict’>, default={})

Dictionary to specify colors for clipped values, allows setting color for NaN values and for values above and below the min and max value. The min, max or NaN color may specify an RGB(A) color as a color hex string of the form #FFFFFF or #FFFFFFFF or a length 3 or length 4 tuple specifying values in the range 0-1 or a named HTML color.

cbar_padding = param.Number(default=0.01, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Padding between colorbar and other plots.

cbar_ticks = param.Parameter()

Ticks along colorbar-axis specified as an integer, explicit list of tick locations, list of tuples containing the locations and labels or a matplotlib tick locator object. If set to None default matplotlib ticking behavior is applied.

cbar_width = param.Number(default=0.05, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Width of the colorbar as a fraction of the main plot

cbar_extend = param.ObjectSelector(objects=[‘neither’, ‘both’, ‘min’, ‘max’])

If not ‘neither’, make pointed end(s) for out-of- range values.

symmetric = param.Boolean(bounds=(0, 1), default=False)

Whether to make the colormap symmetric around zero.

color_index = param.ClassSelector(class_=(<class ‘str’>, <class ‘int’>))

Index of the dimension from which the color will the drawn

azimuth = param.Integer(bounds=(-180, 180), default=-60, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Azimuth angle in the x,y plane.

elevation = param.Integer(bounds=(0, 180), default=30, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Elevation angle in the z-axis.

distance = param.Integer(bounds=(7, 15), default=10, inclusive_bounds=(True, True), time_dependent=False, time_fn=Time(label=’Time’, name=’Time00001’, time_type=<class ‘int’>, timestep=1.0, unit=None, until=Infinity()))

Distance from the plotted object.

disable_axes = param.Boolean(bounds=(0, 1), default=False)

Disable all axes.

anim(start=0, stop=None, fps=30)

Method to return a matplotlib animation. The start and stop frames may be specified as well as the fps.

cleanup()

Cleans up references to the plot on the attached Stream subscribers.