def get_next_step(self):
"""Find the proper step when user clicks the Next button.
:returns: The step to be switched to.
:rtype: WizardStep instance or None
"""
if self.parent.get_layer_geometry_key() == \
layer_geometry_raster['key']:
return self.parent.step_kw_source
layer_purpose = self.parent.step_kw_purpose.selected_purpose()
if layer_purpose['key'] != layer_purpose_aggregation['key']:
subcategory = self.parent.step_kw_subcategory. \
selected_subcategory()
else:
subcategory = {'key': None}
# Check if it can go to inasafe field step
non_compulsory_fields = get_non_compulsory_fields(
layer_purpose['key'], subcategory['key'])
if not skip_inasafe_field(self.parent.layer, non_compulsory_fields):
return self.parent.step_kw_inasafe_fields
# Check if it can go to inasafe default field step
default_inasafe_fields = get_fields(
layer_purpose['key'],
subcategory['key'],
replace_null=True,
in_group=False
)
if default_inasafe_fields:
return self.parent.step_kw_default_inasafe_fields
# Any other case
return self.parent.step_kw_source
def get_next_step(self):
"""Find the proper step when user clicks the Next button.
:returns: The step to be switched to.
:rtype: WizardStep instance or None
"""
if self.parent.get_layer_geometry_key() == \
layer_geometry_raster['key']:
return self.parent.step_kw_source
layer_purpose = self.parent.step_kw_purpose.selected_purpose()
if layer_purpose['key'] != layer_purpose_aggregation['key']:
subcategory = self.parent.step_kw_subcategory. \
selected_subcategory()
else:
subcategory = {'key': None}
# Check if it can go to inasafe field step
non_compulsory_fields = get_non_compulsory_fields(
layer_purpose['key'], subcategory['key'])
if not skip_inasafe_field(self.parent.layer, non_compulsory_fields):
return self.parent.step_kw_inasafe_fields
# Check if it can go to inasafe default field step
default_inasafe_fields = get_fields(
layer_purpose['key'],
subcategory['key'],
replace_null=True,
in_group=False
)
if default_inasafe_fields:
return self.parent.step_kw_default_inasafe_fields
# Any other case
return self.parent.step_kw_source
def get_next_step(self):
"""Find the proper step when user clicks the Next button.
:returns: The step to be switched to
:rtype: WizardStep
"""
layer_purpose = self.parent.step_kw_purpose.selected_purpose()
if layer_purpose != layer_purpose_aggregation:
subcategory = self.parent.step_kw_subcategory.\
selected_subcategory()
else:
subcategory = {'key': None}
# Has classifications, go to multi classifications
if subcategory.get('classifications'):
if layer_purpose == layer_purpose_hazard:
return self.parent.step_kw_multi_classifications
elif layer_purpose == layer_purpose_exposure:
return self.parent.step_kw_classification
# Check if it can go to inasafe field step
non_compulsory_fields = get_non_compulsory_fields(
layer_purpose['key'], subcategory['key'])
if not skip_inasafe_field(self.parent.layer, non_compulsory_fields):
return self.parent.step_kw_inasafe_fields
# Check if it can go to inasafe default field step
default_inasafe_fields = get_fields(
layer_purpose['key'], subcategory['key'], replace_null=True)
if default_inasafe_fields:
return self.parent.step_kw_default_inasafe_fields
# Any other case
return self.parent.step_kw_source
def test_get_not_compulsory_field(self):
"""Test get_non_compulsory_field method."""
non_compulsory_fields = get_non_compulsory_fields(
'exposure', 'structure')
expected_fields = [
field for field in exposure_structure['fields'] if not field[
'replace_null']]
expected_fields += [
field for field in exposure_structure['extra_fields'] if not
field['replace_null']]
expected_fields += [
field for field in fields_in_field_groups(
layer_purpose_exposure['field_groups']) if not
field['replace_null']]
for field in expected_fields:
if field.get('replace_null'):
expected_fields.remove(field)
self.assertListEqual(non_compulsory_fields, expected_fields)
def test_get_not_compulsory_field(self):
"""Test get_non_compulsory_field method."""
non_compulsory_fields = get_non_compulsory_fields(
'exposure', 'structure')
expected_fields = [
field for field in exposure_structure['fields'] if not field[
'replace_null']]
expected_fields += [
field for field in exposure_structure['extra_fields'] if not
field['replace_null']]
expected_fields += [
field for field in fields_in_field_groups(
layer_purpose_exposure['field_groups']) if not
field['replace_null']]
for field in expected_fields:
if field.get('replace_null'):
expected_fields.remove(field)
self.assertListEqual(non_compulsory_fields, expected_fields)
def get_next_step(self):
"""Find the proper step when user clicks the Next button.
:returns: The step to be switched to
:rtype: WizardStep
"""
layer_purpose = self.parent.step_kw_purpose.selected_purpose()
if layer_purpose != layer_purpose_aggregation:
subcategory = self.parent.step_kw_subcategory.\
selected_subcategory()
else:
subcategory = {'key': None}
# Has layer groups, go to field mapping
field_groups = get_field_groups(
layer_purpose['key'], subcategory['key'])
if field_groups:
return self.parent.step_kw_fields_mapping
# Has classifications, go to multi classifications
if subcategory.get('classifications'):
if layer_purpose == layer_purpose_hazard:
return self.parent.step_kw_multi_classifications
elif layer_purpose == layer_purpose_exposure:
return self.parent.step_kw_classification
# Check if it can go to inasafe field step
non_compulsory_fields = get_non_compulsory_fields(
layer_purpose['key'], subcategory['key'])
if not skip_inasafe_field(self.parent.layer, non_compulsory_fields):
return self.parent.step_kw_inasafe_fields
# Check if it can go to inasafe default field step
default_inasafe_fields = get_fields(
layer_purpose['key'],
subcategory['key'],
replace_null=True,
in_group=False)
if default_inasafe_fields:
return self.parent.step_kw_default_inasafe_fields
# Any other case
return self.parent.step_kw_source
def get_next_step(self):
"""Find the proper step when user clicks the Next button.
:returns: The step to be switched to
:rtype: WizardStep
"""
layer_purpose = self.parent.step_kw_purpose.selected_purpose()
if layer_purpose != layer_purpose_aggregation:
subcategory = self.parent.step_kw_subcategory.\
selected_subcategory()
else:
subcategory = {'key': None}
# Has classifications, go to multi classifications
if subcategory.get('classifications'):
if layer_purpose == layer_purpose_hazard:
return self.parent.step_kw_multi_classifications
# Check if it can go to inasafe field step
non_compulsory_fields = get_non_compulsory_fields(
layer_purpose['key'], subcategory['key'])
if not skip_inasafe_field(self.parent.layer, non_compulsory_fields):
# Do not go to InaSAFE Field step if we already visited it.
# For example in place exposure.
if (self.parent.step_kw_inasafe_fields not in
self.parent.keyword_steps):
return self.parent.step_kw_inasafe_fields
# Check if it can go to inasafe default field step
default_inasafe_fields = get_fields(
layer_purpose['key'],
subcategory['key'],
replace_null=True,
in_group=False)
if default_inasafe_fields:
return self.parent.step_kw_default_inasafe_fields
# Any other case
return self.parent.step_kw_source
def from_counts_to_ratios(layer, callback=None):
"""Transform counts to ratios.
Formula: ratio = subset count / total count
:param layer: The vector layer.
:type layer: QgsVectorLayer
:param callback: A function to all to indicate progress. The function
should accept params 'current' (int), 'maximum' (int) and 'step' (str).
Defaults to None.
:type callback: function
:return: The layer with new ratios.
:rtype: QgsVectorLayer
.. versionadded:: 4.0
"""
output_layer_name = recompute_counts_steps['output_layer_name']
processing_step = recompute_counts_steps['step_name']
exposure = definition(layer.keywords['exposure'])
inasafe_fields = layer.keywords['inasafe_fields']
layer.keywords['title'] = output_layer_name
if not population_count_field['key'] in inasafe_fields:
# There is not a population count field. Let's skip this layer.
LOGGER.info(
'Population count field {population_count_field} is not detected '
'in the exposure. We will not compute a ratio from this field '
'because the formula needs Population count field. Formula: '
'ratio = subset count / total count.'.format(
population_count_field=population_count_field['key']))
return layer
layer.startEditing()
mapping = {}
non_compulsory_fields = get_non_compulsory_fields(
layer_purpose_exposure['key'], exposure['key'])
for count_field in non_compulsory_fields:
exists = count_field['key'] in inasafe_fields
if count_field['key'] in count_ratio_mapping.keys() and exists:
ratio_field = definition(count_ratio_mapping[count_field['key']])
field = create_field_from_definition(ratio_field)
layer.addAttribute(field)
name = ratio_field['field_name']
layer.keywords['inasafe_fields'][ratio_field['key']] = name
mapping[count_field['field_name']] = layer.fieldNameIndex(name)
LOGGER.info(
'Count field {count_field} detected in the exposure, we are '
'going to create a equivalent field {ratio_field} in the '
'exposure layer.'.format(count_field=count_field['key'],
ratio_field=ratio_field['key']))
else:
LOGGER.info(
'Count field {count_field} not detected in the exposure. We '
'will not compute a ratio from this field.'.format(
count_field=count_field['key']))
if len(mapping) == 0:
# There is not a subset count field. Let's skip this layer.
layer.commitChanges()
return layer
for feature in layer.getFeatures():
total_count = feature[inasafe_fields[population_count_field['key']]]
for count_field, index in mapping.iteritems():
count = feature[count_field]
try:
new_value = count / total_count
except TypeError:
new_value = ''
layer.changeAttributeValue(feature.id(), index, new_value)
layer.commitChanges()
check_layer(layer)
return layer
def from_counts_to_ratios(layer):
"""Transform counts to ratios.
Formula: ratio = subset count / total count
:param layer: The vector layer.
:type layer: QgsVectorLayer
:return: The layer with new ratios.
:rtype: QgsVectorLayer
.. versionadded:: 4.0
"""
output_layer_name = recompute_counts_steps['output_layer_name']
exposure = definition(layer.keywords['exposure'])
inasafe_fields = layer.keywords['inasafe_fields']
layer.keywords['title'] = output_layer_name
if not population_count_field['key'] in inasafe_fields:
# There is not a population count field. Let's skip this layer.
LOGGER.info(
'Population count field {population_count_field} is not detected '
'in the exposure. We will not compute a ratio from this field '
'because the formula needs Population count field. Formula: '
'ratio = subset count / total count.'.format(
population_count_field=population_count_field['key']))
return layer
layer.startEditing()
mapping = {}
non_compulsory_fields = get_non_compulsory_fields(
layer_purpose_exposure['key'], exposure['key'])
for count_field in non_compulsory_fields:
exists = count_field['key'] in inasafe_fields
if count_field['key'] in list(count_ratio_mapping.keys()) and exists:
ratio_field = definition(count_ratio_mapping[count_field['key']])
field = create_field_from_definition(ratio_field)
layer.addAttribute(field)
name = ratio_field['field_name']
layer.keywords['inasafe_fields'][ratio_field['key']] = name
mapping[count_field['field_name']
] = layer.fields().lookupField(name)
LOGGER.info(
'Count field {count_field} detected in the exposure, we are '
'going to create a equivalent field {ratio_field} in the '
'exposure layer.'.format(
count_field=count_field['key'],
ratio_field=ratio_field['key']))
else:
LOGGER.info(
'Count field {count_field} not detected in the exposure. We '
'will not compute a ratio from this field.'.format(
count_field=count_field['key']))
if len(mapping) == 0:
# There is not a subset count field. Let's skip this layer.
layer.commitChanges()
return layer
for feature in layer.getFeatures():
total_count = feature[inasafe_fields[population_count_field['key']]]
for count_field, index in list(mapping.items()):
count = feature[count_field]
try:
# For #4669, fix always get 0
new_value = count / float(total_count)
except TypeError:
new_value = ''
except ZeroDivisionError:
new_value = 0
layer.changeAttributeValue(feature.id(), index, new_value)
layer.commitChanges()
check_layer(layer)
return layer
def from_counts_to_ratios(layer):
"""Transform counts to ratios.
Formula: ratio = subset count / total count
:param layer: The vector layer.
:type layer: QgsVectorLayer
:return: The layer with new ratios.
:rtype: QgsVectorLayer
.. versionadded:: 4.0
"""
output_layer_name = recompute_counts_steps['output_layer_name']
exposure = definition(layer.keywords['exposure'])
inasafe_fields = layer.keywords['inasafe_fields']
layer.keywords['title'] = output_layer_name
if not population_count_field['key'] in inasafe_fields:
# There is not a population count field. Let's skip this layer.
LOGGER.info(
'Population count field {population_count_field} is not detected '
'in the exposure. We will not compute a ratio from this field '
'because the formula needs Population count field. Formula: '
'ratio = subset count / total count.'.format(
population_count_field=population_count_field['key']))
return layer
layer.startEditing()
mapping = {}
non_compulsory_fields = get_non_compulsory_fields(
layer_purpose_exposure['key'], exposure['key'])
for count_field in non_compulsory_fields:
exists = count_field['key'] in inasafe_fields
if count_field['key'] in list(count_ratio_mapping.keys()) and exists:
ratio_field = definition(count_ratio_mapping[count_field['key']])
field = create_field_from_definition(ratio_field)
layer.addAttribute(field)
name = ratio_field['field_name']
layer.keywords['inasafe_fields'][ratio_field['key']] = name
mapping[count_field['field_name']] = layer.fields().lookupField(
name)
LOGGER.info(
'Count field {count_field} detected in the exposure, we are '
'going to create a equivalent field {ratio_field} in the '
'exposure layer.'.format(count_field=count_field['key'],
ratio_field=ratio_field['key']))
else:
LOGGER.info(
'Count field {count_field} not detected in the exposure. We '
'will not compute a ratio from this field.'.format(
count_field=count_field['key']))
if len(mapping) == 0:
# There is not a subset count field. Let's skip this layer.
layer.commitChanges()
return layer
for feature in layer.getFeatures():
total_count = feature[inasafe_fields[population_count_field['key']]]
for count_field, index in list(mapping.items()):
count = feature[count_field]
try:
# For #4669, fix always get 0
new_value = count / float(total_count)
except TypeError:
new_value = ''
except ZeroDivisionError:
new_value = 0
layer.changeAttributeValue(feature.id(), index, new_value)
layer.commitChanges()
check_layer(layer)
return layer
def from_counts_to_ratios(layer, callback=None):
"""Transform counts to ratios.
Formula: ratio = subset count / total count
:param layer: The vector layer.
:type layer: QgsVectorLayer
:param callback: A function to all to indicate progress. The function
should accept params 'current' (int), 'maximum' (int) and 'step' (str).
Defaults to None.
:type callback: function
:return: The layer with new ratios.
:rtype: QgsVectorLayer
.. versionadded:: 4.0
"""
output_layer_name = recompute_counts_steps['output_layer_name']
processing_step = recompute_counts_steps['step_name']
exposure = definition(layer.keywords['exposure'])
inasafe_fields = layer.keywords['inasafe_fields']
layer.keywords['title'] = output_layer_name
if not population_count_field['key'] in inasafe_fields:
# There is not a population count field. Let's skip this layer.
LOGGER.info(
'Population count field {population_count_field} is not detected '
'in the exposure. We will not compute a ratio from this field '
'because the formula needs Population count field. Formula: '
'ratio = subset count / total count.'.format(
population_count_field=population_count_field['key']))
return layer
layer.startEditing()
mapping = {}
non_compulsory_fields = get_non_compulsory_fields(
layer_purpose_exposure['key'], exposure['key'])
for count_field in non_compulsory_fields:
exists = count_field['key'] in inasafe_fields
if count_field['key'] in count_ratio_mapping.keys() and exists:
ratio_field = definition(count_ratio_mapping[count_field['key']])
field = create_field_from_definition(ratio_field)
layer.addAttribute(field)
name = ratio_field['field_name']
layer.keywords['inasafe_fields'][ratio_field['key']] = name
mapping[count_field['field_name']] = layer.fieldNameIndex(name)
LOGGER.info(
'Count field {count_field} detected in the exposure, we are '
'going to create a equivalent field {ratio_field} in the '
'exposure layer.'.format(
count_field=count_field['key'],
ratio_field=ratio_field['key']))
else:
LOGGER.info(
'Count field {count_field} not detected in the exposure. We '
'will not compute a ratio from this field.'.format(
count_field=count_field['key']))
if len(mapping) == 0:
# There is not a subset count field. Let's skip this layer.
layer.commitChanges()
return layer
for feature in layer.getFeatures():
total_count = feature[inasafe_fields[population_count_field['key']]]
for count_field, index in mapping.iteritems():
count = feature[count_field]
try:
new_value = count / total_count
except TypeError:
new_value = ''
layer.changeAttributeValue(feature.id(), index, new_value)
layer.commitChanges()
check_layer(layer)
return layer