Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def str_param(pdef):
return param.String(
default=pdef.get('default', ''),
doc=pdef.get('desc', ''),
)
callback = param.Callable(default=None, doc="""
A callable that returns the file path or file-like object.""")
data = param.String(default=None, doc="""
The data being transferred.""")
embed = param.Boolean(default=False, doc="""
Whether to embed the file on initialization.""")
file = param.Parameter(default=None, doc="""
The file, file-like object or file contents to transfer. If
the file is not pointing to a file on disk a filename must
also be provided.""")
filename = param.String(default=None, doc="""
A filename which will also be the default name when downloading
the file.""")
label = param.String(default="Download file", doc="""
The label of the download button""")
_clicks = param.Integer(default=0)
_transfers = param.Integer(default=0)
_mime_types = {
'application': {
'pdf': 'pdf', 'zip': 'zip'
},
'audio': {
'mp3': 'mp3', 'ogg': 'ogg', 'wav': 'wav', 'webm': 'webm'
"""
The Location component can be made available in a server context
to provide read and write access to the URL components in the
browser.
"""
href = param.String(readonly=True, doc="""
The full url, e.g. 'https://localhost:80?color=blue#interact'""")
hostname = param.String(readonly=True, doc="""
hostname in window.location e.g. 'panel.holoviz.org'""")
pathname = param.String(regex=r"^$|[\/].*$", doc="""
pathname in window.location e.g. '/user_guide/Interact.html'""")
protocol = param.String(readonly=True, doc="""
protocol in window.location e.g. 'http:' or 'https:'""")
port = param.String(readonly=True, doc="""
port in window.location e.g. '80'""")
search = param.String(regex=r"^$|\?", doc="""
search in window.location e.g. '?color=blue'""")
hash = param.String(regex=r"^$|#", doc="""
hash in window.location e.g. '#interact'""")
reload = param.Boolean(default=False, doc="""
Reload the page when the location is updated. For multipage
apps this should be set to True, For single page apps this
should be set to False""")
browser.
"""
href = param.String(readonly=True, doc="""
The full url, e.g. 'https://localhost:80?color=blue#interact'""")
hostname = param.String(readonly=True, doc="""
hostname in window.location e.g. 'panel.holoviz.org'""")
pathname = param.String(regex=r"^$|[\/].*$", doc="""
pathname in window.location e.g. '/user_guide/Interact.html'""")
protocol = param.String(readonly=True, doc="""
protocol in window.location e.g. 'http:' or 'https:'""")
port = param.String(readonly=True, doc="""
port in window.location e.g. '80'""")
search = param.String(regex=r"^$|\?", doc="""
search in window.location e.g. '?color=blue'""")
hash = param.String(regex=r"^$|#", doc="""
hash in window.location e.g. '#interact'""")
reload = param.Boolean(default=False, doc="""
Reload the page when the location is updated. For multipage
apps this should be set to True, For single page apps this
should be set to False""")
# Mapping from parameter name to bokeh model property name
_rename = {"name": None}
According to Material Design Palette.
Source: https://github.com/angular/components/blob/master/src/material/core/theming/_palette.scss
"""
import param
from . import color
from .color_palette import GREY
class ThemeForeground(param.Parameterized):
"""Material Design Theme Foreground settings"""
base = param.String(color.BLACK)
divider = param.String(color.DARK_DIVIDERS)
dividers = param.String(color.DARK_DIVIDERS)
disabled = param.String(color.DARK_DISABLED_TEXT)
disabled_button = param.String("rgba(0,0,0, 0.26)")
disabled_text = param.String(color.DARK_DISABLED_TEXT)
elevation = param.String(color.BLACK)
hint_text = param.String(color.DARK_DISABLED_TEXT)
primary_text = param.String(color.DARK_PRIMARY_TEXT)
secondary_text = param.String(color.DARK_SECONDARY_TEXT)
icon = param.String("rgba(0,0,0 , 0.54)")
icons = param.String("rgba(0,0,0 , 0.54)")
text = param.String("rgba(0,0,0 , 0.87)")
slider_min = param.String("rgba(0,0,0 , 0.87)")
slider_off = param.String("rgba(0,0,0 , 0.26)")
slider_off_active = param.String("rgba(0,0,0 , 0.38)")
def __eq__(self, other):
return self.name == other.name
return RGB(matplotlib.cm.get_cmap(self.p.cmap)(matrix.data),
bounds = matrix.bounds,
label = matrix.label,
group=self.p.group)
class alpha_overlay(ElementOperation):
"""
Accepts an overlay of a Image defined with a cmap and converts it
to an RGB element whereby the alpha channel of the result is
obtained from the second layer of the overlay.
"""
group = param.String(default='AlphaOverlay', doc="""
The group string for the output (an RGB element).""")
cmap = param.String(default='jet', doc="""
The name of matplotlib color map to apply.""")
def _process(self, overlay, key=None):
R,G,B,_ = split_raster(colormap(overlay[0], cmap=self.p.cmap))
return RGB(R*G*B*overlay[1],
bounds=self.get_overlay_extents(overlay),
label=self.get_overlay_label(overlay),
group=self.p.group)
class colorizeHSV(ElementOperation):
"""
Given an Overlay consisting of two Image elements, colorize the
__abstract = True
seed = param.Integer(default=None, bounds=(0, 2**32-1), doc="""
Random seed used to initialize the pseudo-random number
generator.""")
x = param.String(default='x', doc="""
Column name for each node's x coordinate.""")
y = param.String(default='y', doc="""
Column name for each node's y coordinate.""")
source = param.String(default='source', doc="""
Column name for each edge's source.""")
target = param.String(default='target', doc="""
Column name for each edge's target.""")
weight = param.String(default=None, allow_None=True, doc="""
Column name for each edge weight. If None, weights are ignored.""")
id = param.String(default=None, allow_None=True, doc="""
Column name for a unique identifier for the node. If None, the
dataframe index is used.""")
def __call__(self, nodes, edges, **params):
"""
This method takes two dataframes representing a graph's nodes
and edges respectively. For the nodes dataframe, the only
column accessed is the specified `id` value (or the index if
no 'id'). For the edges dataframe, the columns are `id`,
`source`, `target`, and (optionally) `weight`.
expansions = param.Dict(default={}, constant=True, doc='''
Allows extension of the specification that supports functions
that expand to valid argument values. If a function is used,
it must have the signature (spec, info, tid). A typical usage
for a function value is to build a valid output filename given
the context.
Three such subclasses are provided:
'RootDirectory', 'LongFilename' and 'Expand'.''')
posargs = param.List(default=[], constant=True, doc='''
The list of positional argument keys. Positional arguments are
always supplied at the end of a command in the order given.''')
short_prefix = param.String(default='-', constant=True, doc='''
Although the single dash is a GNU coding convention, the
argument prefix may depend on the applications and/or platform.''')
long_prefix = param.String(default='--', constant=True, doc='''
Although the double dash is a GNU coding convention, some
applications use single dashes for long options.''')
def __init__(self, executable, **params):
super(ShellCommand,self).__init__(executable = executable,
do_format=False,
**params)
self.pprint_args(['executable','posargs'],['long_prefix'])
def __call__(self, spec, tid=None, info={}):
# Function expansions are called here.
expanded = type(spec)()
text = param.String(default='', doc="Text associated with the arrow.")
direction = param.ObjectSelector(default='<',
objects=['<', '^', '>', 'v'], doc="""
The cardinal direction in which the arrow is pointing. Accepted
arrow directions are '<', '^', '>' and 'v'.""")
arrowstyle = param.ObjectSelector(default='->',
objects=['-', '->', '-[', '-|>', '<->', '<|-|>'],
doc="""
The arrowstyle used to draw the arrow. Accepted arrow styles are
'-', '->', '-[', '-|>', '<->' and '<|-|>'""")
points = param.Number(default=40, doc="Font size of arrow text (if any).")
group = param.String(default='Arrow', constant=True)
__pos_params = ['x', 'y', 'text', 'direction', 'points', 'arrowstyle']
def __init__(self, x, y, text='', direction='<',
points=40, arrowstyle='->', **params):
info = (x, y, text, direction, points, arrowstyle)
super(Arrow, self).__init__(info, x=x, y=y,
text=text, direction=direction,
points=points, arrowstyle=arrowstyle,
**params)
def __setstate__(self, d):
"""
Add compatibility for unpickling old Arrow types with different
.data format.
def define(cls, name, **kwargs):
"""
Utility to quickly and easily declare Stream classes. Designed
for interactive use such as notebooks and shouldn't replace
parameterized class definitions in source code that is imported.
Takes a stream class name and a set of keywords where each
keyword becomes a parameter. If the value is already a
parameter, it is simply used otherwise the appropriate parameter
type is inferred and declared, using the value as the default.
Supported types: bool, int, float, str, dict, tuple and list
"""
params = {'name':param.String(default=name)}
for k,v in kwargs.items():
kws = dict(default=v, constant=True)
if isinstance(v, param.Parameter):
params[k] = v
elif isinstance(v, bool):
params[k] = param.Boolean(**kws)
elif isinstance(v, int):
params[k] = param.Integer(**kws)
elif isinstance(v, float):
params[k] = param.Number(**kws)
elif isinstance(v,str):
params[k] = param.String(**kws)
elif isinstance(v,dict):
params[k] = param.Dict(**kws)
elif isinstance(v, tuple):
params[k] = param.Tuple(**kws)