def _start(self):
if not self.model.get_option("license_accepted_and_read"):
self.view_license(already_accepted=False)
log_writer("width",self.winfo_screenwidth())
log_writer("height",self.winfo_screenheight())
self.mainloop()
def _start(self):
if not self.model.get_option("license_accepted_and_read"):
self.view_license(already_accepted=False)
log_writer("width",self.winfo_screenwidth())
log_writer("height",self.winfo_screenheight())
self.mainloop()
def get_site_info(start_date, end_date):
headers = {'Authorization': 'OAuth ' + cfg.token}
sources_sites = {
'metrics':
'ym:s:visits,ym:s:users,ym:s:pageviews,ym:s:bounceRate,ym:s:pageDepth,ym:s:avgVisitDurationSeconds',
'dimensions':
'ym:s:startURL,ym:s:startURLPathLevel1,ym:s:startURLPathLevel2,ym:s:startURLPathLevel3,'
'ym:s:startURLPathLevel4',
'date1':
start_date,
'date2':
end_date,
'ids':
23871871,
'filters':
"ALL(ym:s:startURL=='https://mbufk.roskazna.gov.ru/')"
}
response = requests.get('https://api-metrika.yandex.net/stat/v1/data',
params=sources_sites,
headers=headers)
lw.log_writer(f"server response code {response.status_code}")
metrika_data = response.json()
if response.status_code != 200 or metrika_data['total_rows'] == 0:
metrika_df = pd.DataFrame(columns=[
'startURL', 'Level1', 'Level2', 'Level3', 'Level4', 'visits',
'users', 'pageviews', 'bounceRate', 'pageDepth',
'avgVisitDurationSeconds'
])
metrika_df.loc[0] = '-', '-', '-', '-', 0, 0, 0, 0, 0, 0, 0
else:
list_of_dicts = []
dimensions_list = metrika_data['query']['dimensions']
metrics_list = metrika_data['query']['metrics']
for data_item in metrika_data['data']:
d = {}
for i, dimension in enumerate(data_item['dimensions']):
d[dimensions_list[i]] = dimension['name']
for i, metric in enumerate(data_item['metrics']):
d[metrics_list[i]] = metric
list_of_dicts.append(d)
metrika_df = pd.DataFrame(list_of_dicts)
metrika_df.columns = [
'startURL', 'Level1', 'Level2', 'Level3', 'Level4', 'visits',
'users', 'pageviews', 'bounceRate', 'pageDepth',
'avgVisitDurationSeconds'
]
return metrika_df
def update_figure_user(start_date_user, end_date_user, choosen_month,
choosen_week, choice_type_period):
if choice_type_period == 'm':
period_choice = True
week_choice = True
month_choice = False
lw.log_writer(f'User choice "month = {choosen_month}"')
if int(choosen_month) > 1:
etsp_prev_filt_df = etsp_df[etsp_df['month_open'] == (
int(choosen_month) - 1)]
sue_prev_filt_df = sue_df[sue_df['month_open'] == (
int(choosen_month) - 1)]
osp_prev_filt_df = osp_df[osp_df['month_open'] == (
int(choosen_month) - 1)]
else:
etsp_prev_filt_df = etsp_df[etsp_df['month_open'] == 12]
sue_prev_filt_df = sue_df[sue_df['month_open'] == 12]
osp_prev_filt_df = osp_df[osp_df['month_open'] == 12]
etsp_filtered_df = etsp_df[etsp_df['month_open'] == int(choosen_month)]
sue_filtered_df = sue_df[sue_df['month_open'] == int(choosen_month)]
osp_filtered_df = osp_df[osp_df['month_open'] == int(choosen_month)]
sue_incidents_filtered_df = sue_incidents_df[
sue_incidents_df['month_open'] == int(choosen_month)]
print(sue_incidents_filtered_df)
start_date_metrika = ld.GetMonthPeriod(ld.current_year,
choosen_month)[0]
end_date_metrika = ld.GetMonthPeriod(ld.current_year, choosen_month)[1]
filtered_metrika_df = si.get_site_info(start_date_metrika,
end_date_metrika)
elif choice_type_period == 'p':
period_choice = False
week_choice = True
month_choice = True
lw.log_writer(
f'User choice "range period start = {start_date_user}, end = {end_date_user}"'
)
if int(start_date_user[5:7]) > 1:
etsp_prev_filt_df = etsp_df[etsp_df['month_open'] == (
int(start_date_user[5:7]) - 1)]
sue_prev_filt_df = sue_df[sue_df['month_open'] == (
int(start_date_user[5:7]) - 1)]
osp_prev_filt_df = osp_df[osp_df['month_open'] == (
int(start_date_user[5:7]) - 1)]
else:
etsp_prev_filt_df = etsp_df[etsp_df['month_open'] == 12]
sue_prev_filt_df = sue_df[sue_df['month_open'] == 12]
osp_prev_filt_df = osp_df[osp_df['month_open'] == 12]
etsp_filtered_df = etsp_df[(etsp_df['start_date'] >= start_date_user)
& (etsp_df['start_date'] <= end_date_user)]
sue_filtered_df = sue_df[(sue_df['start_date'] >= start_date_user)
& (sue_df['start_date'] <= end_date_user)]
osp_filtered_df = osp_df[(osp_df['start_date'] >= start_date_user)
& (osp_df['start_date'] <= end_date_user)]
sue_incidents_filtered_df = sue_incidents_df[
(sue_incidents_df['Дата обращения'] >= start_date_user)
& (sue_incidents_df['Дата обращения'] <= end_date_user)]
start_date_metrika = start_date_user
end_date_metrika = end_date_user
filtered_metrika_df = si.get_site_info(start_date_metrika,
end_date_metrika)
else:
period_choice = True
week_choice = False
month_choice = True
lw.log_writer(
f'User choice "week = {choosen_week} ({ld.GetPeriod(ld.current_year, choosen_week)})"'
)
if int(choosen_week) > 1:
etsp_prev_filt_df = etsp_df[etsp_df['week_open'] == (
int(choosen_week) - 1)]
sue_prev_filt_df = sue_df[sue_df['week_open'] == (
int(choosen_week) - 1)]
osp_prev_filt_df = osp_df[osp_df['week_open'] == (
int(choosen_week) - 1)]
else:
etsp_prev_filt_df = etsp_df[etsp_df['week_open'] == 52]
sue_prev_filt_df = sue_df[sue_df['week_open'] == 52]
osp_prev_filt_df = osp_df[osp_df['week_open'] == 52]
etsp_filtered_df = etsp_df[etsp_df['week_open'] == int(choosen_week)]
sue_filtered_df = sue_df[sue_df['week_open'] == int(choosen_week)]
osp_filtered_df = osp_df[osp_df['week_open'] == int(choosen_week)]
sue_incidents_filtered_df = sue_incidents_df[
sue_incidents_df['week_open'] == int(choosen_week)]
start_date_metrika = ld.GetPeriod(ld.current_year, choosen_week,
's')[0]
end_date_metrika = ld.GetPeriod(ld.current_year, choosen_week, 's')[1]
filtered_metrika_df = si.get_site_info(start_date_metrika,
end_date_metrika)
etsp_count_tasks = etsp_filtered_df['count_task'].sum()
sue_count_tasks = sue_filtered_df['count_task'].sum()
osp_count_tasks = osp_filtered_df['count_task'].sum()
etsp_prev_count_tasks = etsp_prev_filt_df['count_task'].sum()
sue_prev_count_tasks = sue_prev_filt_df['count_task'].sum()
osp_prev_count_tasks = osp_prev_filt_df['count_task'].sum()
etsp_avg_time = ld.CountMeanTime(etsp_filtered_df)
sue_avg_time = ld.CountMeanTime(sue_filtered_df)
osp_avg_time = ld.CountMeanTime(osp_filtered_df)
visits = str(int(filtered_metrika_df['visits'][0]))
users = str(int(filtered_metrika_df['users'][0]))
pageviews = str(int(filtered_metrika_df['pageviews'][0]))
bounceRate = ''.join(
[str(round(filtered_metrika_df['bounceRate'][0], 2)), "%"])
pageDepth = str(round(filtered_metrika_df['pageDepth'][0], 2))
avgVisitDurSec = str(
dt.timedelta(seconds=round(
filtered_metrika_df['avgVisitDurationSeconds'][0], 0)))[2:]
site_stat_data = [{
'Визиты': visits,
'Посетители': users,
'Просмотры': pageviews,
'Отказы': bounceRate,
'Глубина просмотра': pageDepth,
'Время на сайте': avgVisitDurSec
}]
fig_support = go.Figure(
go.Bar(y=[etsp_count_tasks, sue_count_tasks, osp_count_tasks],
x=['ЕЦП', 'СУЭ', 'ОСП'],
base=0,
marker=dict(color=['#a92b2b', '#37a17c', '#a2d5f2']),
text=[etsp_count_tasks, sue_count_tasks, osp_count_tasks],
textposition='auto'))
fig_support.update_layout(autosize=True,
legend=dict(orientation="h",
yanchor="bottom",
y=0.2,
xanchor="right",
x=0.5),
paper_bgcolor='#ebecf1',
plot_bgcolor='#ebecf1')
fig_support.update_xaxes(ticks="inside", tickson="boundaries")
total_curr_tasks = etsp_count_tasks + sue_count_tasks + osp_count_tasks
total_prev_tasks = etsp_prev_count_tasks + sue_prev_count_tasks + osp_prev_count_tasks
diff_tasks = total_curr_tasks - total_prev_tasks
if diff_tasks > 0:
style_tasks = {'font-size': '2em', 'color': 'green'}
diff_tasks = '+ ' + str(diff_tasks)
elif diff_tasks == 0:
style_tasks = {'font-size': '2em'}
diff_tasks = str(diff_tasks)
else:
style_tasks = {'font-size': '2em', 'color': 'red'}
diff_tasks = str(diff_tasks)
total_tasks = ''.join([str(total_curr_tasks), ' ( ', diff_tasks, ' )'])
total_curr_users = len(etsp_filtered_df['user'].unique()) + len(
sue_filtered_df['user'].unique()) + len(
osp_filtered_df['user'].unique())
total_prev_users = len(etsp_prev_filt_df['user'].unique()) + len(
sue_prev_filt_df['user'].unique()) + len(
osp_prev_filt_df['user'].unique())
diff_users = total_curr_users - total_prev_users
if diff_users > 0:
style_users = {'font-size': '2em', 'color': 'green'}
diff_users = '+ ' + str(diff_users)
elif diff_users == 0:
style_users = {'font-size': '2em'}
diff_users = str(diff_users)
else:
style_users = {'font-size': '2em', 'color': 'red'}
diff_users = str(diff_users)
total_users = ''.join([str(total_curr_users), ' ( ', diff_users, ' )'])
labels_figure_support = ["ЕЦП", "СУЭ", "ОСП"]
values_figure_support = [
etsp_filtered_df['count_task'].sum(),
sue_filtered_df['count_task'].sum(),
osp_filtered_df['count_task'].sum()
]
colors = ['#a92b2b', '#37a17c', '#a2d5f2']
fig = go.Figure(
go.Pie(labels=labels_figure_support,
values=values_figure_support,
marker_colors=colors))
fig.update_traces(hoverinfo="label+percent+name")
fig.update_layout(paper_bgcolor='#ebecf1', showlegend=True)
etsp_top_user_filtered_df = ld.TopUser(etsp_filtered_df)
sue_top_user_filtered_df = ld.TopUser(sue_filtered_df)
if len(sue_incidents_filtered_df) > 0:
style_data = dict(width='20%', backgroundColor='#ff847c')
tooltip_data = [{
column: {
'value': str(value),
'type': 'markdown'
}
for column, value in row.items()
} for row in sue_incidents_filtered_df.to_dict('records')]
else:
style_data = dict(width='20%', backgroundColor='#c4fbdb')
sue_incidents_filtered_df = ld.NoIncidents()
tooltip_data = sue_incidents_filtered_df.to_dict('records')
return (period_choice, month_choice, week_choice, fig_support, total_tasks,
style_tasks, total_users, style_users, etsp_avg_time,
sue_avg_time, osp_avg_time, fig,
sue_incidents_filtered_df.to_dict('records'), style_data,
etsp_top_user_filtered_df.to_dict('records'),
sue_top_user_filtered_df.to_dict('records'), site_stat_data,
tooltip_data)
messages.append(_(u"Déclaration du type de document introuvable, insérez <!DOCTYPE html>"))
if not parsed_html.doctype_first:
messages.append(_(u"La déclaration du type de document doit se trouver en haut du document"))
for should, closed in parsed_html.close_before_error_list:
messages.append(_(u"Vous devez fermer {} avant {}").format(should, closed))
if len(parsed_html.start_list) > len(parsed_html.end_list):
messages.append(_(u"Il faut fermer toutes les balises !"))
for parent, child in parsed_html.must_parent_errors:
messages.append(
_(u"Les balises {} doivent êtres contenus dans des balises {}").format(child, parent)
)
# elif
return messages
def return_fragment(self, wanted="html"):
for inline in self.tabs_html[self.selected_tab].inlines:
if inline[0] == wanted:
return inline[1]
else:
print("wanted fragment not found")
def return_copy_document(self, wanted="html"):
return self.tabs_html[self.selected_tab].text
if __name__ == "__main__":
log_writer("platform", platform.platform())
log_writer("python_build", platform.python_build())
WebSpreeInstance = WebSpree()
if not parsed_html.declaration:
messages.append(_(u"Déclaration du type de document introuvable, insérez <!DOCTYPE html>"))
if not parsed_html.doctype_first:
messages.append(_(u"La déclaration du type de document doit se trouver en haut du document"))
for should,closed in parsed_html.close_before_error_list:
messages.append(_(u"Vous devez fermer {} avant {}").format(should,closed))
if len(parsed_html.start_list) > len(parsed_html.end_list):
messages.append(_(u"Il faut fermer toutes les balises !"))
for parent,child in parsed_html.must_parent_errors:
messages.append(_(u"Les balises {} doivent êtres contenus dans des balises {}").format(child,parent))
#elif
return messages
def return_fragment(self, wanted="html"):
for inline in self.tabs_html[self.selected_tab].inlines:
if inline[0] == wanted:
return inline[1]
else:
print("wanted fragment not found")
def return_copy_document(self, wanted="html"):
return self.tabs_html[self.selected_tab].text
if __name__ == '__main__':
log_writer("platform", platform.platform())
log_writer("python_build", platform.python_build())
WebSpreeInstance=WebSpree()
