Allow custom Series/dict for line_color and node_color in plot_plotly (issue #385)

doc/whatsnew/v0-3-0.rst

@@ -28,4 +28,7 @@ Changes
 * Move function to assign feeder to Topology class and add methods to the Grid class to get information on the feeders `#360 <https://github.com/openego/eDisGo/pull/360>`_
 * Added a storage operation strategy where the storage is charged when PV feed-in is higher than electricity demand of the household and discharged when electricity demand exceeds PV generation `#386 <https://github.com/openego/eDisGo/pull/386>`_
 * Added an estimation of the voltage deviation over a cable when selecting a suitable cable to connect a new component `#411 <https://github.com/openego/eDisGo/pull/411>`_
-* Added clipping of heat pump electrical power at its maximum value #428 <https://github.com/openego/eDisGo/pull/428>
+* Added clipping of heat pump electrical power at its maximum value `#428 <https://github.com/openego/eDisGo/pull/428>`_
+* Loading predefined time series now automatically sets the timeindex to the default year of the database if it is empty. `#457 <https://github.com/openego/eDisGo/pull/457>`_
+* Made OEP database call optional in get_database_alias_dictionaries, allowing setup without OEP when using an alternative eGon-data database. `#451 <https://github.com/openego/eDisGo/pull/451>`_
+* Fixed database import issues by addressing table naming assumptions and added support for external SSH tunneling in eGon-data configurations. `#451 <https://github.com/openego/eDisGo/pull/451>`_

edisgo/config/config_opf_julia_default.cfg

@@ -11,4 +11,4 @@
 
 [julia_dir]
 
-julia_bin = julia-1.1.0/bin
+julia_bin = julia/bin

edisgo/edisgo.py

@@ -41,6 +41,7 @@
 )
 from edisgo.io.heat_pump_import import oedb as import_heat_pumps_oedb
 from edisgo.io.storage_import import home_batteries_oedb
+from edisgo.io.timeseries_import import _timeindex_helper_func
 from edisgo.network import timeseries
 from edisgo.network.dsm import DSM
 from edisgo.network.electromobility import Electromobility
@@ -71,6 +72,11 @@ class EDisGo:
     ----------
     ding0_grid : :obj:`str`
         Path to directory containing csv files of network to be loaded.
+    engine : :sqlalchemy:`sqlalchemy.Engine<sqlalchemy.engine.Engine>` or None
+        Database engine for connecting to the `OpenEnergy DataBase OEDB
+        <https://openenergyplatform.org/dataedit/schemas>`_ or other eGon-data
+        databases. Defaults to the OEDB engine. Can be set to None if no scenario is to
+        be loaded.
     generator_scenario : None or :obj:`str`, optional
         If None, the generator park of the imported grid is kept as is.
         Otherwise defines which scenario of future generator park to use
@@ -158,8 +164,10 @@ class EDisGo:
     """
 
     def __init__(self, **kwargs):
+        # Set database engine for future scenarios
+        self.engine: Engine | None = kwargs.pop("engine", egon_engine())
         # load configuration
-        self._config = Config(**kwargs)
+        self._config = Config(engine=self.engine, **kwargs)
 
         # instantiate topology object and load grid data
         self.topology = Topology(config=self.config)
@@ -418,12 +426,9 @@ def set_time_series_active_power_predefined(
                 Technology- and weather cell-specific hourly feed-in time series are
                 obtained from the
                 `OpenEnergy DataBase
-                <https://openenergyplatform.org/dataedit/schemas>`_. See
-                :func:`edisgo.io.timeseries_import.feedin_oedb` for more information.
-
-                This option requires that the parameter `engine` is provided in case
-                new ding0 grids with geo-referenced LV grids are used. For further
-                settings, the parameter `timeindex` can also be provided.
+                <https://openenergyplatform.org/dataedit/schemas>`_ or other eGon-data
+                databases. See :func:`edisgo.io.timeseries_import.feedin_oedb` for more
+                information.
 
             * :pandas:`pandas.DataFrame<DataFrame>`
 
@@ -536,9 +541,6 @@ def set_time_series_active_power_predefined(
 
         Other Parameters
         ------------------
-        engine : :sqlalchemy:`sqlalchemy.Engine<sqlalchemy.engine.Engine>`
-            Database engine. This parameter is only required in case
-            `conventional_loads_ts` or `fluctuating_generators_ts` is 'oedb'.
         scenario : str
             Scenario for which to retrieve demand data. Possible options are 'eGon2035'
             and 'eGon100RE'. This parameter is only required in case
@@ -556,15 +558,42 @@ def set_time_series_active_power_predefined(
             is indexed using a default year and set for the whole year.
 
         """
+        timeindex = kwargs.get("timeindex", None)
         engine = kwargs["engine"] if "engine" in kwargs else egon_engine()
         if self.timeseries.timeindex.empty:
             logger.warning(
-                "When setting time series using predefined profiles it is better to "
-                "set a time index as all data in TimeSeries class is indexed by the"
-                "time index. You can set the time index upon initialisation of "
-                "the EDisGo object by providing the input parameter 'timeindex' or by "
-                "using the function EDisGo.set_timeindex()."
+                "The given timeindex is different from the EDisGo.TimeSeries.timeindex."
+                " Therefore the EDisGo.TimeSeries.timeindex will be overwritten by the "
+                "given timeindex."
             )
+
+            set_timeindex = True
+
+        elif self.timeseries.timeindex.empty:
+            logger.warning(
+                "The EDisGo.TimeSeries.timeindex is empty. By default, this function "
+                "will set the timeindex to the default year of the provided database "
+                "connection. To ensure expected behavior, consider setting the "
+                "timeindex explicitly before running this function using "
+                "EDisGo.set_timeindex()."
+            )
+
+            set_timeindex = True
+
+        if set_timeindex:
+            if timeindex is None:
+                timeindex, _ = _timeindex_helper_func(
+                    self, timeindex, allow_leap_year=True
+                )
+
+            logger.warning(f"Setting EDisGo.TimeSeries.timeindex to {timeindex}.")
+
+            self.set_timeindex(timeindex)
+
+        logger.info(
+            f"Trying to set predefined timeseries for {self.timeseries.timeindex}"
+        )
+
         if fluctuating_generators_ts is not None:
             self.timeseries.predefined_fluctuating_generators_by_technology(
                 self,
@@ -972,9 +1001,7 @@ def import_generators(self, generator_scenario=None, **kwargs):
         Other Parameters
         ----------------
         kwargs :
-            In case you are using new ding0 grids, where the LV is geo-referenced, a
-            database engine needs to be provided through keyword argument `engine`.
-            In case you are using old ding0 grids, where the LV is not geo-referenced,
+            If you are using old ding0 grids, where the LV is not geo-referenced,
             you can check :func:`edisgo.io.generators_import.oedb_legacy` for possible
             keyword arguments.
 
@@ -1352,7 +1379,7 @@ def reinforce(
 
         """
         if copy_grid:
-            edisgo_obj = copy.deepcopy(self)
+            edisgo_obj = self.copy()
         else:
             edisgo_obj = self
 
@@ -1921,9 +1948,8 @@ def _aggregate_time_series(attribute, groups, naming):
 
     def import_electromobility(
         self,
-        data_source: str,
+        data_source: str = "oedb",
         scenario: str = None,
-        engine: Engine = None,
         charging_processes_dir: PurePath | str = None,
         potential_charging_points_dir: PurePath | str = None,
         import_electromobility_data_kwds=None,
@@ -1965,10 +1991,8 @@ def import_electromobility(
             * "oedb"
 
                 Electromobility data is obtained from the `OpenEnergy DataBase
-                <https://openenergyplatform.org/dataedit/schemas>`_.
-
-                This option requires that the parameters `scenario` and `engine` are
-                provided.
+                <https://openenergyplatform.org/dataedit/schemas>`_ or other eGon-data
+                databases depending on the provided Engine.
 
             * "directory"
 
@@ -1978,9 +2002,6 @@ def import_electromobility(
         scenario : str
             Scenario for which to retrieve electromobility data in case `data_source` is
             set to "oedb". Possible options are "eGon2035" and "eGon100RE".
-        engine : :sqlalchemy:`sqlalchemy.Engine<sqlalchemy.engine.Engine>`
-            Database engine. Needs to be provided in case `data_source` is set to
-            "oedb".
         charging_processes_dir : str or pathlib.PurePath
             Directory holding data on charging processes (standing times, charging
             demand, etc. per vehicle), including metadata, from SimBEV.
@@ -2042,7 +2063,7 @@ def import_electromobility(
             import_electromobility_from_oedb(
                 self,
                 scenario=scenario,
-                engine=engine,
+                engine=self.engine,
                 **import_electromobility_data_kwds,
             )
         elif data_source == "directory":
@@ -2135,10 +2156,11 @@ def apply_charging_strategy(self, strategy="dumb", **kwargs):
         """
         charging_strategy(self, strategy=strategy, **kwargs)
 
-    def import_heat_pumps(self, scenario, engine, timeindex=None, import_types=None):
+    def import_heat_pumps(self, scenario, timeindex=None, import_types=None):
         """
-        Gets heat pump data for specified scenario from oedb and integrates the heat
-        pumps into the grid.
+        Gets heat pump data for specified scenario from the OEDB or other eGon-data
+        databases depending on the provided Engine and integrates the heat pumps into
+        the grid.
 
         Besides heat pump capacity the heat pump's COP and heat demand to be served
         are as well retrieved.
@@ -2193,8 +2215,6 @@ def import_heat_pumps(self, scenario, engine, timeindex=None, import_types=None)
         scenario : str
             Scenario for which to retrieve heat pump data. Possible options
             are 'eGon2035' and 'eGon100RE'.
-        engine : :sqlalchemy:`sqlalchemy.Engine<sqlalchemy.engine.Engine>`
-            Database engine.
         timeindex : :pandas:`pandas.DatetimeIndex<DatetimeIndex>` or None
             Specifies time steps for which to set COP and heat demand data. Leap years
             can currently not be handled. In case the given
@@ -2235,31 +2255,31 @@ def import_heat_pumps(self, scenario, engine, timeindex=None, import_types=None)
             year = tools.get_year_based_on_scenario(scenario)
             return self.import_heat_pumps(
                 scenario,
-                engine,
+                self.engine,
                 timeindex=pd.date_range(f"1/1/{year}", periods=8760, freq="H"),
                 import_types=import_types,
             )
 
         integrated_heat_pumps = import_heat_pumps_oedb(
             edisgo_object=self,
             scenario=scenario,
-            engine=engine,
+            engine=self.engine,
             import_types=import_types,
         )
         if len(integrated_heat_pumps) > 0:
             self.heat_pump.set_heat_demand(
                 self,
                 "oedb",
                 heat_pump_names=integrated_heat_pumps,
-                engine=engine,
+                engine=self.engine,
                 scenario=scenario,
                 timeindex=timeindex,
             )
             self.heat_pump.set_cop(
                 self,
                 "oedb",
                 heat_pump_names=integrated_heat_pumps,
-                engine=engine,
+                engine=self.engine,
                 timeindex=timeindex,
             )
 
@@ -2307,7 +2327,7 @@ def apply_heat_pump_operating_strategy(
         """
         hp_operating_strategy(self, strategy=strategy, heat_pump_names=heat_pump_names)
 
-    def import_dsm(self, scenario: str, engine: Engine, timeindex=None):
+    def import_dsm(self, scenario: str, timeindex=None):
         """
         Gets industrial and CTS DSM profiles from the
         `OpenEnergy DataBase <https://openenergyplatform.org/dataedit/schemas>`_.
@@ -2326,8 +2346,6 @@ def import_dsm(self, scenario: str, engine: Engine, timeindex=None):
         scenario : str
             Scenario for which to retrieve DSM data. Possible options
             are 'eGon2035' and 'eGon100RE'.
-        engine : :sqlalchemy:`sqlalchemy.Engine<sqlalchemy.engine.Engine>`
-            Database engine.
         timeindex : :pandas:`pandas.DatetimeIndex<DatetimeIndex>` or None
             Specifies time steps for which to get data. Leap years can currently not be
             handled. In case the given timeindex contains a leap year, the data will be
@@ -2340,7 +2358,7 @@ def import_dsm(self, scenario: str, engine: Engine, timeindex=None):
 
         """
         dsm_profiles = dsm_import.oedb(
-            edisgo_obj=self, scenario=scenario, engine=engine, timeindex=timeindex
+            edisgo_obj=self, scenario=scenario, engine=self.engine, timeindex=timeindex
         )
         self.dsm.p_min = dsm_profiles["p_min"]
         self.dsm.p_max = dsm_profiles["p_max"]
@@ -2350,7 +2368,6 @@ def import_dsm(self, scenario: str, engine: Engine, timeindex=None):
     def import_home_batteries(
         self,
         scenario: str,
-        engine: Engine,
     ):
         """
         Gets home battery data for specified scenario and integrates the batteries into
@@ -2361,7 +2378,8 @@ def import_home_batteries(
         between two scenarios: 'eGon2035' and 'eGon100RE'.
 
         The data is retrieved from the
-        `open energy platform <https://openenergyplatform.org/>`_.
+        `open energy platform <https://openenergyplatform.org/>`_ or other eGon-data
+        databases depending on the given Engine.
 
         The batteries are integrated into the grid (added to
         :attr:`~.network.topology.Topology.storage_units_df`) based on their building
@@ -2378,14 +2396,12 @@ def import_home_batteries(
         scenario : str
             Scenario for which to retrieve home battery data. Possible options
             are 'eGon2035' and 'eGon100RE'.
-        engine : :sqlalchemy:`sqlalchemy.Engine<sqlalchemy.engine.Engine>`
-            Database engine.
 
         """
         home_batteries_oedb(
             edisgo_obj=self,
             scenario=scenario,
-            engine=engine,
+            engine=self.engine,
         )
 
     def plot_mv_grid_topology(self, technologies=False, **kwargs):
@@ -2412,6 +2428,7 @@ def plot_mv_grid_topology(self, technologies=False, **kwargs):
             xlim=kwargs.get("xlim", None),
             ylim=kwargs.get("ylim", None),
             title=kwargs.get("title", ""),
+            **kwargs,
         )
 
     def plot_mv_voltages(self, **kwargs):
@@ -3135,7 +3152,7 @@ def spatial_complexity_reduction(
 
         """
         if copy_edisgo is True:
-            edisgo_obj = copy.deepcopy(self)
+            edisgo_obj = self.copy()
         else:
             edisgo_obj = self
         busmap_df, linemap_df = spatial_complexity_reduction(
@@ -3349,6 +3366,44 @@ def resample_timeseries(
         self.heat_pump.resample_timeseries(method=method, freq=freq)
         self.overlying_grid.resample(method=method, freq=freq)
 
+    def copy(self, deep=True):
+        """
+        Returns a copy of the object, with an option for a deep copy.
+
+        The SQLAlchemy engine is excluded from the copying process and restored
+        afterward.
+
+        Parameters
+        ----------
+        deep : bool
+            If True, performs a deep copy; otherwise, performs a shallow copy.
+
+        Returns
+        ---------
+        :class:`~.EDisGo`
+            Copied EDisGo object.
+
+        """
+        tmp_engine = (
+            getattr(self, "engine", None)
+            if isinstance(getattr(self, "engine", None), Engine)
+            else None
+        )
+
+        if tmp_engine:
+            logging.info("Temporarily removing the SQLAlchemy engine before copying.")
+            self.engine = self.config._engine = None
+
+        cpy = copy.deepcopy(self) if deep else copy.copy(self)
+
+        if tmp_engine:
+            logging.info("Restoring the SQLAlchemy engine after copying.")
+            self.engine = self.config._engine = cpy.engine = cpy.config._engine = (
+                tmp_engine
+            )
+
+        return cpy
+
 
 def import_edisgo_from_pickle(filename, path=""):
     """