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

reV/hybrids/hybrids.py

@@ -3,35 +3,46 @@
 
 @author: ppinchuk
 """
+
 import logging
-import numpy as np
 import re
-import pandas as pd
+from collections import namedtuple
 from string import ascii_letters
 from warnings import warn
-from collections import namedtuple
-
-from reV.handlers.outputs import Outputs
-from reV.utilities.exceptions import (FileInputError, InputError,
-                                      InputWarning, OutputWarning)
-from reV.hybrids.hybrid_methods import HYBRID_METHODS
 
+import numpy as np
+import pandas as pd
 from rex.resource import Resource
 from rex.utilities.utilities import to_records_array
 
+from reV.handlers.outputs import Outputs
+from reV.hybrids.hybrid_methods import HYBRID_METHODS
+from reV.utilities import SupplyCurveField
+from reV.utilities.exceptions import (
+    FileInputError,
+    InputError,
+    InputWarning,
+    OutputWarning,
+)
+
 logger = logging.getLogger(__name__)
 
-MERGE_COLUMN = 'sc_point_gid'
+MERGE_COLUMN = SupplyCurveField.SC_POINT_GID
 PROFILE_DSET_REGEX = 'rep_profiles_[0-9]+$'
 SOLAR_PREFIX = 'solar_'
 WIND_PREFIX = 'wind_'
 NON_DUPLICATE_COLS = {
-    'latitude', 'longitude', 'country', 'state', 'county', 'elevation',
-    'timezone', 'sc_point_gid', 'sc_row_ind', 'sc_col_ind'
+    SupplyCurveField.LATITUDE, SupplyCurveField.LONGITUDE,
+    SupplyCurveField.COUNTRY, SupplyCurveField.STATE, SupplyCurveField.COUNTY,
+    SupplyCurveField.ELEVATION, SupplyCurveField.TIMEZONE,
+    SupplyCurveField.SC_POINT_GID, SupplyCurveField.SC_ROW_IND,
+    SupplyCurveField.SC_COL_IND
 }
-DROPPED_COLUMNS = ['gid']
-DEFAULT_FILL_VALUES = {'solar_capacity': 0, 'wind_capacity': 0,
-                       'solar_mean_cf': 0, 'wind_mean_cf': 0}
+HYBRIDS_GID_COL = "gid"
+DEFAULT_FILL_VALUES = {f'solar_{SupplyCurveField.CAPACITY_AC_MW}': 0,
+                       f'wind_{SupplyCurveField.CAPACITY_AC_MW}': 0,
+                       f'solar_{SupplyCurveField.MEAN_CF_AC}': 0,
+                       f'wind_{SupplyCurveField.MEAN_CF_AC}': 0}
 OUTPUT_PROFILE_NAMES = ['hybrid_profile',
                         'hybrid_solar_profile',
                         'hybrid_wind_profile']
@@ -40,7 +51,8 @@ RatioColumns = namedtuple('RatioColumns', ['num', 'denom', 'fixed'],
 
 
 class ColNameFormatter:
-    """Column name formatting helper class. """
+    """Column name formatting helper class."""
+
     ALLOWED = set(ascii_letters)
 
     @classmethod
@@ -61,11 +73,11 @@ class ColNameFormatter:
             The column name with all characters except ascii stripped
             and all lowercase.
         """
-        return ''.join(c for c in n if c in cls.ALLOWED).lower()
+        return "".join(c for c in n if c in cls.ALLOWED).lower()
 
 
 class HybridsData:
-    """Hybrids input data container. """
+    """Hybrids input data container."""
 
     def __init__(self, solar_fpath, wind_fpath):
         """
@@ -158,7 +170,8 @@ class HybridsData:
         """
         if self._hybrid_time_index is None:
             self._hybrid_time_index = self.solar_time_index.join(
-                self.wind_time_index, how='inner')
+                self.wind_time_index, how="inner"
+            )
         return self._hybrid_time_index
 
     def contains_col(self, col_name):
@@ -202,9 +215,11 @@ class HybridsData:
             If len(time_index) < 8760 for the hybrid profile.
         """
         if len(self.hybrid_time_index) < 8760:
-            msg = ("The length of the merged time index ({}) is less than "
-                   "8760. Please ensure that the input profiles have a "
-                   "time index that overlaps >= 8760 times.")
+            msg = (
+                "The length of the merged time index ({}) is less than "
+                "8760. Please ensure that the input profiles have a "
+                "time index that overlaps >= 8760 times."
+            )
             e = msg.format(len(self.hybrid_time_index))
             logger.error(e)
             raise FileInputError(e)
@@ -220,17 +235,18 @@ class HybridsData:
         for fp in [self.solar_fpath, self.wind_fpath]:
             with Resource(fp) as res:
                 profile_dset_names = [
-                    n for n in res.dsets
-                    if self.__profile_reg_check.match(n)
+                    n for n in res.dsets if self.__profile_reg_check.match(n)
                 ]
                 if not profile_dset_names:
-                    msg = ("Did not find any data sets matching the regex: "
-                           "{!r} in {!r}. Please ensure that the profile data "
-                           "exists and that the data set is named correctly.")
+                    msg = (
+                        "Did not find any data sets matching the regex: "
+                        "{!r} in {!r}. Please ensure that the profile data "
+                        "exists and that the data set is named correctly."
+                    )
                     e = msg.format(PROFILE_DSET_REGEX, fp)
                     logger.error(e)
                     raise FileInputError(e)
-                elif len(profile_dset_names) > 1:
+                if len(profile_dset_names) > 1:
                     msg = ("Found more than one profile in {!r}: {}. "
                            "This module is not intended for hybridization of "
                            "multiple representative profiles. Please re-run "
@@ -238,8 +254,7 @@ class HybridsData:
                     e = msg.format(fp, profile_dset_names)
                     logger.error(e)
                     raise FileInputError(e)
-                else:
-                    self.profile_dset_names += profile_dset_names
+                self.profile_dset_names += profile_dset_names
 
     def _validate_merge_col_exists(self):
         """Validate the existence of the merge column.
@@ -250,13 +265,17 @@ class HybridsData:
             If merge column is missing from either the solar or
             the wind meta data.
         """
-        msg = ("Cannot hybridize: merge column {!r} missing from the "
-               "{} meta data! ({!r})")
+        msg = (
+            "Cannot hybridize: merge column {!r} missing from the "
+            "{} meta data! ({!r})"
+        )
 
         mc = ColNameFormatter.fmt(MERGE_COLUMN)
-        for cols, fp, res in zip([self.__solar_cols, self.__wind_cols],
-                                 [self.solar_fpath, self.wind_fpath],
-                                 ['solar', 'wind']):
+        for cols, fp, res in zip(
+            [self.__solar_cols, self.__wind_cols],
+            [self.solar_fpath, self.wind_fpath],
+            ["solar", "wind"],
+        ):
             if mc not in cols:
                 e = msg.format(MERGE_COLUMN, res, fp)
                 logger.error(e)
@@ -271,16 +290,20 @@ class HybridsData:
             If merge column contains duplicate values  in either the solar or
             the wind meta data.
         """
-        msg = ("Duplicate {}s were found. This is likely due to resource "
-               "class binning, which is not supported at this time. "
-               "Please re-run supply curve aggregation without "
-               "resource class binning and ensure there are no duplicate "
-               "values in {!r}. File: {!r}")
+        msg = (
+            "Duplicate {}s were found. This is likely due to resource "
+            "class binning, which is not supported at this time. "
+            "Please re-run supply curve aggregation without "
+            "resource class binning and ensure there are no duplicate "
+            "values in {!r}. File: {!r}"
+        )
 
         mc = ColNameFormatter.fmt(MERGE_COLUMN)
-        for ds, cols, fp in zip([self.solar_meta, self.wind_meta],
-                                [self.__solar_cols, self.__wind_cols],
-                                [self.solar_fpath, self.wind_fpath]):
+        for ds, cols, fp in zip(
+            [self.solar_meta, self.wind_meta],
+            [self.__solar_cols, self.__wind_cols],
+            [self.solar_fpath, self.wind_fpath],
+        ):
             merge_col = ds.columns[cols == mc].item()
             if not ds[merge_col].is_unique:
                 e = msg.format(merge_col, merge_col, fp)
@@ -303,11 +326,14 @@ class HybridsData:
         self.merge_col_overlap_values = solar_vals & wind_vals
 
         if not self.merge_col_overlap_values:
-            msg = ("No overlap detected in the values of {!r} across the "
-                   "input files. Please ensure that at least one of the "
-                   "{!r} values is the same for input files {!r} and {!r}")
-            e = msg.format(merge_col, merge_col, self.solar_fpath,
-                           self.wind_fpath)
+            msg = (
+                "No overlap detected in the values of {!r} across the "
+                "input files. Please ensure that at least one of the "
+                "{!r} values is the same for input files {!r} and {!r}"
+            )
+            e = msg.format(
+                merge_col, merge_col, self.solar_fpath, self.wind_fpath
+            )
             logger.error(e)
             raise FileInputError(e)
 
@@ -315,12 +341,18 @@ class HybridsData:
 class MetaHybridizer:
     """Framework to handle hybridization of meta data."""
 
-    _INTERNAL_COL_PREFIX = '_h_internal'
-
-    def __init__(self, data, allow_solar_only=False,
-                 allow_wind_only=False, fillna=None,
-                 limits=None, ratio_bounds=None,
-                 ratio='solar_capacity/wind_capacity'):
+    _INTERNAL_COL_PREFIX = "_h_internal"
+
+    def __init__(
+        self,
+        data,
+        allow_solar_only=False,
+        allow_wind_only=False,
+        fillna=None,
+        limits=None,
+        ratio_bounds=None,
+        ratio="solar_capacity/wind_capacity",
+    ):
         """
         Parameters
         ----------
@@ -383,8 +415,8 @@ class MetaHybridizer:
         self._hybrid_meta = None
         self.__hybrid_meta_cols = None
         self.__col_name_map = None
-        self.__solar_rpi_n = '{}_solar_rpidx'.format(self._INTERNAL_COL_PREFIX)
-        self.__wind_rpi_n = '{}_wind_rpidx'.format(self._INTERNAL_COL_PREFIX)
+        self.__solar_rpi_n = "{}_solar_rpidx".format(self._INTERNAL_COL_PREFIX)
+        self.__wind_rpi_n = "{}_wind_rpidx".format(self._INTERNAL_COL_PREFIX)
 
     @property
     def hybrid_meta(self):
@@ -398,8 +430,7 @@ class MetaHybridizer:
         """
         if self._hybrid_meta is None or self.__hybrid_meta_cols is None:
             return self._hybrid_meta
-        else:
-            return self._hybrid_meta[self.__hybrid_meta_cols]
+        return self._hybrid_meta[self.__hybrid_meta_cols]
 
     def validate_input(self):
         """Validate the input parameters.
@@ -426,18 +457,20 @@ class MetaHybridizer:
         """
         for col in self._limits:
             self.__validate_col_prefix(
-                col, (SOLAR_PREFIX, WIND_PREFIX), input_name='limits'
+                col, (SOLAR_PREFIX, WIND_PREFIX), input_name="limits"
             )
 
     @staticmethod
     def __validate_col_prefix(col, prefixes, input_name):
-        """Validate the the col starts with the correct prefix. """
+        """Validate the the col starts with the correct prefix."""
 
         missing = [not col.startswith(p) for p in prefixes]
         if all(missing):
-            msg = ("Input {0} column {1!r} does not start with a valid "
-                   "prefix: {2!r}. Please ensure that the {0} column "
-                   "names specify the correct resource prefix.")
+            msg = (
+                "Input {0} column {1!r} does not start with a valid "
+                "prefix: {2!r}. Please ensure that the {0} column "
+                "names specify the correct resource prefix."
+            )
             e = msg.format(input_name, col, prefixes)
             logger.error(e)
             raise InputError(e)
@@ -457,7 +490,7 @@ class MetaHybridizer:
         """
         for col in self._fillna:
             self.__validate_col_prefix(
-                col, (SOLAR_PREFIX, WIND_PREFIX), input_name='fillna'
+                col, (SOLAR_PREFIX, WIND_PREFIX), input_name="fillna"
             )
 
     def _validate_ratio_input(self):
@@ -487,18 +520,22 @@ class MetaHybridizer:
 
         try:
             if len(self._ratio_bounds) != 2:
-                msg = ("Length of input for ratio_bounds is {} - but is "
-                       "required to be of length 2. Please make sure this "
-                       "input is a len 2 container of floats. If you would "
-                       "like to specify a single ratio value, use the same "
-                       "float for both limits (i.e. ratio_bounds=(1, 1)).")
+                msg = (
+                    "Length of input for ratio_bounds is {} - but is "
+                    "required to be of length 2. Please make sure this "
+                    "input is a len 2 container of floats. If you would "
+                    "like to specify a single ratio value, use the same "
+                    "float for both limits (i.e. ratio_bounds=(1, 1))."
+                )
                 e = msg.format(len(self._ratio_bounds))
                 logger.error(e)
                 raise InputError(e)
         except TypeError:
-            msg = ("Input for ratio_bounds not understood: {!r}. "
-                   "Please make sure this value is a len 2 container "
-                   "of floats.")
+            msg = (
+                "Input for ratio_bounds not understood: {!r}. "
+                "Please make sure this value is a len 2 container "
+                "of floats."
+            )
             e = msg.format(self._ratio_bounds)
             logger.error(e)
             raise InputError(e) from None
@@ -512,10 +549,12 @@ class MetaHybridizer:
             If `ratio` is not a string.
         """
         if not isinstance(self._ratio, str):
-            msg = ("Ratio input type {} not understood. Please make sure "
-                   "the ratio input is a string in the form "
-                   "'numerator_column_name/denominator_column_name'. Ratio "
-                   "input: {!r}")
+            msg = (
+                "Ratio input type {} not understood. Please make sure "
+                "the ratio input is a string in the form "
+                "'numerator_column_name/denominator_column_name'. Ratio "
+                "input: {!r}"
+            )
             e = msg.format(type(self._ratio), self._ratio)
             logger.error(e)
             raise InputError(e)
@@ -529,18 +568,22 @@ class MetaHybridizer:
             If the '/' character is missing or of there are too many
             '/' characters.
         """
-        if '/' not in self._ratio:
-            msg = ("Ratio input {} does not contain the '/' character. "
-                   "Please make sure the ratio input is a string in the form "
-                   "'numerator_column_name/denominator_column_name'")
+        if "/" not in self._ratio:
+            msg = (
+                "Ratio input {} does not contain the '/' character. "
+                "Please make sure the ratio input is a string in the form "
+                "'numerator_column_name/denominator_column_name'"
+            )
             e = msg.format(self._ratio)
             logger.error(e)
             raise InputError(e)
 
         if len(self._ratio_cols) != 2:
-            msg = ("Ratio input {} contains too many '/' characters. Please "
-                   "make sure the ratio input is a string in the form "
-                   "'numerator_column_name/denominator_column_name'.")
+            msg = (
+                "Ratio input {} contains too many '/' characters. Please "
+                "make sure the ratio input is a string in the form "
+                "'numerator_column_name/denominator_column_name'."
+            )
             e = msg.format(self._ratio)
             logger.error(e)
             raise InputError(e)
@@ -561,7 +604,7 @@ class MetaHybridizer:
 
         for col in self._ratio_cols:
             self.__validate_col_prefix(
-                col, (SOLAR_PREFIX, WIND_PREFIX), input_name='ratios'
+                col, (SOLAR_PREFIX, WIND_PREFIX), input_name="ratios"
             )
 
     def _validate_ratio_cols_exist(self):
@@ -574,27 +617,30 @@ class MetaHybridizer:
         """
 
         for col in self._ratio_cols:
-            no_prefix_name = "_".join(col.split('_')[1:])
+            no_prefix_name = "_".join(col.split("_")[1:])
             if not self.data.contains_col(no_prefix_name):
-                msg = ("Input ratios column {!r} not found in either meta "
-                       "data! Please check the input files {!r} and {!r}")
-                e = msg.format(no_prefix_name, self.data.solar_fpath,
-                               self.data.wind_fpath)
+                msg = (
+                    "Input ratios column {!r} not found in either meta "
+                    "data! Please check the input files {!r} and {!r}"
+                )
+                e = msg.format(
+                    no_prefix_name, self.data.solar_fpath, self.data.wind_fpath
+                )
                 logger.error(e)
                 raise FileInputError(e)
 
     @property
     def _ratio_cols(self):
-        """Get the ratio columns from the ratio input. """
+        """Get the ratio columns from the ratio input."""
         if self._ratio is None:
             return []
-        return self._ratio.strip().split('/')
+        return self._ratio.strip().split("/")
 
     def hybridize(self):
         """Combine the solar and wind metas and run hybridize methods."""
         self._format_meta_pre_merge()
         self._merge_solar_wind_meta()
-        self._verify_lat_long_match_post_merge()
+        self._verify_lat_lon_match_post_merge()
         self._format_meta_post_merge()
         self._fillna_meta_cols()
         self._apply_limits()
@@ -603,7 +649,7 @@ class MetaHybridizer:
         self._sort_hybrid_meta_cols()
 
     def _format_meta_pre_merge(self):
-        """Prepare solar and wind meta for merging. """
+        """Prepare solar and wind meta for merging."""
         self.__col_name_map = {
             ColNameFormatter.fmt(c): c
             for c in self.data.solar_meta.columns.values
@@ -616,49 +662,50 @@ class MetaHybridizer:
 
     @staticmethod
     def _rename_cols(df, prefix):
-        """Replace column names with the ColNameFormatter.fmt is needed. """
+        """Replace column names with the ColNameFormatter.fmt is needed."""
         df.columns = [
             ColNameFormatter.fmt(col_name)
             if col_name in NON_DUPLICATE_COLS
-            else '{}{}'.format(prefix, col_name)
+            else "{}{}".format(prefix, col_name)
             for col_name in df.columns.values
         ]
 
     def _save_rep_prof_index_internally(self):
-        """Save rep profiles index in hybrid meta for access later. """
+        """Save rep profiles index in hybrid meta for access later."""
 
         self.data.solar_meta[self.__solar_rpi_n] = self.data.solar_meta.index
         self.data.wind_meta[self.__wind_rpi_n] = self.data.wind_meta.index
 
     def _merge_solar_wind_meta(self):
-        """Merge the wind and solar meta DataFrames. """
+        """Merge the wind and solar meta DataFrames."""
         self._hybrid_meta = self.data.solar_meta.merge(
             self.data.wind_meta,
             on=ColNameFormatter.fmt(MERGE_COLUMN),
-            suffixes=[None, '_x'], how=self._merge_type()
+            suffixes=[None, "_x"],
+            how=self._merge_type(),
         )
 
     def _merge_type(self):
-        """Determine the type of merge to use for meta based on user input. """
+        """Determine the type of merge to use for meta based on user input."""
         if self._allow_solar_only and self._allow_wind_only:
             return 'outer'
-        elif self._allow_solar_only and not self._allow_wind_only:
+        if self._allow_solar_only and not self._allow_wind_only:
             return 'left'
-        elif not self._allow_solar_only and self._allow_wind_only:
+        if not self._allow_solar_only and self._allow_wind_only:
             return 'right'
         return 'inner'
 
     def _format_meta_post_merge(self):
-        """Format hybrid meta after merging. """
+        """Format hybrid meta after merging."""
 
         duplicate_cols = [n for n in self._hybrid_meta.columns if "_x" in n]
         self._propagate_duplicate_cols(duplicate_cols)
         self._drop_cols(duplicate_cols)
         self._hybrid_meta.rename(self.__col_name_map, inplace=True, axis=1)
-        self._hybrid_meta.index.name = 'gid'
+        self._hybrid_meta.index.name = HYBRIDS_GID_COL
 
     def _propagate_duplicate_cols(self, duplicate_cols):
-        """Fill missing column values from outer merge. """
+        """Fill missing column values from outer merge."""
         for duplicate in duplicate_cols:
             no_suffix = "_".join(duplicate.split("_")[:-1])
             null_idx = self._hybrid_meta[no_suffix].isnull()
@@ -666,49 +713,61 @@ class MetaHybridizer:
             self._hybrid_meta.loc[null_idx, no_suffix] = non_null_vals
 
     def _drop_cols(self, duplicate_cols):
-        """Drop any remaning duplicate and 'DROPPED_COLUMNS' columns. """
+        """Drop any remaining duplicate and 'HYBRIDS_GID_COL' columns."""
         self._hybrid_meta.drop(
-            duplicate_cols + DROPPED_COLUMNS,
-            axis=1, inplace=True, errors='ignore'
+            duplicate_cols + [HYBRIDS_GID_COL],
+            axis=1,
+            inplace=True,
+            errors="ignore",
         )
 
     def _sort_hybrid_meta_cols(self):
-        """Sort the columns of the hybrid meta. """
+        """Sort the columns of the hybrid meta."""
         self.__hybrid_meta_cols = sorted(
-            [c for c in self._hybrid_meta.columns
-             if not c.startswith(self._INTERNAL_COL_PREFIX)],
-            key=self._column_sorting_key
+            [
+                c
+                for c in self._hybrid_meta.columns
+                if not c.startswith(self._INTERNAL_COL_PREFIX)
+            ],
+            key=self._column_sorting_key,
         )
 
     def _column_sorting_key(self, c):
-        """Helper function to sort hybrid meta columns. """
+        """Helper function to sort hybrid meta columns."""
         first_index = 0
-        if c.startswith('hybrid'):
+        if c.startswith("hybrid"):
             first_index = 1
-        elif c.startswith('solar'):
+        elif c.startswith("solar"):
             first_index = 2
-        elif c.startswith('wind'):
+        elif c.startswith("wind"):
             first_index = 3
         elif c == MERGE_COLUMN:
             first_index = -1
         return first_index, self._hybrid_meta.columns.get_loc(c)
 
-    def _verify_lat_long_match_post_merge(self):
+    def _verify_lat_lon_match_post_merge(self):
         """Verify that all the lat/lon values match post merge."""
-        lat = self._verify_col_match_post_merge(col_name='latitude')
-        lon = self._verify_col_match_post_merge(col_name='longitude')
+        lat = self._verify_col_match_post_merge(
+            col_name=ColNameFormatter.fmt(SupplyCurveField.LATITUDE)
+        )
+        lon = self._verify_col_match_post_merge(
+            col_name=ColNameFormatter.fmt(SupplyCurveField.LONGITUDE)
+        )
         if not lat or not lon:
-            msg = ("Detected mismatched coordinate values (latitude or "
-                   "longitude) post merge. Please ensure that all matching "
-                   "values of {!r} correspond to the same values of latitude "
-                   "and longitude across the input files {!r} and {!r}")
-            e = msg.format(MERGE_COLUMN, self.data.solar_fpath,
-                           self.data.wind_fpath)
+            msg = (
+                "Detected mismatched coordinate values (latitude or "
+                "longitude) post merge. Please ensure that all matching "
+                "values of {!r} correspond to the same values of latitude "
+                "and longitude across the input files {!r} and {!r}"
+            )
+            e = msg.format(
+                MERGE_COLUMN, self.data.solar_fpath, self.data.wind_fpath
+            )
             logger.error(e)
             raise FileInputError(e)
 
     def _verify_col_match_post_merge(self, col_name):
-        """Verify that all (non-null) values in a column match post merge. """
+        """Verify that all (non-null) values in a column match post merge."""
         c1, c2 = col_name, '{}_x'.format(col_name)
         if c1 in self._hybrid_meta.columns and c2 in self._hybrid_meta.columns:
             compare_df = self._hybrid_meta[
@@ -716,23 +775,22 @@ class MetaHybridizer:
                 & (self._hybrid_meta[c2].notnull())
             ]
             return np.allclose(compare_df[c1], compare_df[c2])
-        else:
-            return True
+        return True
 
     def _fillna_meta_cols(self):
-        """Fill N/A values as specified by user (and internals). """
+        """Fill N/A values as specified by user (and internals)."""
         for col_name, fill_value in self._fillna.items():
             if col_name in self._hybrid_meta.columns:
                 self._hybrid_meta[col_name].fillna(fill_value, inplace=True)
             else:
-                self.__warn_missing_col(col_name, action='fill')
+                self.__warn_missing_col(col_name, action="fill")
 
         self._hybrid_meta[self.__solar_rpi_n].fillna(-1, inplace=True)
         self._hybrid_meta[self.__wind_rpi_n].fillna(-1, inplace=True)
 
     @staticmethod
     def __warn_missing_col(col_name, action):
-        """Warn that a column the user request an action for is missing. """
+        """Warn that a column the user request an action for is missing."""
         msg = ("Skipping {} values for {!r}: Unable to find column "
                "in hybrid meta. Did you forget to prefix with "
                "{!r} or {!r}? ")
@@ -741,15 +799,15 @@ class MetaHybridizer:
         warn(w, InputWarning)
 
     def _apply_limits(self):
-        """Clip column values as specified by user. """
+        """Clip column values as specified by user."""
         for col_name, max_value in self._limits.items():
             if col_name in self._hybrid_meta.columns:
                 self._hybrid_meta[col_name].clip(upper=max_value, inplace=True)
             else:
-                self.__warn_missing_col(col_name, action='limit')
+                self.__warn_missing_col(col_name, action="limit")
 
     def _limit_by_ratio(self):
-        """ Limit the given pair of ratio columns based on input ratio. """
+        """Limit the given pair of ratio columns based on input ratio."""
 
         if self._ratio_bounds is None:
             return
@@ -765,8 +823,7 @@ class MetaHybridizer:
         denominator_vals = self._hybrid_meta[denominator_col].copy()
 
         ratios = (
-            numerator_vals.loc[overlap_idx]
-            / denominator_vals.loc[overlap_idx]
+            numerator_vals.loc[overlap_idx] / denominator_vals.loc[overlap_idx]
         )
         ratio_too_low = (ratios < min_ratio) & overlap_idx
         ratio_too_high = (ratios > max_ratio) & overlap_idx
@@ -784,16 +841,18 @@ class MetaHybridizer:
         self._hybrid_meta[h_denom_name] = denominator_vals.values
 
     def _add_hybrid_cols(self):
-        """Add new hybrid columns using registered hybrid methods. """
+        """Add new hybrid columns using registered hybrid methods."""
         for new_col_name, method in HYBRID_METHODS.items():
             out = method(self)
             if out is not None:
                 try:
                     self._hybrid_meta[new_col_name] = out
                 except ValueError as e:
-                    msg = ("Unable to add {!r} column to hybrid meta. The "
-                           "following exception was raised when adding "
-                           "the data output by '{}': {!r}.")
+                    msg = (
+                        "Unable to add {!r} column to hybrid meta. The "
+                        "following exception was raised when adding "
+                        "the data output by '{}': {!r}."
+                    )
                     w = msg.format(new_col_name, method.__name__, e)
                     logger.warning(w)
                     warn(w, OutputWarning)
@@ -843,9 +902,17 @@ class MetaHybridizer:
 class Hybridization:
     """Hybridization"""
 
-    def __init__(self, solar_fpath, wind_fpath, allow_solar_only=False,
-                 allow_wind_only=False, fillna=None, limits=None,
-                 ratio_bounds=None, ratio='solar_capacity/wind_capacity'):
+    def __init__(
+        self,
+        solar_fpath,
+        wind_fpath,
+        allow_solar_only=False,
+        allow_wind_only=False,
+        fillna=None,
+        limits=None,
+        ratio_bounds=None,
+        ratio="solar_capacity/wind_capacity",
+    ):
         """Framework to handle hybridization of SC and corresponding profiles.
 
         ``reV`` hybrids computes a "hybrid" wind and solar supply curve,
@@ -909,34 +976,57 @@ class Hybridization:
             variables. By default ``'solar_capacity/wind_capacity'``.
         """
 
-        logger.info('Running hybridization of rep profiles with solar_fpath: '
-                    '"{}"'.format(solar_fpath))
-        logger.info('Running hybridization of rep profiles with solar_fpath: '
-                    '"{}"'.format(wind_fpath))
-        logger.info('Running hybridization of rep profiles with '
-                    'allow_solar_only: "{}"'.format(allow_solar_only))
-        logger.info('Running hybridization of rep profiles with '
-                    'allow_wind_only: "{}"'.format(allow_wind_only))
-        logger.info('Running hybridization of rep profiles with fillna: "{}"'
-                    .format(fillna))
-        logger.info('Running hybridization of rep profiles with limits: "{}"'
-                    .format(limits))
-        logger.info('Running hybridization of rep profiles with ratio_bounds: '
-                    '"{}"'.format(ratio_bounds))
-        logger.info('Running hybridization of rep profiles with ratio: "{}"'
-                    .format(ratio))
+        logger.info(
+            "Running hybridization of rep profiles with solar_fpath: "
+            '"{}"'.format(solar_fpath)
+        )
+        logger.info(
+            "Running hybridization of rep profiles with solar_fpath: "
+            '"{}"'.format(wind_fpath)
+        )
+        logger.info(
+            "Running hybridization of rep profiles with "
+            'allow_solar_only: "{}"'.format(allow_solar_only)
+        )
+        logger.info(
+            "Running hybridization of rep profiles with "
+            'allow_wind_only: "{}"'.format(allow_wind_only)
+        )
+        logger.info(
+            'Running hybridization of rep profiles with fillna: "{}"'.format(
+                fillna
+            )
+        )
+        logger.info(
+            'Running hybridization of rep profiles with limits: "{}"'.format(
+                limits
+            )
+        )
+        logger.info(
+            "Running hybridization of rep profiles with ratio_bounds: "
+            '"{}"'.format(ratio_bounds)
+        )
+        logger.info(
+            'Running hybridization of rep profiles with ratio: "{}"'.format(
+                ratio
+            )
+        )
 
         self.data = HybridsData(solar_fpath, wind_fpath)
         self.meta_hybridizer = MetaHybridizer(
-            data=self.data, allow_solar_only=allow_solar_only,
-            allow_wind_only=allow_wind_only, fillna=fillna, limits=limits,
-            ratio_bounds=ratio_bounds, ratio=ratio
+            data=self.data,
+            allow_solar_only=allow_solar_only,
+            allow_wind_only=allow_wind_only,
+            fillna=fillna,
+            limits=limits,
+            ratio_bounds=ratio_bounds,
+            ratio=ratio,
         )
         self._profiles = None
         self._validate_input()
 
     def _validate_input(self):
-        """Validate the user input and input files. """
+        """Validate the user input and input files."""
         self.data.validate()
         self.meta_hybridizer.validate_input()
 
@@ -1042,7 +1132,7 @@ class Hybridization:
         if fout is not None:
             self.save_profiles(fout, save_hybrid_meta=save_hybrid_meta)
 
-        logger.info('Hybridization of representative profiles complete!')
+        logger.info("Hybridization of representative profiles complete!")
         return fout
 
     def run_meta(self):
@@ -1067,54 +1157,68 @@ class Hybridization:
             hybridized profiles as attributes.
         """
 
-        logger.info('Running hybrid profile calculations.')
+        logger.info("Running hybrid profile calculations.")
 
         self._init_profiles()
         self._compute_hybridized_profile_components()
         self._compute_hybridized_profiles_from_components()
 
-        logger.info('Profile hybridization complete.')
+        logger.info("Profile hybridization complete.")
 
         return self
 
     def _init_profiles(self):
         """Initialize the output rep profiles attribute."""
         self._profiles = {
-            k: np.zeros((len(self.hybrid_time_index), len(self.hybrid_meta)),
-                        dtype=np.float32)
-            for k in OUTPUT_PROFILE_NAMES}
+            k: np.zeros(
+                (len(self.hybrid_time_index), len(self.hybrid_meta)),
+                dtype=np.float32,
+            )
+            for k in OUTPUT_PROFILE_NAMES
+        }
 
     def _compute_hybridized_profile_components(self):
-        """Compute the resource components of the hybridized profiles. """
+        """Compute the resource components of the hybridized profiles."""
 
         for params in self.__rep_profile_hybridization_params:
             col, (hybrid_idxs, solar_idxs), fpath, p_name, dset_name = params
             capacity = self.hybrid_meta.loc[hybrid_idxs, col].values
 
             with Resource(fpath) as res:
-                data = res[dset_name,
-                           res.time_index.isin(self.hybrid_time_index)]
-                self._profiles[p_name][:, hybrid_idxs] = (data[:, solar_idxs]
-                                                          * capacity)
+                data = res[
+                    dset_name, res.time_index.isin(self.hybrid_time_index)
+                ]
+                self._profiles[p_name][:, hybrid_idxs] = (
+                    data[:, solar_idxs] * capacity
+                )
 
     @property
     def __rep_profile_hybridization_params(self):
-        """Zip the rep profile hybridization parameters. """
+        """Zip the rep profile hybridization parameters."""
 
-        cap_col_names = ['hybrid_solar_capacity', 'hybrid_wind_capacity']
-        idx_maps = [self.meta_hybridizer.solar_profile_indices_map,
-                    self.meta_hybridizer.wind_profile_indices_map]
+        cap_col_names = [f"hybrid_solar_{SupplyCurveField.CAPACITY_AC_MW}",
+                         f"hybrid_wind_{SupplyCurveField.CAPACITY_AC_MW}"]
+        idx_maps = [
+            self.meta_hybridizer.solar_profile_indices_map,
+            self.meta_hybridizer.wind_profile_indices_map,
+        ]
         fpaths = [self.data.solar_fpath, self.data.wind_fpath]
-        zipped = zip(cap_col_names, idx_maps, fpaths, OUTPUT_PROFILE_NAMES[1:],
-                     self.data.profile_dset_names)
+        zipped = zip(
+            cap_col_names,
+            idx_maps,
+            fpaths,
+            OUTPUT_PROFILE_NAMES[1:],
+            self.data.profile_dset_names,
+        )
         return zipped
 
     def _compute_hybridized_profiles_from_components(self):
-        """Compute the hybridized profiles from the resource components. """
+        """Compute the hybridized profiles from the resource components."""
 
         hp_name, sp_name, wp_name = OUTPUT_PROFILE_NAMES
-        self._profiles[hp_name] = (self._profiles[sp_name]
-                                   + self._profiles[wp_name])
+        self._profiles[hp_name] = (
+            self._profiles[sp_name] + self._profiles[wp_name]
+        )
 
     def _init_h5_out(self, fout, save_hybrid_meta=True):
         """Initialize an output h5 file for hybrid profiles.
@@ -1146,14 +1250,26 @@ class Hybridization:
             except ValueError:
                 pass
 
-        Outputs.init_h5(fout, dsets, shapes, attrs, chunks, dtypes,
-                        meta, time_index=self.hybrid_time_index)
+        Outputs.init_h5(
+            fout,
+            dsets,
+            shapes,
+            attrs,
+            chunks,
+            dtypes,
+            meta,
+            time_index=self.hybrid_time_index,
+        )
 
         if save_hybrid_meta:
-            with Outputs(fout, mode='a') as out:
+            with Outputs(fout, mode="a") as out:
                 hybrid_meta = to_records_array(self.hybrid_meta)
-                out._create_dset('meta', hybrid_meta.shape,
-                                 hybrid_meta.dtype, data=hybrid_meta)
+                out._create_dset(
+                    "meta",
+                    hybrid_meta.shape,
+                    hybrid_meta.dtype,
+                    data=hybrid_meta,
+                )
 
     def _write_h5_out(self, fout, save_hybrid_meta=True):
         """Write hybrid profiles and meta to an output file.
@@ -1166,10 +1282,10 @@ class Hybridization:
             Flag to save hybrid SC table to hybrid rep profile output.
         """
 
-        with Outputs(fout, mode='a') as out:
-            if 'meta' in out.datasets and save_hybrid_meta:
+        with Outputs(fout, mode="a") as out:
+            if "meta" in out.datasets and save_hybrid_meta:
                 hybrid_meta = to_records_array(self.hybrid_meta)
-                out['meta'] = hybrid_meta
+                out["meta"] = hybrid_meta
 
             for dset, data in self.profiles.items():
                 out[dset] = data