def get_feature_row(self):
all_features_reported = self.get_unique_values("Features")
themes_fromdb = FEATURES_DB_2018
rows = []
all_features = []
all_themes = defaultdict(list)
for feat in all_features_reported:
all_features.extend(feat.split(','))
all_features = set(all_features)
for feature in all_features:
if feature not in themes_fromdb:
all_themes['No subject: No theme'].append(feature)
continue
subject_and_theme = "{}: {}".format(themes_fromdb[feature].subject,
themes_fromdb[feature].theme)
all_themes[subject_and_theme].append(feature)
# First sort by THEME
all_themes = sorted(all_themes.items(),
key=lambda t: fixedorder_sortkey(
t[0].split(': ')[1], THEMES_2018_ORDER))
# Second sort by SUBJECT
all_themes = sorted(all_themes,
key=lambda t: fixedorder_sortkey(
t[0].split(': ')[0], SUBJECT_2018_ORDER))
for subject_and_theme, feats in all_themes:
values = []
for country_code, country_name in self.countries:
value = []
data = [
row.Features.split(',') for row in self.db_data
if row.CountryCode == country_code and row.Features
]
all_features_rep = [x for x in chain(*data)]
count_features = Counter(all_features_rep)
for feature in feats:
cnt = count_features.get(feature, 0)
if not cnt:
continue
label = self.get_label_for_value(feature)
val = u"{} ({})".format(label, cnt)
value.append(val)
values.append(simple_itemlist(value))
rows.append((subject_and_theme, values))
return rows
def get_article_folders(self, descr_folder):
article_folders = self.filter_contentvalues_by_iface(
descr_folder, interfaces.INationalDescriptorAssessment)
article_folders = sorted(
article_folders,
key=lambda i: fixedorder_sortkey(i.title, self.ARTICLE_ORDER))
return article_folders
def get_features_by_subject(self, subjects):
features_order = [x[0] for x in ANTHROPOGENIC_FEATURES_SHORT_NAMES]
filtered = defaultdict(list)
for k, v in self.features.items():
if v.subject not in subjects:
continue
filtered[v.theme].append(v.name)
out = [(k,
sorted(v, key=lambda i: fixedorder_sortkey(i, features_order)))
for k, v in filtered.items()]
sorted_out = sorted(
out, key=lambda i: fixedorder_sortkey(i[0], THEMES_2018_ORDER))
return sorted_out
def setup_data(self):
# setup data to be available at 'features_pressures_data' attr
self.get_features_pressures_data()
data = self.features_pressures_data
out = []
for activ_theme, activ_features in self.uses_activities_features:
activ_features = sorted(
activ_features,
key=lambda i: fixedorder_sortkey(i, FEATURES_ORDER))
theme_data = []
for activ_feat in activ_features:
# if activ_feat.endswith('All'):
# continue
activity_data = []
for country_id, country_name in self.available_countries:
pressures = [
x[3] for x in data
if x[0] == country_id and x[2] == activ_feat
]
sorted_press = sorted(
set(pressures),
key=lambda i: fixedorder_sortkey(i, FEATURES_ORDER))
pressures = [
ItemLabel(x, self.get_feature_short_name(x))
for x in sorted_press
]
activity_data.append(
ItemListOverview(pressures, sort=False))
theme_data.append((get_label(activ_feat,
'features'), activity_data))
out.append((activ_theme, theme_data))
return out
def get_all_wf_states(self, context=None):
if context is None:
context = self.context
wftool = get_tool('portal_workflow')
wf = wftool.getWorkflowsFor(context)[0] # assumes one wf
states = [k for k, v in wf.states.items()]
states_sorted = sorted(
states, key=lambda i: fixedorder_sortkey(i, STATUS_ORDER))
titles = [wf.states[s].title for s in states_sorted]
return titles
def get_feature_row(self):
all_features = self.get_unique_values("Feature")
themes_fromdb = FEATURES_DB_2018
rows = []
all_themes = defaultdict(list)
for feature in all_features:
if feature not in themes_fromdb:
all_themes['No theme'].append(feature)
continue
theme = themes_fromdb[feature].theme
all_themes[theme].append(feature)
all_themes = sorted(
all_themes.items(),
key=lambda t: fixedorder_sortkey(t[0], THEMES_2018_ORDER)
)
for theme, feats in all_themes:
values = []
for country_code, country_name in self.countries:
value = []
data = [
row.Feature
for row in self.db_data
if row.CountryCode == country_code
and row.Feature
]
count_features = Counter(data)
for feature in feats:
cnt = count_features.get(feature, 0)
if not cnt:
continue
label = self.get_label_for_value(feature)
val = u"{} ({})".format(label, cnt)
value.append(val)
values.append(simple_itemlist(value))
rows.append((theme, values))
return rows
def ordered_regions_sortkey(region_id):
""" Sorting function to sort regions by the order defined in vocabulary.py
REGIONAL_DESCRIPTORS_REGIONS
"""
regions = REGIONAL_DESCRIPTORS_REGIONS
regions_order = []
for region in regions:
if not region.is_main:
continue
regions_order.extend(region.subregions)
return fixedorder_sortkey(region_id, regions_order)
def get_data_from_db(self):
data = self.get_data_from_view(self.article)
data = [Proxy2018(row, self) for row in data]
order = ORDER_COLS_ART11
data_ = consolidate_singlevalue_to_list(data, 'Element', order)
grouped_fields = ('Element', 'GESCriteria', 'P_Parameters',
'ParameterOther')
data_by_mru, features = group_multiple_fields(data_, 'Feature',
grouped_fields, order)
if data_by_mru:
data_by_mru = {"": data_by_mru}
else:
data_by_mru = {}
res = []
fields = self.get_report_definition()
feature_field_orig = [a for a in fields if a.title == 'Features'][0]
f_field_index = fields.index(feature_field_orig)
feature_fields = [
DummyReportField(f) for f in sorted(
features,
key=lambda i: fixedorder_sortkey(i.name, FEATURES_ORDER))
]
fields_all = (fields[:f_field_index] + feature_fields +
fields[f_field_index + len(grouped_fields) + 1:])
for mru, rows in data_by_mru.items():
_rows = items_to_rows(rows, fields_all)
res.append((mru, _rows))
return res
def get_updatetype_row(self):
rows = []
values = []
order = [
'Same as 2012 definition', 'Modified from 2012 definition',
'New target'
]
for country_code, country_name in self.countries:
value = []
data = [
row.UpdateType for row in self.db_data
if row.CountryCode == country_code and row.UpdateType
]
total = len(data)
if not total:
values.append(self.not_rep)
continue
updatetypes = sorted(set(data),
key=lambda t: fixedorder_sortkey(t, order))
for updatetype in updatetypes:
found = len([x for x in data if x == updatetype])
percentage = total and (found / float(total)) * 100 or 0
value.append(u"{0} ({1} - {2:0.1f}%)".format(
updatetype, found, percentage))
values.append(simple_itemlist(value, sort=False))
rows.append(('No. of targets per category', values))
return rows
def get_feature_row(self):
all_features_reported = self.get_unique_values("Features")
themes_fromdb = FEATURES_DB_2018
rows = []
all_features = []
all_themes = defaultdict(list)
for feat in all_features_reported:
all_features.extend(feat.split(','))
all_features = sorted(set(all_features))
ok_features = all_features
if self.descriptor.startswith('D1') and '.' in self.descriptor:
ok_features = set([f.name for f in get_features(self.descriptor)])
for feature in all_features:
if feature not in themes_fromdb:
all_themes['No subject: No theme'].append(feature)
continue
subject_and_theme = "{}: {}".format(themes_fromdb[feature].subject,
themes_fromdb[feature].theme)
all_themes[subject_and_theme].append(feature)
# First sort by THEME
all_themes = sorted(all_themes.items(),
key=lambda t: fixedorder_sortkey(
t[0].split(': ')[1], THEMES_2018_ORDER))
# Second sort by SUBJECT
all_themes = sorted(all_themes,
key=lambda t: fixedorder_sortkey(
t[0].split(': ')[0], SUBJECT_2018_ORDER))
for subject_and_theme, feats in all_themes:
for feature in feats:
if feature not in ok_features:
continue
values = []
feature_label = self.get_label_for_value(feature)
for country_code, country_name in self.countries:
value = []
data = [
row.GESComponent for row in self.db_data
if row.CountryCode == country_code and row.Features
and feature in row.Features.split(',')
]
count_gescomps = Counter(data)
if count_gescomps:
value = [
u'{} ({})'.format(k, v)
for k, v in count_gescomps.items()
]
values.append(simple_itemlist(value))
rows.append((subject_and_theme, feature_label, values))
return rows
def setup_descriptor_level_assessment_data(self):
""" Setup the regional assessments data for a region
:return: res = [("Baltic Sea", [
("D7 - Hydrographical changes", [
("Art8", DESCRIPTOR_SUMMARY),
("Art9", DESCRIPTOR_SUMMARY),
("Art10", DESCRIPTOR_SUMMARY),
]
),
("D1.4 - Birds", [
("Art8", DESCRIPTOR_SUMMARY),
("Art9", DESCRIPTOR_SUMMARY),
("Art10", DESCRIPTOR_SUMMARY),
]
),
]
)]
"""
self.overall_scores = {}
res = []
region_folder = [
region
for region in self._reg_desc_region_folders
if region.id == self.region_code.lower()
][0]
self.reg_desc_region_folder = region_folder
region_code = region_folder.id
region_name = region_folder.title
descriptor_data = []
descriptor_folders = self.filter_contentvalues_by_iface(
region_folder, IDescriptorFolder
)
for descriptor_folder in descriptor_folders:
desc_id = descriptor_folder.id.upper()
if desc_id == 'D1':
continue
desc_name = descriptor_folder.title
articles = []
article_folders = self.filter_contentvalues_by_iface(
descriptor_folder, IRegionalDescriptorAssessment
)
for article_folder in article_folders:
article = article_folder.title
if article in ('Art11', ):
continue
assess_data = self._get_assessment_data(article_folder)
article_data = self._get_article_data(
region_code.upper(), desc_id, assess_data, article
)
articles.append((article, article_data))
articles = sorted(
articles,
key=lambda i: fixedorder_sortkey(i[0], self.ARTICLE_ORDER)
)
descriptor_data.append(
((desc_id, desc_name), articles)
)
res.append((region_name, descriptor_data))
return res
def setup_descriptor_level_assessment_data(self):
"""
:return: res = [("Baltic Sea", [
("D7 - Hydrographical changes", [
("Art8", DESCRIPTOR_SUMMARY),
("Art9", DESCRIPTOR_SUMMARY),
("Art10", DESCRIPTOR_SUMMARY),
]
),
("D1.4 - Birds", [
("Art8", DESCRIPTOR_SUMMARY),
("Art9", DESCRIPTOR_SUMMARY),
("Art10", DESCRIPTOR_SUMMARY),
]
),
]
)]
"""
res = []
country_folder = [
country for country in self._nat_desc_folder.contentValues()
if country.id == self.country_code.lower()
][0]
self.nat_desc_country_folder = country_folder
region_folders = self.filter_contentvalues_by_iface(
country_folder, INationalRegionDescriptorFolder)
region_folders_sorted = sorted(
region_folders,
key=lambda i: ordered_regions_sortkey(i.id.upper()))
for region_folder in region_folders_sorted:
region_code = region_folder.id
region_name = region_folder.title
descriptor_data = []
descriptor_folders = self.filter_contentvalues_by_iface(
region_folder, IDescriptorFolder)
for descriptor_folder in descriptor_folders:
desc_id = descriptor_folder.id.upper()
desc_name = descriptor_folder.title
articles = []
article_folders = self.filter_contentvalues_by_iface(
descriptor_folder, INationalDescriptorAssessment)
for article_folder in article_folders:
article = article_folder.title
assess_data = self._get_assessment_data(article_folder)
article_data = self._get_article_data(
region_code.upper(), country_folder.title, desc_id,
assess_data, article)
articles.append((article, article_data))
articles = sorted(
articles,
key=lambda i: fixedorder_sortkey(i[0], self.ARTICLE_ORDER))
descriptor_data.append(((desc_id, desc_name), articles))
res.append((region_name, descriptor_data))
return res
def _sortkey(self, value, order):
return fixedorder_sortkey(value, order)
