From 46d40fff86fa1d651d423ede11c7ba5c014700a1 Mon Sep 17 00:00:00 2001 From: linozen Date: Thu, 25 Nov 2021 15:00:14 +0100 Subject: [PATCH] beautified merged until constraints --- explorer/lib/figures.py | 6 - explorer/merged.py | 448 +++++++------ publication/graphs.ipynb | 1305 ++++++++++++++++++++++++++++++++++++-- scripts/clean_merged.py | 136 ++-- 4 files changed, 1575 insertions(+), 320 deletions(-) diff --git a/explorer/lib/figures.py b/explorer/lib/figures.py index 2550636..8cb8385 100644 --- a/explorer/lib/figures.py +++ b/explorer/lib/figures.py @@ -26,12 +26,6 @@ def generate_overlaid_histogram(traces, names, colors): return fig -def generate_stacked_bar_chart(data): - fig = go.Figure(data=data) - fig.update_layout(width=800, height=800, barmode="stack") - return fig - - def generate_ranking_plot(df, input_col, options, scoring): input_col_score = pd.Series(index=options) for i in range(1, 7): diff --git a/explorer/merged.py b/explorer/merged.py index 5811e1b..a452269 100644 --- a/explorer/merged.py +++ b/explorer/merged.py @@ -7,16 +7,9 @@ from pathlib import Path from lib.figures import ( - generate_overlaid_histogram, - generate_stacked_bar_chart, generate_ranking_plot, ) -from lib.download import ( - get_csv_download_link, - get_excel_download_link, -) - # =========================================================================== # Define GUARDINT color scheme # =========================================================================== @@ -30,7 +23,7 @@ "#ff8e8f", "#ffc7c7", "#ffe3e3", - "#ffffff", + "#efefef", ] # =========================================================================== @@ -67,7 +60,7 @@ def gen_px_pie(df, values, names, color_discrete_sequence=colors, **kwargs): font={"size": 18, "family": "Roboto Mono, monospace"}, legend={ "font": {"size": kwargs.get("legend_font_size", 12)}, - "orientation": "h", + "orientation": kwargs.get("legend_orientation", "h"), "bgcolor": "#efefef", "x": -0.2, "y": 1.1, @@ -92,7 +85,7 @@ def gen_px_pie(df, values, names, color_discrete_sequence=colors, **kwargs): @st.cache -def gen_go_pie(labels, values, marker_colors=colors): +def gen_go_pie(labels, values, marker_colors=colors, **kwargs): fig = go.Figure( data=[ go.Pie( @@ -100,6 +93,45 @@ def gen_go_pie(labels, values, marker_colors=colors): ) ] ) + # Update what is shown on the slices (on hover) + fig.update_traces( + texttemplate="%{value}
%{percent}", + hovertemplate="""Answer %{label} +

given by %{value} respondents or %{percent} +
of all who answered the question +
given the current filter. + """, + ) + # Update layout + fig.update_layout( + autosize=False, + width=700, + height=kwargs.get("height", 450), + margin=dict(l=0, r=0, b=50, t=30), + font={"size": kwargs.get("font_size", 18), "family": "Roboto Mono, monospace"}, + legend={ + "font": {"size": kwargs.get("legend_font_size", 12)}, + "orientation": "v", + "bgcolor": "#efefef", + "x": kwargs.get("legend_x", -0.2), + "y": kwargs.get("legend_y", 1.1), + }, + modebar={"orientation": "v"}, + ) + # Add logo + fig.add_layout_image( + dict( + source="https://raw.githubusercontent.com/snv-berlin/ioi/master/guardint_logo.png", + xref="paper", + yref="paper", + x=1.00, + y=0.00, + sizex=0.15, + sizey=0.15, + xanchor="right", + yanchor="bottom", + ) + ) return fig @@ -122,7 +154,7 @@ def gen_px_histogram( width=700, height=450, margin=dict(l=0, r=0, b=100, t=30), - font={"size": 13, "family": "Roboto Mono, monospace"}, + font={"size": kwargs.get("font_size", 13), "family": "Roboto Mono, monospace"}, legend={ "font": {"size": kwargs.get("legend_font_size", 10)}, }, @@ -186,13 +218,36 @@ def gen_px_box(df, x, y, points, color, labels, color_discrete_map=colors, **kwa @st.cache -def render_overlaid_histogram(traces): - return generate_overlaid_histogram(traces) - - -@st.cache -def render_stacked_bar_chart(data): - return generate_stacked_bar_chart(data) +def gen_go_bar_stack(data, **kwargs): + fig = go.Figure(data=data) + # Update layout + fig.update_layout( + barmode="stack", + autosize=False, + width=700, + height=700, + margin=dict(l=0, r=0, b=100, t=30), + font={"size": 13, "family": "Roboto Mono, monospace"}, + legend={ + "font": {"size": kwargs.get("legend_font_size", 10)}, + }, + modebar={"orientation": "h"}, + ) + # Add logo + fig.add_layout_image( + dict( + source="https://raw.githubusercontent.com/snv-berlin/ioi/master/guardint_logo.png", + xref="paper", + yref="paper", + x=1.18, + y=-0.005, + sizex=0.15, + sizey=0.15, + xanchor="right", + yanchor="bottom", + ) + ) + return fig @st.cache @@ -367,6 +422,12 @@ def callback(): width: 100%; } + strong { + font-style: bold; + font-weight: 700; + color: #600b0c; + } + a { color: #ff1c1f !important; } @@ -375,6 +436,10 @@ def callback(): color: #ff5557 !important; } + a:visited { + color: #600b0c !important; + } + """, unsafe_allow_html=True, @@ -629,6 +694,7 @@ def callback(): labels={"expertise1": "years"}, ), use_container_width=True, + config=chart_config, ) st.plotly_chart( @@ -639,13 +705,14 @@ def callback(): y="expertise1", color="country", color_discrete_map={ - "Germany": colors[5], - "France": colors[1], - "United Kingdom": colors[7], + "Germany": colors[0], + "France": colors[2], + "United Kingdom": colors[5], }, labels={"expertise1": "years"}, ), use_container_width=True, + config=chart_config, ) st.write( @@ -657,99 +724,63 @@ def callback(): st.plotly_chart( gen_go_pie( labels=expertise2_counts.sort_index().index, - values=expertise2_counts.sort_index().values - # color_discrete_map={ - # "Expert knowledge": colors[0], - # "Advanced knowledge": colors[1], - # "Some knowledge": colors[2], - # "Basic knowledge": colors[3], - # "No knowledge": colors[4], - # "I don't know": colors[5], - # "I prefer not to say": colors[6], - # }, + values=expertise2_counts.sort_index().values, ), use_container_width=True, + config=chart_config, ) st.write( - "### How do you assess your level of expertise concerning the **political** aspects of surveillance by intelligence agencies?` [expertise3]`" + "### How do you assess your level of expertise concerning the **political** aspects of surveillance by intelligence agencies?" ) - expertise3_counts = df[filter]["expertise3"].value_counts() + expertise3_counts = df[filter]["expertise3"].value_counts().sort_index() + print_total(expertise3_counts.sum()) st.plotly_chart( - gen_px_pie( - df[filter], - values=expertise3_counts, - names=expertise3_counts.index, - color_discrete_sequence=None, - color=expertise3_counts.index, - color_discrete_map={ - "Expert knowledge": colors[9], - "Advanced knowledge": colors[8], - "Some knowledge": colors[7], - "Basic knowledge": colors[6], - "No knowledge": colors[5], - "I don't know": colors[10], - "I prefer not to say": colors[10], - }, + gen_go_pie( + labels=expertise3_counts.sort_index().index, + values=expertise3_counts.sort_index().values, ), use_container_width=True, + config=chart_config, ) st.write( - "### How do you assess your level of expertise concerning the **technical** aspects of surveillance by intelligence agencies?` [expertise4]`" + "### How do you assess your level of expertise concerning the **technical** aspects of surveillance by intelligence agencies?" ) - expertise4_counts = df[filter]["expertise4"].value_counts() + expertise4_counts = df[filter]["expertise4"].value_counts().sort_index() + print_total(expertise4_counts.sum()) st.plotly_chart( - gen_px_pie( - df[filter], - values=expertise4_counts, - names=expertise4_counts.index, - color_discrete_sequence=None, - color=expertise4_counts.index, - color_discrete_map={ - "Expert knowledge": colors[9], - "Advanced knowledge": colors[8], - "Some knowledge": colors[7], - "Basic knowledge": colors[6], - "No knowledge": colors[5], - "I don't know": colors[10], - "I prefer not to say": colors[10], - }, + gen_go_pie( + labels=expertise4_counts.sort_index().index, + values=expertise4_counts.sort_index().values, ), use_container_width=True, + config=chart_config, ) st.write("## Financial Resources") st.write( - "### How do you assess the financial resources that have been available for your work on intelligence over the past 5 years? `[finance1]`" + "### How do you assess the financial resources that have been available for your work on intelligence over the past 5 years?" ) - finance1_counts = df[filter]["finance1"].value_counts() + finance1_counts = df[filter]["finance1"].value_counts().sort_index() + print_total(finance1_counts.sum()) st.plotly_chart( - gen_px_pie( - df[filter], - values=finance1_counts, - names=finance1_counts.index, - color_discrete_sequence=None, - color=finance1_counts.index, - color_discrete_map={ - "A great deal of funding": colors[9], - "Sufficient funding": colors[8], - "Some funding": colors[7], - "Little funding": colors[6], - "No funding": colors[5], - "I don't know": colors[10], - "I prefer not to say": colors[10], - }, - ) + gen_go_pie( + labels=finance1_counts.sort_index().index, + values=finance1_counts.sort_index().values, + ), + use_container_width=True, + config=chart_config, ) st.write("## Freedom of Information") st.write( - "### Have you requested information under the national FOI law when you worked on intelligence-related issues over the past 5 years? `[foi1]`" + "### Have you requested information under the national FOI law when you worked on intelligence-related issues over the past 5 years?" ) foi1_counts = df[filter]["foi1"].value_counts() + print_total(foi1_counts.sum()) st.plotly_chart( gen_px_pie( foi1_counts, @@ -757,16 +788,18 @@ def callback(): names=foi1_counts.index, color=foi1_counts.index, color_discrete_map={ - "No": colors[8], - "Yes": colors[2], - "I don't know": colors[10], - "I prefer not to say": colors[10], + "No": colors[0], + "Yes": colors[3], + "I don't know": colors[4], + "I prefer not to say": colors[5], }, ), use_container_width=True, ) - st.write("### How often did you request information? `[foi2]`") + st.write("### How often did you request information?") + foi2_counts = df[filter]["foi3"].value_counts() + print_total(foi2_counts.sum()) st.plotly_chart( gen_px_histogram( df[filter], @@ -775,9 +808,9 @@ def callback(): nbins=10, color="country", color_discrete_map={ - "Germany": colors[5], - "France": colors[1], - "United Kingdom": colors[7], + "Germany": colors[0], + "France": colors[2], + "United Kingdom": colors[5], }, labels={"foi2": "Number of requests"}, ), @@ -792,51 +825,45 @@ def callback(): y="foi2", color="country", color_discrete_map={ - "Germany": colors[5], - "France": colors[1], - "United Kingdom": colors[7], + "Germany": colors[0], + "France": colors[2], + "United Kingdom": colors[5], }, + labels={"foi2": "Number of requests"}, ), use_container_width=True, ) st.write( - "### Over the past 5 years, did you receive a response to your FOI request(s) in a timely manner? `[foi3]`" + "### Over the past 5 years, did you receive a response to your FOI request(s) in a timely manner?" ) foi3_counts = df[filter]["foi3"].value_counts() + print_total(foi3_counts.sum()) st.plotly_chart( - gen_px_pie( - foi3_counts, - values=foi3_counts, - names=foi3_counts.index, - color=foi3_counts.index, - color_discrete_map={ - "Never": colors[9], - "No, usually longer than 30 days": colors[8], - "Yes, within 30 days": colors[2], - "I don't know": colors[10], - "I prefer not to say": colors[10], - }, + gen_go_pie( + labels=foi3_counts.sort_index().index, + values=foi3_counts.sort_index().values, ), use_container_width=True, + config=chart_config, ) st.write( - "### How helpful have Freedom of Information requests been for your work on intelligence-related issues? `[foi4]`" + "### How helpful have Freedom of Information requests been for your work on intelligence-related issues?" ) foi4_counts = df[filter]["foi4"].value_counts() - + print_total(foi4_counts.sum()) st.plotly_chart( - gen_px_pie( - df[filter], - values=foi4_counts, - names=foi4_counts.index, + gen_go_pie( + labels=foi4_counts.sort_index().index, + values=foi4_counts.sort_index().values, ), use_container_width=True, + config=chart_config, ) st.write( - "### Why haven’t you requested information under the national FOI law when you reported on intelligence-related issues over the past 5 years? `[foi5]`" + "### Why haven’t you requested information under the national FOI law when you reported on intelligence-related issues over the past 5 years?" ) foi5_df = pd.DataFrame(columns=("option", "count", "country")) # TODO Map proper labels @@ -858,6 +885,19 @@ def callback(): ignore_index=True, ) foi5_df = foi5_df.drop_duplicates() + foi5_df = foi5_df.replace( + { + "not_aware": "I was not aware", + "not_covered": "The authority was not covered
by FOI law", + "too_expensive": "It seemed to expensive", + "too_time_consuming": "It seemed to time-consuming", + "afraid_of_data_destruction": "I was afraid the request
could lead to data destruction", + "other": "Other", + "prefer_not_to_say": "I prefer not to say", + "dont_know": "I don't know ", + } + ) + print_total(foi5_df["count"].sum()) st.plotly_chart( gen_px_histogram( foi5_df, @@ -865,20 +905,21 @@ def callback(): y="count", nbins=None, color="country", + font_size=11, color_discrete_map={ - "Germany": colors[5], - "France": colors[1], - "United Kingdom": colors[7], + "Germany": colors[0], + "France": colors[2], + "United Kingdom": colors[5], }, labels={"count": "people who answered 'Yes'"}, ), use_container_width=True, + config=chart_config, ) - st.write("### If you selected ‘other’, please specify `[foi5other]`") - for i in df[filter]["foi5other"].to_list(): - if type(i) != float: - st.write("- " + i) +# =========================================================================== +# Protection +# =========================================================================== if selected_section == "Protection": st.write("# Protection") @@ -886,11 +927,11 @@ def callback(): st.write("## Operational Protection") st.write( - "### Have you taken any of the following measures to protect your datas from attacks and surveillance? `[protectops1]`" + "### Have you taken any of the following measures to protect your datas from attacks and surveillance?" ) protectops1_options = [ - "Participation in digital security training", - "Use of E2E encrypted communication channels", + "Participation in
digital security training", + "Use of E2E encrypted
communication channels", ] protectops1_yes = [] @@ -918,55 +959,67 @@ def callback(): protectops1_prefer_not_to_say.append(count) else: continue - + totals = [ + df[filter]["protectops1[sectraining]"].value_counts().sum(), + df[filter]["protectops1[e2e]"].value_counts().sum(), + ] + print_total(max(totals)) st.plotly_chart( - render_stacked_bar_chart( + gen_go_bar_stack( data=[ go.Bar( name="Yes", x=protectops1_options, y=protectops1_yes, - marker_color=colors[2], + marker_color=colors[1], ), go.Bar( name="No", x=protectops1_options, y=protectops1_no, - marker_color=colors[8], + marker_color=colors[0], ), go.Bar( name="I don't know", x=protectops1_options, y=protectops1_dont_know, - marker_color=colors[10], + marker_color=colors[4], ), go.Bar( name="I prefer not to say", x=protectops1_options, y=protectops1_prefer_not_to_say, - marker_color=colors[10], + marker_color=colors[5], ), ], ), use_container_width=True, + config=chart_config, ) - st.write( - "### Were any of these measures provided by your employer? `[protectops2]`" - ) + st.write("### Were any of these measures provided by your employer?") protectops2_counts = df[filter]["protectops2"].value_counts() + print_total(protectops2_counts.sum()) st.plotly_chart( gen_px_pie( df[filter], values=protectops2_counts, names=protectops2_counts.index, - color_discrete_sequence=colors, + color=protectops2_counts.index, + color_discrete_map={ + "No": colors[0], + "Yes": colors[2], + "I prefer not to say": colors[5], + "I don't know": colors[4], + }, + legend_orientation="v", ), use_container_width=True, + config=chart_config, ) st.write( - "### How important is the use of the following technical tools for you to protect your communications, your online activities and the data you handle? `[protectops3]`" + "### How important is the use of the following technical tools for you to protect your communications, your online activities and the data you handle?" ) protectops3_options = [ "Encrypted Email", @@ -1016,107 +1069,91 @@ def callback(): else: continue + totals = [ + df[filter]["protectops3[encrypted_email]"].value_counts().sum(), + df[filter]["protectops3[vpn]"].value_counts().sum(), + df[filter]["protectops3[tor]"].value_counts().sum(), + df[filter]["protectops3[e2e_chat]"].value_counts().sum(), + df[filter]["protectops3[encrypted_hardware]"].value_counts().sum(), + df[filter]["protectops3[2fa]"].value_counts().sum(), + df[filter]["protectops3[other]"].value_counts().sum(), + ] + print_total(max(totals)) st.plotly_chart( - render_stacked_bar_chart( + gen_go_bar_stack( data=[ go.Bar( name="Very important", x=protectops3_options, y=protectops3_very_important, - marker_color="#581845", + marker_color=colors[0], ), go.Bar( name="Somewhat important", x=protectops3_options, y=protectops3_somewhat_important, - marker_color="#900C3F", + marker_color=colors[1], ), go.Bar( name="Important", x=protectops3_options, y=protectops3_important, - marker_color="#C70039", + marker_color=colors[2], ), go.Bar( name="Slightly important", x=protectops3_options, y=protectops3_slightly_important, - marker_color="#FF5733", + marker_color=colors[3], ), go.Bar( name="Not important at all", x=protectops3_options, y=protectops3_not_important, - marker_color="#FFC300", + marker_color=colors[5], ), ], ), use_container_width=True, ) - st.write("### If you selected ‘other’, please specify `[protectops3other]`") - for i in df[filter]["protectops3other"].to_list(): - if type(i) != float: - st.write("- " + i) - st.write( - "### Which of the following statements best describes your level of confidence in the protection offered by technological tools? `[protectops4]`" + "### Which of the following statements best describes your level of confidence in the protection offered by technological tools?" ) protectops4_counts = df[filter]["protectops4"].value_counts() + print_total(protectops4_counts.sum()) st.plotly_chart( - gen_px_pie( - protectops4_counts, - values=protectops4_counts, - names=protectops4_counts.index, - color=protectops4_counts.index, - color_discrete_map={ - "I have full confidence that the right tools
will protect my communication from surveillance": colors[ - 4 - ], - "Technological tools help to protect my identity
to some extent, but an attacker with sufficient power
may eventually be able to bypass my technological
safeguards": colors[ - 5 - ], - "Under the current conditions of communications
surveillance, technological solutions cannot offer
sufficient protection for the data I handle": colors[ - 6 - ], - "I have no confidence in the protection offered by
technological tools": colors[ - 7 - ], - "I try to avoid technology-based communication whenever
possible when I work on intelligence-related issues": colors[ - 8 - ], - "I don't know": colors[10], - "I prefer not to say": colors[10], - }, + gen_go_pie( + labels=protectops4_counts.sort_index().index, + values=protectops4_counts.sort_index().values, + height=600, + font_size=13, + legend_font_size=11, + legend_x=-1.0, + legend_y=2.0, ), use_container_width=True, + config=chart_config, ) st.write("## Legal Protection") - # TODO Clarify that in MS it's about source protection (also for protectleg2) st.write( - "### When working on intelligence-related issues, do you feel you have reason to be concerned about... surveillance of your activities (_CSO representatives_) | regarding the protection of your sources (_media representatives_) `[protectleg1]`" + """### When working on intelligence-related issues, do you feel you have reason to be concerned about... + +- surveillance of your activities (CSO representatives) +- regarding the protection of your sources (media representatives)""" ) protectleg1_counts = df[filter]["protectleg1"].value_counts() + print_total(protectleg1_counts.sum()) st.plotly_chart( - gen_px_pie( - df[filter], - values=protectleg1_counts, - names=protectleg1_counts.index, - color=protectleg1_counts.index, - color_discrete_map={ - "Always": colors[9], - "Often": colors[8], - "Sometimes": colors[7], - "Rarely": colors[6], - "Never": colors[5], - "I don't know": colors[10], - "I prefer not to say": colors[10], - }, + gen_go_pie( + labels=protectleg1_counts.sort_index().index, + values=protectleg1_counts.sort_index().values, ), use_container_width=True, + config=chart_config, ) st.write( @@ -1124,6 +1161,7 @@ def callback(): ) protectleg2_counts = df[filter]["protectleg2"].value_counts() + print_total(protectleg2_counts.sum()) st.plotly_chart( gen_px_pie( protectleg2_counts, @@ -1132,22 +1170,17 @@ def callback(): color_discrete_sequence=colors, color=protectleg2_counts.index, color_discrete_map={ - "No": colors[8], + "No": colors[0], "Yes": colors[2], - "I don't know": colors[10], - "I prefer not to say": colors[10], + "I don't know": colors[5], + "I prefer not to say": colors[4], }, ), use_container_width=True, ) - st.write("### If you selected ‘no’, please specify `[protectleg2no]`") - for i in df[filter]["protectleg2no"].to_list(): - if type(i) != float: - st.write("- " + i) - st.write( - "### Are any of the following forms of institutional support readily available to you? `[protectleg3]`" + "### Are any of the following forms of institutional support readily available to you?" ) protectleg3_options = ["Free legal counsel", "Legal cost insurance", "Other"] protectleg3_yes = [] @@ -1171,7 +1204,7 @@ def callback(): else: continue st.plotly_chart( - render_stacked_bar_chart( + gen_go_bar_stack( data=[ go.Bar( name="Yes", @@ -1183,20 +1216,20 @@ def callback(): name="No", x=protectleg3_options, y=protectleg3_no, - marker_color=colors[8], + marker_color=colors[0], ), go.Bar( name="I don't know", x=protectleg3_options, y=protectleg3_dont_know, - marker_color="#7f7f7f", + marker_color=colors[5], opacity=0.8, ), go.Bar( name="I prefer not to say", x=protectleg3_options, y=protectleg3_prefer_not_to_say, - marker_color="#525252", + marker_color=colors[4], opacity=0.8, ), ], @@ -1204,10 +1237,9 @@ def callback(): use_container_width=True, ) - st.write("### If you selected ‘other’, please specify `[protectleg3other]`") - for i in df[filter]["protectleg3other"].to_list(): - if type(i) != float: - st.write("- " + i) +# =========================================================================== +# Constraints +# =========================================================================== if selected_section == "Constraints": st.write("# Constraints") @@ -1288,7 +1320,7 @@ def callback(): else: continue st.plotly_chart( - render_stacked_bar_chart( + gen_go_bar_stack( data=[ go.Bar( name="Yes", @@ -1350,7 +1382,7 @@ def callback(): else: continue st.plotly_chart( - render_stacked_bar_chart( + gen_go_bar_stack( data=[ go.Bar( name="Yes", @@ -1427,7 +1459,7 @@ def callback(): else: continue st.plotly_chart( - render_stacked_bar_chart( + gen_go_bar_stack( data=[ go.Bar( name="Yes", diff --git a/publication/graphs.ipynb b/publication/graphs.ipynb index 2c07594..ecfded8 100644 --- a/publication/graphs.ipynb +++ b/publication/graphs.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 4, "id": "a9f59342-c043-4a8d-b881-4933ba9705aa", "metadata": {}, "outputs": [], @@ -12,12 +12,12 @@ "import plotly.graph_objects as go\n", "from plotly.subplots import make_subplots\n", "\n", - "df = pd.read_pickle(\"./data/merged.pkl\")" + "df = pd.read_pickle(\"../data/merged.pkl\")" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 5, "id": "8664f5f2-4334-414b-9190-252c59b70ecc", "metadata": {}, "outputs": [], @@ -1253,7 +1253,7 @@ } } }, - "image/png": "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", + "image/png": "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", "text/html": [ "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Now, generate some graph\n", + "import plotly.express as px\n", + "from plotly.subplots import make_subplots\n", + "\n", + "config = {\n", + " \"toImageButtonOptions\": {\n", + " \"format\": \"png\", # one of png, svg, jpeg, webp\n", + " \"filename\": \"custom_image\",\n", + " \"height\": 1000,\n", + " \"width\": 1000,\n", + " \"scale\": (210 / 25.4) / (1900 / 300),\n", + " }\n", + "}\n", + "\n", + "answer_colors = [green, yellow, orange, red, grey]\n", + "\n", + "values_all = df[\"protectleg2\"].value_counts().to_frame()\n", + "values_all = values_all.sort_index(ascending=False)\n", + "\n", + "values_de = (\n", + " df[(df.country == \"Germany\")][\"protectleg2\"].value_counts().to_frame().sort_index(ascending=False)\n", + ")\n", + "values_fr = (\n", + " df[(df.country == \"France\")][\"protectleg2\"].value_counts().to_frame().sort_index(ascending=False)\n", + ")\n", + "values_uk = (\n", + " df[(df.country == \"United Kingdom\")][\"protectleg2\"]\n", + " .value_counts()\n", + " .to_frame()\n", + " .sort_index(ascending=False)\n", + ")\n", + "\n", + "fig = make_subplots(\n", + " rows=2,\n", + " cols=3,\n", + " subplot_titles=(\"All\", \"Germany\", \"France\", \"United Kingdom\"),\n", + " vertical_spacing=0.17,\n", + " specs=[\n", + " [{\"type\": \"pie\", \"colspan\": 3},None, None],\n", + " [{\"type\": \"pie\"}, {\"type\": \"pie\"}, {\"type\": \"pie\"}],\n", + " ],\n", + ")\n", + "fig.add_trace(\n", + " go.Pie(\n", + " labels=values_all.index,\n", + " values=values_all[\"protectleg2\"],\n", + " scalegroup=\"one\",\n", + " name=\"All\",\n", + " marker_colors=[green, red, \"#808080\", grey],\n", + " sort=False,\n", + " ),\n", + " 1,\n", + " 1,\n", + ")\n", + "fig.add_trace(\n", + " go.Pie(\n", + " labels=values_de.index,\n", + " values=values_de[\"protectleg2\"],\n", + " scalegroup=\"one\",\n", + " name=\"Germany\",\n", + " marker_colors=[green, red, \"#808080\", grey],\n", + " sort=False,\n", + " ),\n", + " 2,\n", + " 1,\n", + ")\n", + "fig.add_trace(\n", + " go.Pie(\n", + " labels=values_fr.index,\n", + " values=values_fr[\"protectleg2\"],\n", + " scalegroup=\"one\",\n", + " name=\"France\",\n", + " marker_colors=[green, red],\n", + " sort=False,\n", + " ),\n", + " 2,\n", + " 2,\n", + ")\n", + "fig.add_trace(\n", + " go.Pie(\n", + " labels=values_uk.index,\n", + " values=values_uk[\"protectleg2\"],\n", + " scalegroup=\"one\",\n", + " name=\"United Kingdom\",\n", + " marker_colors=[green, red, \"#808080\", grey],\n", + " sort=False,\n", + " ),\n", + " 2,\n", + " 3,\n", + ")\n", + "\n", + "fig.update_traces(texttemplate=\"%{percent}
%{value}\")\n", + "\n", + "fig.update_annotations(font_size=28)\n", + "\n", + "fig.update_layout(\n", + " autosize=False,\n", + " height=1000,\n", + " width=1000,\n", + " title_font_size=40,\n", + " margin=dict(l=100, r=0, b=0, t=50),\n", + " font={\"size\": 18, \"family\": \"Fira Sans\", \"color\": \"#000000\"},\n", + " legend={\n", + " \"font\": {\"color\": \"#000000\", \"size\": 14},\n", + " \"bgcolor\": \"#efefef\",\n", + " \"x\": 0.01,\n", + " \"y\": 1.03,\n", + " },\n", + ")\n", + "\n", + "\n", + "fig.show(config=config)" + ] + }, { "cell_type": "code", "execution_count": 8, @@ -7115,7 +8344,7 @@ } } }, - "image/png": "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", + "image/png": "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", "text/html": [ "