'rgb(44, 160, 44)', 'rgb(214, 39, 40)',

'rgb(148, 103, 189)', 'rgb(140, 86, 75)',

'rgb(227, 119, 194)', 'rgb(127, 127, 127)',

'YlGnBu': ['rgb(8,29,88)', 'rgb(255,255,217)'],

'Greens': ['rgb(0,68,27)', 'rgb(247,252,245)'],

'YlOrRd': ['rgb(128,0,38)', 'rgb(255,255,204)'],

'Bluered': ['rgb(0,0,255)', 'rgb(255,0,0)'],

'RdBu': ['rgb(5,10,172)', 'rgb(178,10,28)'],

'Reds': ['rgb(220,220,220)', 'rgb(178,10,28)'],

'Blues': ['rgb(5,10,172)', 'rgb(220,220,220)'],

'Picnic': ['rgb(0,0,255)', 'rgb(255,0,0)'],

'Rainbow': ['rgb(150,0,90)', 'rgb(255,0,0)'],

'Portland': ['rgb(12,51,131)', 'rgb(217,30,30)'],

'Jet': ['rgb(0,0,131)', 'rgb(128,0,0)'],

'Hot': ['rgb(0,0,0)', 'rgb(255,255,255)'],

'Blackbody': ['rgb(0,0,0)', 'rgb(160,200,255)'],

'Earth': ['rgb(0,0,130)', 'rgb(255,255,255)'],

'Electric': ['rgb(0,0,0)', 'rgb(255,250,220)'],

"""

"""Ensure that filesystem is setup/filled out in a valid way.

if check_file_permissions():

for fn in [CREDENTIALS_FILE, CONFIG_FILE]:

utils.ensure_file_exists(fn)

contents = utils.load_json_dict(fn)

contents_orig = contents.copy()

for key, val in list(FILE_CONTENT[fn].items()):

# TODO: removed type checking below, may want to revisit

if key not in contents:

contents[key] = val

contents_keys = list(contents.keys())

for key in contents_keys:

if key not in FILE_CONTENT[fn]:

del contents[key]

# save only if contents has changed.

# This is to avoid .credentials or .config file to be overwritten randomly,

# which we constantly keep experiencing

# (sync issues? the file might be locked for writing by other process in file._permissions)

if contents_orig.keys() != contents.keys():

utils.save_json_dict(fn, contents)

else:

warnings.warn("Looks like you don't have 'read-write' permission to "

"your 'home' ('~') directory or to our '~/.plotly' "

"directory. That means plotly's python api can't setup "

"local configuration files. No problem though! You'll "

"just have to sign-in using 'plotly.plotly.sign_in()'. "

"For help with that: 'help(plotly.plotly.sign_in)'."

api_key=None,

stream_ids=None,

proxy_username=None,

proxy_password=None):

"""Set the keyword-value pairs in `~/.plotly_credentials`.

if not check_file_permissions():

raise exceptions.PlotlyError("You don't have proper file permissions "

"to run this function.")

ensure_local_plotly_files() # make sure what's there is OK

credentials = get_credentials_file()

if isinstance(username, six.string_types):

credentials['username'] = username

if isinstance(api_key, six.string_types):

credentials['api_key'] = api_key

if isinstance(proxy_username, six.string_types):

credentials['proxy_username'] = proxy_username

if isinstance(proxy_password, six.string_types):

credentials['proxy_password'] = proxy_password

if isinstance(stream_ids, (list, tuple)):

credentials['stream_ids'] = stream_ids

utils.save_json_dict(CREDENTIALS_FILE, credentials)

"""Return specified args from `~/.plotly_credentials`. as dict.

if check_file_permissions():

ensure_local_plotly_files() # make sure what's there is OK

return utils.load_json_dict(CREDENTIALS_FILE, *args)

else:

plotly_streaming_domain=None,

plotly_api_domain=None,

plotly_ssl_verification=None,

plotly_proxy_authorization=None,

world_readable=None,

sharing=None,

auto_open=None):

"""Set the keyword-value pairs in `~/.plotly/.config`.

if not check_file_permissions():

raise exceptions.PlotlyError("You don't have proper file permissions "

"to run this function.")

ensure_local_plotly_files() # make sure what's there is OK

utils.validate_world_readable_and_sharing_settings({

'sharing': sharing, 'world_readable': world_readable})

settings = get_config_file()

if isinstance(plotly_domain, six.string_types):

settings['plotly_domain'] = plotly_domain

elif plotly_domain is not None:

raise TypeError('plotly_domain should be a string')

if isinstance(plotly_streaming_domain, six.string_types):

settings['plotly_streaming_domain'] = plotly_streaming_domain

elif plotly_streaming_domain is not None:

raise TypeError('plotly_streaming_domain should be a string')

if isinstance(plotly_api_domain, six.string_types):

settings['plotly_api_domain'] = plotly_api_domain

elif plotly_api_domain is not None:

raise TypeError('plotly_api_domain should be a string')

if isinstance(plotly_ssl_verification, (six.string_types, bool)):

settings['plotly_ssl_verification'] = plotly_ssl_verification

elif plotly_ssl_verification is not None:

raise TypeError('plotly_ssl_verification should be a boolean')

if isinstance(plotly_proxy_authorization, (six.string_types, bool)):

settings['plotly_proxy_authorization'] = plotly_proxy_authorization

elif plotly_proxy_authorization is not None:

raise TypeError('plotly_proxy_authorization should be a boolean')

if isinstance(auto_open, bool):

settings['auto_open'] = auto_open

elif auto_open is not None:

raise TypeError('auto_open should be a boolean')

# validate plotly_domain and plotly_api_domain

utils.validate_plotly_domains(

{'plotly_domain': plotly_domain, 'plotly_api_domain': plotly_api_domain}

)

if isinstance(world_readable, bool):

settings['world_readable'] = world_readable

settings.pop('sharing')

elif world_readable is not None:

raise TypeError('Input should be a boolean')

if isinstance(sharing, six.string_types):

settings['sharing'] = sharing

elif sharing is not None:

raise TypeError('sharing should be a string')

utils.set_sharing_and_world_readable(settings)

utils.save_json_dict(CONFIG_FILE, settings)

"""Return specified args from `~/.plotly/.config`. as tuple.

if check_file_permissions():

ensure_local_plotly_files() # make sure what's there is OK

return utils.load_json_dict(CONFIG_FILE, *args)

else:

ensure_local_plotly_files() # make sure what's there is OK

f = open(CONFIG_FILE, 'w')

f.close()

"""Returns HTML code to embed figure on a webpage as an <iframe>

plotly_rest_url = (session.get_session_config().get('plotly_domain') or

get_config_file()['plotly_domain'])

if file_id is None: # assume we're using a url

url = file_owner_or_url

if url[:len(plotly_rest_url)] != plotly_rest_url:

raise exceptions.PlotlyError(

"Because you didn't supply a 'file_id' in the call, "

"we're assuming you're trying to snag a figure from a url. "

"You supplied the url, '{0}', we expected it to start with "

"'{1}'."

"\nRun help on this function for more information."

"".format(url, plotly_rest_url))

urlsplit = six.moves.urllib.parse.urlparse(url)

file_owner = urlsplit.path.split('/')[1].split('~')[1]

file_id = urlsplit.path.split('/')[2]

# to check for share_key we check urlsplit.query

query_dict = six.moves.urllib.parse.parse_qs(urlsplit.query)

if query_dict:

share_key = query_dict['share_key'][-1]

else:

share_key = ''

else:

file_owner = file_owner_or_url

share_key = ''

try:

test_if_int = int(file_id)

except ValueError:

raise exceptions.PlotlyError(

"The 'file_id' argument was not able to be converted into an "

"integer number. Make sure that the positional 'file_id' argument "

"is a number that can be converted into an integer or a string "

"that can be converted into an integer."

)

if int(file_id) < 0:

raise exceptions.PlotlyError(

"The 'file_id' argument must be a non-negative number."

)

if share_key is '':

s = ("<iframe id=\"igraph\" scrolling=\"no\" style=\"border:none;\" "

"seamless=\"seamless\" "

"src=\"{plotly_rest_url}/"

"~{file_owner}/{file_id}.embed\" "

"height=\"{iframe_height}\" width=\"{iframe_width}\">"

"</iframe>").format(

plotly_rest_url=plotly_rest_url,

file_owner=file_owner, file_id=file_id,

iframe_height=height, iframe_width=width)

else:

s = ("<iframe id=\"igraph\" scrolling=\"no\" style=\"border:none;\" "

"seamless=\"seamless\" "

"src=\"{plotly_rest_url}/"

"~{file_owner}/{file_id}.embed?share_key={share_key}\" "

"height=\"{iframe_height}\" width=\"{iframe_width}\">"

"</iframe>").format(

plotly_rest_url=plotly_rest_url,

file_owner=file_owner, file_id=file_id, share_key=share_key,

iframe_height=height, iframe_width=width)

"""Embeds existing Plotly figure in IPython Notebook

try:

s = get_embed(file_owner_or_url, file_id=file_id, width=width,

height=height)

# see if we are in the SageMath Cloud

if sage_salvus:

return sage_salvus.html(s, hide=False)

except:

pass

if ipython_core_display:

if file_id:

plotly_domain = (

session.get_session_config().get('plotly_domain') or

get_config_file()['plotly_domain']

)

url = "{plotly_domain}/~{un}/{fid}".format(

plotly_domain=plotly_domain,

un=file_owner_or_url,

fid=file_id)

else:

url = file_owner_or_url

return PlotlyDisplay(url, width, height)

else:

if (get_config_defaults()['plotly_domain']

!= session.get_session_config()['plotly_domain']):

feedback_contact = 'Visit support.plot.ly'

else:

# different domain likely means enterprise

feedback_contact = 'Contact your On-Premise account executive'

warnings.warn(

"Looks like you're not using IPython or Sage to embed this "

"plot. If you just want the *embed code*,\ntry using "

"`get_embed()` instead."

"""Convert a matplotlib figure to plotly dictionary and send.

matplotlylib = optional_imports.get_module('plotly.matplotlylib')

if matplotlylib:

renderer = matplotlylib.PlotlyRenderer()

matplotlylib.Exporter(renderer).run(fig)

if resize:

renderer.resize()

if strip_style:

renderer.strip_style()

if verbose:

print(renderer.msg)

return renderer.plotly_fig

else:

warnings.warn(

"To use Plotly's matplotlylib functionality, you'll need to have "

"matplotlib successfully installed with all of its dependencies. "

"You're getting this error because matplotlib or one of its "

"""Return a dictionary instance with the subplots set in 'layout'.

# TODO: protected until #282

from plotly.graph_objs import graph_objs

warnings.warn(

"tools.get_subplots is depreciated. "

"Please use tools.make_subplots instead."

)

# Throw exception for non-integer rows and columns

if not isinstance(rows, int) or rows <= 0:

raise Exception("Keyword argument 'rows' "

"must be an int greater than 0")

if not isinstance(columns, int) or columns <= 0:

raise Exception("Keyword argument 'columns' "

"must be an int greater than 0")

# Throw exception if non-valid kwarg is sent

VALID_KWARGS = ['horizontal_spacing', 'vertical_spacing']

for key in kwargs.keys():

if key not in VALID_KWARGS:

raise Exception("Invalid keyword argument: '{0}'".format(key))

# Set 'horizontal_spacing' / 'vertical_spacing' w.r.t. rows / columns

try:

horizontal_spacing = float(kwargs['horizontal_spacing'])

except KeyError:

horizontal_spacing = 0.2 / columns

try:

vertical_spacing = float(kwargs['vertical_spacing'])

except KeyError:

vertical_spacing = 0.3 / rows

fig = dict(layout=graph_objs.Layout()) # will return this at the end

plot_width = (1 - horizontal_spacing * (columns - 1)) / columns

plot_height = (1 - vertical_spacing * (rows - 1)) / rows

plot_num = 0

for rrr in range(rows):

for ccc in range(columns):

xaxis_name = 'xaxis{0}'.format(plot_num + 1)

x_anchor = 'y{0}'.format(plot_num + 1)

x_start = (plot_width + horizontal_spacing) * ccc

x_end = x_start + plot_width

yaxis_name = 'yaxis{0}'.format(plot_num + 1)

y_anchor = 'x{0}'.format(plot_num + 1)

y_start = (plot_height + vertical_spacing) * rrr

y_end = y_start + plot_height

xaxis = dict(domain=[x_start, x_end], anchor=x_anchor)

fig['layout'][xaxis_name] = xaxis

yaxis = dict(domain=[y_start, y_end], anchor=y_anchor)

fig['layout'][yaxis_name] = yaxis

plot_num += 1

if print_grid:

print("This is the format of your plot grid!")

grid_string = ""

plot = 1

for rrr in range(rows):

grid_line = ""

for ccc in range(columns):

grid_line += "[{0}]\t".format(plot)

plot += 1

grid_string = grid_line + '\n' + grid_string

print(grid_string)

shared_xaxes=False, shared_yaxes=False,

start_cell='top-left', print_grid=True,

**kwargs):

"""Return an instance of plotly.graph_objs.Figure

# TODO: protected until #282

from plotly.graph_objs import graph_objs

# Throw exception for non-integer rows and cols

if not isinstance(rows, int) or rows <= 0:

raise Exception("Keyword argument 'rows' "

"must be an int greater than 0")

if not isinstance(cols, int) or cols <= 0:

raise Exception("Keyword argument 'cols' "

"must be an int greater than 0")

# Dictionary of things start_cell

START_CELL_all = {

'bottom-left': {

# 'natural' setup where x & y domains increase monotonically

'col_dir': 1,

'row_dir': 1

},

'top-left': {

# 'default' setup visually matching the 'specs' list of lists

'col_dir': 1,

'row_dir': -1

}

# TODO maybe add 'bottom-right' and 'top-right'

}

# Throw exception for invalid 'start_cell' values

try:

START_CELL = START_CELL_all[start_cell]

except KeyError:

raise Exception("Invalid 'start_cell' value")

# Throw exception if non-valid kwarg is sent

VALID_KWARGS = ['horizontal_spacing', 'vertical_spacing',

'specs', 'insets', 'subplot_titles', 'column_width',

'row_width']

for key in kwargs.keys():

if key not in VALID_KWARGS:

raise Exception("Invalid keyword argument: '{0}'".format(key))

# Set 'subplot_titles'

subplot_titles = kwargs.get('subplot_titles', [""] * rows * cols)

# Set 'horizontal_spacing' / 'vertical_spacing' w.r.t. rows / cols

try:

horizontal_spacing = float(kwargs['horizontal_spacing'])

except KeyError:

horizontal_spacing = 0.2 / cols

try:

vertical_spacing = float(kwargs['vertical_spacing'])

except KeyError:

if 'subplot_titles' in kwargs:

vertical_spacing = 0.5 / rows

else:

vertical_spacing = 0.3 / rows

# Sanitize 'specs' (must be a list of lists)

exception_msg = "Keyword argument 'specs' must be a list of lists"

try:

specs = kwargs['specs']

if not isinstance(specs, list):

raise Exception(exception_msg)

else:

for spec_row in specs:

if not isinstance(spec_row, list):

raise Exception(exception_msg)

except KeyError:

specs = [[{}

for c in range(cols)]

for r in range(rows)] # default 'specs'

# Throw exception if specs is over or under specified

if len(specs) != rows:

raise Exception("The number of rows in 'specs' "

"must be equal to 'rows'")

for r, spec_row in enumerate(specs):

if len(spec_row) != cols:

raise Exception("The number of columns in 'specs' "

"must be equal to 'cols'")

# Sanitize 'insets'

try:

insets = kwargs['insets']

if not isinstance(insets, list):

raise Exception("Keyword argument 'insets' must be a list")

except KeyError:

insets = False

# Throw exception if non-valid key / fill in defaults

def _check_keys_and_fill(name, arg, defaults):

def _checks(item, defaults):

if item is None:

return

if not isinstance(item, dict):

raise Exception("Items in keyword argument '{name}' must be "

"dictionaries or None".format(name=name))

for k in item.keys():

if k not in defaults.keys():

raise Exception("Invalid key '{k}' in keyword "

"argument '{name}'".format(k=k, name=name))

for k in defaults.keys():

if k not in item.keys():

item[k] = defaults[k]

for arg_i in arg:

if isinstance(arg_i, list):

for arg_ii in arg_i:

_checks(arg_ii, defaults)

elif isinstance(arg_i, dict):

_checks(arg_i, defaults)

# Default spec key-values

SPEC_defaults = dict(

is_3d=False,

colspan=1,

rowspan=1,

l=0.0,

r=0.0,

b=0.0,

t=0.0

# TODO add support for 'w' and 'h'

)

_check_keys_and_fill('specs', specs, SPEC_defaults)

# Default inset key-values

if insets:

INSET_defaults = dict(

cell=(1, 1),

is_3d=False,

l=0.0,

w='to_end',

b=0.0,

h='to_end'

)

_check_keys_and_fill('insets', insets, INSET_defaults)

# set heights (with 'column_width')

try:

column_width = kwargs['column_width']

if not isinstance(column_width, list) or len(column_width) != cols:

raise Exception(

"Keyword argument 'column_width' must be a list with {} "

"numbers in it, the number of subplot cols.".format(cols)

)

except KeyError:

column_width = None

if column_width:

cum_sum = float(sum(column_width))

widths = []

for w in column_width:

widths.append(

(1. - horizontal_spacing * (cols - 1)) * (w / cum_sum)

)

else:

widths = [(1. - horizontal_spacing * (cols - 1)) / cols] * cols

# set widths (with 'row_width')

try:

row_width = kwargs['row_width']

if not isinstance(row_width, list) or len(row_width) != rows:

raise Exception(

"Keyword argument 'row_width' must be a list with {} "

"numbers in it, the number of subplot rows.".format(rows)

)

except KeyError:

row_width = None

if row_width:

cum_sum = float(sum(row_width))

heights = []

for h in row_width:

heights.append(

(1. - vertical_spacing * (rows - 1)) * (h / cum_sum)

)

else:

heights = [(1. - vertical_spacing * (rows - 1)) / rows] * rows

# Built row/col sequence using 'row_dir' and 'col_dir'

COL_DIR = START_CELL['col_dir']

ROW_DIR = START_CELL['row_dir']

col_seq = range(cols)[::COL_DIR]

row_seq = range(rows)[::ROW_DIR]

# [grid] Build subplot grid (coord tuple of cell)

grid = [

[

(

(sum(widths[:c]) + c * horizontal_spacing),

(sum(heights[:r]) + r * vertical_spacing)

) for c in col_seq

] for r in row_seq

]