change to make append, select and clear valid for every exposures child class

Author: gabrielaznar

climada/entity/exposures/base.py

@@ -51,6 +51,31 @@ class Exposures():
             centroid(s) affecting each exposure. Filled in 'assign' method.
     """
 
+    vars_oblig = {'tag',
+                  'ref_year',
+                  'value_unit',
+                  '_coord',
+                  'value',
+                  'impact_id',
+                  'id'
+                 }
+    """Name of the variables needed to compute the impact. Types: scalar, str,
+    list, 1dim np.array of size num_exposures, GridPoints and Tag."""
+
+    vars_def = {'assigned'
+               }
+    """Name of the variables used in impact calculation whose value is
+    descriptive or can be recomputed. Types: dict.
+    """
+
+    vars_opt = {'deductible',
+                'cover',
+                'category_id',
+                'region_id'
+               }
+    """Name of the variables that aren't need to compute the impact. Types:
+    scalar, string, list, 1dim np.array of size num_exposures."""
+
     def __init__(self, file_name='', description=''):
         """Fill values from file, if provided.
 
@@ -73,20 +98,13 @@ def __init__(self, file_name='', description=''):
             >>> exp_city.id = np.array([11, 12, 13])
             >>> exp_city.check()
 
-            Read exposures from Zurich.mat and checks consistency data.
+            Read exposures from ENT_TEMPLATE_XLS and checks consistency data.
 
             >>> exp_city = Exposures(ENT_TEMPLATE_XLS)
         """
-        self.clear()
-        if file_name != '':
-            self.read(file_name, description)
-
-    def clear(self):
-        """Reinitialize attributes."""
-        # Optional variables
         self.tag = Tag()
         self.ref_year = CONFIG['entity']['present_ref_year']
-        self.value_unit = 'NA'
+        self.value_unit = ''
         # Following values defined for each exposure
         # Obligatory variables
         self.coord = GridPoints()
@@ -100,9 +118,21 @@ def clear(self):
         self.region_id = np.array([], int)
         self.assigned = dict()
 
+        if file_name != '':
+            self.read(file_name, description)
+
+    def clear(self):
+        """Reinitialize attributes."""
+        for (var_name, var_val) in self.__dict__.items():
+            if isinstance(var_val, np.ndarray) and var_val.ndim == 1:
+                setattr(self, var_name, np.array([]))
+            else:
+                setattr(self, var_name, var_val.__class__())
+        self.ref_year = CONFIG['entity']['present_ref_year']
+
     def assign(self, hazard):
-        """Compute the hazard centroids affecting to each exposure. The
-        position of the centroids are provided, not their ids.
+        """Compute the hazard centroids affecting to each exposure. Returns the
+        position of the centroids, not their ids.
 
         Parameters:
             hazard (subclass Hazard): one hazard
@@ -123,8 +153,18 @@ def check(self):
         if np.unique(self.id).size != num_exp:
             LOGGER.error("There are exposures with the same identifier.")
             raise ValueError
-        self._check_obligatories(num_exp)
-        self._check_optionals(num_exp)
+
+        check.check_oligatories(self.__dict__, self.vars_oblig, 'Exposures.',
+                                num_exp, num_exp, 2)
+        check.check_optionals(self.__dict__, self.vars_opt, 'Exposures.', num_exp)
+
+        check.empty_optional(self.assigned, "Exposures.assigned")
+        for (ass_haz, ass) in self.assigned.items():
+            if not ass_haz:
+                LOGGER.warning('Exposures.assigned: assigned hazard type ' \
+                               'not set.')
+            check.array_optional(num_exp, ass, 'Exposures.assigned')
+
 
     def plot(self, ignore_zero=True, pop_name=True, buffer_deg=1.0,
              extend='neither', **kwargs):
@@ -192,18 +232,17 @@ def remove(self, exp_id):
         except IndexError:
             LOGGER.info('No exposure with id %s.', exp_id)
             return
-        self.coord = np.delete(self.coord, pos_del, axis=0)
-        self.value = np.delete(self.value, pos_del)
-        self.impact_id = np.delete(self.impact_id, pos_del)
-        self.id = np.delete(self.id, pos_del)
-        if self.deductible.size:
-            self.deductible = np.delete(self.deductible, pos_del)
-        if self.cover.size:
-            self.cover = np.delete(self.cover, pos_del)
-        if self.category_id.size:
-            self.category_id = np.delete(self.category_id, pos_del)
-        if self.region_id.size:
-            self.region_id = np.delete(self.region_id, pos_del)
+
+        for (var_name, var_val) in self.__dict__.items():
+            if var_name in self.vars_oblig:
+                if isinstance(var_val, np.ndarray) and var_val.ndim == 1:
+                    setattr(self, var_name, np.delete(var_val, pos_del))
+                elif isinstance(var_val, np.ndarray) and var_val.ndim == 2:
+                    setattr(self, var_name, np.delete(var_val, pos_del, axis=0))
+            else:
+                if isinstance(var_val, np.ndarray) and var_val.size:
+                    setattr(self, var_name, np.delete(var_val, pos_del))
+
         old_assigned = self.assigned.copy()
         for key, val in old_assigned.items():
             self.assigned[key] = np.delete(val, pos_del)
@@ -222,37 +261,37 @@ def append(self, exposures):
             self.__dict__ = exposures.__dict__.copy()
             return
 
-        self.tag.append(exposures.tag)
         if self.ref_year != exposures.ref_year:
             LOGGER.error("Append not possible. Different reference years.")
             raise ValueError
-        if (self.value_unit == 'NA') and (exposures.value_unit != 'NA'):
+        if not self.value_unit and exposures.value_unit:
             self.value_unit = exposures.value_unit
             LOGGER.info("Exposures units set to %s.", self.value_unit)
-        elif exposures.value_unit == 'NA':
+        elif not exposures.value_unit:
             LOGGER.info("Exposures units set to %s.", self.value_unit)
         elif self.value_unit != exposures.value_unit:
             LOGGER.error("Append not possible. Different units: %s != %s.", \
                              self.value_unit, exposures.value_unit)
             raise ValueError
+        self.tag.append(exposures.tag)
+
+        # append all 1-dim variables and 2-dim coordinate variable
+        for (var_name, var_val), haz_val in zip(self.__dict__.items(),
+                                                exposures.__dict__.values()):
+            if isinstance(var_val, np.ndarray) and var_val.ndim == 1 \
+            and var_val.size:
+                setattr(self, var_name, np.append(var_val, haz_val). \
+                        astype(var_val.dtype, copy=False))
+            elif isinstance(var_val, np.ndarray) and var_val.ndim == 2:
+                setattr(self, var_name, np.append(var_val, haz_val, axis=0). \
+                        astype(var_val.dtype, copy=False))
+            elif isinstance(var_val, list) and len(var_val):
+                setattr(self, var_name, var_val + haz_val)
 
-        self.coord = np.append(self.coord, exposures.coord, axis=0)
-        self.value = np.append(self.value, exposures.value)
-        self.impact_id = np.append(self.impact_id, exposures.impact_id)
-        self.id = np.append(self.id, exposures.id)
-        self.deductible = self._append_optional(self.deductible,
-                                                exposures.deductible)
-        self.cover = self._append_optional(self.cover, exposures.cover)
-        self.category_id = self._append_optional(self.category_id, \
-                          exposures.category_id)
-        self.region_id = self._append_optional(self.region_id, \
-                        exposures.region_id)
         for (ass_haz, ass) in exposures.assigned.items():
-            if ass_haz not in self.assigned:
-                self.assigned[ass_haz] = ass
-            else:
-                self.assigned[ass_haz] = self._append_optional( \
-                                         self.assigned[ass_haz], ass)
+            if ass_haz in self.assigned:
+                self.assigned[ass_haz] = np.append(
+                    self.assigned[ass_haz], ass).astype(ass.dtype, copy=False)
 
         # provide new ids to repeated ones
         _, indices = np.unique(self.id, return_index=True)
@@ -278,24 +317,16 @@ def select(self, reg_id):
             return None
 
         sel_exp = self.__class__()
-        sel_exp.tag.file_name = self.tag.file_name
-        sel_exp.tag.description = 'Region ' + str(reg_id)
-        sel_exp.ref_year = self.ref_year
-        sel_exp.value_unit = self.value_unit
-        # Obligatory variables
-        sel_exp.coord = self.coord[sel_idx, :]
-        sel_exp.value = self.value[sel_idx]
-        sel_exp.impact_id = self.impact_id[sel_idx]
-        sel_exp.id = self.id[sel_idx]
-        # Optional variables.
-        if self.deductible.size:
-            sel_exp.deductible = self.deductible[sel_idx]
-        if self.cover.size:
-            sel_exp.cover = self.cover[sel_idx]
-        if self.category_id.size:
-            sel_exp.category_id = self.category_id[sel_idx]
-        if self.region_id.size:
-            sel_exp.region_id = self.region_id[sel_idx]
+        for (var_name, var_val) in self.__dict__.items():
+            if isinstance(var_val, np.ndarray) and var_val.ndim == 1 and \
+            var_val.size:
+                setattr(sel_exp, var_name, var_val[sel_idx])
+            elif isinstance(var_val, np.ndarray) and var_val.ndim == 2:
+                setattr(sel_exp, var_name, var_val[sel_idx, :])
+            elif isinstance(var_val, list) and var_val:
+                setattr(sel_exp, var_name, [var_val[idx] for idx in sel_idx])
+            else:
+                setattr(sel_exp, var_name, var_val)
 
         sel_exp.assigned = dict()
         for key, value in self.assigned.items():
@@ -359,8 +390,8 @@ def size(self):
         self.check()
         return self.value.size
 
-    @staticmethod
-    def _read_one(file_name, description='', var_names=None):
+    @classmethod
+    def _read_one(cls, file_name, description='', var_names=None):
         """Read one file and fill attributes.
 
         Parameters:
@@ -375,7 +406,7 @@ def _read_one(file_name, description='', var_names=None):
             Exposures
         """
         LOGGER.info('Reading file: %s', file_name)
-        new_exp = Exposures()
+        new_exp = cls()
         new_exp.tag = Tag(file_name, description)
 
         extension = os.path.splitext(file_name)[1]
@@ -388,36 +419,6 @@ def _read_one(file_name, description='', var_names=None):
 
         return new_exp
 
-    @staticmethod
-    def _append_optional(ini, to_add):
-        """Append variable only if both are filled."""
-        if (ini.size != 0) and (to_add.size != 0):
-            ini = np.append(ini, to_add)
-        else:
-            ini = np.array([], float)
-        return ini
-
-    def _check_obligatories(self, num_exp):
-        """Check coherence obligatory variables."""
-        check.size(num_exp, self.value, 'Exposures.value')
-        check.size(num_exp, self.impact_id, 'Exposures.impact_id')
-        check.shape(num_exp, 2, self.coord, 'Exposures.coord')
-
-    def _check_optionals(self, num_exp):
-        """Check coherence optional variables. Warn if empty."""
-        check.array_optional(num_exp, self.category_id, \
-                             'Exposures.category_id')
-        check.array_optional(num_exp, self.region_id, \
-                             'Exposures.region_id')
-        check.empty_optional(self.assigned, "Exposures.assigned")
-        check.array_optional(num_exp, self.deductible, 'Exposures.deductible')
-        check.array_optional(num_exp, self.cover, 'Exposures.cover')
-        for (ass_haz, ass) in self.assigned.items():
-            if ass_haz == 'NA':
-                LOGGER.warning('Exposures.assigned: assigned hazard type ' \
-                               'not set.')
-            check.array_optional(num_exp, ass, 'Exposures.assigned')
-
     def __str__(self):
         return self.tag.__str__()
 

climada/entity/exposures/test/test_base.py

@@ -75,7 +75,7 @@ def test_assign_diff(self):
         expo_app.assigned['WS'] = np.ones((5, 2))
         expo.append(expo_app)
         self.assertTrue(len(expo.assigned['TC']), 8)
-        self.assertTrue(len(expo.assigned['WS']), 5)
+        self.assertTrue(len(expo.assigned), 1)
 
     def test_append_to_empty_same(self):
         """Append Exposure to empty one."""
@@ -268,7 +268,7 @@ def test_check_wrongCoord_fail(self):
         with self.assertLogs('climada.util.checker', level='ERROR') as cm:
             with self.assertRaises(ValueError):
                 expo.check()
-        self.assertIn('Invalid Exposures.coord row size: 3 != 1.', \
+        self.assertIn('Invalid Exposures._coord row size: 3 != 1.', \
                       cm.output[0])
 
     def test_check_wrongDeduct_fail(self):