'filename': "plot from API",

'fileopt': "new",

'world_readable': True,

'auto_open': True,

'validate': True

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

"""

plot_options = copy.deepcopy(DEFAULT_PLOT_OPTIONS)

session_plot_options = get_session_plot_options()

for plot_option_key in plot_options:

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

session_value = session_plot_options.get(plot_option_key)

if session_value is False or session_value:

plot_options[plot_option_key] = session_value

"""

session_plot_options = get_session_plot_options()

current_plot_options = get_plot_options()

current_plot_options.update(plot_options)

if (('filename' in plot_options or 'filename' in session_plot_options) and

'fileopt' not in session_plot_options and

'fileopt' not in plot_options):

current_plot_options['fileopt'] = 'overwrite'

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

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

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

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(

"""

linear_back_off_rate = 0.250 # additional seconds per retry

linear_wait_max = 16 # seconds

exponential_back_off_base = 5 # base for exponentiation

exponential_wait_max = 320 # seconds

eol = '\r\n' # end of line character for our http communication

def __init__(self, token, ignore_status_codes=(None, 200),

ignore_errors=(), queue_length=500, initial_write_timeout=4):

"""

self.token = token

self.ignore_status_codes = ignore_status_codes

self.ignore_errors = ignore_errors

self.queue_length = queue_length

self.initial_write_timeout = initial_write_timeout

self._queue = deque(maxlen=self.queue_length) # prevent memory leaks

self._last_beat = None

self._connect_errors = 0

self._last_connect_error = time.time()

self._disconnections = 0

self._last_disconnection = time.time()

self._thread = None

self._reader = None

self._writer = None

self._error = None

self._response = None

# hold reference to germain credentials/config at instantiation time.

self.host = get_config()['plotly_streaming_domain']

self.port = 80

self._headers = {'Plotly-Streamtoken': self.token, 'Host': self.host,

'Transfer-Encoding': 'chunked',

'Content-Type': 'text/plain'}

def _reset(self):

"""Prep some attributes to reconnect."""

self._response = None

self._error = None

self._last_beat = None

self._reader = None

self._writer = None

def _back_off_linearly(self):

"""Back off linearly if connect exceptions are thrown in the thread."""

now = time.time()

if now - self._last_connect_error > self.linear_wait_max * 2:

self._connect_errors = 0

self._last_connect_error = now

self._connect_errors += 1

wait_time = self._connect_errors * self.linear_back_off_rate

if wait_time > self.linear_wait_max:

raise exceptions.TooManyConnectFailures

else:

time.sleep(wait_time)

def _back_off_exponentially(self):

"""Back off exponentially if peer keeps disconnecting."""

now = time.time()

if now - self._last_disconnection > self.exponential_wait_max * 2:

self._disconnections = 0

self._last_disconnection = now

self._disconnections += 1

wait_time = self.exponential_back_off_base ** self._disconnections

if wait_time > self.exponential_wait_max:

raise exceptions.TooManyConnectFailures

else:

time.sleep(wait_time)

def _raise_for_response(self):

"""If we got a response, the server disconnected. Possibly raise."""

if self._response is None:

return

try:

response = self.response

message = response.read()

status = response.status

except (AttributeError, six.moves.http_client.BadStatusLine):

message = ''

status = None

if status not in self.ignore_status_codes:

raise exceptions.ClosedConnection(message, status_code=status)

# if we didn't raise here, we need to at least back off

if status >= 500:

self._back_off_linearly() # it's the server's fault.

else:

self._back_off_exponentially() # it's the client's fault.

def _raise_for_error(self):

"""If there was an error during reading/writing, possibly raise."""

if self._error is None:

return

if not isinstance(self._error, self.ignore_errors):

raise self._error

# if we didn't raise here, we need to at least back off

if isinstance(self._error, socket.error):

self._back_off_linearly()

# TODO: do we need to dive into the socket error numbers here?

def _check_pulse(self):

"""Streams get shut down after 60 seconds of inactivity."""

self._last_beat = self._last_beat or time.time()

now = time.time()

if now - self._last_beat > 30:

self._last_beat = now

if not self._queue:

self.write('')

def _initial_write(self):

"""Write our request-line and readers with a blank body."""

self._writer.write('POST / HTTP/1.1')

self._writer.write(self.eol)

for header, header_value in self._headers.items():

self._writer.write('{}: {}'.format(header, header_value))

self._writer.write(self.eol)

self._writer.write(self.eol)

def _write(self):

"""Check the queue, if it's not empty, write a chunk!"""

if self._queue:

self._chunk = self._queue.pop()

hex_len = format(len(self._chunk), 'x')

self._writer.write()

message = '{}\r\n{}\r\n'.format(hex_len, self._chunk)

self._writer.write(message.encode('utf-8'))

@trollius.coroutine

def _read(self, timeout=0.01):

"""

try:

data = yield From(trollius.wait_for(self._reader.read(),

timeout=timeout))

except TimeoutError:

data = None

# This is how we return from coroutines with trollius

raise Return(data)

@trollius.coroutine

def _read_write(self):

"""

try:

# open up a connection and get our StreamReader/StreamWriter

current_thread = threading.current_thread()

self._reader, self._writer = yield From(trollius.wait_for(

trollius.open_connection(self.host, self.port), timeout=60

))

# wait for an initial failure response, e.g., bad headers

self._initial_write()

self._response = yield From(self._read(self.initial_write_timeout))

# read/write until server responds or thread is disconnected.

while self._response is None and current_thread.connected:

self._check_pulse()

self._response = yield From(self._read()) # usually just None.

self._write()

except Exception as e:

self._error = e

finally:

if self._writer:

self._writer.close()

def _thread_func(self, loop):

"""

trollius.set_event_loop(loop)

loop.run_until_complete(self._read_write())

@property

def connected(self):

"""Returns state of the StreamWriter's thread."""

return self._thread and self._thread.isAlive()

@property

def response(self):

"""Return a response object parsed from server string response."""

if self._response is None:

return None

return HttpResponseParser(self._response).get_response()

def open(self):

"""

if self.connected:

return

# if we've previously hit a failure, we should let the user know

self._raise_for_response()

self._raise_for_error()

# reset our error, response, pulse information, etc.

self._reset()

# start up a new daemon thread

loop = trollius.get_event_loop()

self._thread = DisconnectThread(target=self._thread_func, args=(loop,))

self._thread.setDaemon(True)

self._thread.start()

def write(self, chunk):

"""

if not self.connected:

self.open()

if not isinstance(chunk, six.string_types):

chunk = json.dumps(chunk, cls=utils.PlotlyJSONEncoder)

self._queue.appendleft(chunk + '\n') # needs at least 1 trailing '\n'

def close(self):

"""

if not self.connected:

return

self._thread.disconnect() # lets thread know to stop communicating

"""

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

)

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

"""

try:

self._stream.close()

except AttributeError:

"""

@staticmethod

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

"""

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

)

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

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

"""

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

"""

# 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

else:

filename += '.'+format

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

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

}