fram-core 0.1.0a1__tar.gz → 0.1.1__tar.gz

{fram_core-0.1.0a1 → fram_core-0.1.1}/PKG-INFO

@@ -1,18 +1,19 @@
 Metadata-Version: 2.4
 Name: fram-core
-Version: 0.1.0a1
+Version: 0.1.1
 Summary: 
 License: LICENSE.md
 License-File: LICENSE.md
 Author: The Norwegian Water Resources and Energy Directorate
 Author-email: fram@nve.no
-Requires-Python: >=3.11
+Requires-Python: >=3.11,<4
 Classifier: License :: Other/Proprietary License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: juliacall (>=0.9.28,<0.10.0)
 Requires-Dist: numexpr (>=2.10.2)
 Requires-Dist: numpy (>=2.2.2)
 Requires-Dist: pandas (>=2.2.3)
@@ -23,11 +24,11 @@ Description-Content-Type: text/markdown
 
 ## About
 
-**fram-core** is the main package in **FRAM** modelling framework. The package contains essential features, interfaces and components for running energy market models in FRAM.
+**fram-core** is the main package in the **FRAM** modelling framework. The package holds the functionality used to describe and manipulate the energy system, handle time series operations, and hold the definition of key interfaces in FRAM.
 
-For package documentation see [fram-core](https://nve.github.io/fram-core){:target="_blank"}. 
+For package documentation see [fram-core](https://nve.github.io/fram-core). 
 
-For FRAM documentation see [FRAM mainpage](https://nve.github.io/fram){:target="_blank"}.
+For FRAM documentation see [FRAM mainpage](https://nve.github.io/fram).
 
 ## Installation
 

fram_core-0.1.1/README.md

@@ -0,0 +1,19 @@
+# fram-core
+
+## About
+
+**fram-core** is the main package in the **FRAM** modelling framework. The package holds the functionality used to describe and manipulate the energy system, handle time series operations, and hold the definition of key interfaces in FRAM.
+
+For package documentation see [fram-core](https://nve.github.io/fram-core). 
+
+For FRAM documentation see [FRAM mainpage](https://nve.github.io/fram).
+
+## Installation
+
+To add the package to your project use:
+
+    pip install fram-core
+
+With poetry:
+
+    poetry add fram-core

{fram_core-0.1.0a1 → fram_core-0.1.1}/framcore/Base.py

@@ -1,5 +1,6 @@
 import contextlib
 import inspect
+from collections.abc import Callable
 from typing import Any
 
 from framcore.events import (
@@ -18,9 +19,7 @@ class Base:
     """Core base class to share methods."""
 
     def _check_type(self, value, class_or_tuple) -> None:  # noqa: ANN001
-        if not isinstance(value, class_or_tuple):
-            message = f"Expected {class_or_tuple} for {self}, got {type(value).__name__}"
-            raise TypeError(message)
+        check_type(value, class_or_tuple, caller=self)
 
     def _ensure_float(self, value: object) -> float:
         with contextlib.suppress(Exception):
@@ -140,3 +139,23 @@ class Base:
         except Exception:
             pass
         return type(value).__name__
+
+
+# could not place this in utils and use __init__ as modules in utils also import queries, if queries then import via utils __init__ we get circular imports.
+def check_type(value: object, expected: type | tuple[type], caller: Callable | None = None) -> None:
+    """
+    Check a value matches expected type(s).
+
+    Args:
+        value (object): value being checked.
+        expected (type | tuple[type]): Expected types.
+        caller (Callable): The origin of the check.
+
+    Raises:
+        TypeError: When value does not match expected types.
+
+    """
+    if not isinstance(value, expected):
+        message = f"{expected}, got {type(value).__name__}"
+        message = "Expected " + message if caller is None else f"{caller} expected " + message
+        raise TypeError(message)

{fram_core-0.1.0a1 → fram_core-0.1.1}/framcore/Model.py

@@ -10,9 +10,12 @@ from framcore.timevectors import TimeVector
 if TYPE_CHECKING:
     from framcore.aggregators import Aggregator
 
+
 class ModelDict(dict):
     """Dict storing only values of type Component | Expr | TimeVector | Curve."""
-    def __setitem__(self, key, value):
+
+    def __setitem__(self, key: str, value: Component | Expr | TimeVector | Curve) -> None:
+        """Set item with type checking."""
         if not isinstance(key, str):
             message = f"Expected str for key {key}, got {type(key).__name__}"
             raise TypeError(message)
@@ -21,24 +24,39 @@ class ModelDict(dict):
             raise TypeError(message)
         return super().__setitem__(key, value)
 
+
 class Model(Base):
-    """Definition of the Model class."""
+    """
+    Model stores the representation of the energy system with Components, TimeVectors, Expression, and the Aggregators applied to the Model.
+
+    - Components describe the main elements in the energy system. Can have additional Attributes.
+    - TimeVector and Curve hold the time series data.
+    - Expressions for data manipulation of TimeVectors and Curves. Can be queried.
+    - Aggregators handle aggregation and disaggregation of Components. Aggregators are added to Model when used (Aggregator.aggregate(model)),
+    and can be undone in LIFO order with disaggregate().
+
+    Methods:
+        get_data(): Get dict of Components, Expressions, TimeVectors and Curves stored in the Model. Can be modified.
+        disaggregate(): Undo all aggregations applied to Model in LIFO order.
+        get_content_counts(): Return number of objects stored in model organized into concepts and types.
+
+    """
 
     def __init__(self) -> None:
-        """Create a new model instance."""
+        """Create a new model instance with empty data and no aggregators."""
         self._data = ModelDict()
         self._aggregators: list[Aggregator] = []
 
+    def get_data(self) -> ModelDict:
+        """Get dict of Components, Expressions, TimeVectors and Curves stored in the Model. Can be modified."""
+        return self._data
+
     def disaggregate(self) -> None:
-        """Undo all aggregations in LIFO order."""
+        """Undo all aggregations applied to Model in LIFO order."""
         while self._aggregators:
             aggregator = self._aggregators.pop(-1)  # last item
             aggregator.disaggregate(self)
 
-    def get_data(self) -> ModelDict:
-        """Get internal data. Modify this with care."""
-        return self._data
-
     def get_content_counts(self) -> dict[str, Counter]:
         """Return number of objects stored in model organized into concepts and types."""
         data_values = self.get_data().values()
@@ -70,4 +88,3 @@ class Model(Base):
             counts["aggregators"][type(a).__name__] += 1
 
         return counts
-

{fram_core-0.1.0a1 → fram_core-0.1.1}/framcore/__init__.py

@@ -1,9 +1,10 @@
 # framcore/__init__.py
-
+from framcore.Base import check_type
 from framcore.Base import Base
 from framcore.Model import Model
 
 __all__ = [
     "Base",
     "Model",
+    "check_type",
 ]

{fram_core-0.1.0a1 → fram_core-0.1.1}/framcore/aggregators/Aggregator.py

@@ -18,17 +18,36 @@ class Aggregator(Base, ABC):
     """
     Aggregator interface class.
 
-    Public API is the aggregate and disaggregate methods.
+    Aggregators handles aggregation and disaggregation of Components.
+    - The general approach for aggregation is to group Components, aggregate Components in the same group to (a) new Component(s),
+    delete the detailed Components, and add the mapping to self._aggregation_map.
+    - The general approach for disaggregation is to restore the detailed Components, move results from aggregated
+    Components to detailed Components, and delete the aggregated Components.
+
+    Concrete Aggregators must implement the abstract methods _aggregate() and _disaggregate().
+
+    Some rules for using Aggregators:
+    1. Disaggragate can only be called after aggregate has been called.
+    2. Not allowed to call aggregate twice. Must call disaggregate before aggregate can be called again.
+    3. Aggregators are stored in Model when aggregate is called. Disaggregate by calling Model.disaggregate(),
+         which will disaggregate all Aggregators in LIFO order.
+    4. At the moment we allow changes to the aggregated Components, which is ignored during disaggregation. TODO: Handle this
+    5. It is recommended to only use the same Aggregator type once on the same components of a Model.
+        If you want to go from one aggregation level to another, it is better to use Model.disaggregate first and then aggregate again.
+        This is to keep the logic simple and avoid complex expressions.
+
+    Some design notes:
+    - Levels and profiles are aggregated separately and then combined into attributes.
+    - We have chosen to eagerly evaluate weights for aggregation (weighted averages) and disaggregation of levels and profiles.
+        This approach supports any form of aggregation by varying the weights, and complex weights can be created by eagerly evaluating
+        expressions and using the result to compute those weights.
+    - This is a balance between eagerly evaluating everything and setting up complex expressions.
+        Eagerly evaluating everything would require setting up new TimeVectors after evaluation, which is not ideal.
+        While setting up complex expressions gives expressions that are harder to work with and slower to query from.
+    - This trade-off simplifies adding logic that recognises if result expressions come from aggregations or disaggregations.
+        When aggregating or disaggregating these, we can go back to the original results rather than setting up complex expressions
+        that for examples aggregates the disaggregated results.
 
-    These methods come with the folloing calling rules:
-    1. Not allowed to call aggregate twice. Must call disaggregate before aggregate can be called again.
-    2. Disaggragate can only be called after aggregate has been called.
-
-    Implementations should implement _aggregate and _disaggregate.
-    - The general approach for aggregation is to group components, aggregated components in the same group, delete the detailed components,
-    and add the mapping to self._aggregation_map.
-    - The general approach for disaggregation is to restore the detailed components, move results from aggregated components to detailed components,
-    and delete the aggregated components.
     """
 
     def __init__(self) -> None:
@@ -42,7 +61,7 @@ class Aggregator(Base, ABC):
         self._check_type(model, Model)
 
         if self._is_last_call_aggregate is True:
-            message = f"Will overwrite existing aggregation."
+            message = "Will overwrite existing aggregation."
             self.send_warning_event(message)
 
         self._original_data = deepcopy(model.get_data())

{fram_core-0.1.0a1 → fram_core-0.1.1}/framcore/aggregators/HydroAggregator.py

@@ -27,9 +27,10 @@ if TYPE_CHECKING:
 
 class HydroAggregator(Aggregator):
     """
-    Aggregate hydro modules into two equivalent modules based on the regulation factor, into one regulated and one unregulated module per area.
+    Aggregate HydroModules into two equivalent modules based on the regulation factor, into one regulated and one unregulated module per area.
 
     Aggregation steps (self._aggregate):
+
     1. Group modules based on their power nodes (self._group_modules_by_power_node)
         - Modules with generators are grouped based on their power nodes. You can choose to only group modules for certain power nodes by giving
         self._power_node_members alone or together with self._metakey_power_node. NB! Watershed that crosses power nodes should not be aggregated in two
@@ -54,30 +55,24 @@ class HydroAggregator(Aggregator):
     3a. Aggregate results if all modules in group have results.
         - Production is the sum of production levels with weighted profiles
         - Reservoir filling is the sum of energy reservoir filling levels (filling*energy_equivalent_downstream/agg_energy_equivalent) with weighted profiles
-        - TODO: Spill, bypass and pumping results are currently ignored in the aggregation.
+        - TODO: Water values, spill, bypass and pumping results are currently ignored in the aggregation.
         - TODO: Add possibility to skip results aggregation.
     3b. Make new hydro module and delete original modules from model data.
     4. Add mapping from detailed to aggregated modules to self._aggregation_map.
 
+
     Disaggregation steps (self._disaggregate):
+
     1. Restore original modules from self._original_data. NB! Changes to aggregated modules are lost except for results (TODO)
     2. Move production and filling results from aggregated modules to detailed modules, weighted based on production capacity and reservoir capacity.
-        - TODO: Spill and bypass results are currently ignored in the disaggregation.
+        - TODO: Water values, spill, bypass and pumping results are currently ignored in the disaggregation.
     3. Delete aggregated modules.
 
     NB! Watershed that crosses power nodes should not be aggregated in two different HydroAggregators as the aggregator will remove all connected modules
     from the model after the first aggregation. Reservoirs will also be assigned to the power node which has the highest cumulative energy equivalent, so
     this aggregator does not work well for reservoirs that are upstream of multiple power nodes.
 
-    Other comments:
-        - It is recommended to only use the same aggregator type once on the same components of a model. If you want to go from one aggregation level to
-        another, it is better to use model.disaggregate first and then aggregate again. This is to keep the logic simple and avoid complex expressions.
-        We have also logic that recognises if result expressions come from aggregations or disaggregations. When aggregating or disaggregating these,
-        we can go back to the original results rather than setting up complex expressions that for examples aggregates the disaggregated results.
-        - Levels and profiles are aggregated separately, and then combined into attributes.
-        - We have chosen to eagerly evaluate weights for aggregation and disaggregation of levels and profiles. This is a balance between eagerly evaluating
-        everything, and setting up complex expressions. Eagerly evaluating everything would require setting up new timevectors after eager evaluation, which
-        is not ideal. While setting up complex expressions gives expressions that are harder to work with and slower to query from.
+    See Aggregator for general design notes and rules to follow when using Aggregators.
 
     Attributes:
         _metakey_energy_eq_downstream (str): Metadata key for energy equivalent downstream.
@@ -93,6 +88,7 @@ class HydroAggregator(Aggregator):
         _release_capacity_profile (TimeVector | None): If given, use this profile for all aggregated modules' release capacities.
 
     Parent Attributes (see framcore.aggregators.Aggregator):
+
         _is_last_call_aggregate (bool | None): Tracks whether the last operation was an aggregation.
         _original_data (dict[str, Component | TimeVector | Curve | Expr] | None): Original detailed data before aggregation.
         _aggregation_map (dict[str, set[str]] | None): Maps aggregated components to their detailed components. detailed to agg
@@ -128,13 +124,15 @@ class HydroAggregator(Aggregator):
         super().__init__()
         self._check_type(metakey_energy_eq_downstream, str)
         self._check_type(ror_threshold, float)
-        assert ror_threshold >= 0, ValueError(f"ror_threshold must be non-negative, got {ror_threshold}.")
         self._check_type(data_dim, SinglePeriodTimeIndex)
         self._check_type(scen_dim, FixedFrequencyTimeIndex)
         self._check_type(metakey_power_node, (str, type(None)))
         self._check_type(power_node_members, (list, type(None)))
-        if metakey_power_node is not None:
-            assert len(power_node_members) > 0, ValueError("If metakey_power_node is given, power_node_members must also be given.")
+        if ror_threshold < 0:
+            msg = f"ror_threshold must be non-negative, got {ror_threshold}."
+            raise ValueError(msg)
+        if metakey_power_node is not None and len(power_node_members) <= 0:
+            raise ValueError("If metakey_power_node is given, power_node_members must also be given.")
 
         self._metakey_energy_eq_downstream = metakey_energy_eq_downstream
         self._ror_threshold = ror_threshold
@@ -183,7 +181,7 @@ class HydroAggregator(Aggregator):
             for dd in d:
                 if dd not in self._aggregation_map:
                     self._aggregation_map[dd] = set([a])
-                elif not data[dd].get_reservoir():  # if reservoir module already in map, skip as reservoir mapping is main mapping
+                elif not (data[dd].get_reservoir() and data[a].get_reservoir()):  # reservoir modules can only be mapped to one aggregated reservoir module
                     self._aggregation_map[dd].add(a)
         self.send_debug_event(f"add generator modules to _aggregation_map time: {round(time() - t, 3)} seconds")
 
@@ -450,7 +448,7 @@ class HydroAggregator(Aggregator):
                     (
                         mm,
                         get_level_value(
-                            data[mm].get_generator().get_energy_eq().get_level() * data[mm].get_release_capacity().get_level(),
+                            data[mm].get_generator().get_energy_equivalent().get_level() * data[mm].get_release_capacity().get_level(),
                             model,
                             "MW",
                             self._data_dim,
@@ -466,7 +464,7 @@ class HydroAggregator(Aggregator):
 
         return ignore_production_capacity_modules
 
-    def _aggregate_groups(  # noqa: C901
+    def _aggregate_groups(  # noqa: C901, PLR0915
         self,
         model: Model,
         upstream_topology: dict[str, list[str]],
@@ -487,10 +485,10 @@ class HydroAggregator(Aggregator):
 
             generator = HydroGenerator(
                 power_node=data[generator_module_names[0]].get_generator().get_power_node(),
-                energy_eq=Conversion(level=ConstantTimeVector(1.0, "kWh/m3", is_max_level=True)),
+                energy_equivalent=Conversion(level=ConstantTimeVector(1.0, "kWh/m3", is_max_level=True)),
                 production=sum_production,
             )
-            energy_eq = generator.get_energy_eq().get_level()
+            energy_eq = generator.get_energy_equivalent().get_level()
 
             # Release capacity
             release_capacities = [data[m].get_release_capacity() for m in generator_module_names if m not in ignore_capacity]
@@ -501,9 +499,16 @@ class HydroAggregator(Aggregator):
                 release_capacities = deepcopy(release_capacities)
                 for rc in release_capacities:
                     rc.set_profile(self._release_capacity_profile)
-            generator_energy_eqs = [data[m].get_generator().get_energy_eq() for m in generator_module_names if m not in ignore_capacity]
+            generator_energy_eqs = [data[m].get_generator().get_energy_equivalent() for m in generator_module_names if m not in ignore_capacity]
             release_capacity_levels = [rc.get_level() * ee.get_level() for rc, ee in zip(release_capacities, generator_energy_eqs, strict=True)]
-            release_capacity = MaxFlowVolume(level=sum(release_capacity_levels) / energy_eq, profile=self._release_capacity_profile)
+            
+            release_capacity_profile = None
+            if any(rc.get_profile() for rc in release_capacities):
+                one_profile_max = Expr(src=ConstantTimeVector(1.0, is_zero_one_profile=False), is_profile=True)
+                weights = [get_level_value(rcl, model, "MW", self._data_dim, self._scen_dim, is_max=True) for rcl in release_capacity_levels]
+                profiles = [rc.get_profile() if rc.get_profile() else one_profile_max for rc in release_capacities]
+                release_capacity_profile = _aggregate_weighted_expressions(profiles, weights)
+            release_capacity = MaxFlowVolume(level=sum(release_capacity_levels) / energy_eq, profile=release_capacity_profile)
 
             # Inflow level
             upstream_inflow_levels = defaultdict(list)
@@ -513,7 +518,7 @@ class HydroAggregator(Aggregator):
                     if inflow:
                         upstream_inflow_levels[m].append(inflow.get_level())
             inflow_level_energy = sum(
-                sum(upstream_inflow_levels[m]) * data[m].get_generator().get_energy_eq().get_level()
+                sum(upstream_inflow_levels[m]) * data[m].get_generator().get_energy_equivalent().get_level()
                 for m in generator_module_names
                 if len(upstream_inflow_levels[m]) > 0
             )
@@ -524,7 +529,7 @@ class HydroAggregator(Aggregator):
             inflow_profile_to_energyinflow = defaultdict(list)
             inflow_level_to_value = dict()
             for m in generator_module_names:
-                m_energy_eq = data[m].get_generator().get_energy_eq().get_level()
+                m_energy_eq = data[m].get_generator().get_energy_equivalent().get_level()
                 m_energy_eq_value = get_level_value(
                     m_energy_eq,
                     db=model,
@@ -592,6 +597,13 @@ class HydroAggregator(Aggregator):
         """Aggregate reservoir fillings if all fillings are not None."""
         sum_filling = None
         if all(filling.get_level() for filling in fillings):
+            if any(not filling.get_profile() for filling in fillings):
+                missing = [member for member, filling in zip(members, fillings, strict=False) if not filling.get_profile()]
+                message = (
+                    "Some reservoir fillings in grouped modules have no profile. Cannot aggregate profiles.",
+                    f"Group: '{group_id}', missing profile for {missing}.",
+                )
+                raise ValueError(message)
             level, profiles, weights = self._get_level_profiles_weights_fillings(model, fillings, energy_eq_downstreams, energy_eq, weight_unit)
             profile = _aggregate_weighted_expressions(profiles, weights)
             sum_filling = StockVolume(level=level, profile=profile)
@@ -755,7 +767,7 @@ class HydroAggregator(Aggregator):
         for det in detailed_keys:
             det_module = data[det]
             release_capacity_level = det_module.get_release_capacity().get_level()
-            generator_energy_eq = det_module.get_generator().get_energy_eq().get_level()
+            generator_energy_eq = det_module.get_generator().get_energy_equivalent().get_level()
             production_weight = get_level_value(
                 release_capacity_level * generator_energy_eq,
                 db=model,

{fram_core-0.1.0a1 → fram_core-0.1.1}/framcore/aggregators/NodeAggregator.py

@@ -7,24 +7,55 @@ from typing import TYPE_CHECKING
 from framcore.aggregators import Aggregator
 from framcore.aggregators._utils import _aggregate_costs
 from framcore.attributes import MaxFlowVolume, Price
-from framcore.components import Component, Demand, Node, Transmission, Flow
+from framcore.components import Component, Demand, Flow, Node, Transmission
 from framcore.curves import Curve
 from framcore.expressions import Expr
 from framcore.metadata import Member, Meta
 from framcore.timeindexes import FixedFrequencyTimeIndex, SinglePeriodTimeIndex
 from framcore.timevectors import TimeVector
-from framcore.utils import get_component_to_nodes, get_transports_by_commodity, get_supported_components, get_flow_infos, get_node_to_commodity
-
-# TODO: Support internal loss demand
-# TODO: Document method appropriate place (which docstring? module? class? __init__? _aggregate?)
-# TODO: transfer member metadata to internal loss Demand
+from framcore.utils import get_component_to_nodes, get_flow_infos, get_node_to_commodity, get_supported_components, get_transports_by_commodity
 
 if TYPE_CHECKING:
     from framcore import Model
 
 
 class NodeAggregator(Aggregator):
-    """Aggregate groups of nodes for a commodity. Subclass of Aggregator."""
+    """
+    Aggregate groups of Nodes for a commodity. Subclass of Aggregator.
+
+    Aggregation steps (self._aggregate):
+
+    1. Map all Components to their Nodes of the correct commodity if they are referencing any. This is important to redirect all references to the
+        new Nodes after aggregation.
+    2. Create mapping of what members the new Nodes will be aggregated from. This step also does alot of error handling and checks the validity of the
+        metadata and groupings. Raises error if:
+        - Nodes do not have any metadata for the meta key.
+        - Nodes have the wrong metadata object type for the meta key (must be Member).
+        - Exogenous Nodes are grouped together for aggregation with endogenous Nodes.
+    3. Initialize new Node objects and set prices and exogenous status. Prices are calculated as a weighted average of all the member Node prices.
+    4. Old Nodes are deleted from the Model data, after which the aggregated Node is added, and references in the rest of the system are updated to point to
+        the new Node.
+    5. Handling of transports: All Components which transport the same commodity as the aggregated Nodes are analysed. If the two Nodes they connect is now
+        the same aggregated Node, the transpart is 'internal' meaning it is now operating within a Node. If the transport Component is lossy, it is replaced
+        by a Demand Component representing the commodity consumption caused by the loss. All internal transports are afterwards deleted.
+
+
+    Disaggregation steps (self._aggregate):
+
+    1. Collect set of Nodes group keys for which have been either removed from the Model data or changed to reference something other than Nodes.
+    2. Validate that IDs of Nodes to be restored have not been used to reference something else in the meantime.
+    3. Delete the aggregated Nodes and restore the old Nodes to the Model. Also copy shadow price results from the aggregated Nodes to the disaggregated.
+        NB! This will overwrite the possible previous shadow prices of the original disaggregated Nodes.
+    4. Restore the references in all objects to the disaggregated Nodes. A mapping created during aggregation is used for this.
+    5. Validate that no restorable internal transports has a name conflict with existing objects in the Model.
+        NB! an internal transport is not restorable if one or both of its referenced Nodes have been removed from the Model or is now referencing another
+        object. See step 1.
+    6. Restore all the restorable internal transports from the original data.
+    7. Delete the aggregation-created Demand objects representing internal transports.
+
+    See Aggregator for general design notes and rules to follow when using Aggregators.
+
+    """
 
     def __init__(
         self,
@@ -125,16 +156,16 @@ class NodeAggregator(Aggregator):
         out: set[str] = set()
         nodes_and_flows = get_supported_components(components, supported_types=(Node, Flow), forbidden_types=tuple())
         node_to_commodity = get_node_to_commodity(nodes_and_flows)
-        for flow in nodes_and_flows.values():            
+        for flow in nodes_and_flows.values():
             if not isinstance(flow, Flow):
                 continue
             flow_infos = get_flow_infos(flow, node_to_commodity)
-            if not len(flow_infos) == 1:
+            if len(flow_infos) != 1:
                 continue
             flow_info = flow_infos[0]
             if flow_info.category != "direct_out":
                 continue
-            if flow_info.commodity_out != self._commodity: 
+            if flow_info.commodity_out != self._commodity:
                 continue
             demand = flow
             for key in demand.get_meta_keys():
@@ -142,7 +173,6 @@ class NodeAggregator(Aggregator):
                 if isinstance(meta, Member):
                     out.add(key)
         return out
-                
 
     def _add_internal_transport_demands(
         self,
@@ -163,7 +193,9 @@ class NodeAggregator(Aggregator):
         for key in self._internal_transports:
             transport = components[key]
             from_node, to_node = transports[key]
-            assert from_node == to_node, f"{from_node}, {to_node}"
+            assert from_node == to_node, (
+                f"Transport {key} added to internal transport when it should not. Source node {from_node}, and destination node {to_node} are not the same."
+            )
             node = from_node
 
             transport: Transmission
@@ -192,13 +224,15 @@ class NodeAggregator(Aggregator):
                     ),
                 )
 
-                for meta_key in demand_member_meta_keys:
+                for meta_key in demand_member_meta_keys:  # transfer member metadata to internal loss Demand
                     internal_losses_demand.add_meta(meta_key, Member("InternalTransportLossFromNodeAggregator"))
 
                 demand_key = key + "_InternalTransportLossDemand_" + node
 
                 self._internal_transport_demands.add(demand_key)
-                assert demand_key not in data, f"{demand_key}"
+                if demand_key in data:
+                    msg = f"Could not use key {demand_key} for internal transport demand because it already exists in the Model."
+                    raise KeyError(msg)
                 data[demand_key] = internal_losses_demand
 
     def _delete_internal_transports(
@@ -227,6 +261,13 @@ class NodeAggregator(Aggregator):
         data = model.get_data()
         weights = [1.0 / len(member_node_names)] * len(member_node_names)
         prices = [data[key].get_price() for key in member_node_names]
+
+        exogenous = [data[key].is_exogenous() for key in member_node_names]
+        if all(exogenous):
+            group_node.set_exogenous()
+        elif any(exogenous):
+            message = f"Only some member Nodes of group {group_node} are exogenous. This is ambiguous. Either all or none must be exogenous."
+            raise ValueError(message)
         if all(prices):
             level, profile, intercept = _aggregate_costs(
                 model=model,
@@ -241,7 +282,7 @@ class NodeAggregator(Aggregator):
             group_node.get_price().set_intercept(intercept)
         elif any(prices):
             missing = [key for key in member_node_names if data[key].get_price() is None]
-            self.send_warning_event(f"Only some member nodes of group {group_node} have a Price, skip aggregate prices. Missing: {missing}")
+            self.send_warning_event(f"Only some member Nodes of group {group_node} have a Price, skip aggregate prices. Missing: {missing}")
 
     def _replace_node(
         self,
@@ -316,17 +357,11 @@ class NodeAggregator(Aggregator):
 
         for group_name in exogenous_groups:  # Check exogenous groups.
             node_keys = grouped_nodes[group_name]
-            if len(node_keys) != 1:  # allow unchanged or renamed exogenous Nodes.
-                self._errors.add(
-                    f"Group {group_name} contains an exogenous Node and must therefore contain only one Node."
-                    " Exogenous Nodes cannot be grouped together with other Nodes.",
-                )
-                # For if we want to allow pure exogenous groups.
-                # for node_key in node_keys:
-                #     node: Node = components[node_key]
-                #     if not node.is_exogenous():
-                #         self._errors.add(f"Group {group_name} contains both exogenous and endogenous Nodes. This is not allowed.")
-                #         break
+            if len(node_keys) > 1:  # allow unchanged or renamed exogenous Nodes.
+                # We allow pure exogenous groups.
+                exogenous = [components[node_key].is_exogenous() for node_key in node_keys]
+                if (not all(exogenous)) and any(exogenous):
+                    self._errors.add(f"Group {group_name} contains both exogenous and endogenous Nodes. This is ambiguous and therefore not allowed.")
 
         # remove single groups with unchanged names and check for duplicated names
         for group_name, node_keys in grouped_nodes.items():
@@ -359,7 +394,7 @@ class NodeAggregator(Aggregator):
                 flipped[member].add(group)
         for k, v in flipped.items():
             if len(v) > 1:
-                self._errors.add(f"Node {k} belong to more than one group {v}")
+                self._errors.add(f"Node {k} belongs to more than one group {v}")
 
     def _disaggregate(
         self,
@@ -393,7 +428,7 @@ class NodeAggregator(Aggregator):
 
             group_node = new_data[group_name]
 
-            if not isinstance(group_node, Node):
+            if not (isinstance(group_node, Node) and group_node.get_commodity() == self._commodity):
                 deleted_group_names.add(group_name)
 
         return deleted_group_names
@@ -409,7 +444,7 @@ class NodeAggregator(Aggregator):
             for key in member_node_names:
                 if key in new_data:
                     obj = new_data[key]
-                    if not isinstance(obj, Node) and obj.get_commodity() == self._commodity:
+                    if not (isinstance(obj, Node) and obj.get_commodity() == self._commodity):
                         typ = type(obj).__name__
                         message = f"Restoring node {key} from group node {group_name} failed because model already stores object of {typ} with that name."
                         self._errors.add(message)
@@ -463,7 +498,7 @@ class NodeAggregator(Aggregator):
             if key in new_data:
                 obj = new_data[key]
                 typ = type(obj).__name__
-                message = f"Restoring deleted transport {key} from group node {group_name} failed becausemodel already stores object of {typ} with that name."
+                message = f"Restoring deleted transport {key} from group node {group_name} failed because model already stores object of {typ} with that name."
                 self._errors.add(message)
 
         self._report_errors(self._errors)