Miscellaneous tidying for the rabbit

Signed-off-by: Davey Elder <iandavidelder@gmail.com>

Author: idelder

temoa/components/time.py

@@ -336,9 +336,8 @@ def create_time_season_to_sequential(model: TemoaModel) -> None:
                 f'No data in time_season_sequential but time_sequencing parameter set to '
                 f'{model.time_sequencing.first()} and inter-season features used. '
                 'time_season_sequential must be filled for this type of time sequencing if '
-                'seasonal storage or inter-season constraints like ramp_up/ramp_down are used. '
-                'Check '
-                'the config file.'
+                'seasonal storage or inter-season constraints like ramp_up/ramp_down or'
+                'unit_commitment are used. Check the config file.'
             )
             logger.error(msg)
             raise ValueError(msg)

temoa/data_io/hybrid_loader.py

@@ -564,7 +564,7 @@ def _load_tech_group_members(
         filtered_data: Sequence[tuple[object, ...]],
     ) -> None:
         """Loads members into the indexed set `tech_group_members`."""
-        model = TemoaModel()
+        model = self.model
         validator = self.viable_techs.members if self.viable_techs else None
         for group_name, tech in filtered_data:
             if validator is None or tech in validator:
@@ -582,7 +582,7 @@ def _load_time_season(
         """
         Loads time_season as a flat ordered set of season names.
         """
-        model = TemoaModel()
+        model = self.model
         if not filtered_data:
             logger.warning('No time_season table found. Loading a single filler season "S".')
             seasons_to_load: list[tuple[object, ...]] = [('S',)]
@@ -599,7 +599,7 @@ def _load_time_season_sequential(
         """
         Composite loader for time_season_sequential and its associated index sets.
         """
-        model = TemoaModel()
+        model = self.model
         if filtered_data:
             seg_frac_data = [
                 (row[0], row[2]) for row in filtered_data
@@ -623,7 +623,7 @@ def _load_existing_capacity(
         Handles different queries for myopic vs. standard runs and also
         populates the `tech_exist` set.
         """
-        model = TemoaModel()
+        model = self.model
         cur = self.con.cursor()
         mi = self.myopic_index
 
@@ -652,7 +652,6 @@ def _load_existing_capacity(
             self._load_component_data(data, model.vintage_exist, vintage_exist_data)
 
             # Collect existing capacity data indices
-            self.viable_existing_techs = {row[1] for row in rows_to_load}
             self.viable_existing_rt = {(row[0], row[1]) for row in rows_to_load}
             self.viable_existing_rtv = {(row[0], row[1], row[2]) for row in rows_to_load}
 
@@ -672,7 +671,7 @@ def _load_retired_existing_capacity(
             )
             return
 
-        model = TemoaModel()
+        model = self.model
         cur = self.con.cursor()
         mi = self.myopic_index
 
@@ -701,12 +700,12 @@ def _load_lifetime_tech(
         filtered_data: Sequence[tuple[object, ...]],
     ) -> None:
         """Loads the lifetime_tech component."""
-        model = TemoaModel()
+        model = self.model
         cur = self.con.cursor()
         rows_to_load = cur.execute('SELECT region, tech, lifetime FROM lifetime_tech').fetchall()
         rt_getter = itemgetter(0, 1)
         if self.viable_rt:
-            valid_rt = self.viable_rt.members | self.viable_existing_rt
+            valid_rt = self.viable_rt.member_tuples | self.viable_existing_rt
             rows_to_load = [item for item in rows_to_load if rt_getter(item) in valid_rt]
         self._load_component_data(data, model.lifetime_tech, rows_to_load)
 
@@ -717,7 +716,7 @@ def _load_lifetime_process(
         filtered_data: Sequence[tuple[object, ...]],
     ) -> None:
         """Loads the lifetime_process component."""
-        model = TemoaModel()
+        model = self.model
         cur = self.con.cursor()
         mi = self.myopic_index
 
@@ -743,7 +742,7 @@ def _load_lifetime_survival_curve(
         filtered_data: Sequence[tuple[object, ...]],
     ) -> None:
         """Loads the lifetime_survival_curve component."""
-        model = TemoaModel()
+        model = self.model
         cur = self.con.cursor()
         mi = self.myopic_index
 
@@ -771,7 +770,7 @@ def _load_global_discount_rate(
         filtered_data: Sequence[tuple[object, ...]],
     ) -> None:
         """Loads the required singleton global_discount_rate."""
-        model = TemoaModel()
+        model = self.model
         if filtered_data:
             data[model.global_discount_rate.name] = {None: cast('float', filtered_data[0][0])}
         else:
@@ -787,7 +786,7 @@ def _load_default_loan_rate(
         filtered_data: Sequence[tuple[object, ...]],
     ) -> None:
         """Loads the optional singleton default_loan_rate."""
-        model = TemoaModel()
+        model = self.model
         if filtered_data:
             data[model.default_loan_rate.name] = {None: cast('float', filtered_data[0][0])}
 
@@ -799,7 +798,7 @@ def _load_efficiency(
         filtered_data: Sequence[tuple[object, ...]],
     ) -> None:
         """Loads the main efficiency parameter, which is pre-calculated."""
-        model = TemoaModel()
+        model = self.model
         self._load_component_data(data, model.efficiency, self.efficiency_values)
 
     def _load_linked_techs(
@@ -832,7 +831,7 @@ def _load_ramping_down(
         filtered_data: Sequence[tuple[object, ...]],
     ) -> None:
         """Composite loader for ramp_down_hourly and its index set `tech_downramping`."""
-        model = TemoaModel()
+        model = self.model
         self._load_component_data(data, model.ramp_down_hourly, filtered_data)
         if filtered_data:
             tech_data = sorted({(row[1],) for row in filtered_data})
@@ -848,7 +847,7 @@ def _load_ramping_up(
         filtered_data: Sequence[tuple[object, ...]],
     ) -> None:
         """Composite loader for ramp_up_hourly and its index set `tech_upramping`."""
-        model = TemoaModel()
+        model = self.model
         self._load_component_data(data, model.ramp_up_hourly, filtered_data)
         if filtered_data:
             tech_data = sorted({(row[1],) for row in filtered_data})
@@ -864,7 +863,7 @@ def _load_rps_requirement(
         filtered_data: Sequence[tuple[object, ...]],
     ) -> None:
         """Handles deprecation warning for renewable_portfolio_standard."""
-        model = TemoaModel()
+        model = self.model
         self._load_component_data(data, model.renewable_portfolio_standard, filtered_data)
         if filtered_data:
             logger.warning(

temoa/extensions/economies_of_scale/components/cost_invest_eos.py

@@ -397,25 +397,26 @@ def period_cost(model: EOSModel, r: Region, p: Period, t: Technology) -> Express
         # Existing capacity costs to subtract (needed for myopic)
         regions = geography.gather_group_regions(model, r)
         techs = technology.gather_group_techs(model, t)
-        existing_capacity = quicksum(
+        existing_capacity = sum(
             value(model.existing_capacity[_r, _t, _v])
             for _r, _t, _v in model.existing_capacity
             if _r in regions and _t in techs
         )
-        if existing_capacity:
-            for n in model.cost_invest_eos_segments[r, t]:
-                cap_lower, cap_upper, _, _ = model.cost_invest_eos[r, t, n]
-                if value(cap_lower) <= existing_capacity <= value(cap_upper):
-                    prev_cum_cost = cost_invest_eos_segment_cost(model, r, t, n, existing_capacity)
-                    continue  # in case we're exactly on the boundary of two segments
-            if not prev_cum_cost:
-                msg = (
-                    'Existing capacity for a cost_invest_eos cluster is outside the bounds of '
-                    'the cost curve. Check the cost_invest_eos table and existing_capacity '
-                    f'for {r, t}: {existing_capacity}'
-                )
-                logger.error(msg)
-                raise ValueError(msg)
+        in_bounds = False
+        for n in model.cost_invest_eos_segments[r, t]:
+            cap_lower, cap_upper, _, _ = model.cost_invest_eos[r, t, n]
+            if value(cap_lower) <= existing_capacity <= value(cap_upper):
+                prev_cum_cost = cost_invest_eos_segment_cost(model, r, t, n, existing_capacity)
+                in_bounds = True
+                break
+        if not in_bounds:
+            msg = (
+                'Existing capacity for a cost_invest_eos cluster is outside the bounds of '
+                'the cost curve. Check the cost_invest_eos table and existing_capacity '
+                f'for {r, t}: {existing_capacity}'
+            )
+            logger.error(msg)
+            raise ValueError(msg)
 
     return cumulative_cost - prev_cum_cost
 

temoa/extensions/economies_of_scale/core/model.py

@@ -14,9 +14,11 @@
     Var,
 )
 
-import temoa.extensions.economies_of_scale.components.cost_fixed_eos as cost_fixed_eos
-import temoa.extensions.economies_of_scale.components.cost_invest_eos as cost_invest_eos
-import temoa.extensions.economies_of_scale.components.cost_variable_eos as cost_variable_eos
+from temoa.extensions.economies_of_scale.components import (
+    cost_fixed_eos,
+    cost_invest_eos,
+    cost_variable_eos,
+)
 
 if TYPE_CHECKING:
     from temoa.core.model import TemoaModel

temoa/extensions/framework.py

@@ -43,7 +43,7 @@ def normalize_extension_ids(extension_ids: Sequence[str | object] | None) -> tup
         if not isinstance(ext_id, str):
             msg = f'Extension ids must be strings. Received: {type(ext_id).__name__}'
             logger.error(msg)
-            raise ValueError(msg)
+            raise TypeError(msg)
         cleaned = ext_id.strip().lower()
         if not cleaned:
             continue
@@ -133,10 +133,7 @@ def assert_disabled_extension_tables_are_empty(
         if not spec.fail_if_tables_populated_when_disabled:
             continue
 
-        populated: list[str] = []
-        for table in spec.owned_tables:
-            if _table_has_rows(con, table):
-                populated.append(table)
+        populated = [table for table in spec.owned_tables if _table_has_rows(con, table)]
 
         if populated:
             table_list = ', '.join(sorted(populated))