def grphosxxx(request):
if request.method == 'POST':
vname = request.POST['Vendor_name']
idesc = request.POST['Item_desc']
loc = request.POST['Vendor_loc']
rat = int(request.POST['Overall'])
cat = request.POST['Category']
queryset = queryfilter(request, vname, idesc, loc, rat, cat)
vendors = queryset.values('Category', 'Item_desc', 'Vendor_name',
'Vendor_loc', 'Approval').distinct()
else:
vendors = vendor.objects.values('Category', 'Item_desc', 'Vendor_name',
'Vendor_loc', 'Approval').distinct()
if (len(list(vendors)) == 0):
messages.warning(request, 'No Data Found!!')
return redirect("display2")
data = [['Vendor Name', 'Overall Rating']]
for i in vendors:
veninf = vendor.objects.filter(Category=i['Category'],
Item_desc=i['Item_desc'],
Vendor_name=i['Vendor_name'],
Vendor_loc=i['Vendor_loc'],
Approval=i['Approval'])
new = []
new.append(veninf[0].Vendor_name + '|' + veninf[0].Category + '|' +
veninf[0].Vendor_loc)
new.append(veninf[0].Average_Rating)
data.append(new)
data_source1 = SimpleDataSource(data)
chart1 = gchart.ColumnChart(
data_source1,
options={'title': 'Overall Rating of different Vendors'},
width='100%',
height=800)
return render(request, 'graph2.html', {'chart1': chart1})
def comparechart(post1, post2, compare1, compare2):
data = []
templist = ['status']
templist.append(post1)
templist.append(post2)
data.append(templist)
d1 = {}
d2 = {}
d1 = draw_chart1(compare1)
d2 = draw_chart1(compare2)
candidate1 = d1['data']
candidate2 = d2['data']
# agendapercent=[]
# ['completed', 20, 40, 20]
# ['Completed', 31.03448275862069],
for i in range(1, 8):
agendapercent = []
agendapercent.append(candidate1[i][0])
agendapercent.append(candidate1[i][1])
agendapercent.append(candidate2[i][1])
if agendapercent[1] or agendapercent[2]:
data.append(agendapercent.copy())
print("abc:")
print(data)
data_source = SimpleDataSource(data=data)
# Chart object
chart = gchart.ColumnChart(data_source)
return chart
def grphosxx(request):
maxpro = []
if request.method == 'POST':
vname = request.POST['Vendor_name']
idesc = request.POST['Item_desc']
loc = request.POST['Vendor_loc']
rat = int(request.POST['Overall'])
cat = request.POST['Category']
queryset = queryfilter(request, vname, idesc, loc, rat, cat)
print(queryset)
else:
queryset = vendor.objects.all()
data = [['Vendor Name']]
for i in queryset:
maxpro.append(i.Project)
maxpro = list(set(maxpro))
if None in maxpro:
maxpro.remove(None)
if (len(maxpro) == 0):
messages.warning(request, 'Vendor Not Found!!')
return redirect("display2")
for i in range(1, max(set(maxpro)) + 1):
data[0].append('Project' + ' ' + str(i) + ' Rating')
vendors = queryset.values('Category', 'Item_desc', 'Vendor_name',
'Vendor_loc', 'Approval').distinct()
for i in vendors:
inlist = []
veninf = vendor.objects.filter(Category=i['Category'],
Item_desc=i['Item_desc'],
Vendor_name=i['Vendor_name'],
Vendor_loc=i['Vendor_loc'],
Approval=i['Approval'])
inlist.append(veninf[0].Category + '|' + veninf[0].Vendor_name + '|' +
veninf[0].Vendor_loc)
for j in range(1, max(set(maxpro)) + 1):
l = veninf.filter(Project=j)
if len(l) == 0:
inlist.append(0)
else:
inlist.append(l[0].Project_Rating)
data.append(inlist)
data_source1 = SimpleDataSource(data)
chart1 = gchart.ColumnChart(
data_source1,
options={'title': 'Rating of different Vendors'},
width='100%',
height=800)
return render(request, 'graph.html', {'chart1': chart1})
def global_charts(request):
qs = Log.objects.all()
week = [qs.filter(ts_input__week_day=i).count() for i in range(7)]
data = [[
'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday',
'Sunday'
], week]
#data_source = ModelDataSource(queryset, fields=['year', 'sales'])
chart = gchart.ColumnChart(SimpleDataSource(data=data),
html_id="line_chart")
return render(request, 'access/global_charts.html', {'chart': chart})
def draw_chart(post_dict):
data = []
data.append(['status', 'No of task'])
for status, temp_dict in post_dict.items():
data.append([status, len(temp_dict)])
print(data)
# DataSource object
# options = { 'width': 400,'height': 240,'title': "Toppings I Like On My Pizza",'colors': ["#00b300", "#e6693e", "#ec8f6e", "#f3b49f", "#e60000"]}
data = [[
'status', 'General Secretary, Technical Board 2018-19',
'Vice-President, Gymkhana Council 2017-18'
], ['Completed', 0.0, 31.03448275862069], ['Ongoing-Long-Term', 0.0, 0.0],
['Ongoing-Short-Term', 0.0, 0.0],
['Not-Evaluated', 0.0, 20.689655172413794],
['Not-Evaluated-Subjective', 0.0, 0.0],
['Not-Started', 100.0, 37.93103448275862],
['Broken', 0.0, 10.344827586206897]]
data_source = SimpleDataSource(data=data)
# Chart object
chart = gchart.ColumnChart(data_source)
return chart
def gchart_demo(request):
create_demo_accounts()
queryset = Account.objects.all()
data_source = ModelDataSource(queryset, fields=['year', 'sales'])
line_chart = gchart.LineChart(data_source,
options={'title': "Sales Growth"})
column_chart = gchart.ColumnChart(SimpleDataSource(data=data),
options={'title': "Sales vs Expense"})
bar_chart = gchart.BarChart(data_source,
options={'title': "Expense Growth"})
candlestick_chart = gchart.CandlestickChart(
SimpleDataSource(data=candlestick_data))
pie_chart = gchart.PieChart(data_source)
custom_chart = CustomGchart(data_source)
context = {
"line_chart": line_chart,
"column_chart": column_chart,
'bar_chart': bar_chart,
'candlestick_chart': candlestick_chart,
'pie_chart': pie_chart,
"custom_chart": custom_chart
}
return render(request, 'demo/gchart.html', context)
def comparepast(request):
if request.method == "POST":
designation = request.POST.get('designation')
# compare2 = request.POST.get('senator2')
print("in")
incldingsenator = agenda.objects.filter(
user__userprofileinfo__post_description__contains=designation)
obj1 = incldingsenator.exclude(user__username__contains="senator")
# agenda.objects.filter(user__userprofileinfo__p)
# obj2 = agenda.objects.filter(user__username=compare2)
print(designation)
# print(obj1)
# print(compare2)
chartdict = {}
chartdict = pastchart(obj1)
options1 = {'title': "Completed", 'colors': ["#109618"]}
flag = check(chartdict['Completed'])
chartcompleted = ''
chartsubjective = ''
chartnotevaluated = ''
chartnotstarted = ''
chartongoinshort = ''
chartongoinlong = ''
chartbroken = ''
if flag == 1:
data_source = SimpleDataSource(data=chartdict['Completed'])
chartcompleted = gchart.ColumnChart(data_source, options=options1)
# type(chartcompleted)
flag = check(chartdict['Ongoing-Long-Term'])
if flag == 1:
options2 = {}
options2['title'] = "Ongoing-Long-Term"
options2['colors'] = ["#660066"]
# options['colors']=[""]
data_source = SimpleDataSource(data=chartdict['Ongoing-Long-Term'])
chartongoinlong = gchart.ColumnChart(data_source, options=options2)
flag = check(chartdict['Ongoing-Short-Term'])
if flag == 1:
options3 = {}
options3['colors'] = ["#ff9900"]
options3['title'] = "Ongoing-Short-Term"
data_source = SimpleDataSource(
data=chartdict['Ongoing-Short-Term'])
chartongoinshort = gchart.ColumnChart(data_source,
options=options3)
flag = check(chartdict['Not-Evaluated'])
if flag == 1:
options4 = {}
options4['colors'] = ["#3366cc"]
options4['title'] = "Not-Evaluated"
data_source = SimpleDataSource(data=chartdict['Not-Evaluated'])
chartnotevaluated = gchart.ColumnChart(data_source,
options=options4)
flag = check(chartdict['Not-Evaluated-Subjective'])
if flag == 1:
options5 = {}
options5['colors'] = ["#0099c6"]
options5['title'] = "Not-Evaluated-Subjective"
data_source = SimpleDataSource(
data=chartdict['Not-Evaluated-Subjective'])
chartsubjective = gchart.ColumnChart(data_source, options=options5)
print(chartsubjective)
flag = check(chartdict['Not-Started'])
if flag == 1:
options6 = {}
options6['colors'] = ["#ff6600"]
options6['title'] = "Not-Started"
data_source = SimpleDataSource(data=chartdict['Not-Started'])
chartnotstarted = gchart.ColumnChart(data_source, options=options6)
flag = check(chartdict['Broken'])
if flag == 1:
options7 = {}
options7['colors'] = ["#dc3912"]
options7['title'] = "Broken"
data_source = SimpleDataSource(data=chartdict['Broken'])
chartbroken = gchart.ColumnChart(data_source, options=options7)
# print(chart)
return render(
request, 'gsecWorkStatus/compareview.html', {
'chartcompleted': chartcompleted,
'chartbroken': chartbroken,
'chartnotstarted': chartnotstarted,
'chartsubjective': chartsubjective,
'chartnotevaluated': chartnotevaluated,
'chartongoinshort': chartongoinshort,
'chartongoinlong': chartongoinlong
})
# return HttpResponseRedirect(reverse('candidate:vp'))
else:
# members = UserProfileInfo.objects.all()
# senators = User.objects.filter(username__contains="senator")
return render(request, 'gsecWorkStatus/compare.html')
def get_context_data(self, **kwargs):
context = super(Dashboard, self).get_context_data(**kwargs)
startd = self.request.GET.get('start-date')
endd = self.request.GET.get('end-date')
if self.request.GET.get('date'):
try:
today = datetime.strptime(self.request.GET.get('date'),
'%Y-%m-%d').date()
context["data_list"] = context["data_list"].filter(
datetime__year=today.year,
datetime__month=today.month,
datetime__day=today.day).order_by("datetime")
dv = Site.objects.all()
context["device1"] = context["data_list"].filter(
file__site=dv[0])[:24]
context["device2"] = context["data_list"].filter(
file__site=dv[1])
except Exception as e:
context['errors'] = ["Invalid Date Format Selected"]
elif startd and endd:
try:
startd = datetime.strptime(startd, '%Y-%m-%d').date()
endd = datetime.strptime(endd, '%Y-%m-%d').date()
context["data_list"] = context["data_list"].filter(
datetime__date__range=[startd, endd])
dv = Site.objects.all()
context["device1"] = context["data_list"].filter(
file__site=dv[0])
context["device2"] = context["data_list"].filter(
file__site=dv[1])
except Exception as e:
context['errors'] = ["Invalid Date Format Selected"]
else:
today = datetime.today()
context["data_list"] = context["data_list"].filter(
datetime__year=today.year,
datetime__month=today.month,
datetime__day=today.day).order_by("datetime")
dv = Site.objects.all()
context["device1"] = context["data_list"].filter(
file__site=dv[0])[:24]
context["device2"] = context["data_list"].filter(file__site=dv[1])
# # print(context)
# if self.request.GET.get('date'):
# try:
# today = datetime.strptime(self.request.GET.get('date'), '%Y-%m-%d').date()
# context["data_list"] = context["data_list"].filter(datetime__year=today.year, datetime__month=today.month, datetime__day=today.day).order_by("datetime")
# # print(context['data_list'])
# dv = Site.objects.all()
# # print(dv)
# print(context['data_list'])
# context["device1"] = context["data_list"].filter(file__name=dv[0].name)
# context["device2"] = context["data_list"].filter(file__name=dv[1])
# print("context is ", context['device1'])
# except Exception as e:
# context['errors'] = ["Invalid Date Format Selected"]
# return context
data = []
data1 = []
r1 = []
r2 = []
r3 = []
r4 = []
if context['device1']:
data = [['DateTime', 'Water_Level']]
for i in context['device1']:
data.append([i.datetime, i.volt])
chart = gchart.ColumnChart(SimpleDataSource(data=data),
options={'title': 'NHPC_Sewa'},
height=400,
width=600)
context["chart"] = chart
# return context
if context['device2']:
data1 = [['DateTime', 'Water_Level']]
for i in context['device2']:
data1.append([i.datetime, i.level])
chart1 = gchart.ColumnChart(SimpleDataSource(data=data1),
options={'title': 'NHPC_Sewa'},
height=400,
width=600)
context["chart1"] = chart1
# if context['device3']:
r1 = [['DateTime', 'Rain_Fall']]
for i in range(5):
r1.append([0, 0])
chart2 = gchart.ColumnChart(SimpleDataSource(data=r1),
options={'title': 'NHPC_Sewa'},
height=400,
width=600)
context["chart2"] = chart2
# if context['device4']:
r2 = [['DateTime', 'Rain_Fall']]
for i in range(5):
r2.append([0, 0])
chart3 = gchart.ColumnChart(SimpleDataSource(data=r2),
options={'title': 'NHPC_Sewa'},
height=400,
width=600)
context["chart3"] = chart3
# if context['device5']:
r3 = [['DateTime', 'Rain_Fall']]
for i in range(5):
r3.append([0, 0])
chart4 = gchart.ColumnChart(SimpleDataSource(data=r3),
options={'title': 'NHPC_Sewa'},
height=400,
width=600)
context["chart4"] = chart4
# if context['device6']:
r4 = [['DateTime', 'Rain_Fall']]
for i in range(5):
r4.append([0, 0])
chart5 = gchart.ColumnChart(SimpleDataSource(data=r4),
options={'title': 'NHPC_Sewa'},
height=400,
width=600)
context["chart5"] = chart5
return context
def get_context_data(self, **kwargs):
# Call the base implementation first to get a context
context = super(Dashboard, self).get_context_data(**kwargs)
startd = self.request.GET.get('start-date')
endd = self.request.GET.get('end-date')
if self.request.GET.get('date'):
try:
today = datetime.strptime(self.request.GET.get('date'),
'%Y-%m-%d').date()
context["data_list"] = context["data_list"].filter(
datetime__year=today.year,
datetime__month=today.month,
datetime__day=today.day).order_by("datetime")
dv = Devices.objects.all()
context["device1"] = context["data_list"].filter(
port__device=dv[0])
context["device2"] = context["data_list"].filter(
port__device=dv[1])
except Exception as e:
context['errors'] = ["Invalid Date Format Selected"]
elif startd and endd:
try:
startd = datetime.strptime(startd, '%Y-%m-%d').date()
endd = datetime.strptime(endd, '%Y-%m-%d').date()
context["data_list"] = context["data_list"].filter(
datetime__date__range=[startd, endd])
dv = Devices.objects.all()
context["device1"] = context["data_list"].filter(
port__device=dv[0])
context["device2"] = context["data_list"].filter(
port__device=dv[1])
except Exception as e:
context['errors'] = ["Invalid Date Format Selected"]
else:
today = datetime.today()
context["data_list"] = context["data_list"].filter(
datetime__year=today.year,
datetime__month=today.month,
datetime__day=today.day).order_by("datetime")
dv = Devices.objects.all()
context["device1"] = context["data_list"].filter(
port__device=dv[0])
context["device2"] = context["data_list"].filter(
port__device=dv[1])
print("devices", context)
context['mobile'] = Mobile.objects.all()
context["device1_max"] = context["device1"].aggregate(
Max('value'))["value__max"]
context["device1_min"] = context["device1"].aggregate(
Min('value'))["value__min"]
context["device1_avg"] = context["device1"].aggregate(
Avg('value'))["value__avg"]
context["device2_max"] = context["device2"].aggregate(
Max('value'))["value__max"]
context["device2_min"] = context["device2"].aggregate(
Min('value'))["value__min"]
context["device2_avg"] = context["device2"].aggregate(
Avg('value'))["value__avg"]
context["today_alert_times"] = len(
[i for i in context['device1'] if i.value > i.port.alert_level])
context["today_alert_times"] = len(
[i for i in context['device2'] if i.value > i.port.alert_level])
#context["last_sms"] = context["sms"].latest("datetime").datetime
data = []
data1 = []
if context['device1']:
data = [['DateTime', 'Water']]
for i in context['device1']:
data.append(
[i.datetime.strftime("%d/%m/%y %H:%I %p"), i.value])
chart = gchart.ColumnChart(SimpleDataSource(data=data),
options={'title': 'Water Level'},
height=400,
width=600)
context["chart"] = chart
# return context
if context['device2']:
data1 = [['DateTime', 'Water']]
for i in context['device2']:
data1.append(
[i.datetime.strftime("%d/%m/%y %H:%I %p"), i.value])
chart1 = gchart.ColumnChart(SimpleDataSource(data=data1),
options={'title': 'Water Level'},
height=400,
width=600)
context["chart1"] = chart1
return context
def index(request):
# Used later to keep track of the maximum JSS
lastResets = []
no_seum_delta = timedelta.max
# First select our counter
try:
myCounter = Counter.objects.get(user__id=request.user.id)
myLastReset = Reset.objects.select_related('who').filter(
counter=myCounter).order_by('-timestamp').first()
if myLastReset is None:
# This person never had the seum
myCounter.lastReset = Reset()
myCounter.lastReset.delta = no_seum_delta
myCounter.lastReset.formatted_delta = format_timedelta(
myCounter.lastReset.delta, locale=get_language(), threshold=1)
myCounter.lastReset.noSeum = True
else:
myCounter.lastReset = myLastReset
myCounter.lastReset.noSeum = False
if myCounter.lastReset.who is None or myCounter.lastReset.who.id == myCounter.id:
myCounter.lastReset.selfSeum = True
else:
myCounter.lastReset.selfSeum = False
likesMe = list(
Like.objects.select_related('liker').filter(
reset=myCounter.lastReset))
myCounter.likeCount = len(likesMe)
if myCounter.likeCount > 0:
myCounter.likersString = ", ".join(
[like.liker.trigramme for like in likesMe])
myCounter.lastReset.formatted_delta = arrow.Arrow.fromdatetime(
myCounter.lastReset.timestamp).humanize(locale=get_language())
except Counter.DoesNotExist:
return HttpResponseRedirect(reverse('login'))
# Building data for counters display
counters = Counter.objects.prefetch_related(
'resets__likes',
Prefetch('resets',
queryset=Reset.objects.prefetch_related(
'who',
Prefetch('likes',
queryset=Like.objects.select_related(
'liker'))).order_by('-timestamp'),
to_attr='lastReset'))
for counter in counters:
# Only the last reset is displayed
lastReset = list(counter.lastReset)
if len(lastReset) == 0: # This person never had the seum
counter.lastReset = Reset()
counter.lastReset.delta = no_seum_delta
counter.lastReset.formatted_delta = format_timedelta(
counter.lastReset.delta, locale=get_language(), threshold=1)
counter.lastReset.noSeum = True
counter.lastReset.likes_count = -1
counter.CSSclass = "warning"
else: # This person already had the seum
counter.lastReset = lastReset[0]
# To display the last seum we have to know if it is self-inflicted
if counter.lastReset.who is None or counter.lastReset.who == counter:
counter.lastReset.selfSeum = True
else:
counter.lastReset.selfSeum = False
# Now we compute the duration since the reset
counter.lastReset.noSeum = False
counter.lastReset.delta = datetime.now(
) - counter.lastReset.timestamp.replace(tzinfo=None)
# Defining CSS attributes for the counter
counter.CSSclass = 'primary' if counter == myCounter else 'default'
# Computing the total number of likes for this counter
likesMe = list(counter.lastReset.likes.all())
counter.lastReset.likes_count = len(likesMe)
counter.alreadyLiked = myCounter.id in [
likeMe.liker.id for likeMe in likesMe
]
if counter.lastReset.likes_count > 0:
counter.likersString = ", ".join(
[like.liker.trigramme for like in likesMe])
counter.lastReset.formatted_delta = arrow.Arrow.fromdatetime(
counter.lastReset.timestamp).humanize(locale=get_language())
counter.likeCount = counter.lastReset.likes_count
counter.isHidden = 'hidden'
if myCounter.sort_by_score:
# Now we sort the counters according to a reddit-like ranking formula
# We take into account the number of likes of a reset and recentness
# The log on the score will give increased value to the first likes
# The counters with no seum have a like count of -1 by convention
sorting_key = lambda t: -(math.log(t.lastReset.likes_count + 2) /
(1 + (t.lastReset.delta.total_seconds()) /
(24 * 3600)))
counters = sorted(counters, key=sorting_key)
else:
counters = sorted(counters,
key=lambda t: +t.lastReset.delta.total_seconds())
# ### GRAPHS ###
resets_raw = list(
Reset.objects.select_related(
'who', 'counter').annotate(likes_count=Count('likes')))
likes_raw = list(
Like.objects.select_related('liker', 'reset__counter').all())
hashtags_raw = list(Hashtag.objects.select_related('keyword').all())
# Prepare pandas.DataFrames to efficiently process the data
# About the counters
resets_cols = [
'date', 'counter', 'counter_trigram', 'who', 'who_trigram', 'reason',
'likes_count'
]
resets_data = [[
r.timestamp, r.counter.id, r.counter.trigramme, r.who, r.who, r.reason,
r.likes_count
] for r in resets_raw]
for r in resets_data:
r[3] = 0 if r[3] is None else r[3].id
r[4] = '' if r[4] is None else r[4].trigramme
resets_df = pd.DataFrame(resets_data, columns=resets_cols)
resets_df['timestamp'] = resets_df.date.map(lambda d: d.timestamp())
resets_df['self_seum'] = (resets_df.who.eq(np.zeros(resets_df.shape[0]))
| resets_df.who.eq(resets_df.counter)).map(float)
resets_df['formatted_delta'] = resets_df.date.map(
lambda d: arrow.Arrow.fromdatetime(d).humanize(locale=get_language()))
# About the likes
likes_cols = ['liker', 'liker_trigram', 'counter', 'counter_trigram']
likes_data = [[
l.liker.id, l.liker.trigramme, l.reset.counter.id,
l.reset.counter.trigramme
] for l in likes_raw]
likes_df = pd.DataFrame(likes_data, columns=likes_cols)
# About the hashtags
hashtags_cols = ['keyword']
hashtags_data = [[h.keyword.text] for h in hashtags_raw]
hashtags_df = pd.DataFrame(hashtags_data, columns=hashtags_cols)
# Timeline graph
timeline_resets = resets_df[resets_df.date > (
datetime.now() - timedelta(days=1))].copy().reset_index()
if timeline_resets.shape[0] == 0:
noTimeline = True
line_chart = None
else:
noTimeline = False
# Construct legend for timeline dots
legend_ = np.zeros(timeline_resets.shape[0], dtype=np.object)
for i in range(timeline_resets.shape[0]):
row = timeline_resets.iloc[i]
if row['self_seum'] == 1:
legend_[i] = _('%(counter)s: %(reason)s') % {
'counter': row['counter_trigram'],
'reason': row['reason']
}
else:
legend_[i] = _('%(who)s to %(counter)s: %(reason)s') % {
'who': row['who_trigram'],
'counter': row['counter_trigram'],
'reason': row['reason']
}
timeline_resets['legend'] = legend_
# Generate graph
resets_ = [['', _('Seum')]]
for i in range(timeline_resets.shape[0]):
r = timeline_resets.iloc[i]
resets_.append([{
'v': r.timestamp,
'f': r.formatted_delta
}, {
'v': 0,
'f': r.legend
}])
# resets_.append({
# 'timestamp': {'v': r.date.timestamp(), 'f': r.formatted_delta},
# 'Seum': {'v': 0, 'f': r.legend},
# })
line_data = SimpleDataSource(resets_)
line_chart = gchart.LineChart(
line_data,
options={
'lineWidth': 0,
'pointSize': 10,
'title': '',
'vAxis': {
'ticks': []
},
'hAxis': {
'ticks': [{
'v': (datetime.now() - timedelta(days=1)).timestamp(),
'f':
_('24h ago')
}, {
'v': datetime.now().timestamp(),
'f': _('Now')
}]
},
'legend': 'none',
'height': 90
})
# Graph of greatest seumers
seum_counts_df = resets_df[['counter_trigram', 'self_seum']].copy()
seum_counts_df['seum_count'] = np.ones(seum_counts_df.shape[0],
dtype=np.float32)
seum_counts_df = seum_counts_df.groupby(['counter_trigram'
]).sum().reset_index()
# TODO: Add the ratio self_seum / seum_count
if (seum_counts_df.shape[0] == 0):
noBestSeum = True
best_chart = None
else:
noBestSeum = False
seum_counts_data = seum_counts_df.sort_values(by='seum_count',
ascending=False)[[
'counter_trigram',
'seum_count'
]].values.tolist()
seum_counts_data.insert(0, [_('Trigram'), _('Number of seums')])
best_data = SimpleDataSource(seum_counts_data[:bestSeumeursNumber])
best_chart = gchart.ColumnChart(best_data,
options={
'title': '',
'legend': 'none',
'vAxis': {
'title': _('Number of seums')
},
'hAxis': {
'title': _('Trigram')
},
})
# Graph of seum activity
resets_act = resets_df[resets_df.date > (timezone.now() -
timedelta(days=365))][['date'
]].copy()
resets_act['year'] = resets_df.date.map(lambda d: d.year)
resets_act['month'] = resets_df.date.map(lambda d: d.month)
resets_act = resets_act.drop(['date'], axis=1)
resets_act['month_counts'] = np.ones(resets_act.shape[0], dtype=int)
resets_act = resets_act.groupby(['year', 'month']).sum().reset_index()
if resets_act.shape[0] == 0:
noSeumActivity = True
activity_chart = None
else:
noSeumActivity = False
seumActivity = [[
arrow.Arrow(a[0], a[1],
1).format("MMM YYYY",
locale=get_language()).capitalize(), a[2]
] for a in resets_act.values.tolist()]
seumActivity.insert(0, [_('Month'), _('Number of seums')])
activity_data = SimpleDataSource(seumActivity)
activity_chart = gchart.ColumnChart(activity_data,
options={
'title': '',
'legend': 'none',
'vAxis': {
'title':
_('Number of seums')
},
'hAxis': {
'title': _('Month')
},
})
# Graph of best likers
best_likers_df = likes_df.drop(['liker', 'counter', 'counter_trigram'],
axis=1)
best_likers_df['count'] = np.ones(best_likers_df.shape[0], dtype=int)
best_likers_df = best_likers_df.groupby(['liker_trigram'
]).sum().reset_index()
if best_likers_df.shape[0] == 0:
noBestLikers = True
likers_chart = None
else:
noBestLikers = False
likersCounts = best_likers_df.sort_values(
by='count', ascending=False).values.tolist()
likersCounts.insert(0, [_('Trigram'), _('Number of given likes')])
likers_data = SimpleDataSource(likersCounts[:bestSeumeursNumber])
likers_chart = gchart.ColumnChart(likers_data,
options={
'title': '',
'legend': 'none',
'vAxis': {
'title':
_('Number of given likes')
},
'hAxis': {
'title': _('Trigram')
},
})
# Graph of popular hashtags
hashtags_df['count'] = np.ones(hashtags_df.shape[0], dtype=int)
hashtags_df = hashtags_df.groupby(['keyword']).sum().reset_index()
hashtags_df['keyword'] = hashtags_df.keyword.map(lambda x: '#' + x)
if hashtags_df.shape[0] == 0:
noBestHashtags = True
hashtags_chart = None
else:
noBestHashtags = False
hashtags_data = hashtags_df.sort_values(
by='count', ascending=False).values.tolist()
hashtags_data.insert(
0, [_('Hashtag'),
_('Number of seums containing the hashtag')])
hashtags_data = SimpleDataSource(hashtags_data[:bestSeumeursNumber])
hashtags_chart = gchart.ColumnChart(
hashtags_data,
options={
'title': '',
'legend': 'none',
'vAxis': {
'title': _('Number of seums containing the hashtag')
},
'hAxis': {
'title': _('Hashtag')
},
})
# Graph of best likee
best_likees_df = likes_df.drop(['counter', 'liker', 'liker_trigram'],
axis=1)
best_likees_df['count'] = np.ones(best_likees_df.shape[0], dtype=int)
best_likees_df = best_likees_df.groupby(['counter_trigram'
]).sum().reset_index()
if best_likees_df.shape[0] == 0:
noBestLikees = True
likees_chart = None
else:
noBestLikees = False
likeesCounts = best_likees_df.sort_values(
by='count', ascending=False).values.tolist()
likeesCounts.insert(0, [_('Trigram'), _('Number of received likes')])
likees_data = SimpleDataSource(likeesCounts[:bestSeumeursNumber])
likees_chart = gchart.ColumnChart(likees_data,
options={
'title': '',
'legend': 'none',
'vAxis': {
'title':
_('Number of received likes')
},
'hAxis': {
'title': _('Trigram')
},
})
# At last we render the page
return render(
request, 'homeTemplate.html', {
'counters': counters,
'line_chart': line_chart,
'best_chart': best_chart,
'likers_chart': likers_chart,
'likees_chart': likees_chart,
'hashtags_chart': hashtags_chart,
'activity_chart': activity_chart,
'noTimeline': noTimeline,
'noBestSeum': noBestSeum,
'noBestLikers': noBestLikers,
'noBestLikees': noBestLikees,
'noBestHashtags': noBestHashtags,
'noSeumActivity': noSeumActivity,
'myCounter': myCounter,
})
