def initPlot(stream_id1, stream_id2, graph_title, max_points=8000):
print("Plotly Version=" + plotly.__version__)
print("Setting plotly credentials...")
tls.set_credentials_file(username=PLOTLY_USERNAME, api_key=PLOTLY_API_KEY)
#stream_ids = tls.get_credentials_file()['stream_ids']
## 1. SETUP STREAM_ID OBJECT
# Make instance of stream id object
stream_1 = go.Stream(
token=stream_id1, # link stream id to 'token' key
#maxpoints=max_points # keep a max of 80 pts on screen
)
stream_2 = go.Stream(
token=stream_id2, # link stream id to 'token' key
#maxpoints=max_points # keep a max of 80 pts on screen
)
# Initialize trace of streaming plot_init by embedding the unique stream_id
trace1 = go.Scatter(
x=[],
y=[],
name='高溫',
mode='lines+markers+text',
line=dict(shape='spline', color='rgb(255, 128, 0)'),
stream=stream_1 # (!) embed stream id, 1 per trace
)
trace2 = go.Scatter(
x=[],
y=[],
name='低溫',
mode='lines+markers+text',
line=dict(shape='spline', color='rgb(102, 178, 255)'),
stream=stream_2 # (!) embed stream id, 1 per trace
)
data = go.Data([trace1, trace2])
# Add title to layout object
layout = go.Layout(title=graph_title,
xaxis=dict(title='日期 (年/月/日)',
showgrid=False,
showline=True,
linewidth=2,
tickwidth=2),
yaxis=dict(
title='溫度 (°C)',
showgrid=True,
showline=False,
))
# Make a figure object
fig = go.Figure(data=data, layout=layout)
# Send fig to Plotly, initialize streaming plot_init, open new tab
py.plot(fig, filename=graph_title)
def initialize_graph():
global stream_1
global s
tls.set_credentials_file(username='******',
api_key='9pjer55x5e',
stream_ids=['efzmil96bw'])
stream_id = tls.get_credentials_file()['stream_ids'][0]
stream_1 = go.Stream(
token=stream_id, # link stream id to 'token' key
maxpoints=80 # keep a max of 80 pts on screen
)
# pick up where we left off
x_data = ab.get_column('time', 'prices', 'test_table.sqlite')
y_data = ab.get_column('last', 'prices', 'test_table.sqlite')
# some magic that makes the plot and uploads it to the plotly hosting site
trace0 = go.Scatter(x=x_data, y=y_data, stream=stream_1)
data = [trace0]
layout = go.Layout(xaxis=dict(showticklabels=False))
fig = go.Figure(data=data, layout=layout)
unique_url = py.plot(fig, filename='basic-line', auto_open=False)
# open stream connection
s = py.Stream(stream_id)
s.open()
def setup_metric_streams(self, local_stream_ids, metric_name, num_channels):
for i in range(num_channels):
stream_id = local_stream_ids[i]
self.stream_ids.append(stream_id)
py_stream = py.Stream(stream_id)
py_stream.open()
self.py_streams.append(py_stream)
go_stream = go.Stream(token=stream_id, maxpoints=self.max_points)
self.go_streams.append(go_stream)
traces = []
for i in range(num_channels):
channel_name = "channel_%s" % i
go_stream = self.go_streams[i]
trace = go.Scatter(
x=[],
y=[],
mode='splines',
stream=go_stream,
name=channel_name
)
traces.append(trace)
data = go.Data(traces)
layout = go.Layout(title=metric_name)
fig = go.Figure(data=data, layout=layout)
py.iplot(fig, filename=metric_name)
def getTraces():
stream_ids = tools.get_credentials_file()['stream_ids']
stream_ids = stream_ids[:max_streams]
traces = list()
for stream_id in stream_ids:
stream = go.Stream(token=stream_id, maxpoints=200)
trace = go.Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream)
traces.append(trace)
return stream_ids, traces
def GPSTrack_setup():
stream_id = stream_ids[0]
stream_1 = go.Stream(
token=stream_id, # link stream id to 'token' key
maxpoints=200)
trace1 = go.Scatter(
x=[],
y=[],
mode='markers',
stream=stream_1 # (!) embed stream id, 1 per trace
)
data = go.Data([trace1])
layout = go.Layout(title='GPS Track')
fig = go.Figure(data=data, layout=layout)
py.iplot(fig, filename='python-streaming')
GPSTrack_plot = py.Stream(stream_id)
return GPSTrack_plot
def TrueWind_setup():
stream_id = stream_ids[1]
stream_1 = go.Stream(
token=stream_id, # link stream id to 'token' key
maxpoints=200)
trace1 = go.Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream_1 # (!) embed stream id, 1 per trace
)
data = go.Data([trace1])
layout = go.Layout(title='True Wind Speed')
fig = go.Figure(data=data, layout=layout)
py.iplot(fig, filename='python-true-wind-speed')
s = py.Stream(stream_id)
return s
maxpoints = 10000
streamit = False
stream = []
if streamit:
stream_id = "" # Put your own token
trace1 = py_gr.Scatter(x=[],
y=[],
xaxis=dict(title="Game"),
yaxis=dict(title="Score"),
mode='line',
name="Game",
stream=py_gr.Stream(token=stream_id,
maxpoints=maxpoints))
data = go.Data([trace1])
layout = go.Layout(title='Martins stupid PhD algorithm')
fig = go.Figure(data=data, layout=layout)
py.plot(fig, auto_open=False)
stream = py.Stream(stream_id)
stream.open()
for game in range(maxpoints):
print("game:", game)
scores.append(Play())
print(scores[-1])
if streamit:
def setup_streams(number, maxpoints):
stream_ids = tls.get_credentials_file()['stream_ids']
for i in range(0, number):
stream_id_i = stream_ids[i]
stream_i = go.Stream(token=stream_id_i, maxpoints=maxpoints)
streams.append(stream_i)
import plotly.graph_objs as go
import plotly.plotly as py
from config import stream_tokens
pie_stream_id = stream_tokens[-1]
pie_stream = go.Stream(token=pie_stream_id)
transactions_pie_trace = go.Pie(labels=[],
values=[],
textfont=dict(size=20),
hoverinfo='label+percent',
textinfo='percent',
stream=pie_stream)
transactions_pie_url = py.plot([transactions_pie_trace],
filename='Transactions by Location (last period)',
fileopt="overwrite",
auto_open=False)
transactions_pie_stream = py.Stream(pie_stream_id)
import plotly
import numpy as np
import plotly.plotly as py
import plotly.tools as tls
import plotly.graph_objs as go
plotly.tools.set_credentials_file(username='******',
api_key='h5qictce9t',
stream_ids=('wzwtxkdhnp', '9ovqspax14'))
stream_ids = plotly.tools.get_credentials_file()['stream_ids']
stream_id = stream_ids[0]
stream_1 = go.Stream(token=stream_id, maxpoints=80)
trace1 = go.Scatter(x=[], y=[], stream=stream_1)
data = go.Data([trace1])
layout = go.Layout(title='Time Series')
fig = go.Figure(data=data, layout=layout)
py.plot(fig, filename='python-streaming')
s = py.Stream(stream_id)
s.open()
import datetime
import time
i = 0
k = 5
def setupPlotly(points):
'''
Sets up plotly graph to write to
:param points: <int> of max number of points to keep plotted on graph
:return: Plotly Stream object
'''
# Setup plotly
stream_ids = tls.get_credentials_file()['stream_ids']
# Get stream id from stream id list
stream_id = stream_ids[0]
# Make instance of stream id object
stream_1 = go.Stream(
token=stream_id, # link stream id to 'token' key
maxpoints=points # keep a max of 80 pts on screen
)
# Initialize trace of streaming plot by embedding the unique stream_id
trace1 = go.Scatter(
x=[],
y=[],
mode='lines',
stream=stream_1 # (!) embed stream id, 1 per trace
)
data = go.Data([trace1])
# Add title to layout object
layout = go.Layout(
title='Twitter Overwatch Sentiment',
xaxis=dict(
title='Date & Time',
titlefont=dict(
size=18,
color='#7f7f7f'
)
),
yaxis=dict(
title='Aggregate Sentiment',
titlefont=dict(
size=18,
color='#7f7f7f'
)
)
)
# Make a figure object
fig = go.Figure(data=data, layout=layout)
# Send fig to Plotly, initialize streaming plot, open new tab
py.iplot(fig, filename='python-streaming')
# We will provide the stream link object the same token that's associated with the trace we wish to stream to
stream_object = py.Stream(stream_id)
# We then open a connection
stream_object.open()
time.sleep(5)
return stream_object
def __init__(self, chart_type, window_size=20):
"""
INPUT:
- chart_type: 'line', 'pie', 'bar'
- window_size: how many data points to keep track of
"""
# 2 stream id
# api_cred.yml looks like this:
# plotly:
# username: xxxx
# api_key: xxxx
# stream_ids:
# - xxxx
# - xxxx
# - xxxxx
credentials = yaml.load(open(expanduser('tristan_cred.yml')))
plotly.tools.set_credentials_file(
**credentials['plotly']) # plotly credentials
stream_ids = tls.get_credentials_file()['stream_ids']
self.ids = {
'line': stream_ids[0],
'pie': stream_ids[1],
'bar': stream_ids[2]
}
self.traces = {
'line': {
'stream_id':
self.ids['line'],
'trace':
go.Scatter(x=[],
y=[],
mode='lines+markers',
marker=dict(color="black"),
stream=go.Stream(token=self.ids['line'],
maxpoints=80),
name='Average Score',
showlegend=False),
'title':
'Meetup RSVP Recent Total Count',
'filename':
'line-streaming'
},
'pie': {
'stream_id':
self.ids['pie'],
'trace':
go.Pie(
labels=['yes', 'no', 'other'],
values=[100, 50, 20],
domain=dict(x=[0, 1]),
#text=['yes', 'no', 'other'],
stream=go.Stream(token=self.ids['pie'], maxpoints=80),
sort=False),
'title':
'Meetup RSVP Running Response Count',
'filename':
'pie-streaming'
},
'bar': {
'stream_id':
self.ids['bar'],
'trace':
go.Bar(
x=[],
y=[],
# xaxis='x2',
# yaxis='y2',
marker=dict(color="blue"),
name='Dynamic Bar',
stream=go.Stream(token=self.ids['bar'], maxpoints=80),
showlegend=False),
'title':
'Meetup RSVP Recent Top Event',
'filename':
'bar-streaming'
}
}
self.WIN_SIZE = window_size
self.streams = {}
self.chart_url = None
# self.init_interview_stream()
self.init_stream(chart_type=chart_type)
import plotly.graph_objs as go
import plotly.plotly as py
from plotly.graph_objs import *
from config import mapbox_access_tokens, stream_tokens
# Maps plot streaming
# Stream definition
maps_stream_token = stream_tokens[-2]
maps_stream_id = go.Stream(token=maps_stream_token, maxpoints=100000)
mapbox_access_token = mapbox_access_tokens[-1]
# Trace
maps_stream_trace = Data([
Scattermapbox(lat=[],
lon=[],
mode='markers',
marker=Marker(size=6, color='rgb(0, 255, 0)'),
stream=maps_stream_id)
])
# Layout
maps_stream_layout = dict(autosize=True,
hovermode='closest',
mapbox=dict(accesstoken=mapbox_access_token,
bearing=0,
center=dict(lat=51.4974948,
lon=-0.13565829999993184),
pitch=0,
zoom=10))
import numpy as np
import plotly.plotly as py
import plotly.tools as tls
import plotly.graph_objs as go
import pandas as pd
import datetime
import time
stream_ids = tls.get_credentials_file()['stream_ids']
print stream_ids
# Make instance of stream id object
stream_1 = go.Stream(
token=stream_ids[0], # link stream id to 'token' key
maxpoints=80 # keep a max of 80 pts on screen
)
# Make instance of stream id object
stream_2 = go.Stream(
token=stream_ids[1], # link stream id to 'token' key
maxpoints=80 # keep a max of 80 pts on screen
)
# Make instance of stream id object
stream_3 = go.Stream(
token=stream_ids[2], # link stream id to 'token' key
maxpoints=80 # keep a max of 80 pts on screen
)
# Make instance of stream id object
stream_4 = go.Stream(
token=stream_ids[3], # link stream id to 'token' key
maxpoints=80 # keep a max of 80 pts on screen
import socket
import json
import datetime
import random
import plotly
import plotly.plotly as py
import plotly.graph_objs as go
from plotly.graph_objs import *
plotly.tools.set_credentials_file(username='******',
api_key='VhSOVBTQMUDQ3hqlyLRr')
plotly.tools.set_config_file(world_readable=True, sharing='public')
# Make instance of stream id object
stream_1 = go.Stream(
token='xfto8kd7cp', # link stream id to 'token' key
maxpoints=80 # keep a max of 80 pts on screen
)
trace1 = go.Scatter(x=[], y=[], mode="lines + markers", stream=stream_1)
data = go.Data([trace1])
layout = go.Layout(title='Time Series')
# Make a figure object
fig = go.Figure(data=trace1, layout=layout)
# Send fig to Plotly, initialize streaming plot, open new tab
py.iplot(fig, filename='python-streaming')
# We will provide the stream link object the same token that's associated with the trace we wish to stream to
print "Creating interval timer. This step takes almost 2 minutes on the Raspberry Pi..."
#create timer that is called every n seconds, without accumulating delays as when using sleep
scheduler = BackgroundScheduler()
scheduler.add_job(write_hist_value_callback, 'interval', seconds=sec_between_log_entries)
scheduler.start()
print "Started interval timer which will be called the first time in {0} seconds.".format(sec_between_log_entries);
# setting the plot streaming
stream_ids = tls.get_credentials_file()['stream_ids']
# Get stream id from stream id list
stream_id_0 = stream_ids[0]
stream_id_1 = stream_ids[0]
# Make instance of stream id object
stream_0 = go.Stream(
token=stream_id_0, # (!) link stream id to 'token' key
maxpoints= 24 * 3600 / sec_between_stream_entries # (!) keep a max of pts on screen
)
# Initialize trace of streaming plot by embedding the unique stream_id
trace_0 = go.Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream_0 # (!) embed stream id, 1 per trace
)
data = go.Data([trace_0])
# Add title to layout object
layout = go.Layout(title='Leaving Room Temperature (' + degree_sign + 'C)')
def graph_issues_by_component(self,
stats,
table_title='Issues by Component (High/Med)',
table_filename='tower_issues_by_component',
maxpoints=60,
build_table=False): # 60 days
# Confirm there are enough stream ids
print "Confirm have enough stream ids"
components = sorted(stats.keys())
num_components = len(components)
assert len(self.stream_tokens) >= num_components, \
"Not enough plotly stream keys to plot data. Found %s (needed %s)" % \
(len(self.stream_tokens), num_components)
stream_ids = []
for index in range(num_components):
stream = go.Stream(token=self.stream_tokens[index],
maxpoints=maxpoints)
stream_ids.append(stream)
# Build Table
if build_table:
print "Building plot"
traces = []
for index in range(num_components):
name = components[index].replace(self.component_tag,
'') # Strip component prefix
trace = go.Scatter(
x=[],
y=[],
stream=stream_ids[index],
name=name,
marker=dict(
color=self.colors[index])) # mode='lines+markers'
traces.append(trace)
layout = go.Layout(title=table_title)
fig = go.Figure(data=traces, layout=layout)
url = py.plot(fig, filename=table_filename)
print "Graph url: ", url
# Create streams
print "Creating streams"
streams = []
for index in range(num_components):
stream = py.Stream(stream_id=self.stream_tokens[index])
streams.append(stream)
# Open streams
print "Opening streams"
for index in range(num_components):
streams[index].open()
# Write data
print "Writing data"
for index in range(num_components):
x = datetime.datetime.now().strftime('%Y-%m-%d %H:%M')
component = components[index]
y = stats[component]
streams[index].write(dict(x=x, y=y))
# Close streams
print "Closing streams"
for index in range(num_components):
streams[index].close()
def graph_issues_by_priority(self,
stats,
table_title='Issues by Severity',
table_filename='tower_issues_by_priority',
maxpoints=60,
build_table=False): # 60 days
# Confirm there are enough stream ids
print "Confirm have enough stream ids"
def priority_weight(priority):
'''Hack to sort keys logically instead of alphabetically'''
weight = {
'priority:high': 0,
'priority:medium': 1,
'priority:low': 2
}
if priority in weight.keys():
return weight[priority]
return 0
priority_levels = sorted(stats.keys(), key=priority_weight)
num_priority_levels = len(priority_levels)
assert len(self.stream_tokens) >= num_priority_levels, \
"Not enough plotly stream keys to plot data. Found %s (needed %s)" % \
(len(self.stream_tokens), num_priority_levels)
stream_ids = []
for index in range(num_priority_levels):
stream = go.Stream(token=self.stream_tokens[index],
maxpoints=maxpoints)
stream_ids.append(stream)
# Build Table
if build_table:
print "Building plot"
traces = []
for index in range(num_priority_levels):
name = priority_levels[index].replace(
self.priority_tag, '') # Strip priority prefix
trace = go.Scatter(
x=[],
y=[],
stream=stream_ids[index],
name=name,
marker=dict(
color=self.colors[index])) # mode='lines+markers'
traces.append(trace)
layout = go.Layout(title=table_title)
fig = go.Figure(data=traces, layout=layout)
url = py.plot(fig, filename=table_filename, show_link=False)
print "Graph url: ", url
# Create streams
print "Creating streams"
streams = []
for index in range(num_priority_levels):
stream = py.Stream(stream_id=self.stream_tokens[index])
streams.append(stream)
# Open streams
print "Opening streams"
for index in range(num_priority_levels):
streams[index].open()
# Write data
print "Writing data"
for index in range(num_priority_levels):
x = datetime.datetime.now().strftime('%Y-%m-%d %H:%M')
priority = priority_levels[index]
y = stats[priority]
streams[index].write(dict(x=x, y=y))
# Close streams
print "Closing streams"
for index in range(num_priority_levels):
streams[index].close()
def initGraph():
# get list of all your stream ids
stream_ids = tls.get_credentials_file()['stream_ids']
# Get stream id from stream id list
stream_id1 = stream_ids[0]
# Make instance of stream id object
stream_1 = go.Stream(
token=stream_id1, # link stream id to 'token' key
maxpoints=20 # keep a max of 5 pts on screen
)
# Initialize trace of streaming plot by embedding the unique stream_id
trace1 = go.Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream_1 # (!) embed stream id, 1 per trace
)
data = [trace1]
# Add title to layout object
layout = {
'title':
'example lample mample',
'xaxis': {
'range': [0, 300]
},
'yaxis': {
'range': [0, 300]
},
'shapes': [
{
'type': 'line',
'x0': 0,
'y0': 0,
'x1': 300,
'y1': 0,
'line': {
'color': 'rgb(55, 128, 191)',
'width': 3,
},
},
{
'type': 'line',
'x0': 0,
'y0': 0,
'x1': 0,
'y1': 300,
'line': {
'color': 'rgb(55, 128, 191)',
'width': 3,
},
},
{
'type': 'line',
'x0': 300,
'y0': 0,
'x1': 300,
'y1': 300,
'line': {
'color': 'rgb(55, 128, 191)',
'width': 3,
},
},
{
'type': 'line',
'x0': 0,
'y0': 300,
'x1': 300,
'y1': 300,
'line': {
'color': 'rgb(55, 128, 191)',
'width': 3,
},
},
]
}
# Make a figure object
fig = {'data': data, 'layout': layout}
# Send fig to Plotly, initialize streaming plot, open new tab
py.plot(fig, filename='python-streaming')
# We will provide the stream link object the same token that's associated with the trace we wish to stream to
s_1 = py.Stream(stream_id1)
return s_1
import plotly.plotly as py
import plotly.graph_objs as go
import datetime
import time
import numpy as np
#py.sign_in('cebeka', '475knde90n') #username, apikey
#stream_id = 'rrbzcid5ty' # token
py.sign_in('adrienPlotly', '2vzts6z07f')
stream_id = 'u3pvpjla4o'
stream1 = go.Stream(token=stream_id, maxpoints=60)
plotUrl = py.plot(go.Data([go.Scatter(x=[], y=[], stream=stream1)]), filename="test", auto_open=False, sharing='public', fileopt='new')
print(plotUrl)
s = py.Stream(stream_id)
s.open() # Open the stream
i = 0 # a counter
k = 5 # some shape parameter
n = 0
# Delay start of stream by 5 sec (time to switch tabs)
time.sleep(5)
while True:
# Current time on x-axis, random numbers on y-axis
x = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')
y = (np.cos(k*i/50.)*np.cos(i/50.)+np.random.randn(1))[0]
# Send data to your plot
s.write(dict(x=x, y=y))
print(n)
n = n+1
# Write numbers to stream to append current data on plot,
from os.path import abspath, dirname, join
json_path = join(dirname(abspath(__file__)), 'config.json')
# Parse the configuration
with open(json_path) as config_file:
plotly_user_config = json.load(config_file)
# Sign in to plotly
py.sign_in(plotly_user_config["plotly_username"],
plotly_user_config["plotly_api_key"])
stream_id = plotly_user_config['plotly_streaming_tokens'][4]
stream_config = go.Stream(token=stream_id, maxpoints=1)
data = [
go.Scatter(x=[0.5],
y=[0.5],
stream=stream_config,
marker=dict(size=60,
color='rgba(152, 0, 0, .8)',
line=dict(width=2, color='rgb(0, 0, 0)')))
]
layout = go.Layout(
# dragmode='select',
xaxis=dict(
range=[0, 3],
dtick=1,
fixedrange=True,
1: "CH4 Concentration (ppm)",
2: "LPG Concentration (ppm)",
3: "CO2 Concentration (ppm) ",
4: "Dust Concentration (micrograms/m3)",
5: "Temperature (degree C)",
6: "Humidity (%)",
}.get(x, "none") # "none" is default if x not found
# Get stream id from stream id list
for i in range(0, 3):
stream_id[i] = stream_ids[i]
# Make instance of stream id object
stream_obj[i] = go.Stream(
token=stream_id[i], # link stream id to 'token' key
maxpoints=80 # keep a max of 80 pts on screen
)
# Initialize trace of streaming plot by embedding the unique stream_id
trace[i] = go.Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream_obj[i] # (!) embed stream id, 1 per trace
)
data = go.Data([trace[i]])
# Add title to layout object
layout = go.Layout(title=map_sensor_id_to_title(i + 1))
# Parse the configuration
with open(json_path) as config_file:
plotly_user_config = json.load(config_file)
# Sign in to plotly
py.sign_in(plotly_user_config["plotly_username"],
plotly_user_config["plotly_api_key"])
# Here we get the 4 stream IDs
stream_id1 = plotly_user_config['plotly_streaming_tokens'][0]
stream_id2 = plotly_user_config['plotly_streaming_tokens'][1]
stream_id3 = plotly_user_config['plotly_streaming_tokens'][2]
stream_id4 = plotly_user_config['plotly_streaming_tokens'][3]
# Create the proper stream objects
stream_config_1 = go.Stream(token=stream_id1, maxpoints=200)
stream_config_2 = go.Stream(token=stream_id2, maxpoints=200)
stream_config_3 = go.Stream(token=stream_id3, maxpoints=200)
stream_config_4 = go.Stream(token=stream_id4, maxpoints=200)
plot1 = go.Scatter(x=[], y=[], stream=stream_config_1, name='Humidity (%)')
plot2 = go.Scatter(x=[], y=[], stream=stream_config_2, name='Temperature (C)')
plot3 = go.Scatter(x=[], y=[], stream=stream_config_3, name='VIS')
plot4 = go.Scatter(x=[], y=[], stream=stream_config_4, name='IR')
# Create a plot
url1 = py.plot([plot1, plot2],
filename='Arduino Sensors data - Area conditions',
fileopt='overwrite',
auto_open=False)
import plotly.plotly as py
import plotly.graph_objs as go
import plotly.tools as tls
import numpy as np
import time
import datetime
import random
import sentiment
py.sign_in('SamarthJain', 'zse4msy081')
stream_ids = tls.get_credentials_file()['stream_ids']
stream_id = stream_ids[0]
# Make instance of stream id object
stream_1 = go.Stream(
token=stream_id, # link stream id to 'token' key
maxpoints=100 # keep a max of 80 pts on screen
)
# Initialize trace of streaming plot by embedding the unique stream_id
trace1 = go.Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream_1 # (!) embed stream id, 1 per trace
)
data = go.Data([trace1])
# Add title to layout object
layout = go.Layout(title='Time Series')
username = '******' // 입력
api_key = "1234567"; // 입력
py.sign_in(username, api_key);
size = len(stream_ids);
colorArray = ['red','blue','green']
streamArray = [];
traceArray = [];
streamingServerArray = [];
for i in range(0,size):
streamArray.append(go.Stream(token = stream_ids[i], maxpoints = 80));
traceArray.append(go.Scatter(go.Scatter(x=[],y=[], mode ='lines+markers', stream= streamArray[i], marker = { 'color' : colorArray[i%3]}, name = 'Server'+str(i) )));
streamingServerArray.append(py.Stream(stream_ids[i]));
data = go.Data(traceArray);
layout = go.Layout(title='Traffic Level');
fig = go.Figure(data=data, layout= layout);
py.plot(fig,filename='Traffice Streaming');
serverSock = socket(AF_INET, SOCK_STREAM);
serverSock.bind(('',8000));
serverSock.listen(5);
logfile.flush()
#================================================================
# initialise the plotly stream
#================================================================
# Get stream id from stream id list
stream_ids = tls.get_credentials_file()['stream_ids']
stream_id = stream_ids[0]
logfile.write(
"brew_monitor.py: got the stream ids. About to start go.Stream...\n")
logfile.flush()
# Make instance of stream id object
stream_1 = go.Stream(
token=stream_id, # link stream id to 'token' key
maxpoints=max_points # keep a max of max_points pts on screen
)
logfile.write("brew_monitor.py: stream_1 object created.")
logfile.write("About to try an initialise the trace...\n")
logfile.flush()
# Initialize trace of streaming plot by embedding the unique stream_id
trace1 = go.Scatter(
x=[],
y=[],
mode='lines+markers',
stream=stream_1 # (!) embed stream id, 1 per trace
)
data = go.Data([trace1])
def __init__(self, window_size=20):
"""
INPUT:
- window_size: how many data points to keep track of
"""
# 2 stream id
# api_cred.yml looks like this:
# plotly:
# username: xxxx
# api_key: xxxx
# stream_ids:
# - xxxx
# - xxxx
# - xxxxx
credentials = yaml.load(open(expanduser('tmp_cred.yml')))
plotly.tools.set_credentials_file(**credentials['plotly']) # plotly credentials
stream_ids = tls.get_credentials_file()['stream_ids']
self.ids = {
'line': stream_ids[0],
'pie': stream_ids[1],
'bar': stream_ids[2]
}
self.traces = {
'line': {
'stream_id': self.ids['line'],
'trace': go.Scatter(
x=[],
y=[],
mode='lines+markers',
marker=dict(color="black"),
stream=go.Stream(token=self.ids['line'], maxpoints=80),
name='Average Score',
showlegend=False
),
'title': 'Time Series',
'filename': 'line-streaming'
},
'pie': {
'stream_id': self.ids['pie'],
'trace': go.Pie(
labels=['one','two','three'],
values=[20,50,100],
domain=dict(x=[0, 1]),
text=['one', 'two', 'three'],
stream=go.Stream(token=self.ids['pie'], maxpoints=80),
sort=False
),
'title': 'Moving Pie',
'filename': 'pie-streaming'
},
'bar': {
'stream_id': self.ids['bar'],
'trace': go.Bar(
x=[],
y=[],
# xaxis='x2',
# yaxis='y2',
marker=dict(color="green"),
name='Sentiment Score',
stream=go.Stream(token=self.ids['bar'], maxpoints=80),
showlegend=False
),
'title': 'Moving Bar',
'filename': 'bar-streaming'
}
}
self.x = np.array([]) # list of x labels
self.y = np.array([]) # list of y values
self.y_mean = np.array([]) # list of y.mean()
self.WIN_SIZE = window_size
self.stream_line = None
self.stream_bar = None
self.chart_url = None
self.init_interview_stream()
def __init__(self, plotqueue):
print("initiating StreamingGraph")
self.plotqueue = plotqueue
# Make instance of stream id object
self.stream_1 = go.Stream(
token=self.stream_id, # link stream id to 'token' key
maxpoints=80 # keep a max of 80 pts on screen
)
print("stream 1 created")
trace1 = go.Scatter(
x=[],
y=[],
mode='lines+markers',
stream=self.stream_1 # (!) embed stream id, 1 per trace
)
data = go.Data([trace1])
# Add title to layout object
layout = go.Layout(title='Time Series')
print("layout created")
# Make a figure object
fig = go.Figure(data=data, layout=layout)
# Send fig to Plotly, initialize streaming plot, open new tab
py.iplot(fig, filename='python-streaming')
# We will provide the stream link object the same token that's associated with the trace we wish to stream to
self.s = py.Stream(self.stream_id)
# We then open a connection
self.s.open()
# (*) Import module keep track and format current time
import datetime
import time
i = 0 # a counter
k = 5 # some shape parameter
print("sleeping")
# Delay start of stream by 5 sec (time to switch tabs)
time.sleep(5)
print("slept")
self.plot_queue = Queue(maxsize=0)
while True:
if not self.plot_queue.empty():
x, y = self.plotqueue.get()
self.add_data(x, y)
## # Current time on x-axis, random numbers on y-axis
## x = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')
## y = (np.cos(k*i/50.)*np.cos(i/50.)+np.random.randn(1))[0]
##
## # Send data to your plot
## self.s.write(dict(x=x, y=y))
##
## # Write numbers to stream to append current data on plot,
## # write lists to overwrite existing data on plot
##
## time.sleep(1) # plot a point every second
self.s.close()
