filename="plot from API",

fileopt="new",

world_readable=True,

auto_open=True,

"""Set module-scoped _credentials for session. Optionally, set config info.

_credentials['username'], _credentials['api_key'] = username, api_key

# TODO: verify these _credentials with plotly

_config['plotly_domain'] = kwargs.get('plotly_domain')

_config['plotly_streaming_domain'] = kwargs.get('plotly_streaming_domain')

_config['plotly_api_domain'] = kwargs.get('plotly_api_domain')

""" Returns a copy of the user supplied plot options.

"""Returns the credentials that will be sent to plotly."""

credentials = tools.get_credentials_file()

for credentials_key in credentials:

if _credentials.get(credentials_key):

credentials[credentials_key] = _credentials[credentials_key]

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

res = plot(figure_or_data, **plot_options)

urlsplit = res.split('/')

username, plot_id = urlsplit[-2][1:], urlsplit[-1] # TODO: HACKY!

embed_options = dict()

if 'width' in plot_options:

embed_options['width'] = plot_options['width']

if 'height' in plot_options:

embed_options['height'] = plot_options['height']

"""Sets plot_options via a precedence hierarchy."""

options = dict()

options.update(_DEFAULT_PLOT_OPTIONS)

options.update(_plot_options)

options.update(plot_options)

if ('filename' in plot_options

and 'fileopt' not in _plot_options

and 'fileopt' not in plot_options):

options['fileopt'] = 'overwrite'

"""Returns either module config or file config."""

config = tools.get_config_file()

for config_key in config:

if _config.get(config_key):

config[config_key] = _config[config_key]

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

if isinstance(figure_or_data, dict):

figure = figure_or_data

elif isinstance(figure_or_data, list):

figure = {'data': figure_or_data}

else:

raise exceptions.PlotlyError("The `figure_or_data` positional argument "

"must be either `dict`-like or "

"`list`-like.")

if validate:

try:

tools.validate(figure, obj_type='Figure')

except exceptions.PlotlyError as err:

raise exceptions.PlotlyError("Invalid 'figure_or_data' argument. "

"Plotly will not be able to properly "

"parse the resulting JSON. If you "

"want to send this 'figure_or_data' "

"to Plotly anyway (not recommended), "

"you can set 'validate=False' as a "

"plot option.\nHere's why you're "

"seeing this error:\n\n{0}"

"".format(err))

if not figure['data']:

raise exceptions.PlotlyEmptyDataError(

"Empty data list found. Make sure that you populated the "

"list of data objects you're sending and try again.\n"

"Questions? support@plot.ly"

)

for entry in figure['data']:

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

try:

if len(val) > 40000:

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

"browser limitations, Plotly has 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) Trying using the image API to return an image "

"instead of a graph URL\n"

"(2) Use matplotlib\n"

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

res = _send_to_plotly(figure, **plot_options)

if res['error'] == '':

if plot_options['auto_open']:

_open_url(res['url'])

return res['url']

else:

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

try:

fig.update(update)

fig.validate()

except exceptions.PlotlyGraphObjectError as err:

err.add_note("Your updated figure could not be properly validated.")

err.prepare()

raise

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

try:

fig.update(update)

fig.validate()

except exceptions.PlotlyGraphObjectError as err:

err.add_note("Your updated figure could not be properly validated.")

err.prepare()

raise

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

)

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

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

file_id=file_id)

(username, api_key) = _validation_key_logic()

headers = {'plotly-username': username,

'plotly-apikey': api_key,

'plotly-version': version.__version__,

'plotly-platform': 'python'}

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

)

response = requests.get(plotly_rest_url + resource, headers=headers)

if response.status_code == 200:

if six.PY3:

content = json.loads(response.content.decode('unicode_escape'))

else:

content = json.loads(response.content)

response_payload = content['payload']

figure = response_payload['figure']

utils.decode_unicode(figure)

if raw:

return figure

else:

return tools.get_valid_graph_obj(figure, obj_type='Figure')

else:

try:

content = json.loads(response.content)

raise exceptions.PlotlyError(content)

except:

raise exceptions.PlotlyError(

""" Interface to Plotly's real-time graphing API.

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

def __init__(self, stream_id):

""" Initialize a Stream object with your unique stream_id.

self.stream_id = stream_id

self.connected = False

def open(self):

"""Open streaming connection to plotly.

streaming_url = get_config()['plotly_streaming_domain']

self._stream = chunked_requests.Stream(streaming_url,

80,

{'Host': streaming_url,

'plotly-streamtoken': self.stream_id})

def write(self, trace, layout=None, validate=True,

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

"""Write to an open stream.

stream_object = dict()

stream_object.update(trace)

if 'type' not in stream_object:

stream_object['type'] = 'scatter'

if validate:

try:

tools.validate(stream_object, stream_object['type'])

except exceptions.PlotlyError as err:

raise exceptions.PlotlyError(

"Part of the data object with type, '{0}', is invalid. "

"This will default to 'scatter' if you do not supply a "

"'type'. If you do not want to validate your data objects "

"when streaming, you can set 'validate=False' in the call "

"to 'your_stream.write()'. Here's why the object is "

"invalid:\n\n{1}".format(stream_object['type'], err)

)

try:

tools.validate_stream(stream_object, stream_object['type'])

except exceptions.PlotlyError as err:

raise exceptions.PlotlyError(

"Part of the data object with type, '{0}', cannot yet be "

"streamed into Plotly. If you do not want to validate your "

"data objects when streaming, you can set 'validate=False' "

"in the call to 'your_stream.write()'. Here's why the "

"object cannot be streamed:\n\n{1}"

"".format(stream_object['type'], err)

)

if layout is not None:

try:

tools.validate(layout, 'Layout')

except exceptions.PlotlyError as err:

raise exceptions.PlotlyError(

"Your layout kwarg was invalid. "

"Here's why:\n\n{0}".format(err)

)

del stream_object['type']

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

""" Close the stream connection to plotly's streaming servers.

try:

self._stream.close()

except AttributeError:

''' Helper functions wrapped around plotly's static image generation api.

@staticmethod

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

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

if isinstance(figure_or_data, dict):

figure = figure_or_data

elif isinstance(figure_or_data, list):

figure = {'data': figure_or_data}

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

(username, api_key) = _validation_key_logic()

headers = {'plotly-username': username,

'plotly-apikey': api_key,

'plotly-version': version.__version__,

'plotly-platform': 'python'}

payload = {

'figure': figure,

'format': format

}

if width is not None:

payload['width'] = width

if height is not None:

payload['height'] = height

url = get_config()['plotly_domain'] + "/apigenimage/"

res = requests.post(url,

data=json.dumps(payload,

cls=utils._plotlyJSONEncoder),

headers=headers)

headers = res.headers

if res.status_code == 200:

if ('content-type' in headers and

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

'application/pdf',

'image/svg+xml']):

return res.content

elif ('content-type' in headers and

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

return_data = json.loads(res.content)

return return_data['image']

else:

try:

if ('content-type' in headers and

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

return_data = json.loads(res.content)

else:

return_data = {'error': res.content}

except:

raise exceptions.PlotlyError("The response "

"from plotly could "

"not be translated.")

raise exceptions.PlotlyError(return_data['error'])

@classmethod

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

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

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)

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

""" Save a static image of the plot described by `figure` locally as `filename`.

(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

else:

filename += '.'+format

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

f = open(filename, 'wb')

f.write(img)

""" Interface to Plotly's File System API

@classmethod

def mkdirs(cls, folder_path):

""" Create folder(s) specified by folder_path

# trim trailing slash TODO: necessesary?

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

folder_path = folder_path[0:-1]

payload = {

'path': folder_path

}

url = _api_v2.api_url('folders')

res = requests.post(url, data=payload, headers=_api_v2.headers())

_api_v2.response_handler(res)

""" Interface to Plotly's Grid API.

@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 = '{}/{}'.format(grid_id, resp_col['uid'])

response_columns.remove(resp_col)

@classmethod

def upload(cls, grid, filename,

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

""" Upload a grid to your Plotly account with the specified filename.

# 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,

'data': json.dumps(grid_json, cls=utils._plotlyJSONEncoder),

'world_readable': world_readable

}

if parent_path != '':

payload['parent_path'] = parent_path

upload_url = _api_v2.api_url('grids')

req = requests.post(upload_url, data=payload,

headers=_api_v2.headers())

res = _api_v2.response_handler(req)

response_columns = res['file']['cols']

grid_id = res['file']['fid']

# mutate the grid columns with the id's returned from the server

cls._fill_in_response_column_ids(grid, response_columns, grid_id)

grid.id = grid_id

plotly_domain = get_config()['plotly_domain']

grid_url = '{}/~{}'.format(plotly_domain, grid_id.replace(':', '/'))

if meta is not None:

meta_ops.upload(meta, grid=grid)

if auto_open:

_open_url(grid_url)

return grid_url

@classmethod

def append_columns(cls, columns, grid=None, grid_url=None):

'''

grid_id = _api_v2.parse_grid_id_args(grid, grid_url)

# Verify unique column names

column_names = [c.name for c in columns]

if grid:

existing_column_names = [c.name for c in grid]

column_names.extend(existing_column_names)

duplicate_name = utils.get_first_duplicate(column_names)

if duplicate_name:

err = exceptions.NON_UNIQUE_COLUMN_MESSAGE.format(duplicate_name)

raise exceptions.InputError(err)

payload = {

'cols': json.dumps(columns, cls=utils._plotlyJSONEncoder)

}

api_url = _api_v2.api_url('grids')+'/{grid_id}/col'.format(grid_id=grid_id)

res = requests.post(api_url, data=payload, headers=_api_v2.headers())

res = _api_v2.response_handler(res)

cls._fill_in_response_column_ids(columns, res['cols'], grid_id)

if grid:

grid.extend(columns)

@classmethod

def append_rows(cls, rows, grid=None, grid_url=None):

'''

grid_id = _api_v2.parse_grid_id_args(grid, grid_url)

if grid:

n_columns = len([column for column in grid])

for row_i, row in enumerate(rows):

if len(row) != n_columns:

raise exceptions.InputError(

"The number of entries in "

"each row needs to equal the number of columns in "

"the grid. Row {} has {} {} but your "

"grid has {} {}. "

.format(row_i, len(row),

'entry' if len(row) == 1 else 'entries',

n_columns,

'column' if n_columns == 1 else 'columns'))

payload = {

'rows': json.dumps(rows, cls=utils._plotlyJSONEncoder)

}

api_url = (_api_v2.api_url('grids')+

'/{grid_id}/row'.format(grid_id=grid_id))

res = requests.post(api_url, data=payload, headers=_api_v2.headers())

_api_v2.response_handler(res)

if grid:

longest_column_length = max([len(col.data) for col in grid])

for column in grid:

n_empty_rows = longest_column_length - len(column.data)

empty_string_rows = ['' for _ in range(n_empty_rows)]

column.data.extend(empty_string_rows)

column_extensions = zip(*rows)

for local_column, column_extension in zip(grid, column_extensions):

local_column.data.extend(column_extension)

@classmethod

def delete(cls, grid=None, grid_url=None):

'''