NREL-reV 0.8.7__py3-none-any.whl → 0.9.0__py3-none-any.whl

reV/rep_profiles/rep_profiles.py

@@ -5,26 +5,26 @@ Created on Thu Oct 31 12:49:23 2019
 
 @author: gbuster
 """
-from abc import ABC, abstractmethod
-from concurrent.futures import as_completed
-from copy import deepcopy
+import contextlib
 import json
 import logging
-import numpy as np
 import os
-import pandas as pd
-from scipy import stats
+from abc import ABC, abstractmethod
+from concurrent.futures import as_completed
+from copy import deepcopy
 from warnings import warn
 
-
-from reV.handlers.outputs import Outputs
-from reV.utilities.exceptions import FileInputError, DataShapeError
-from reV.utilities import log_versions
-
+import numpy as np
+import pandas as pd
 from rex.resource import Resource
 from rex.utilities.execution import SpawnProcessPool
 from rex.utilities.loggers import log_mem
 from rex.utilities.utilities import parse_year, to_records_array
+from scipy import stats
+
+from reV.handlers.outputs import Outputs
+from reV.utilities import ResourceMetaField, SupplyCurveField, log_versions
+from reV.utilities.exceptions import DataShapeError, FileInputError
 
 logger = logging.getLogger(__name__)
 
@@ -32,8 +32,9 @@ logger = logging.getLogger(__name__)
 class RepresentativeMethods:
     """Class for organizing the methods to determine representative-ness"""
 
-    def __init__(self, profiles, weights=None, rep_method='meanoid',
-                 err_method='rmse'):
+    def __init__(
+        self, profiles, weights=None, rep_method="meanoid", err_method="rmse"
+    ):
         """
         Parameters
         ----------
@@ -61,30 +62,35 @@ class RepresentativeMethods:
             self._weights = np.array(self._weights)
 
         if self._weights is not None:
-            emsg = ('Weighting factors array of length {} does not match '
-                    'profiles of shape {}'
-                    .format(len(self._weights), self._profiles.shape[1]))
+            emsg = (
+                "Weighting factors array of length {} does not match "
+                "profiles of shape {}".format(
+                    len(self._weights), self._profiles.shape[1]
+                )
+            )
             assert len(self._weights) == self._profiles.shape[1], emsg
 
     @property
     def rep_methods(self):
         """Lookup table of representative methods"""
-        methods = {'mean': self.meanoid,
-                   'meanoid': self.meanoid,
-                   'median': self.medianoid,
-                   'medianoid': self.medianoid,
-                   }
+        methods = {
+            "mean": self.meanoid,
+            "meanoid": self.meanoid,
+            "median": self.medianoid,
+            "medianoid": self.medianoid,
+        }
 
         return methods
 
     @property
     def err_methods(self):
         """Lookup table of error methods"""
-        methods = {'mbe': self.mbe,
-                   'mae': self.mae,
-                   'rmse': self.rmse,
-                   None: None,
-                   }
+        methods = {
+            "mbe": self.mbe,
+            "mae": self.mae,
+            "rmse": self.rmse,
+            None: None,
+        }
 
         return methods
 
@@ -105,7 +111,7 @@ class RepresentativeMethods:
         i : int
             Location of the Nth min value in arr.
         """
-        return arr.argsort()[:(n + 1)][-1]
+        return arr.argsort()[: (n + 1)][-1]
 
     @staticmethod
     def meanoid(profiles, weights=None):
@@ -241,8 +247,14 @@ class RepresentativeMethods:
         return profiles[:, i_rep], i_rep
 
     @classmethod
-    def run(cls, profiles, weights=None, rep_method='meanoid',
-            err_method='rmse', n_profiles=1):
+    def run(
+        cls,
+        profiles,
+        weights=None,
+        rep_method="meanoid",
+        err_method="rmse",
+        n_profiles=1,
+    ):
         """Run representative profile methods.
 
         Parameters
@@ -270,8 +282,12 @@ class RepresentativeMethods:
             representative profile(s). If err_method is None, this value is
             also set to None.
         """
-        inst = cls(profiles, weights=weights, rep_method=rep_method,
-                   err_method=err_method)
+        inst = cls(
+            profiles,
+            weights=weights,
+            rep_method=rep_method,
+            err_method=err_method,
+        )
 
         if inst._weights is not None:
             baseline = inst._rep_method(inst._profiles, weights=inst._weights)
@@ -299,11 +315,12 @@ class RepresentativeMethods:
 class RegionRepProfile:
     """Framework to handle rep profile for one resource region"""
 
-    RES_GID_COL = 'res_gids'
-    GEN_GID_COL = 'gen_gids'
+    RES_GID_COL = SupplyCurveField.RES_GIDS
+    GEN_GID_COL = SupplyCurveField.GEN_GIDS
 
     def __init__(self, gen_fpath, rev_summary, cf_dset='cf_profile',
-                 rep_method='meanoid', err_method='rmse', weight='gid_counts',
+                 rep_method='meanoid', err_method='rmse',
+                 weight=SupplyCurveField.GID_COUNTS,
                  n_profiles=1):
         """
         Parameters
@@ -355,38 +372,46 @@ class RegionRepProfile:
 
         self._weights = np.ones(len(res_gids))
         if self._weight is not None:
-            self._weights = self._get_region_attr(self._rev_summary,
-                                                  self._weight)
+            self._weights = self._get_region_attr(
+                self._rev_summary, self._weight
+            )
 
-        df = pd.DataFrame({self.GEN_GID_COL: gen_gids,
-                           self.RES_GID_COL: res_gids,
-                           'weights': self._weights})
+        df = pd.DataFrame(
+            {
+                self.GEN_GID_COL: gen_gids,
+                self.RES_GID_COL: res_gids,
+                "weights": self._weights,
+            }
+        )
         df = df.sort_values(self.RES_GID_COL)
         self._gen_gids = df[self.GEN_GID_COL].values
         self._res_gids = df[self.RES_GID_COL].values
         if self._weight is not None:
-            self._weights = df['weights'].values
+            self._weights = df["weights"].values
         else:
             self._weights = None
 
         with Resource(self._gen_fpath) as res:
             meta = res.meta
 
-            assert 'gid' in meta
-            source_res_gids = meta['gid'].values
+            assert ResourceMetaField.GID in meta
+            source_res_gids = meta[ResourceMetaField.GID].values
             msg = ('Resource gids from "gid" column in meta data from "{}" '
                    'must be sorted! reV generation should always be run with '
                    'sequential project points.'.format(self._gen_fpath))
             assert np.all(source_res_gids[:-1] <= source_res_gids[1:]), msg
 
             missing = set(self._res_gids) - set(source_res_gids)
-            msg = ('The following resource gids were found in the rev summary '
-                   'supply curve file but not in the source generation meta '
-                   'data: {}'.format(missing))
+            msg = (
+                "The following resource gids were found in the rev summary "
+                "supply curve file but not in the source generation meta "
+                "data: {}".format(missing)
+            )
             assert not any(missing), msg
 
-            unique_res_gids, u_idxs = np.unique(self._res_gids,
-                                                return_inverse=True)
+            unique_res_gids, u_idxs = np.unique(
+                self._res_gids, return_inverse=True
+            )
             iloc = np.where(np.isin(source_res_gids, unique_res_gids))[0]
             self._source_profiles = res[self._cf_dset, :, iloc[u_idxs]]
 
@@ -441,7 +466,7 @@ class RegionRepProfile:
         if any(data):
             if isinstance(data[0], str):
                 # pylint: disable=simplifiable-condition
-                if ('[' and ']' in data[0]) or ('(' and ')' in data[0]):
+                if ("[" and "]" in data[0]) or ("(" and ")" in data[0]):
                     data = [json.loads(s) for s in data]
 
             if isinstance(data[0], (list, tuple)):
@@ -453,27 +478,32 @@ class RegionRepProfile:
         """Run the representative profile methods to find the meanoid/medianoid
         profile and find the profiles most similar."""
 
-        if self.weights is not None:
-            if len(self.weights) != self.source_profiles.shape[1]:
-                e = ('Weights column "{}" resulted in {} weight scalars '
-                     'which doesnt match gid column which yields '
-                     'profiles with shape {}.'
-                     .format(self._weight, len(self.weights),
-                             self.source_profiles.shape))
-                logger.debug('Gids from column "res_gids" with len {}: {}'
-                             .format(len(self._res_gids), self._res_gids))
-                logger.debug('Weights from column "{}" with len {}: {}'
-                             .format(self._weight, len(self.weights),
-                                     self.weights))
-                logger.error(e)
-                raise DataShapeError(e)
+        num_profiles = self.source_profiles.shape[1]
+        bad_data_shape = (self.weights is not None
+                          and len(self.weights) != num_profiles)
+        if bad_data_shape:
+            e = ('Weights column "{}" resulted in {} weight scalars '
+                 'which doesnt match gid column which yields '
+                 'profiles with shape {}.'
+                 .format(self._weight, len(self.weights),
+                         self.source_profiles.shape))
+            logger.debug('Gids from column "res_gids" with len {}: {}'
+                         .format(len(self._res_gids), self._res_gids))
+            logger.debug('Weights from column "{}" with len {}: {}'
+                         .format(self._weight, len(self.weights),
+                                 self.weights))
+            logger.error(e)
+            raise DataShapeError(e)
 
         self._profiles, self._i_reps = RepresentativeMethods.run(
-            self.source_profiles, weights=self.weights,
-            rep_method=self._rep_method, err_method=self._err_method,
-            n_profiles=self._n_profiles)
-
-    @property
+            self.source_profiles,
+            weights=self.weights,
+            rep_method=self._rep_method,
+            err_method=self._err_method,
+            n_profiles=self._n_profiles,
+        )
+
+    @ property
     def rep_profiles(self):
         """Get the representative profiles of this region."""
         if self._profiles is None:
@@ -481,7 +511,7 @@ class RegionRepProfile:
 
         return self._profiles
 
-    @property
+    @ property
     def i_reps(self):
         """Get the representative profile index(es) of this region."""
         if self._i_reps is None:
@@ -489,7 +519,7 @@ class RegionRepProfile:
 
         return self._i_reps
 
-    @property
+    @ property
     def rep_gen_gids(self):
         """Get the representative profile gen gids of this region."""
         gids = self._gen_gids
@@ -500,7 +530,7 @@ class RegionRepProfile:
 
         return rep_gids
 
-    @property
+    @ property
     def rep_res_gids(self):
         """Get the representative profile resource gids of this region."""
         gids = self._res_gids
@@ -511,10 +541,12 @@ class RegionRepProfile:
 
         return rep_gids
 
-    @classmethod
+    @ classmethod
     def get_region_rep_profile(cls, gen_fpath, rev_summary,
-                               cf_dset='cf_profile', rep_method='meanoid',
-                               err_method='rmse', weight='gid_counts',
+                               cf_dset='cf_profile',
+                               rep_method='meanoid',
+                               err_method='rmse',
+                               weight=SupplyCurveField.GID_COUNTS,
                                n_profiles=1):
         """Class method for parallelization of rep profile calc.
 
@@ -554,9 +586,15 @@ class RegionRepProfile:
         res_gid_reps : list
             Resource gid(s) of the representative profile(s).
         """
-        r = cls(gen_fpath, rev_summary, cf_dset=cf_dset,
-                rep_method=rep_method, err_method=err_method, weight=weight,
-                n_profiles=n_profiles)
+        r = cls(
+            gen_fpath,
+            rev_summary,
+            cf_dset=cf_dset,
+            rep_method=rep_method,
+            err_method=err_method,
+            weight=weight,
+            n_profiles=n_profiles,
+        )
 
         return r.rep_profiles, r.i_reps, r.rep_gen_gids, r.rep_res_gids
 
@@ -565,8 +603,9 @@ class RepProfilesBase(ABC):
     """Abstract utility framework for representative profile run classes."""
 
     def __init__(self, gen_fpath, rev_summary, reg_cols=None,
-                 cf_dset='cf_profile', rep_method='meanoid', err_method='rmse',
-                 weight='gid_counts', n_profiles=1):
+                 cf_dset='cf_profile', rep_method='meanoid',
+                 err_method='rmse', weight=SupplyCurveField.GID_COUNTS,
+                 n_profiles=1):
         """
         Parameters
         ----------
@@ -597,18 +636,26 @@ class RepProfilesBase(ABC):
             Number of representative profiles to save to fout.
         """
 
-        logger.info('Running rep profiles with gen_fpath: "{}"'
-                    .format(gen_fpath))
-        logger.info('Running rep profiles with rev_summary: "{}"'
-                    .format(rev_summary))
-        logger.info('Running rep profiles with region columns: "{}"'
-                    .format(reg_cols))
-        logger.info('Running rep profiles with representative method: "{}"'
-                    .format(rep_method))
-        logger.info('Running rep profiles with error method: "{}"'
-                    .format(err_method))
-        logger.info('Running rep profiles with weight factor: "{}"'
-                    .format(weight))
+        logger.info(
+            'Running rep profiles with gen_fpath: "{}"'.format(gen_fpath)
+        )
+        logger.info(
+            'Running rep profiles with rev_summary: "{}"'.format(rev_summary)
+        )
+        logger.info(
+            'Running rep profiles with region columns: "{}"'.format(reg_cols)
+        )
+        logger.info(
+            'Running rep profiles with representative method: "{}"'.format(
+                rep_method
+            )
+        )
+        logger.info(
+            'Running rep profiles with error method: "{}"'.format(err_method)
+        )
+        logger.info(
+            'Running rep profiles with weight factor: "{}"'.format(weight)
+        )
 
         self._weight = weight
         self._n_profiles = n_profiles
@@ -630,7 +677,7 @@ class RepProfilesBase(ABC):
         self._rep_method = rep_method
         self._err_method = err_method
 
-    @staticmethod
+    @ staticmethod
     def _parse_rev_summary(rev_summary):
         """Extract, parse, and check the rev summary table.
 
@@ -650,23 +697,24 @@ class RepProfilesBase(ABC):
         """
 
         if isinstance(rev_summary, str):
-            if os.path.exists(rev_summary) and rev_summary.endswith('.csv'):
+            if os.path.exists(rev_summary) and rev_summary.endswith(".csv"):
                 rev_summary = pd.read_csv(rev_summary)
-            elif os.path.exists(rev_summary) and rev_summary.endswith('.json'):
+            elif os.path.exists(rev_summary) and rev_summary.endswith(".json"):
                 rev_summary = pd.read_json(rev_summary)
             else:
-                e = 'Could not parse reV summary file: {}'.format(rev_summary)
+                e = "Could not parse reV summary file: {}".format(rev_summary)
                 logger.error(e)
                 raise FileInputError(e)
         elif not isinstance(rev_summary, pd.DataFrame):
-            e = ('Bad input dtype for rev_summary input: {}'
-                 .format(type(rev_summary)))
+            e = "Bad input dtype for rev_summary input: {}".format(
+                type(rev_summary)
+            )
             logger.error(e)
             raise TypeError(e)
 
         return rev_summary
 
-    @staticmethod
+    @ staticmethod
     def _check_req_cols(df, cols):
         """Check a dataframe for required columns.
 
@@ -681,18 +729,16 @@ class RepProfilesBase(ABC):
             if isinstance(cols, str):
                 cols = [cols]
 
-            missing = []
-            for c in cols:
-                if c not in df:
-                    missing.append(c)
+            missing = [c for c in cols if c not in df]
 
             if any(missing):
-                e = ('Column labels not found in rev_summary table: {}'
-                     .format(missing))
+                e = "Column labels not found in rev_summary table: {}".format(
+                    missing
+                )
                 logger.error(e)
                 raise KeyError(e)
 
-    @staticmethod
+    @ staticmethod
     def _check_rev_gen(gen_fpath, cf_dset, rev_summary):
         """Check rev gen file for requisite datasets.
 
@@ -710,32 +756,42 @@ class RepProfilesBase(ABC):
         with Resource(gen_fpath) as res:
             dsets = res.datasets
             if cf_dset not in dsets:
-                raise KeyError('reV gen file needs to have "{}" '
-                               'dataset to calculate representative profiles!'
-                               .format(cf_dset))
-
-            if 'time_index' not in str(dsets):
-                raise KeyError('reV gen file needs to have "time_index" '
-                               'dataset to calculate representative profiles!')
+                raise KeyError(
+                    'reV gen file needs to have "{}" '
+                    "dataset to calculate representative profiles!".format(
+                        cf_dset
+                    )
+                )
+
+            if "time_index" not in str(dsets):
+                raise KeyError(
+                    'reV gen file needs to have "time_index" '
+                    "dataset to calculate representative profiles!"
+                )
 
             shape = res.get_dset_properties(cf_dset)[0]
 
         if len(rev_summary) > shape[1]:
-            msg = ('WARNING: reV SC summary table has {} sc points and CF '
-                   'dataset "{}" has {} profiles. There should never be more '
-                   'SC points than CF profiles.'
-                   .format(len(rev_summary), cf_dset, shape[1]))
+            msg = (
+                "WARNING: reV SC summary table has {} sc points and CF "
+                'dataset "{}" has {} profiles. There should never be more '
+                "SC points than CF profiles.".format(
+                    len(rev_summary), cf_dset, shape[1]
+                )
+            )
             logger.warning(msg)
             warn(msg)
 
     def _init_profiles(self):
         """Initialize the output rep profiles attribute."""
-        self._profiles = {k: np.zeros((len(self.time_index),
-                                       len(self.meta)),
-                                      dtype=np.float32)
-                          for k in range(self._n_profiles)}
+        self._profiles = {
+            k: np.zeros(
+                (len(self.time_index), len(self.meta)), dtype=np.float32
+            )
+            for k in range(self._n_profiles)
+        }
 
-    @property
+    @ property
     def time_index(self):
         """Get the time index for the rep profiles.
 
@@ -746,16 +802,16 @@ class RepProfilesBase(ABC):
         """
         if self._time_index is None:
             with Resource(self._gen_fpath) as res:
-                ds = 'time_index'
-                if parse_year(self._cf_dset, option='bool'):
-                    year = parse_year(self._cf_dset, option='raise')
-                    ds += '-{}'.format(year)
+                ds = "time_index"
+                if parse_year(self._cf_dset, option="bool"):
+                    year = parse_year(self._cf_dset, option="raise")
+                    ds += "-{}".format(year)
 
                 self._time_index = res._get_time_index(ds, slice(None))
 
         return self._time_index
 
-    @property
+    @ property
     def meta(self):
         """Meta data for the representative profiles.
 
@@ -767,7 +823,7 @@ class RepProfilesBase(ABC):
         """
         return self._meta
 
-    @property
+    @ property
     def profiles(self):
         """Get the arrays of representative CF profiles corresponding to meta.
 
@@ -779,8 +835,9 @@ class RepProfilesBase(ABC):
         """
         return self._profiles
 
-    def _init_h5_out(self, fout, save_rev_summary=True,
-                     scaled_precision=False):
+    def _init_h5_out(
+        self, fout, save_rev_summary=True, scaled_precision=False
+    ):
         """Initialize an output h5 file for n_profiles
 
         Parameters
@@ -799,13 +856,13 @@ class RepProfilesBase(ABC):
         dtypes = {}
 
         for i in range(self._n_profiles):
-            dset = 'rep_profiles_{}'.format(i)
+            dset = "rep_profiles_{}".format(i)
             dsets.append(dset)
             shapes[dset] = self.profiles[0].shape
             chunks[dset] = None
 
             if scaled_precision:
-                attrs[dset] = {'scale_factor': 1000}
+                attrs[dset] = {"scale_factor": 1000}
                 dtypes[dset] = np.uint16
             else:
                 attrs[dset] = None
@@ -813,19 +870,26 @@ class RepProfilesBase(ABC):
 
         meta = self.meta.copy()
         for c in meta.columns:
-            try:
+            with contextlib.suppress(ValueError):
                 meta[c] = pd.to_numeric(meta[c])
-            except ValueError:
-                pass
 
-        Outputs.init_h5(fout, dsets, shapes, attrs, chunks, dtypes,
-                        meta, time_index=self.time_index)
+        Outputs.init_h5(
+            fout,
+            dsets,
+            shapes,
+            attrs,
+            chunks,
+            dtypes,
+            meta,
+            time_index=self.time_index,
+        )
 
         if save_rev_summary:
-            with Outputs(fout, mode='a') as out:
+            with Outputs(fout, mode="a") as out:
                 rev_sum = to_records_array(self._rev_summary)
-                out._create_dset('rev_summary', rev_sum.shape,
-                                 rev_sum.dtype, data=rev_sum)
+                out._create_dset(
+                    "rev_summary", rev_sum.shape, rev_sum.dtype, data=rev_sum
+                )
 
     def _write_h5_out(self, fout, save_rev_summary=True):
         """Write profiles and meta to an output file.
@@ -839,18 +903,18 @@ class RepProfilesBase(ABC):
         scaled_precision : bool
             Flag to scale cf_profiles by 1000 and save as uint16.
         """
-        with Outputs(fout, mode='a') as out:
-
-            if 'rev_summary' in out.datasets and save_rev_summary:
+        with Outputs(fout, mode="a") as out:
+            if "rev_summary" in out.datasets and save_rev_summary:
                 rev_sum = to_records_array(self._rev_summary)
-                out['rev_summary'] = rev_sum
+                out["rev_summary"] = rev_sum
 
             for i in range(self._n_profiles):
-                dset = 'rep_profiles_{}'.format(i)
+                dset = "rep_profiles_{}".format(i)
                 out[dset] = self.profiles[i]
 
-    def save_profiles(self, fout, save_rev_summary=True,
-                      scaled_precision=False):
+    def save_profiles(
+        self, fout, save_rev_summary=True, scaled_precision=False
+    ):
         """Initialize fout and save profiles.
 
         Parameters
@@ -863,19 +927,22 @@ class RepProfilesBase(ABC):
             Flag to scale cf_profiles by 1000 and save as uint16.
         """
 
-        self._init_h5_out(fout, save_rev_summary=save_rev_summary,
-                          scaled_precision=scaled_precision)
+        self._init_h5_out(
+            fout,
+            save_rev_summary=save_rev_summary,
+            scaled_precision=scaled_precision,
+        )
         self._write_h5_out(fout, save_rev_summary=save_rev_summary)
 
-    @abstractmethod
+    @ abstractmethod
     def _run_serial(self):
         """Abstract method for serial run method."""
 
-    @abstractmethod
+    @ abstractmethod
     def _run_parallel(self):
         """Abstract method for parallel run method."""
 
-    @abstractmethod
+    @ abstractmethod
     def run(self):
         """Abstract method for generic run method."""
 
@@ -883,10 +950,12 @@ class RepProfilesBase(ABC):
 class RepProfiles(RepProfilesBase):
     """RepProfiles"""
 
-    def __init__(self, gen_fpath, rev_summary, reg_cols, cf_dset='cf_profile',
-                 rep_method='meanoid', err_method='rmse', weight='gid_counts',
+    def __init__(self, gen_fpath, rev_summary, reg_cols,
+                 cf_dset='cf_profile',
+                 rep_method='meanoid', err_method='rmse',
+                 weight=str(SupplyCurveField.GID_COUNTS),  # str() to fix docs
                  n_profiles=1, aggregate_profiles=False):
-        """reV rep profiles class.
+        """ReV rep profiles class.
 
         ``reV`` rep profiles compute representative generation profiles
         for each supply curve point output by ``reV`` supply curve
@@ -977,7 +1046,7 @@ class RepProfiles(RepProfilesBase):
                *equally* to the meanoid profile unless these weights are
                specified.
 
-            By default, ``'gid_counts'``.
+            By default, :obj:`SupplyCurveField.GID_COUNTS`.
         n_profiles : int, optional
             Number of representative profiles to save to the output
             file. By default, ``1``.
@@ -991,33 +1060,45 @@ class RepProfiles(RepProfilesBase):
         """
 
         log_versions(logger)
-        logger.info('Finding representative profiles that are most similar '
-                    'to the weighted meanoid for each supply curve region.')
+        logger.info(
+            "Finding representative profiles that are most similar "
+            "to the weighted meanoid for each supply curve region."
+        )
 
         if reg_cols is None:
-            e = ('Need to define "reg_cols"! If you want a profile for each '
-                 'supply curve point, try setting "reg_cols" to a primary '
-                 'key such as "sc_gid".')
+            e = (
+                'Need to define "reg_cols"! If you want a profile for each '
+                'supply curve point, try setting "reg_cols" to a primary '
+                'key such as "sc_gid".'
+            )
             logger.error(e)
             raise ValueError(e)
-        elif isinstance(reg_cols, str):
+        if isinstance(reg_cols, str):
             reg_cols = [reg_cols]
         elif not isinstance(reg_cols, list):
             reg_cols = list(reg_cols)
 
         self._aggregate_profiles = aggregate_profiles
         if self._aggregate_profiles:
-            logger.info("Aggregate profiles input set to `True`. Setting "
-                        "'rep_method' to `'meanoid'`, 'err_method' to `None`, "
-                        "and 'n_profiles' to `1`")
-            rep_method = 'meanoid'
+            logger.info(
+                "Aggregate profiles input set to `True`. Setting "
+                "'rep_method' to `'meanoid'`, 'err_method' to `None`, "
+                "and 'n_profiles' to `1`"
+            )
+            rep_method = "meanoid"
             err_method = None
             n_profiles = 1
 
-        super().__init__(gen_fpath, rev_summary, reg_cols=reg_cols,
-                         cf_dset=cf_dset,
-                         rep_method=rep_method, err_method=err_method,
-                         weight=weight, n_profiles=n_profiles)
+        super().__init__(
+            gen_fpath,
+            rev_summary,
+            reg_cols=reg_cols,
+            cf_dset=cf_dset,
+            rep_method=rep_method,
+            err_method=err_method,
+            weight=weight,
+            n_profiles=n_profiles,
+        )
 
         self._set_meta()
         self._init_profiles()
@@ -1030,13 +1111,13 @@ class RepProfiles(RepProfilesBase):
         else:
             self._meta = self._rev_summary.groupby(self._reg_cols)
             self._meta = (
-                self._meta['timezone']
+                self._meta[SupplyCurveField.TIMEZONE]
                 .apply(lambda x: stats.mode(x, keepdims=True).mode[0])
             )
             self._meta = self._meta.reset_index()
 
-        self._meta['rep_gen_gid'] = None
-        self._meta['rep_res_gid'] = None
+        self._meta["rep_gen_gid"] = None
+        self._meta["rep_res_gid"] = None
 
     def _get_mask(self, region_dict):
         """Get the mask for a given region and res class.
@@ -1054,54 +1135,70 @@ class RepProfiles(RepProfilesBase):
         """
         mask = None
         for k, v in region_dict.items():
-            temp = (self._rev_summary[k] == v)
+            temp = self._rev_summary[k] == v
             if mask is None:
                 mask = temp
             else:
-                mask = (mask & temp)
+                mask = mask & temp
 
         return mask
 
     def _run_serial(self):
         """Compute all representative profiles in serial."""
 
-        logger.info('Running {} rep profile calculations in serial.'
-                    .format(len(self.meta)))
+        logger.info(
+            "Running {} rep profile calculations in serial.".format(
+                len(self.meta)
+            )
+        )
         meta_static = deepcopy(self.meta)
         for i, row in meta_static.iterrows():
-            region_dict = {k: v for (k, v) in row.to_dict().items()
-                           if k in self._reg_cols}
+            region_dict = {
+                k: v for (k, v) in row.to_dict().items() if k in self._reg_cols
+            }
             mask = self._get_mask(region_dict)
 
             if not any(mask):
-                logger.warning('Skipping profile {} out of {} '
-                               'for region: {} with no valid mask.'
-                               .format(i + 1, len(meta_static), region_dict))
+                logger.warning(
+                    "Skipping profile {} out of {} "
+                    "for region: {} with no valid mask.".format(
+                        i + 1, len(meta_static), region_dict
+                    )
+                )
             else:
-                logger.debug('Working on profile {} out of {} for region: {}'
-                             .format(i + 1, len(meta_static), region_dict))
+                logger.debug(
+                    "Working on profile {} out of {} for region: {}".format(
+                        i + 1, len(meta_static), region_dict
+                    )
+                )
                 out = RegionRepProfile.get_region_rep_profile(
-                    self._gen_fpath, self._rev_summary[mask],
-                    cf_dset=self._cf_dset, rep_method=self._rep_method,
-                    err_method=self._err_method, weight=self._weight,
-                    n_profiles=self._n_profiles)
+                    self._gen_fpath,
+                    self._rev_summary[mask],
+                    cf_dset=self._cf_dset,
+                    rep_method=self._rep_method,
+                    err_method=self._err_method,
+                    weight=self._weight,
+                    n_profiles=self._n_profiles,
+                )
                 profiles, _, ggids, rgids = out
-                logger.info('Profile {} out of {} complete '
-                            'for region: {}'
-                            .format(i + 1, len(meta_static), region_dict))
+                logger.info(
+                    "Profile {} out of {} complete " "for region: {}".format(
+                        i + 1, len(meta_static), region_dict
+                    )
+                )
 
                 for n in range(profiles.shape[1]):
                     self._profiles[n][:, i] = profiles[:, n]
 
                     if ggids is None:
-                        self._meta.at[i, 'rep_gen_gid'] = None
-                        self._meta.at[i, 'rep_res_gid'] = None
+                        self._meta.at[i, "rep_gen_gid"] = None
+                        self._meta.at[i, "rep_res_gid"] = None
                     elif len(ggids) == 1:
-                        self._meta.at[i, 'rep_gen_gid'] = ggids[0]
-                        self._meta.at[i, 'rep_res_gid'] = rgids[0]
+                        self._meta.at[i, "rep_gen_gid"] = ggids[0]
+                        self._meta.at[i, "rep_res_gid"] = rgids[0]
                     else:
-                        self._meta.at[i, 'rep_gen_gid'] = str(ggids)
-                        self._meta.at[i, 'rep_res_gid'] = str(rgids)
+                        self._meta.at[i, "rep_gen_gid"] = str(ggids)
+                        self._meta.at[i, "rep_res_gid"] = str(rgids)
 
     def _run_parallel(self, max_workers=None, pool_size=72):
         """Compute all representative profiles in parallel.
@@ -1116,39 +1213,49 @@ class RepProfiles(RepProfilesBase):
             parallel futures.
         """
 
-        logger.info('Kicking off {} rep profile futures.'
-                    .format(len(self.meta)))
+        logger.info(
+            "Kicking off {} rep profile futures.".format(len(self.meta))
+        )
 
-        iter_chunks = np.array_split(self.meta.index.values,
-                                     np.ceil(len(self.meta) / pool_size))
+        iter_chunks = np.array_split(
+            self.meta.index.values, np.ceil(len(self.meta) / pool_size)
+        )
         n_complete = 0
         for iter_chunk in iter_chunks:
-            logger.debug('Starting process pool...')
+            logger.debug("Starting process pool...")
             futures = {}
-            loggers = [__name__, 'reV']
-            with SpawnProcessPool(max_workers=max_workers,
-                                  loggers=loggers) as exe:
+            loggers = [__name__, "reV"]
+            with SpawnProcessPool(
+                max_workers=max_workers, loggers=loggers
+            ) as exe:
                 for i in iter_chunk:
                     row = self.meta.loc[i, :]
-                    region_dict = {k: v for (k, v) in row.to_dict().items()
-                                   if k in self._reg_cols}
+                    region_dict = {
+                        k: v
+                        for (k, v) in row.to_dict().items()
+                        if k in self._reg_cols
+                    }
 
                     mask = self._get_mask(region_dict)
 
                     if not any(mask):
-                        logger.info('Skipping profile {} out of {} '
-                                    'for region: {} with no valid mask.'
-                                    .format(i + 1, len(self.meta),
-                                            region_dict))
+                        logger.info(
+                            "Skipping profile {} out of {} "
+                            "for region: {} with no valid mask.".format(
+                                i + 1, len(self.meta), region_dict
+                            )
+                        )
                     else:
                         future = exe.submit(
                             RegionRepProfile.get_region_rep_profile,
-                            self._gen_fpath, self._rev_summary[mask],
+                            self._gen_fpath,
+                            self._rev_summary[mask],
                             cf_dset=self._cf_dset,
                             rep_method=self._rep_method,
                             err_method=self._err_method,
                             weight=self._weight,
-                            n_profiles=self._n_profiles)
+                            n_profiles=self._n_profiles,
+                        )
 
                         futures[future] = [i, region_dict]
 
@@ -1156,27 +1263,34 @@ class RepProfiles(RepProfilesBase):
                     i, region_dict = futures[future]
                     profiles, _, ggids, rgids = future.result()
                     n_complete += 1
-                    logger.info('Future {} out of {} complete '
-                                'for region: {}'
-                                .format(n_complete, len(self.meta),
-                                        region_dict))
-                    log_mem(logger, log_level='DEBUG')
+                    logger.info(
+                        "Future {} out of {} complete "
+                        "for region: {}".format(
+                            n_complete, len(self.meta), region_dict
+                        )
+                    )
+                    log_mem(logger, log_level="DEBUG")
 
                     for n in range(profiles.shape[1]):
                         self._profiles[n][:, i] = profiles[:, n]
 
                     if ggids is None:
-                        self._meta.at[i, 'rep_gen_gid'] = None
-                        self._meta.at[i, 'rep_res_gid'] = None
+                        self._meta.at[i, "rep_gen_gid"] = None
+                        self._meta.at[i, "rep_res_gid"] = None
                     elif len(ggids) == 1:
-                        self._meta.at[i, 'rep_gen_gid'] = ggids[0]
-                        self._meta.at[i, 'rep_res_gid'] = rgids[0]
+                        self._meta.at[i, "rep_gen_gid"] = ggids[0]
+                        self._meta.at[i, "rep_res_gid"] = rgids[0]
                     else:
-                        self._meta.at[i, 'rep_gen_gid'] = str(ggids)
-                        self._meta.at[i, 'rep_res_gid'] = str(rgids)
-
-    def run(self, fout=None, save_rev_summary=True, scaled_precision=False,
-            max_workers=None):
+                        self._meta.at[i, "rep_gen_gid"] = str(ggids)
+                        self._meta.at[i, "rep_res_gid"] = str(rgids)
+
+    def run(
+        self,
+        fout=None,
+        save_rev_summary=True,
+        scaled_precision=False,
+        max_workers=None,
+    ):
         """
         Run representative profiles in serial or parallel and save to disc
 
@@ -1204,12 +1318,17 @@ class RepProfiles(RepProfilesBase):
 
         if fout is not None:
             if self._aggregate_profiles:
-                logger.info("Aggregate profiles input set to `True`. Setting "
-                            "'save_rev_summary' input to `False`")
+                logger.info(
+                    "Aggregate profiles input set to `True`. Setting "
+                    "'save_rev_summary' input to `False`"
+                )
                 save_rev_summary = False
-            self.save_profiles(fout, save_rev_summary=save_rev_summary,
-                               scaled_precision=scaled_precision)
+            self.save_profiles(
+                fout,
+                save_rev_summary=save_rev_summary,
+                scaled_precision=scaled_precision,
+            )
 
-        logger.info('Representative profiles complete!')
+        logger.info("Representative profiles complete!")
 
         return fout