'filename': "plot from API",

'fileopt': "new",

'world_readable': files.FILE_CONTENT[files.CONFIG_FILE]['world_readable'],

'auto_open': files.FILE_CONTENT[files.CONFIG_FILE]['auto_open'],

'validate': True,

'sharing': files.FILE_CONTENT[files.CONFIG_FILE]['sharing']

session.sign_in(username, api_key, **kwargs)

try:

# The only way this can succeed is if the user can be authenticated

# with the given, username, api_key, and plotly_api_domain.

v2.users.current()

except exceptions.PlotlyRequestError:

"""

default_plot_options = copy.deepcopy(DEFAULT_PLOT_OPTIONS)

file_options = tools.get_config_file()

session_options = session.get_session_plot_options()

plot_options_from_call_signature = copy.deepcopy(plot_options_from_call_signature)

# Validate options and fill in defaults w world_readable and sharing

for option_set in [plot_options_from_call_signature,

session_options, file_options]:

utils.validate_world_readable_and_sharing_settings(option_set)

utils.set_sharing_and_world_readable(option_set)

# dynamic defaults

if ('filename' in option_set and

'fileopt' not in option_set):

option_set['fileopt'] = 'overwrite'

user_plot_options = {}

user_plot_options.update(default_plot_options)

user_plot_options.update(file_options)

user_plot_options.update(session_options)

user_plot_options.update(plot_options_from_call_signature)

user_plot_options = {k: v for k, v in user_plot_options.items()

if k in default_plot_options}

"""Create a unique url for this plot in Plotly and open in IPython.

if 'auto_open' not in plot_options:

plot_options['auto_open'] = False

url = plot(figure_or_data, **plot_options)

if isinstance(figure_or_data, dict):

layout = figure_or_data.get('layout', {})

if isinstance(layout, BaseLayoutType):

layout = layout.to_plotly_json()

elif isinstance(figure_or_data, BaseFigure):

layout = figure_or_data.layout.to_plotly_json()

else:

layout = {}

embed_options = dict()

embed_options['width'] = layout.get('width', '100%')

embed_options['height'] = layout.get('height', 525)

try:

float(embed_options['width'])

except (ValueError, TypeError):

pass

else:

embed_options['width'] = str(embed_options['width']) + 'px'

try:

float(embed_options['height'])

except (ValueError, TypeError):

pass

else:

embed_options['height'] = str(embed_options['height']) + 'px'

"""Create a unique url for this plot in Plotly and optionally open url.

figure = tools.return_figure_from_figure_or_data(figure_or_data, validate)

for entry in figure['data']:

if ('type' in entry) and (entry['type'] == 'scattergl'):

continue

for key, val in list(entry.items()):

try:

if len(val) > 40000:

msg = ("Woah there! Look at all those points! Due to "

"browser limitations, the Plotly SVG drawing "

"functions have a hard time "

"graphing more than 500k data points for line "

"charts, or 40k points for other types of charts. "

"Here are some suggestions:\n"

"(1) Use the `plotly.graph_objs.Scattergl` "

"trace object to generate a WebGl graph.\n"

"(2) Trying using the image API to return an image "

"instead of a graph URL\n"

"(3) Use matplotlib\n"

"(4) See if you can create your visualization with "

"fewer data points\n\n"

"If the visualization you're using aggregates "

"points (e.g., box plot, histogram, etc.) you can "

"disregard this warning.")

warnings.warn(msg)

except TypeError:

pass

plot_options = _plot_option_logic(plot_options)

fig = tools._replace_newline(figure) # does not mutate figure

data = fig.get('data', [])

plot_options['layout'] = fig.get('layout', {})

response = v1.clientresp(data, **plot_options)

# Check if the url needs a secret key

url = response.json()['url']

if plot_options['sharing'] == 'secret':

if 'share_key=' not in url:

# add_share_key_to_url updates the url to include the share_key

url = add_share_key_to_url(url)

if plot_options['auto_open']:

_open_url(url)

**plot_options):

"""Replot a matplotlib figure with plotly in IPython.

fig = tools.mpl_to_plotly(fig, resize=resize, strip_style=strip_style)

if update and isinstance(update, dict):

fig.update(update)

fig.validate()

elif update is not None:

raise exceptions.PlotlyGraphObjectError(

"'update' must be dictionary-like and a valid plotly Figure "

"object. Run 'help(plotly.graph_objs.Figure)' for more info."

)

"""Replot a matplotlib figure with plotly.

fig = tools.mpl_to_plotly(fig, resize=resize, strip_style=strip_style)

if update and isinstance(update, dict):

fig.update(update)

elif update is not None:

raise exceptions.PlotlyGraphObjectError(

"'update' must be dictionary-like and a valid plotly Figure "

"object. Run 'help(plotly.graph_objs.Figure)' for more info."

)

"""Swap obj[key1] with obj[key2]"""

val1, val2 = None, None

try:

val2 = obj.pop(key1)

except KeyError:

pass

try:

val1 = obj.pop(key2)

except KeyError:

pass

if val2 is not None:

obj[key2] = val2

if val1 is not None:

"""Swap x and y data and references"""

swaps = [('x', 'y'),

('x0', 'y0'),

('dx', 'dy'),

('xbins', 'ybins'),

('nbinsx', 'nbinsy'),

('autobinx', 'autobiny'),

('error_x', 'error_y')]

for swap in swaps:

_swap_keys(data_obj, swap[0], swap[1])

try:

rows = len(data_obj['z'])

cols = len(data_obj['z'][0])

for row in data_obj['z']:

if len(row) != cols:

raise TypeError

# if we can't do transpose, we hit an exception before here

z = data_obj.pop('z')

data_obj['z'] = [[0 for rrr in range(rows)] for ccc in range(cols)]

for iii in range(rows):

for jjj in range(cols):

data_obj['z'][jjj][iii] = z[iii][jjj]

except (KeyError, TypeError, IndexError) as err:

warn = False

try:

if data_obj['z'] is not None:

warn = True

if len(data_obj['z']) == 0:

warn = False

except (KeyError, TypeError):

pass

if warn:

warnings.warn(

"Data in this file required an 'xy' swap but the 'z' matrix "

"in one of the data objects could not be transposed. Here's "

"why:\n\n{}".format(repr(err))

"""Convert unicode strings in JSON object to byte strings"""

if isinstance(input, dict):

return {byteify(key): byteify(value)

for key, value in input.iteritems()}

elif isinstance(input, list):

return [byteify(element) for element in input]

elif isinstance(input, unicode):

return input.encode('utf-8')

else:

"""Returns a JSON figure representation for the specified file

plotly_rest_url = get_config()['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

try:

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

)

fid = '{}:{}'.format(file_owner, file_id)

response = v2.plots.content(fid, inline_data=True)

figure = response.json()

if six.PY2:

figure = byteify(figure)

# Fix 'histogramx', 'histogramy', and 'bardir' stuff

for index, entry in enumerate(figure['data']):

try:

# Use xbins to bin data in x, and ybins to bin data in y

if all((entry['type'] == 'histogramy', 'xbins' in entry,

'ybins' not in entry)):

entry['ybins'] = entry.pop('xbins')

# Convert bardir to orientation, and put the data into the axes

# it's eventually going to be used with

if entry['type'] in ['histogramx', 'histogramy']:

entry['type'] = 'histogram'

if 'bardir' in entry:

entry['orientation'] = entry.pop('bardir')

if entry['type'] == 'bar':

if entry['orientation'] == 'h':

_swap_xy_data(entry)

if entry['type'] == 'histogram':

if ('x' in entry) and ('y' not in entry):

if entry['orientation'] == 'h':

_swap_xy_data(entry)

del entry['orientation']

if ('y' in entry) and ('x' not in entry):

if entry['orientation'] == 'v':

_swap_xy_data(entry)

del entry['orientation']

figure['data'][index] = entry

except KeyError:

pass

# Remove stream dictionary if found in a data trace

# (it has private tokens in there we need to hide!)

for index, entry in enumerate(figure['data']):

if 'stream' in entry:

del figure['data'][index]['stream']

if raw:

return figure

"""

HTTP_PORT = 80

HTTPS_PORT = 443

@utils.template_doc(**tools.get_config_file())

def __init__(self, stream_id):

"""

self.stream_id = stream_id

self._stream = None

def get_streaming_specs(self):

"""

streaming_url = get_config()['plotly_streaming_domain']

ssl_verification_enabled = get_config()['plotly_ssl_verification']

ssl_enabled = 'https' in streaming_url

port = self.HTTPS_PORT if ssl_enabled else self.HTTP_PORT

# If no scheme (https/https) is included in the streaming_url, the

# host will be None. Use streaming_url in this case.

host = (six.moves.urllib.parse.urlparse(streaming_url).hostname or

streaming_url)

headers = {'Host': host, 'plotly-streamtoken': self.stream_id}

streaming_specs = {

'server': host,

'port': port,

'ssl_enabled': ssl_enabled,

'ssl_verification_enabled': ssl_verification_enabled,

'headers': headers

}

return streaming_specs

def heartbeat(self, reconnect_on=(200, '', 408, 502)):

"""

try:

self._stream.write('\n', reconnect_on=reconnect_on)

except AttributeError:

raise exceptions.PlotlyError(

"Stream has not been opened yet, "

"cannot write to a closed connection. "

"Call `open()` on the stream to open the stream."

)

@property

def connected(self):

if self._stream is None:

return False

return self._stream._isconnected()

def open(self):

"""

streaming_specs = self.get_streaming_specs()

self._stream = chunked_requests.Stream(**streaming_specs)

def write(self, trace, layout=None,

reconnect_on=(200, '', 408, 502)):

"""

# Convert trace objects to dictionaries

if isinstance(trace, BaseTraceType):

stream_object = trace.to_plotly_json()

else:

stream_object = copy.deepcopy(trace)

# Remove 'type' if present since this trace type cannot be changed

stream_object.pop('type', None)

if layout is not None:

stream_object.update(dict(layout=layout))

# TODO: allow string version of this?

jdata = _json.dumps(stream_object, cls=utils.PlotlyJSONEncoder)

jdata += "\n"

try:

self._stream.write(jdata, reconnect_on=reconnect_on)

except AttributeError:

raise exceptions.PlotlyError(

"Stream has not been opened yet, "

"cannot write to a closed connection. "

"Call `open()` on the stream to open the stream.")

def close(self):

"""

try:

self._stream.close()

except AttributeError:

"""

@staticmethod

def get(figure_or_data, format='png', width=None, height=None, scale=None):

"""Return a static image of the plot described by `figure_or_data`.

# TODO: format is a built-in name... we shouldn't really use it

figure = tools.return_figure_from_figure_or_data(figure_or_data, True)

if format not in ['png', 'svg', 'jpeg', 'pdf']:

raise exceptions.PlotlyError(

"Invalid format. This version of your Plotly-Python "

"package currently only supports png, svg, jpeg, and pdf. "

"Learn more about image exporting, and the currently "

"supported file types here: "

"https://plot.ly/python/static-image-export/"

)

if scale is not None:

try:

scale = float(scale)

except:

raise exceptions.PlotlyError(

"Invalid scale parameter. Scale must be a number."

)

payload = {'figure': figure, 'format': format}

if width is not None:

payload['width'] = width

if height is not None:

payload['height'] = height

if scale is not None:

payload['scale'] = scale

response = v2.images.create(payload)

headers = response.headers

if ('content-type' in headers and

headers['content-type'] in ['image/png', 'image/jpeg',

'application/pdf',

'image/svg+xml']):

return response.content

elif ('content-type' in headers and

'json' in headers['content-type']):

return response.json()['image']

@classmethod

def ishow(cls, figure_or_data, format='png', width=None, height=None,

scale=None):

"""Display a static image of the plot described by `figure_or_data`

if format == 'pdf':

raise exceptions.PlotlyError(

"Aw, snap! "

"It's not currently possible to embed a pdf into "

"an IPython notebook. You can save the pdf "

"with the `image.save_as` or you can "

"embed an png, jpeg, or svg.")

img = cls.get(figure_or_data, format, width, height, scale)

from IPython.display import display, Image, SVG

if format == 'svg':

display(SVG(img))

else:

display(Image(img))

@classmethod

def save_as(cls, figure_or_data, filename, format=None, width=None,

height=None, scale=None):

"""Save a image of the plot described by `figure_or_data` locally as

# todo: format shadows built-in name

(base, ext) = os.path.splitext(filename)

if not ext and not format:

filename += '.png'

elif ext and not format:

format = ext[1:]

elif not ext and format:

filename += '.' + format

img = cls.get(figure_or_data, format, width, height, scale)

f = open(filename, 'wb')

f.write(img)

"""

@classmethod

def mkdirs(cls, folder_path):

"""

response = v2.folders.create({'path': folder_path})

"""

@classmethod

def _fill_in_response_column_ids(cls, request_columns,

response_columns, grid_id):

for req_col in request_columns:

for resp_col in response_columns:

if resp_col['name'] == req_col.name:

req_col.id = '{0}:{1}'.format(grid_id, resp_col['uid'])

response_columns.remove(resp_col)

@staticmethod

def ensure_uploaded(fid):

if fid:

return

raise exceptions.PlotlyError(

'This operation requires that the grid has already been uploaded '

'to Plotly. Try `uploading` first.'

)

@classmethod

def upload(cls, grid, filename,

world_readable=True, auto_open=True, meta=None):

"""

# Make a folder path

if filename[-1] == '/':

filename = filename[0:-1]

paths = filename.split('/')

parent_path = '/'.join(paths[0:-1])

filename = paths[-1]

if parent_path != '':

file_ops.mkdirs(parent_path)

# transmorgify grid object into plotly's format

grid_json = grid._to_plotly_grid_json()

if meta is not None:

grid_json['metadata'] = meta

payload = {

'filename': filename,