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

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

credentials = tools.get_credentials_file()

session_credentials = get_session_credentials()

for credentials_key in credentials:

# checking for not false, but truthy value here is the desired behavior

session_value = session_credentials.get(credentials_key)

if session_value is False or session_value:

credentials[credentials_key] = session_value

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

config = tools.get_config_file()

session_config = get_session_config()

for config_key in config:

# checking for not false, but truthy value here is the desired behavior

session_value = session_config.get(config_key)

if session_value is False or session_value:

config[config_key] = session_value

"""

default_plot_options = copy.deepcopy(DEFAULT_PLOT_OPTIONS)

file_options = tools.get_config_file()

session_options = 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', {})

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

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:

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

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

)

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

credentials = get_credentials()

validate_credentials(credentials)

username, api_key = credentials['username'], credentials['api_key']

headers = {'plotly-username': username,

'plotly-apikey': api_key,

'plotly-version': version.__version__,

'plotly-platform': 'python'}

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

)

response = requests.get(plotly_rest_url + resource,

headers=headers,

verify=get_config()['plotly_ssl_verification'])

if response.status_code == 200:

if six.PY3:

content = json.loads(response.content.decode('utf-8'))

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(

"""

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

def __init__(self, stream_id):

"""

self.stream_id = stream_id

self.connected = False

self._stream = None

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

"""

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

)

def open(self):

"""

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

"""

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)

)

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

"""

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

if isinstance(figure_or_data, dict):

figure = figure_or_data

elif isinstance(figure_or_data, list):

figure = {'data': figure_or_data}

else:

raise exceptions.PlotlyEmptyDataError(

"`figure_or_data` must be a dict or a list."

)

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

)

headers = _api_v2.headers()

headers['plotly_version'] = version.__version__

headers['content-type'] = 'application/json'

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

url = _api_v2.api_url('images/')

res = requests.post(

url, data=json.dumps(payload, cls=utils.PlotlyJSONEncoder),

headers=headers, verify=get_config()['plotly_ssl_verification'],

)

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,

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

"""

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

verify=get_config()['plotly_ssl_verification'])

_api_v2.response_handler(res)

"""

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

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

'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(),

verify=get_config()['plotly_ssl_verification'])

res = _api_v2.response_handler(req)

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

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

grid_url = res['file']['web_url']

# 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

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)

}