'api_key': '',

'proxy_username': '',

'proxy_password': '',

'api_key': '',

'stream_ids': []},

CONFIG_FILE: {'plotly_domain': 'https://plot.ly',

'plotly_streaming_domain': 'stream.plot.ly',

'plotly_api_domain': 'https://api.plot.ly',

'plotly_ssl_verification': True,

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

if _file_permissions:

for fn in [CREDENTIALS_FILE, CONFIG_FILE]:

utils.ensure_file_exists(fn)

contents = utils.load_json_dict(fn)

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]

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 _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 _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):

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

if not _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

settings = get_config_file()

if isinstance(plotly_domain, six.string_types):

settings['plotly_domain'] = plotly_domain

if isinstance(plotly_streaming_domain, six.string_types):

settings['plotly_streaming_domain'] = plotly_streaming_domain

if isinstance(plotly_api_domain, six.string_types):

settings['plotly_api_domain'] = plotly_api_domain

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

settings['plotly_ssl_verification'] = plotly_ssl_verification

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

settings['plotly_proxy_authorization'] = plotly_proxy_authorization

utils.save_json_dict(CONFIG_FILE, settings)

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

if _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>

padding = 25

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))

head = plotly_rest_url + "/~"

file_owner = url.replace(head, "").split('/')[0]

file_id = url.replace(head, "").split('/')[1]

else:

file_owner = file_owner_or_url

resource = "/apigetfile/{file_owner}/{file_id}".format(file_owner=file_owner,

file_id=file_id)

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 isinstance(width, int):

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

"seamless=\"seamless\" "

"src=\"{plotly_rest_url}/"

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

"?width={plot_width}&height={plot_height}\" "

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

"</iframe>").format(

plotly_rest_url=plotly_rest_url,

file_owner=file_owner, file_id=file_id,

plot_width=width-padding, plot_height=height-padding,

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\" "

"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)

"""Embeds existing Plotly figure in IPython Notebook

try:

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

# see if we are in the SageMath Cloud

from sage_salvus import html

return html(s, hide=False)

except:

pass

if _ipython_imported:

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:

warnings.warn(

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

"If you just want the *embed code*, try using `get_embed()` "

"instead."

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

if _matplotlylib_imported:

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'.

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 = graph_objs.XAxis(domain=[x_start, x_end], anchor=x_anchor)

fig['layout'][xaxis_name] = xaxis

yaxis = graph_objs.YAxis(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

# 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']

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 width & height of each subplot cell (excluding padding)

width = (1. - horizontal_spacing * (cols - 1)) / cols

height = (1. - vertical_spacing * (rows - 1)) / 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 = [[((width + horizontal_spacing) * c,

(height + vertical_spacing) * r)

for c in col_seq]

for r in row_seq]

# [grid_ref] Initialize the grid and insets' axis-reference lists

grid_ref = [[None for c in range(cols)] for r in range(rows)]

insets_ref = [None for inset in range(len(insets))] if insets else None

layout = graph_objs.Layout() # init layout object

# Function handling logic around 2d axis labels

# Returns 'x{}' | 'y{}'

def _get_label(x_or_y, r, c, cnt, shared_axes):

# Default label (given strictly by cnt)

label = "{x_or_y}{cnt}".format(x_or_y=x_or_y, cnt=cnt)

if isinstance(shared_axes, bool):

if shared_axes:

if x_or_y == 'x':

label = "{x_or_y}{c}".format(x_or_y=x_or_y, c=c+1)

if x_or_y == 'y':

label = "{x_or_y}{r}".format(x_or_y=x_or_y, r=r+1)

if isinstance(shared_axes, list):

if isinstance(shared_axes[0], tuple):

shared_axes = [shared_axes] # TODO put this elsewhere

for shared_axis in shared_axes:

if (r+1, c+1) in shared_axis:

label = {

'x': "x{0}".format(shared_axis[0][1]),

'y': "y{0}".format(shared_axis[0][0])

}[x_or_y]

return label

# Row in grid of anchor row if shared_xaxes=True

ANCHOR_ROW = 0 if ROW_DIR > 0 else rows - 1

# Function handling logic around 2d axis anchors

# Return 'x{}' | 'y{}' | 'free' | False

def _get_anchors(r, c, x_cnt, y_cnt, shared_xaxes, shared_yaxes):

# Default anchors (give strictly by cnt)

x_anchor = "y{y_cnt}".format(y_cnt=y_cnt)

y_anchor = "x{x_cnt}".format(x_cnt=x_cnt)

if isinstance(shared_xaxes, bool):

if shared_xaxes:

if r != ANCHOR_ROW:

x_anchor = False

y_anchor = 'free'

if shared_yaxes and c != 0: # TODO covers all cases?

y_anchor = False

return x_anchor, y_anchor

elif isinstance(shared_xaxes, list):

if isinstance(shared_xaxes[0], tuple):

shared_xaxes = [shared_xaxes] # TODO put this elsewhere

for shared_xaxis in shared_xaxes:

if (r+1, c+1) in shared_xaxis[1:]:

x_anchor = False

y_anchor = 'free' # TODO covers all cases?

if isinstance(shared_yaxes, bool):

if shared_yaxes:

if c != 0:

y_anchor = False

x_anchor = 'free'

if shared_xaxes and r != ANCHOR_ROW: # TODO all cases?

x_anchor = False

return x_anchor, y_anchor

elif isinstance(shared_yaxes, list):

if isinstance(shared_yaxes[0], tuple):

shared_yaxes = [shared_yaxes] # TODO put this elsewhere

for shared_yaxis in shared_yaxes:

if (r+1, c+1) in shared_yaxis[1:]:

y_anchor = False

x_anchor = 'free' # TODO covers all cases?

return x_anchor, y_anchor

list_of_domains = [] # added for subplot titles

# Function pasting x/y domains in layout object (2d case)

def _add_domain(layout, x_or_y, label, domain, anchor, position):

name = label[0] + 'axis' + label[1:]

graph_obj = '{X_or_Y}Axis'.format(X_or_Y=x_or_y.upper())

axis = getattr(graph_objs, graph_obj)(domain=domain)

if anchor:

axis['anchor'] = anchor

if isinstance(position, float):

axis['position'] = position

layout[name] = axis

list_of_domains.append(domain) # added for subplot titles

# Function pasting x/y domains in layout object (3d case)

def _add_domain_is_3d(layout, s_label, x_domain, y_domain):

scene = graph_objs.Scene(domain={'x': x_domain, 'y': y_domain})

layout[s_label] = scene

x_cnt = y_cnt = s_cnt = 1 # subplot axis/scene counters

# Loop through specs -- (r, c) <-> (row, col)

for r, spec_row in enumerate(specs):

for c, spec in enumerate(spec_row):

if spec is None: # skip over None cells

continue

c_spanned = c + spec['colspan'] - 1 # get spanned c

r_spanned = r + spec['rowspan'] - 1 # get spanned r

# Throw exception if 'colspan' | 'rowspan' is too large for grid

if c_spanned >= cols:

raise Exception("Some 'colspan' value is too large for "

"this subplot grid.")

if r_spanned >= rows:

raise Exception("Some 'rowspan' value is too large for "

"this subplot grid.")

# Get x domain using grid and colspan

x_s = grid[r][c][0] + spec['l']

x_e = grid[r][c_spanned][0] + width - spec['r']

x_domain = [x_s, x_e]

# Get y domain (dep. on row_dir) using grid & r_spanned

if ROW_DIR > 0: