filename="plot from API",

fileopt="new",

world_readable=True,

auto_open=True,

"""Set module-scoped _credentials for session. Verify with plotly."""

global _credentials

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

""" Update the module-level _plot_options

global _plot_options

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

global _plot_options

""" Returns a copy of the user supplied credentials.

global _credentials

if ('username' in _credentials) and ('api_key' in _credentials):

return copy.copy(_credentials)

else:

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

"""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{}".format(err))

for entry in figure['data']:

for key, val in 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']:

try:

from webbrowser import open as wbopen

wbopen(res['url'])

except: # TODO: what should we except here? this is dangerous

pass

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 = tools.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, '{}', we expected it to start with '{}'."

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

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 = tools.get_config_file()['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, '{}', 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{}".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, '{}', 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{}"

"".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{}".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 = tools.get_config_file()['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)

"""

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

data = json.dumps(fig['data'] if 'data' in fig else [],

cls=utils._plotlyJSONEncoder)

file_credentials = tools.get_credentials_file()

if ('username' in _credentials) and ('api_key' in _credentials):

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

elif ('username' in file_credentials) and ('api_key' in file_credentials):

(username, api_key) = (file_credentials['username'],

file_credentials['api_key'])

else:

raise exceptions.PlotlyLocalCredentialsError()

kwargs = json.dumps(dict(filename=plot_options['filename'],

fileopt=plot_options['fileopt'],

world_readable=plot_options['world_readable'],

layout=fig['layout'] if 'layout' in fig

else {}),

cls=utils._plotlyJSONEncoder)

payload = dict(platform='python', # TODO: It'd be cool to expose the platform for RaspPi and others

version=version.__version__,

args=data,

un=username,

key=api_key,

origin='plot',

kwargs=kwargs)

url = tools.get_config_file()['plotly_domain'] + "/clientresp"

r = requests.post(url, data=payload)

r.raise_for_status()

r = json.loads(r.text)

if 'error' in r and r['error'] != '':

print(r['error'])

if 'warning' in r and r['warning'] != '':

warnings.warn(r['warning'])

if 'message' in r and r['message'] != '':

print(r['message'])

creds_on_file = tools.get_credentials_file()

if 'username' in _credentials:

username = _credentials['username']

elif 'username' in creds_on_file:

username = creds_on_file['username']

else:

username = None

if 'api_key' in _credentials:

api_key = _credentials['api_key']

elif 'api_key' in creds_on_file:

api_key = creds_on_file['api_key']

else:

api_key = None

if username is None or api_key is None:

raise exceptions.PlotlyLocalCredentialsError()