def _make_navbar(self):
if flask.has_request_context():
custom_setting_count = len(
[k for k in session.keys() if not k.startswith('_')])
else:
custom_setting_count = 0
badge_el = None
if custom_setting_count:
badge_el = dbc.Badge(f'{custom_setting_count} ',
className='badge-danger')
els = [
dbc.DropdownMenu(
[
dbc.DropdownMenuItem(_('Population'), href='/vaesto'),
dbc.DropdownMenuItem(_('Buildings'), href='/rakennukset')
],
nav=True,
in_navbar=True,
label=_("Defaults"),
# id="dropdown-nav"
),
dbc.NavItem(
dbc.NavLink(href='/omat-asetukset',
children=[
_("Own settings"),
badge_el,
])),
dbc.NavItem(html.Span(html.I(className='language-icon')),
className='nav-link pr-0'),
dbc.DropdownMenu(
[
dbc.DropdownMenuItem(
"Suomi", href='/language/fi', external_link=True),
dbc.DropdownMenuItem(
"English", href='/language/en', external_link=True)
],
nav=True,
in_navbar=True,
label=get_active_locale().upper(),
right=True,
),
]
return dbc.NavbarSimple(brand=get_variable('site_name_%s' %
get_active_locale()),
brand_href="/",
color="primary",
dark=True,
fluid=True,
children=els)
def render_sector(s, sector_path, level):
sector_emissions = s.sum(level=0).sort_values(ascending=False)
for subsector_name, emissions in sector_emissions.iteritems():
if not subsector_name:
continue
subsector_path = tuple([*sector_path, subsector_name])
next_metadata = SECTORS
for sp in subsector_path:
metadata = next_metadata[sp]
next_metadata = metadata.get('subsectors', {})
if current_sector == subsector_path:
active = True
else:
active = False
page = get_page_for_emission_sector(*subsector_path)
name = metadata.get('name_%s' % get_active_locale())
if name is None:
name = metadata['name']
item = _make_nav_item(name, emissions, level, page, active=active)
items.append(item)
ss = s[subsector_name]
if isinstance(ss, pd.Series):
render_sector(ss, subsector_path, level + 1)
def get_content(self):
lang = get_active_locale()
main_sector_name = self.emission_sector[0]
main_sector_metadata = SECTORS[main_sector_name]
cols = []
edf = predict_emissions().dropna(axis=1, how='all')
forecast = edf.pop('Forecast')
edf = edf[main_sector_name]
subsectors = main_sector_metadata['subsectors']
colors = generate_color_scale(main_sector_metadata['color'],
len(subsectors))
graph = PredictionFigure(sector_name=main_sector_name,
unit_name='kt',
title=_('Total emissions'),
smoothing=True,
fill=True,
stacked=True,
legend=True,
legend_x=0.8)
for idx, (sector_name,
sector_metadata) in enumerate(subsectors.items()):
df = pd.DataFrame(edf[sector_name])
df['Forecast'] = forecast
fig = self.make_sector_fig(df, sector_name, sector_metadata,
colors[idx])
sector_page = get_page_for_emission_sector(main_sector_name,
sector_name)
card = GraphCard(id='emissions-%s-%s' %
(main_sector_name, sector_name),
graph=dict(figure=fig),
link_to_page=sector_page)
cols.append(dbc.Col(card.render(), md=6))
# Add the summed sector to the all emissions graph
df = df.drop(columns=['Forecast'])
s = df.sum(axis=1)
s.name = 'Emissions'
df = pd.DataFrame(s)
df['Forecast'] = forecast
graph.add_series(df=df,
trace_name=sector_metadata.get(
'name_%s' % lang, sector_metadata['name']),
column_name='Emissions',
historical_color=colors[idx])
self.total_emissions = edf.iloc[-1].sum()
card = GraphCard(id='%s-emissions-total' % main_sector_name,
graph=dict(figure=graph.get_figure()))
return html.Div([
dbc.Row(dbc.Col(card.render())),
dbc.Row(cols),
])
def make_sector_fig(self, df, name, metadata, base_color):
lang = get_active_locale()
fig = PredictionFigure(
sector_name=name,
unit_name='kt',
title=metadata.get('name_%s' % lang, metadata['name']),
smoothing=True,
# allow_nonconsecutive_years=True,
fill=True,
stacked=True,
)
if len(df.columns) == 2:
fig.add_series(df=df,
trace_name=_('Emissions'),
column_name='',
historical_color=base_color)
else:
fig.legend = True
fig.legend_x = 0.8
column_names = list(df.columns)
column_names.remove('Forecast')
colors = generate_color_scale(base_color, len(column_names))
for idx, col_name in enumerate(column_names):
subsector = metadata['subsectors'][col_name]
fig.add_series(df=df,
trace_name=subsector.get(
'name_%s' % lang, metadata['name']),
column_name=col_name,
historical_color=colors[idx])
return fig.get_figure()
def render(self):
els = []
graph_attrs = {
'config': dict(
displayModeBar=False,
responsive=True,
)
}
locale = get_active_locale()
if locale:
graph_attrs['config']['locale'] = locale
if self.graph is not None:
deepupdate(graph_attrs, self.graph)
graph = dcc.Graph(id='%s-graph' % self.id,
className='slider-card__graph',
**graph_attrs)
els.append(graph)
if self.slider:
slider_args = ['min', 'max', 'step', 'value', 'marks']
assert set(self.slider.keys()).issubset(set(slider_args))
slider_el = dcc.Slider(
id='%s-slider' % self.id,
vertical=True,
className='mb-4',
**self.slider,
)
els.append(html.Div(slider_el, className='slider-card__slider'))
return els
def _refresh_trip_cards(self):
df = predict_passenger_kms()
card = self.get_card('number-of-passenger-kms')
fig = PredictionFigure(
sector_name='Transportation',
unit_name='km',
)
fig.add_series(df,
column_name='KmsPerResident',
trace_name=_('passenger kms (p.c.)'))
card.set_figure(fig)
df.pop('KmsPerResident')
total = df.sum(axis=1)
fc = df.pop('Forecast')
df = df.div(total, axis=0)
df *= 100
# df['Other'] += df.pop('Taxi')
df['Rail'] = df.pop('Metro') + df.pop('Tram') + df.pop('Train')
ccard = self.get_card('modal-share-car')
fig = PredictionFigure(
sector_name='Transportation',
unit_name='%',
)
fig.add_series(df=df,
forecast=fc,
column_name='Car',
trace_name='Henkilöautot')
ccard.set_figure(fig)
df.pop('Car')
mcard = self.get_card('modal-shares-rest')
color_scale = len(df.columns)
fig = PredictionFigure(
sector_name='Transportation',
unit_name='%',
legend=True,
color_scale=color_scale,
)
last_hist_year = fc[~fc].index.max()
columns = list(
df.loc[last_hist_year].sort_values(ascending=False).index)
for idx, col in enumerate(columns):
name = MODE_TRANSLATIONS.get(col)
if name is not None:
name = name.get(get_active_locale())
if name is None:
name = col
fig.add_series(df=df,
forecast=fc,
column_name=col,
trace_name=name,
color_idx=idx)
mcard.set_figure(fig)
def render_description(self):
lang = get_active_locale()
if lang in self.description_i18n:
desc = self.description_i18n[lang]
elif self.description is not None:
desc = self.description
else:
return None
return dbc.Col(desc, style=dict(minHeight='8rem'))
def generate_buildings_forecast_graph():
df = generate_building_floor_area_forecast()
cdf = pd.DataFrame(index=df.index)
for name, attrs in BUILDING_USES.items():
cdf[name] = df[attrs['types']].sum(axis=1) / 1000000
# Sort columns based on the amounts in the last measured year
last_year = cdf.loc[cdf.index.max()]
columns = list(last_year.sort_values(ascending=False).index.values)
traces = []
lang = get_active_locale()
for name in columns:
attrs = BUILDING_USES[name]
val = df[attrs['types']].sum(axis=1) / 1000000
label = name
if lang == 'en':
label = BUILDINGS_EN[name]
trace = go.Bar(x=df.index,
y=val,
name=label,
marker=dict(color=attrs['color']),
hoverinfo='name',
hovertemplate='%{x}: %{y} Mkem²')
traces.append(trace)
last_hist_year = df[~df.Forecast].index.max()
forecast_divider = dict(type='line',
x0=last_hist_year + 0.5,
x1=last_hist_year + 0.5,
xref='x',
y0=0,
y1=1,
yref='paper',
line=dict(dash='dot', color='grey'))
layout = make_layout(
barmode='stack',
yaxis=dict(title='1 000 000 kem²', ),
xaxis=dict(title=_('Year')),
title=_('Floor area by building purpose'),
shapes=[forecast_divider],
showlegend=True,
autosize=True,
)
return dict(data=traces, layout=layout)
def render_region_info():
from babel.numbers import format_number
pop = get_population_for_area().sum().sum()
region_card = dbc.CardBody(html.Ul([
html.Li([
html.Strong('%s: ' % _("Region Name")),
html.Span(get_variable('area_name_long'))
]),
html.Li([
html.Strong('%s: ' % _("Region Population")),
html.Span(format_number(pop, locale=get_active_locale())),
]),
]),
className="px-5"),
return region_card
def render(self, is_top_row: bool = True) -> dbc.Card:
graph = Graph(self.id, self.graph, self.slider)
classes = self.get_classes(is_top_row)
graph_el = html.Div(graph.render(), className="slider-card__content")
language = get_active_locale()
title = self.title_i18n.get(language, self.title)
if title:
header_content = dbc.CardHeader(html.H4(title))
else:
header_content = None
if self.link_to_page:
if isinstance(self.link_to_page, tuple):
from pages.routing import get_page_for_emission_sector
page = get_page_for_emission_sector(*self.link_to_page)
else:
page = self.link_to_page
link_el = dcc.Link(html.H5('[+]'),
href=page.path,
className="card-header__link")
header_el = html.Div([link_el, header_content])
else:
header_el = header_content
card = dbc.Card(
[
header_el,
dbc.CardBody(children=[
graph_el,
dbc.Row(children=self.render_description(),
id=self.id + '-description'),
self.extra_content,
])
],
className=' '.join(classes),
)
return card
def _render_subsectors(self, df, sector_name, cur_x):
lang = get_active_locale()
page = self.current_page
if page is not None and page.emission_sector is not None and \
page.emission_sector[0] == sector_name:
active_sector = True
sector_path = page.emission_sector
else:
sector_path = (sector_name, )
active_sector = False
path = list(sector_path)
primary_sector = path.pop(0)
primary_sector_metadata = get_sector_by_path(primary_sector)
df = df[primary_sector]
last_year = df.iloc[-1]
if not isinstance(last_year, pd.Series):
last_year = pd.Series([last_year], index=(sector_name, ))
last_year = last_year.dropna(axis=0)
emissions_left = last_year.dropna(axis=0).sum()
sector_metadata = primary_sector_metadata
for p in path:
try:
next_sector = last_year[p]
if not isinstance(next_sector, pd.Series):
break
last_year = next_sector
sector_metadata = primary_sector_metadata['subsectors'][p]
except KeyError:
# The sector might be missing because it has emissions
# increases instead of decreases.
last_year = pd.Series()
if not active_sector:
last_year = pd.Series()
else:
if isinstance(last_year.index,
pd.MultiIndex) and len(last_year.index.levels) > 1:
last_year = last_year.sum(axis=0, level=0)
colors = generate_color_scale(primary_sector_metadata['color'],
len(last_year.index) + 1)
colors.remove(primary_sector_metadata['color'])
colors.reverse()
traces = []
active_emissions = 0
for sector_name, emissions in last_year.items():
if isinstance(sector_name, tuple):
sector_name = sector_name[0]
if not emissions or np.isnan(emissions):
continue
if not sector_name and len(last_year) == 1:
break
if sector_name:
ss_metadata = sector_metadata['subsectors'][sector_name]
else:
ss_metadata = sector_metadata
color = colors.pop(0)
imp_key = 'improvement_name_%s' % lang
name_key = 'name_%s' % lang
name = ss_metadata.get(imp_key) or ss_metadata.get(
name_key) or ss_metadata.get(
'improvement_name') or ss_metadata['name']
bar = dict(type='bar',
x=[emissions],
name=name,
orientation='h',
hoverinfo='text',
hovertext='%.0f kt: %s' % (emissions, name),
marker=dict(color=color))
traces.append(bar)
emissions_left -= emissions
active_emissions += emissions
md = primary_sector_metadata
name = md.get('improvement_name') or md['name']
if traces:
name = '%s (%s)' % (name, gettext('other'))
else:
active_emissions = emissions_left
traces.append(
dict(type='bar',
x=[emissions_left],
name=name,
orientation='h',
hoverinfo='text',
hovertext='%.0f kt: %s' % (emissions_left, name),
marker=dict(
color=primary_sector_metadata['color'],
line_width=0,
)))
shapes = []
if active_sector:
shapes.append(
dict(type='rect',
x0=cur_x,
x1=cur_x + active_emissions,
y0=0,
y1=1,
yref='paper',
line=dict(
color='#888',
width=4,
)))
return traces, shapes
def render_page():
language = get_active_locale()
cols = []
edf = predict_emissions().dropna(axis=1, how='all')
forecast = edf.pop('Forecast')
graph = PredictionFigure(sector_name=None,
unit_name='kt',
title=_('Total emissions'),
smoothing=True,
fill=True,
stacked=True,
legend=True,
legend_x=0.8)
for sector_name, sector_metadata in SECTORS.items():
df = pd.DataFrame(edf[sector_name])
df['Forecast'] = forecast
fig = make_sector_fig(df, sector_name, sector_metadata)
sector_page = get_page_for_emission_sector(sector_name, None)
card = GraphCard(id='emissions-%s' % sector_name,
graph=dict(figure=fig),
link_to_page=sector_page)
cols.append(dbc.Col(card.render(), md=6))
# Add the summed sector to the all emissions graph
df = df.drop(columns=['Forecast'])
s = df.sum(axis=1)
s.name = 'Emissions'
df = pd.DataFrame(s)
df['Forecast'] = forecast
name = sector_metadata.get('name_%s' % language,
sector_metadata['name'])
graph.add_series(df=df,
trace_name=name,
column_name='Emissions',
historical_color=sector_metadata['color'])
target_year = get_variable('target_year')
ref_year = get_variable('ghg_reductions_reference_year')
perc_off = get_variable('ghg_reductions_percentage_in_target_year')
last_hist_year = edf.loc[~forecast].index.max()
last_hist = edf.loc[last_hist_year].sum()
end_emissions = edf.loc[target_year].sum()
ref_emissions = edf.loc[ref_year].sum()
target_emissions = ref_emissions * (1 - perc_off / 100)
target_year_emissions = edf.loc[target_year].sum()
sticky = StickyBar(
label=_('Total emission reductions'),
goal=last_hist - target_emissions,
value=last_hist - end_emissions,
unit='kt',
below_goal_good=False,
)
card = GraphCard(id='emissions-total',
graph=dict(figure=graph.get_figure()))
return html.Div(
[dbc.Row(dbc.Col(card.render())),
dbc.Row(cols),
sticky.render()])
