def main():
df = pd.read_csv(StringIO(dat),
sep=';',
index_col='ts',
parse_dates=['ts'])
# Basic line plot
chart1 = serialize(df, render_to="my-chart1", title="My Chart")
# Basic column plot
chart2 = serialize(df, render_to="my-chart2", title="Test", kind="bar")
# Basic column plot
chart3 = serialize(df, render_to="my-chart3", title="Test", kind="barh")
# Plot C on secondary axis
chart4 = serialize(df,
render_to="my-chart4",
title="Test",
secondary_y=["C"])
# Plot on a 1000x700 div
chart5 = serialize(df,
render_to="my-chart5",
title="Test",
figsize=(1000, 700))
return render_template('index.html',
chart1=chart1,
chart2=chart2,
chart3=chart3,
chart4=chart4,
chart5=chart5)
def return_number_of_messages_by_week_year_and_user(self, as_chart=False):
m_by_week_year = self.df[['id_message', 'user_name']].copy()
m_by_week_year.loc[:, 'year'] = m_by_week_year.index.year
m_by_week_year.loc[:, 'week'] = m_by_week_year.index.week
m_by_week_year = m_by_week_year.groupby(['year', 'week', 'user_name']).count().unstack().fillna(0)
m_by_week_year = m_by_week_year['id_message']
m_by_week_year.loc[:, 'Total'] = m_by_week_year.sum(axis=1)
if as_chart:
config = serialize(m_by_week_year, kind='bar', title='Messages by Week, Year and User',
output_type='json', rot=45)
config["yAxis"][0]["labels"]["rotation"] = 0
config["yAxis"][0]["title"] = {"text": "# messages"}
config["chart"]["marginTop"] = 70
for k, v in config.iteritems():
if k == "series":
r = np.random.choice(len(v), 2, replace=False)
for j, d in enumerate(v):
if j not in r:
config["series"][j]["visible"] = False
return {'options':config, 'series':config['series']}
else:
return m_by_week_year
def return_share_of_conversations_first_replied_by_user(self, as_chart=False):
counts = dict()
for u in self.chat.users:
counts[u.name] = 0
conv_to_messages, conv_to_users = self.return_conversations(60)
conv_to_user_pos = self.return_users_conversations_at_position(conv_to_messages, pos=1)
for u in conv_to_user_pos.values():
counts[u.name] += 1
m_conv_user = pd.DataFrame(counts.items(), columns=['user', 'Ratio of Conversations'])
total_num_convs = len(conv_to_user_pos.values())
m_conv_user['Ratio of Conversations'] = 100.0 * m_conv_user['Ratio of Conversations'] / total_num_convs
m_conv_user.set_index('user', inplace=True)
if as_chart:
tooltip = {'pointFormat': '{series.name}: <b>{point.percentage:.1f}%</b>'}
config = serialize(m_conv_user, kind='pie', title='Ratio of Conversations First Replied by User',
output_type='json', tooltip=tooltip)
config["chart"]["marginTop"] = 70
return {'options':config, 'series':config['series']}
else:
return m_conv_user
def protocol_summary(request):
'''Relies on django_highcharts for serializing data. Makes multiple chart
rendering on a page more simple, however it doesn't appear to allow much
in they way of customization.
'''
'''define a range, avg, diplay max and min'''
athlete = get_user(request)
data = BoulderingRoutineMetrics.objects.filter(session__athlete = athlete)
test = BoulderingRoutineMetrics.objects.values('min', 'max').filter(session__athlete = athlete)
df = read_frame(data, verbose=False)
df['avg'] = df['total_points']/df['total_climbs']
df['range'] = df['max']-df['min']
df = df.drop(['id','total_climbs', 'total_points'], axis=1).set_index('session')
dataset = BoulderingRoutineMetrics.objects \
.values('session__sessionDate', 'min','max', 'total_points', 'total_climbs') \
.filter(session__athlete = athlete)
df2 = read_frame(dataset, verbose=False).rename(columns={'session__sessionDate':'session date','min':'min value','max':'max value'})
df3 = read_frame(dataset, fieldnames=['min','max'])\
.rename(columns={'session__sessionDate':'Session Date'})
# .drop(['total_points', 'total_climbs'])
df4 = df2.merge(df3, how='left', left_index=True, right_index=True)
print(df4)
df4['avg']=df4['total_points']/df4['total_climbs']
df4['range']=df4['max value']-df4['min value']
chart = serialize(df4, render_to='my-chart', kind="bar", output_type='json')
return render(request, 'schedule/protocol_summary.html', {'chart':chart})
def populateMasterDic(df,col,years,masterDic):
for index in df.index:
name=df['stockname'][index]
boughtprice = df['boughtprice'][index]
boughtamount = df['boughtamount'][index]
data = fix_ticker_details_request(name, datetime.now()-timedelta(days=365*years), datetime.now())
data = data[['Adj Close']]
#make 21 day moving average
data['21DayAvg'] = data['Adj Close'].rolling(21).mean().fillna(0)
#make 100 day average
data['100DayAvg'] = data['Adj Close'].rolling(100).mean().fillna(0)
if not pd.isnull(boughtprice):
bought = [boughtprice]*len(data.index)
data = pd.DataFrame(data)
data['bought'] = bought
else:
data = pd.DataFrame(data)
content = serialize(data,render_to='chart'+str(index), title=name.upper()+' Stock',output_type='json')
content = changeChartOptions(content)
# get total purchase cost, etc
stockPerformance = getStockPerformance(data,boughtamount,boughtprice)
masterDic['chart'+str(index)] = {'stockmetrics':col[name],'highChartsDic':content,
'performance':stockPerformance}
return masterDic
def fp_yyz_sale_figure():
# 读取csv数据
df = pd.read_csv(os.getcwd() +
'/update_data/database/sql_yyz_sale_amount.csv',
nrows=60)
# 小数转换为百分比，是否需要
#for a, b in zip(['total', 'android', 'ios'], ['credit_cnt_total', 'credit_cnt_android', 'credit_cnt_ios']):
#df[a + '_rate'] = (df[b] / df[a] * 100).apply(lambda x: format(x, ".4")).astype(
#float)
# 设置图表
chart = serialize(df[[
'sale_date', 'sale_amount'
]].head(30).sort_values('sale_date').rename(columns={'sale_date': '发售日期'}),
output_type='json',
x='发售日期',
title=u'月月涨销售量',
first_y_type='column')
#chart1 = serialize(
#df[['date', 'total_rate', 'android_rate', 'ios_rate']].head(30).sort_values('date').rename(
#columns={'date': '注册日期', 'total_rate': 'total', 'android_rate': 'android', 'ios_rate': 'ios'
#}),
#output_type='json',
#x='注册日期', title=u'app每日戳额率', first_y_type='line', tooltip={'valueSuffix': '%'}, ytitle="percentage")
return render_template('financial_product_sale_yyz_figure.html',
chart=chart)
def macro_factors(div, library):
factors = {
'Risk on': ['Russell 2000', 'DAX'],
'Quantitative Easing':
['Gold', 'German Bund', 'Gilts', 'US Treasuries 10 Yr'],
'Emerging Markets':
['Copper', 'MXN', 'BRL', 'Ibovespa', 'Taiwan (SIMEX)'],
'EU': ['DAX', 'FTSE 100', 'German Bund', 'Italian 10 year bonds'],
'Energies': ['Crude', 'Rotterdam Coal', 'Natural Gas'],
'Industrials':
['Copper', 'Rotterdam Coal', 'Crude', 'Shanghai Rebar']
}
factor_data = pd.DataFrame()
for f in factors.keys():
df = pd.DataFrame()
for m in factors[f]:
try:
df[m] = library.read(m).data.Price.replace(to_replace=0,
method='ffill')
except:
print m
factor_data[f] = df.resample(
rule='d', how='last').dropna(how='all').pct_change().mean(axis=1)
lookback = 5
zscores = (factor_data.cumsum() - pd.ewma(
factor_data.cumsum(), 60)) / pd.ewmstd(factor_data.cumsum(), 60)
y = zscores.tail(1).T.columns[0].year
return serialize(zscores[str(y)].ffill(),
render_to=div,
title='Factors',
output_type='json')
def power(filename):
"""Return filename of plot of the damped_vibration function."""
df = read_file(filename)
labels = df.columns.tolist()
data = serialize(df, render_to='power', title='',
output_type='dict')
# data['subtitle'] = {'text': 'a subtitle here...'}
data['plotOptions'] = {'spline': {
'lineWidth': 2,
'states': {
'hover': {
'lineWidth': 3}
}}}
data['chart']['type'] = 'line'
data['chart']['zoomType'] = 'x'
data['chart']['panning'] = True
data['chart']['panKey'] = 'shift'
result = 'new Highcharts.StockChart({});'.format(json_encode(data))
return result
def zscore_ranked(div, library):
lookback = 5
markets = 3
data = pd.DataFrame()
for mkt in library.list_symbols():
try:
data[mkt] = library.read(mkt).data.Price
except:
print mkt
zscores = (data - pd.ewma(data, 20)) / pd.ewmstd(data, 20)
latest = zscores.tail(lookback)
zscore_ranked = latest.T.sort_values(
by=latest.T.columns[0]).dropna()[:markets]
zscore_ranked = zscore_ranked.append(
latest.T.sort_values(by=latest.T.columns[0]).dropna()[-markets:])
final_data = pd.DataFrame()
i = 1
for d in zscore_ranked.columns:
final_data['T+' + str(i)] = zscore_ranked[d]
i = i + 1
return serialize(final_data,
render_to=div,
kind="bar",
title="Noteable market moves",
output_type='json')
def datarate(filename):
"""Return filename of plot of the damped_vibration function."""
df = read_file(filename)
# add data volume columns
for column in df.columns.values.tolist():
if 'Accum' in column:
instr = column[0]
df[instr, 'Volume', 'Gbits'] = df[instr, 'Accum', 'Gbits'].sub(
df[instr, 'Accum', 'Gbits'].shift(), fill_value=0)
df = df.sort_index(axis=1)
insts = ['BELA','ISA','MERMAG','MERTIS','MGNS','MIXS_SIXS',
'PHEBUS','SERENA','SIMBIOSYS']
# slice out a few specific dataframes
df_insts_accum_gbits = {
'data': df[insts].filter(like='Accum'),
'title': ''}
df_insts_volume_gbits = {
'data': df[insts].filter(like='Volume'),
'title': 'Data Rate [Gbit/s]'}
df_insts_upload_kbitsps = {
'data': df[insts].filter(like='Upload'),
'title': ''}
df_ssmm_accum_gbits = {
'data': df.filter(like='SSMM').filter(like='Accum'),
'title': ''}
df_ssmm_volume_gbits = {
'data': df.filter(like='SSMM').filter(like='Volume'),
'title': ''}
# select dataframe to use
df = df_insts_volume_gbits
labels = insts # df.columns.tolist()
data = serialize(df['data'], render_to='datarate', title='',
output_type='dict')
for x in data['series']:
x['name'] = x['name'][0]
# data['subtitle'] = {'text': 'a subtitle here...'}
data['plotOptions'] = {'spline': {
'lineWidth': 2,
'states': {
'hover': {
'lineWidth': 3}
}}}
data['chart']['type'] = 'line'
data['chart']['zoomType'] = 'x'
data['chart']['panning'] = True
data['chart']['panKey'] = 'shift'
data['title']['text'] = df['title']
result = 'new Highcharts.StockChart({});'.format(json_encode(data))
return result
def compute_highcharts(A, b, w, T, resolution=10000):
"""Return filename of plot of the damped_vibration function."""
t = linspace(0, T, resolution+1)
u = damped_vibrations(t, A, b, T)
d = {'t': t, 'u': u}
df = pd.DataFrame(d)
df.set_index('t', inplace=True)
data = serialize(df, output_type='dict', chart_type='stock',
render_to='my-chart',
)
data['chart']['type'] = 'line'
data['chart']['zoomType'] = 'x'
data['chart']['panning'] = True
data['chart']['panKey'] = 'shift'
data['chart']['plotBackgroundColor'] = '#FCFFC5'
data["plotOptions"] = {
"spline": {
"color": "#FF0000",
"lineWidth": 1,
"states": { "hover": { "lineWidth": 1 } },
"marker": {"enabled": True }
}
}
chart = 'new Highcharts.Chart({});'.format(json_encode(data))
return chart
def return_number_of_messages_by_dayofweek_and_user(self, as_chart=False):
m_by_day_user = self.df[['id_message','user_name']].copy()
m_by_day_user.loc[:, 'day of the week'] = m_by_day_user.index.dayofweek
m_by_day_user = m_by_day_user.groupby(['day of the week','user_name']).count().unstack().fillna(0)
m_by_day_user = m_by_day_user['id_message']
m_by_day_user.loc[:, 'Total'] = m_by_day_user.sum(axis=1)
m_by_day_user.index = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
if as_chart:
config = serialize(m_by_day_user, kind='bar', title='Messages by Day of the Week and User',
output_type='json')
config["yAxis"][0]["title"] = {"text": "# messages"}
config["chart"]["marginTop"] = 70
for k, v in config.iteritems():
if k == "series":
r = np.random.choice(len(v), 2, replace=False)
for j, d in enumerate(v):
if j not in r:
config["series"][j]["visible"] = False
return {'options':config, 'series':config['series']}
else:
return m_by_day_user
def index():
chart = serialize(df,
render_to='my-chart',
output_type='json',
legend='None',
title='Trending Account Value(Daily)')
return render_template('charts.html', chart=chart)
def compute_highcharts_simple(A, b, w, T, resolution=500):
"""Return filename of plot of the damped_vibration function."""
t = linspace(0, T, resolution+1)
u = damped_vibrations(t, A, b, T)
d = {'t': t, 'u': u}
df = pd.DataFrame(d)
df.set_index('t', inplace=True)
chart = serialize(df, chart_type='stock', render_to='my-chart',
output_type='json' )
return chart
def get_chart_data(sites_arr, ctype, cperiod, agg_period, metric = "kwh"):
readings, start_date, end_date = _get_readings(sites_arr, cperiod)
op_arr, time_steps = _get_op_arr(readings, sites_arr, start_date, end_date, agg_period, metric)
devices = Device.query.filter(Device.id.in_(sites_arr)).all()
df = pd.DataFrame(op_arr, columns = [x.device_id for x in devices])
df['time'] = [time_steps[i].strftime(OUTPUT_DATE_FORMAT) for i in range(len(time_steps) -1 )]
df = df.set_index('time')
print(df.head())
sd_str, ed_str = start_date.strftime(OUTPUT_DATE_FORMAT), end_date.strftime(OUTPUT_DATE_FORMAT)
agg_str = agg_mapping[cperiod]
chart = serialize(df, render_to = CHART_DIV_ID, title = "Average KwH between {} and {} for the {}".format(sd_str, ed_str, agg_str))
return chart
def portfolio_comparison(div, library):
portfolio = {'Treasuries ETF': .4, 'S&P 500 ETF': .6}
final = pd.DataFrame()
for m in portfolio.keys():
final[m] = library.read(m).data.Close.resample(rule='m', how='last')
weights = pd.Series(portfolio)
data = final.resample(rule='m', how='last').pct_change() * weights
final['60/40 Portfolio'] = (1 + data.sum(axis=1)).cumprod()
return serialize(final.pct_change().cumsum(),
render_to=div,
title='Portfolios',
output_type='json')
def get_highchart(data):
# print(data.head())
# print(data.columns)
data['date'] = data['created_at'].apply(get_date)
# print(data.head())
# print(data.tail())
tweets_per_day = data.groupby('date').count()['id_str']
print(tweets_per_day.describe())
statistics = str(tweets_per_day.describe())
return chart(serialize(pd.DataFrame(tweets_per_day), render_to='my-chart', \
output_type='json', title='Tweets Per Day', \
parse_dates='date', kind='bar', zoom='xy'), 'my-chart', statistics)
def equity_markets_charts(div, library):
key_markets = ['FTSE 100', 'S&P 500', 'Russell 2000', 'EuroStoxx 50']
df = pd.DataFrame()
for mkt in key_markets:
try:
df[mkt] = library.read(mkt).data.Price
except:
print mkt
data = df.ffill()['2016':] / df.ffill()['2016':].ix[0]
return serialize(data,
render_to=div,
title='Equities YTD',
output_type='json')
def pd_data():
df = pd.DataFrame(
{
'y': np.random.randn(10),
'z': np.random.randn(10)
},
index=pd.period_range('1-2000', periods=10),
)
import pandas_highcharts
from pandas_highcharts.core import serialize
from pandas.compat import StringIO
dat = """ts;A;B;C
2015-01-01 00:00:00;27451873;29956800;113
2015-01-01 01:00:00;20259882;17906600;76
2015-01-01 02:00:00;11592256;12311600;48
2015-01-01 03:00:00;11795562;11750100;50
2015-01-01 04:00:00;9396718;10203900;43
2015-01-01 05:00:00;14902826;14341100;53"""
df = pd.read_csv(StringIO(dat), sep=';', index_col='ts', parse_dates='ts')
# Basic line plot
chart = serialize(df, render_to="my-chart", title="My Chart")
# Basic column plot
chart = serialize(df, render_to="my-chart", title="Test", kind="bar")
# Basic column plot
chart = serialize(df, render_to="my-chart", title="Test", kind="barh")
# Plot C on secondary axis
chart = serialize(df,
render_to="my-chart",
title="Test",
secondary_y=["C"])
# Plot on a 1000x700 div
chart = serialize(df,
render_to="my-chart",
title="Test",
figsize=(1000, 700))
return html.format(chart)
def return_share_of_messages_by_user(self, as_chart=False):
share_by_user = self.df[['user_name','id_message']].groupby('user_name').count()
total_num_messages = share_by_user['id_message'].sum()
share_by_user['Share of Messages'] = 100.0 * share_by_user['id_message'] / total_num_messages
share_by_user = share_by_user[['Share of Messages']]
if as_chart:
tooltip = {'pointFormat': '{series.name}: <b>{point.percentage:.1f}%</b>'}
config = serialize(share_by_user, kind='pie', title='Share of Messages',
output_type='json', tooltip=tooltip)
config["chart"]["marginTop"] = 70
return {'options':config, 'series':config['series']}
else:
return share_by_user
def return_number_of_messages_by_hour(self, as_chart=False):
m_by_hour = self.df[['id_message']].copy()
m_by_hour.loc[:, 'hour'] = m_by_hour.index.hour
m_by_hour = m_by_hour.groupby('hour').count()
if as_chart:
config = serialize(m_by_hour, kind='line', title='Messages per Hour of the Day',
output_type='json')
config["yAxis"][0]["title"] = {"text": "# messages"}
config["series"][0]["name"] = "Messages"
config["chart"]["marginTop"] = 70
return {'options':config, 'series':config['series']}
else:
return m_by_hour
def register_cnt_figure():
# 读取csv数据
df = pd.read_csv(os.getcwd() + '/update_data/database/sql_sale_amout.csv',
nrows=60)
# 小数转换为百分比，是否需要
# for a, b in zip(['total', 'android', 'ios'], ['credit_cnt_total', 'credit_cnt_android', 'credit_cnt_ios']):
# df[a + '_rate'] = (df[b] / df[a] * 100).apply(lambda x: format(x, ".4")).astype(
# float)
# 设置图表
chart = serialize(df[[
'sale_date', 'sale_amout'
]].head(30).sort_values('sale_date').rename(columns={'sale_date': '销售日期'}),
output_type='json',
x='销售日期',
title=u'彩虹计划销售量',
first_y_type='column')
def return_emoticons_by_user(self, as_chart=False):
e_by_user = pd.DataFrame({u.name:u.num_emoticons for u in self.chat.users}.items(), columns=['user', 'Number of Emoticons'])
e_by_user = e_by_user.sort(['Number of Emoticons'], ascending=[1])
e_by_user.set_index('user', inplace=True)
if as_chart:
config = serialize(e_by_user, kind='bar', title='Number of Emoticons',
output_type='json', rot=45)
config["xAxis"]["title"]["text"] = "user"
config["yAxis"][0]["labels"]["rotation"] = 0
config["yAxis"][0]["title"] = {"text": "# emoticons"}
config["chart"]["marginTop"] = 70
return {'options':config, 'series':config['series']}
else:
return e_by_user
def return_number_of_messages_by_week_and_year(self, as_chart=False):
m_by_week_year = self.df[['id_message']].copy()
m_by_week_year.loc[:, 'year'] = m_by_week_year.index.year
m_by_week_year.loc[:, 'week'] = m_by_week_year.index.week
m_by_week_year = m_by_week_year.groupby(['year', 'week']).count()
if as_chart:
config = serialize(m_by_week_year, kind='bar', title='Messages by Week and Year',
output_type='json', rot=45)
config["yAxis"][0]["labels"]["rotation"] = 0
config["series"][0]["name"] = "Messages"
config["yAxis"][0]["title"] = {"text": "# messages"}
config["chart"]["marginTop"] = 70
return {'options':config, 'series':config['series']}
else:
return m_by_week_year
def return_messages_by_user(self, as_chart=False):
m_by_user = self.df[['user_name', 'id_message']].groupby('user_name').count()
m_by_user['Number of Messages'] = m_by_user['id_message']
m_by_user = m_by_user[['Number of Messages']].sort(['Number of Messages'], ascending=[0])
if as_chart:
config = serialize(m_by_user, kind='bar', title='Number of Messages',
output_type='json', rot=45)
config["yAxis"][0]["labels"]["rotation"] = 0
config["xAxis"]["title"]["text"] = "user"
config["yAxis"][0]["title"] = {"text": "# messages"}
config["chart"]["marginTop"] = 70
return {'options':config, 'series':config['series']}
else:
return m_by_user
def commodity_markets_charts(div, library):
df = pd.DataFrame()
map = pd.read_csv(
'/Users/mrefermat/git/FinancePhD/Practice/Flask_server/markets.csv',
index_col='Market').to_dict()['Sector']
for mkt in library.list_symbols():
if map[mkt] == 'Commodities':
try:
df[mkt] = library.read(mkt).data.Price.replace(to_replace=0,
method='ffill')
except:
print mkt
data = df.ffill()['2016':] / df.ffill()['2016':].ix[0]
return serialize(data,
render_to=div,
title='Commodities YTD',
output_type='json')
def sector_ytd(div, library):
data = pd.DataFrame()
for m in library.list_symbols():
if library.read_metadata(m).metadata['type'] == 'sector':
data[m] = library.read(m).data.Close
d = data.tail(1).T.columns[0]
final = pd.DataFrame()
final['MTD'] = (((data[str(d.year) + '-' + str(d.month)] /
data[str(d.year) + '-' + str(d.month)].ix[0]).tail(1)) -
1).T[d]
final['YTD'] = (((data[str(d.year)] / data[str(d.year)].ix[0]).tail(1)) -
1).T[d]
return serialize(final,
kind='bar',
render_to=div,
title='US Sector Performance',
output_type='json')
def return_average_message_length_user(self, as_chart=False):
average_message_length = [(u.name, self.return_avg_mess_length(u)) for u in self.chat.users]
average_message_length = sorted(average_message_length, key=lambda elt: elt[1], reverse=True)
m_avg_length = pd.DataFrame(average_message_length, columns=['user', 'Average Message Length (in words)'])
m_avg_length.set_index('user', inplace=True)
if as_chart:
config = serialize(m_avg_length, kind='barh', title='Average Message Length (in words)',
output_type='json')
config["xAxis"]["title"]["text"] = "user"
config["yAxis"][0]["title"] = {"text": "average number words / message"}
config["chart"]["marginTop"] = 70
return {'options':config, 'series':config['series']}
else:
return m_avg_length
def return_number_of_jajaja_by_user(self, as_chart=False):
words = ["jaja", "haha", "jeje", "hehe", "hihi", "jiji", "lol"]
word_count = [(u.name, self.return_num_messages_user_including_words(u, words)) for u in self.chat.users]
word_count = sorted(word_count, key=lambda elt: elt[1], reverse=True)
m_jajaja = pd.DataFrame(word_count, columns=['user', 'Number of hahaha'])
m_jajaja.set_index('user', inplace=True)
if as_chart:
config = serialize(m_jajaja, kind='barh', title='Number of hahaha',
output_type='json')
config["xAxis"]["title"]["text"] = "user"
config["yAxis"][0]["title"] = {"text": "# hahaha"}
config["chart"]["marginTop"] = 70
return {'options':config, 'series':config['series']}
else:
return m_jajaja
def test_chart():
import pandas as pd
from pandas_highcharts.core import serialize
from pandas.compat import StringIO
dat = """ts;A;B;C
2015-01-01 00:00:00;27451873;29956800;113
2015-01-01 01:00:00;20259882;17906600;76
2015-01-01 02:00:00;11592256;12311600;48
2015-01-01 03:00:00;11795562;11750100;50
2015-01-01 04:00:00;9396718;10203900;43
2015-01-01 05:00:00;14902826;14341100;53"""
df = pd.read_csv(StringIO(dat),
sep=';',
index_col='ts',
parse_dates=['ts'])
# Basic line plot
chart = serialize(df, render_to='my-chart', output_type='json')
return render_template('test_chart.html', chart=chart)
def return_ratio_media_messages_by_user(self, as_chart=False):
media_by_user = self.df[self.df.isMedia == True][['user_name', 'isMedia']].groupby('user_name').count()
message_by_user = self.df[['user_name', 'id_message']].groupby('user_name').count()
message_by_user['Number of Media'] = media_by_user['isMedia']
message_by_user.fillna(0, inplace=True)
message_by_user['Percentage of Photo/Video Messages'] = 100.0 * message_by_user['Number of Media'] / message_by_user['id_message']
message_by_user = message_by_user[['Percentage of Photo/Video Messages']].sort(['Percentage of Photo/Video Messages'], ascending=[0])
message_by_user = np.round(message_by_user, decimals=2)
if as_chart:
tooltip = {'pointFormat': '{series.name}: <b>{point.y}%</b>'}
config = serialize(message_by_user, kind='barh', title='Percentage of Messages that are Photos or Videos',
output_type='json', tooltip=tooltip)
config["xAxis"]["title"]["text"] = "user"
config["yAxis"][0]["title"] = {"text": "percentage of media messages"}
config["chart"]["marginTop"] = 70
return {'options':config, 'series':config['series']}
else:
return message_by_user
def waves(request):
pathname = os.environ['HOME'] + \
'/Dropbox/projects/BMOP/Processamento/dados/BMOBR06_CF2/op/'
dd = pd.read_csv(pathname + 'Dados_BMOBR06.csv',
index_col='date',
parse_dates=True)
# dd = dd.ix[-14*24:,:] # dd = dd['2016-06-24':]
dd['Hs'] = dd.hs
dd['Tp'] = dd.tp
dd['Dp'] = dd.dp
args = {'kind': 'line', 'zoom': 'xy', 'grid': 'on', 'output_type': 'json'}
param = {
'Hs': ['my-chart1', 'Altura Significativa - Hs'],
'Tp': ['my-chart2', 'Período de Pico - Tp'],
'Dp': ['my-chart3', 'Direção de Pico - Dp']
}
chart = {}
for p in param:
chart[p] = serialize(dd[[p]],
render_to=param[p][0],
title=param[p][1],
kind=args['kind'],
zoom=args['zoom'],
grid=args['grid'],
output_type=args['output_type'],
y_axis_title='teste')
return render(request, 'personal/waves.html', chart)
def get_channel4():
channel4_df = pd.DataFrame({'col': micro_volts[3]})
return serialize(channel4_df, render_to='channel4', output_type='json')
def parse_data(data):
x = serialize(data).split('series":')[1].split(',"yAxis":[{}]')[0]
return x.split('}]')[0] + ',"type":"areaspline"}]'
def parse_data(data):
return serialize(data).split('series":')[1].split(',"yA')[0]
all_matches = new_df.fillna(0)
print ("all_matches:", all_matches)
all_matches['Date'] = all_matches['Date'].apply(pandas.to_datetime)
all_matches = all_matches.set_index('Date')
print ("all_matches:", all_matches)
# and now the plotting
time_chart = vincent.Line(all_matches[['sentiment', 'Close']])
time_chart.axis_titles(x='Time', y='Value')
time_chart.legend(title='Matches')
time_chart.to_json('time_chart.json')
# output sentiment
print "Total tweets", len(lis)
print "no. of positive ", p
print "Positive ", float(p / cout) * 100, "%"
print "Negative ", float(n / cout) * 100, "%"
print "Neutral ", float(net / len(lis)) * 100, "%"
# print lis
# determine if sentiment is positive, negative, or neutral
# output sentiment
# print sentiment
#ax = plt.gca()
#ax.invert_xaxis()
#plt.show()
#highcharts
df = all_matches # create your dataframe here
chart = serialize(df, render_to='container', output_type='json')
def index():
df = mainaction()
chart = ph.serialize(df, render_to='my-chart', output_type='json')
return template("charts.tpl", chart=chart)
import pandas as pd from pandas_highcharts.core import serialize from pandas.compat import StringIO dat = """ts;A;C 2015-01-01 00:00:00;27451873;29956800;113""" df = pd.read_csv(StringIO(dat), sep=';', index_col='ts', parse_dates='ts') chart = serialize(df, render_to="my-chart", title="Test", kind="bar")
def gen_highcharts_json(data,
title,
x_axis=None,
kind='line',
pandas_highcharts=True):
if pandas_highcharts:
json = serialize(data,
output_type='json',
title=title,
kind=kind,
fontsize='12',
grid=True,
legend=False)
else:
# define index type
print(data)
print(data.index)
print(data.index.dtype)
if data.index.dtype == 'datetime64[ns]':
x_axis_type = 'datetime'
else:
x_axis_type = 'category'
print(x_axis_type)
json = """{
title: {
text: '""" + title + """'
},
xAxis: {
type: '""" + x_axis_type + """'
},
yAxis: {
title: {
text: '""" + title + """'
}
},
legend: {
enabled: false
},
credits: false,
plotOptions: {
line: {
marker: {
enabled: null,
radius: 3
},
lineWidth: 2,
states: {
hover: {
lineWidth: 2
}
},
threshold: null
}
},
series: [{
type : '""" + kind + """',
data: ["""
for index, value in data.iteritems():
if x_axis_type == 'datetime':
json += '[Date.UTC({}, {}, {}),{}],'.format(
str(index)[0:4],
str(index)[5:7],
str(index)[8:10], value)
else:
json += '["{}",{}],'.format(str(index), value)
json = json[:-1]
json += """]
}]
}
"""
print(json)
return json
# run the first function and get the DataFrame
last_frame = expression[0].process(start, end, DataFrame())
for i in range(1, len(expression), 2):
conn = expression[i]
fun = expression[i+1]
if not isinstance(fun, QueryFunction):
raise ValueError('NON-QUERY FUNCTION: ' + str(fun))
print('RUNNING: ' + str(fun))
cur_frame = fun.process(start, end, last_frame)
if conn == '>|': # combine the two
last_frame = last_frame.combine_first(cur_frame)
else:
last_frame = cur_frame
i += 2
print("RES:")
print(str(last_frame.head()))
print("...")
print(str(last_frame.tail()))
chart = serialize(last_frame, render_to='my-chart', output_type='json')
print(chart)
