pandapower 2.14.1__zip → 2.14.5__zip

{pandapower-2.14.1 → pandapower-2.14.5}/.github/workflows/github_test_action.yml

@@ -79,7 +79,7 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        python -m pip install pytest
+        python -m pip install pytest setuptools
         if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
         pip install .
         pip install matplotlib

{pandapower-2.14.1 → pandapower-2.14.5}/CHANGELOG.rst

@@ -4,6 +4,20 @@ Change Log
 [upcoming release] - 2024-..-..
 -------------------------------
 
+[2.14.5] - 2024-03-28
+-------------------------------
+- [CHANGED] added possibility to provide custom weights to switches and transformers (before - always zero) when creating a graph
+- [FIXED] many futurewarnings and deprecation warnings
+
+[2.14.4] - 2024-03-28
+-------------------------------
+- [FIXED] internal pgm test returns ANOTHER error when using python 3.8
+- [FIXED] added setuptools to relying tests
+
+[2.14.3] - 2024-03-28
+-------------------------------
+- [FIXED] internal pgm test checked wrong result
+- [FIXED] 2.14.0 - 2.14.3 just minor release fixes to improve workflow
 
 [2.14.0] - 2024-03-26
 -------------------------------
@@ -57,6 +71,7 @@ Change Log
 - [ADDED] cim2pp: added description fields for each asset and added BusbarSection information to nodes
 - [CHANGED] cim2pp: reformat documentation for reading in files
 - [CHANGED] allow providing grid_tables as a parameter to the function that downloads net from PostgreSQL
+- [FIXED] avoid FutureWarning of pandas 2.2
 - [FIXED] compatibility with lightsim2grid after new version 0.8.0
 - [ADDED] allow passing custom runpp-function to pp.diagnostic
 

{pandapower-2.14.1 → pandapower-2.14.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pandapower
-Version: 2.14.1
+Version: 2.14.5
 Summary: An easy to use open source tool for power system modeling, analysis and optimization with a high degree of automation.
 Home-page: http://www.pandapower.org
 Author: Leon Thurner, Alexander Scheidler
@@ -142,6 +142,20 @@ Change Log
 [upcoming release] - 2024-..-..
 -------------------------------
 
+[2.14.5] - 2024-03-28
+-------------------------------
+- [CHANGED] added possibility to provide custom weights to switches and transformers (before - always zero) when creating a graph
+- [FIXED] many futurewarnings and deprecation warnings
+
+[2.14.4] - 2024-03-28
+-------------------------------
+- [FIXED] internal pgm test returns ANOTHER error when using python 3.8
+- [FIXED] added setuptools to relying tests
+
+[2.14.3] - 2024-03-28
+-------------------------------
+- [FIXED] internal pgm test checked wrong result
+- [FIXED] 2.14.0 - 2.14.3 just minor release fixes to improve workflow
 
 [2.14.0] - 2024-03-26
 -------------------------------
@@ -195,6 +209,7 @@ Change Log
 - [ADDED] cim2pp: added description fields for each asset and added BusbarSection information to nodes
 - [CHANGED] cim2pp: reformat documentation for reading in files
 - [CHANGED] allow providing grid_tables as a parameter to the function that downloads net from PostgreSQL
+- [FIXED] avoid FutureWarning of pandas 2.2
 - [FIXED] compatibility with lightsim2grid after new version 0.8.0
 - [ADDED] allow passing custom runpp-function to pp.diagnostic
 

{pandapower-2.14.1 → pandapower-2.14.5}/pandapower/auxiliary.py

@@ -967,9 +967,9 @@ def _clean_up(net, res=True):
     #            res_bus.drop(xward_buses, inplace=True)
     if len(net["dcline"]) > 0:
         dc_gens = net.gen.index[(len(net.gen) - len(net.dcline) * 2):]
-        net.gen.drop(dc_gens, inplace=True)
+        net.gen = net.gen.drop(dc_gens)
         if res:
-            net.res_gen.drop(dc_gens, inplace=True)
+            net.res_gen = net.res_gen.drop(dc_gens)
 
 
 def _set_isolated_buses_out_of_service(net, ppc):

{pandapower-2.14.1 → pandapower-2.14.5}/pandapower/control/util/auxiliary.py

@@ -188,7 +188,7 @@ def drop_same_type_existing_controllers(net, this_ctrl_type, index=None, matchin
         same_type_existing_ctrl = get_controller_index(net, ctrl_type=this_ctrl_type,
                                                        parameters=matching_params)
         if len(same_type_existing_ctrl):
-            net.controller.drop(same_type_existing_ctrl, inplace=True)
+            net.controller = net.controller.drop(same_type_existing_ctrl)
             logger.debug("Controllers " + str(['%i' % idx for idx in same_type_existing_ctrl]) +
                          "got removed because of same type and matching parameters as new " +
                          "controller " + index + ".")

{pandapower-2.14.1 → pandapower-2.14.5}/pandapower/convert_format.py

@@ -216,9 +216,9 @@ def _create_seperate_cost_tables(net, elements_to_deserialize):
 
 def _rename_columns(net, elements_to_deserialize):
     if _check_elements_to_deserialize('line', elements_to_deserialize):
-        net.line.rename(columns={'imax_ka': 'max_i_ka'}, inplace=True)
+        net.line = net.line.rename(columns={'imax_ka': 'max_i_ka'})
     if _check_elements_to_deserialize('gen', elements_to_deserialize):
-        net.gen.rename(columns={"qmin_mvar": "min_q_mvar", "qmax_mvar": "max_q_mvar"}, inplace=True)
+        net.gen = net.gen.rename(columns={"qmin_mvar": "min_q_mvar", "qmax_mvar": "max_q_mvar"})
     for typ, data in net.std_types["line"].items():
         if "imax_ka" in data:
             net.std_types["line"][typ]["max_i_ka"] = net.std_types["line"][typ].pop("imax_ka")
@@ -235,11 +235,11 @@ def _rename_columns(net, elements_to_deserialize):
                     net.measurement.loc[bus_measurements, "bus"].values
                 net.measurement.loc[~bus_measurements, "side"] = \
                     net.measurement.loc[~bus_measurements, "bus"].values
-                net.measurement.rename(columns={'type': 'measurement_type'}, inplace=True)
-                net.measurement.drop(["bus"], axis=1, inplace=True)
+                net.measurement = net.measurement.rename(columns={'type': 'measurement_type'})
+                net.measurement = net.measurement.drop(["bus"], axis=1)
     if _check_elements_to_deserialize('controller', elements_to_deserialize):
         if "controller" in net:
-            net["controller"].rename(columns={"controller": "object"}, inplace=True)
+            net["controller"] = net["controller"].rename(columns={"controller": "object"})
     if "options" in net:
         if "recycle" in net["options"]:
             if "Ybus" in net["options"]["recycle"]:
@@ -371,7 +371,7 @@ def _update_trafo_parameter_names(net, elements_to_deserialize):
     for element in update_data:
         replace_cols = {col: _update_column(col) for col in net[element].columns if
                         col.startswith("tp") or col.startswith("vsc")}
-        net[element].rename(columns=replace_cols, inplace=True)
+        net[element] = net[element].rename(columns=replace_cols)
     _update_trafo_type_parameter_names(net)
 
 
@@ -399,16 +399,16 @@ def _set_data_type_of_columns(net):
 
 def _convert_to_mw(net):
     replace = [("kw", "mw"), ("kvar", "mvar"), ("kva", "mva")]
-    for element, tab in net.items():
-        if isinstance(tab, pd.DataFrame):
+    for element in net.keys():
+        if isinstance(net[element], pd.DataFrame):
             for old, new in replace:
-                diff = {column: column.replace(old, new) for column in tab.columns if old in column
-                        and column != "pfe_kw"}
-                tab.rename(columns=diff, inplace=True)
-                if len(tab) == 0:
+                diff = {column: column.replace(old, new) for column in net[element].columns if
+                    old in column and column != "pfe_kw"}
+                net[element] = net[element].rename(columns=diff)
+                if len(net[element]) == 0:
                     continue
                 for old, new in diff.items():
-                    tab[new] *= 1e-3
+                    net[element][new] *= 1e-3
 
     for element, std_types in net.std_types.items():
         for std_type, parameters in std_types.items():

{pandapower-2.14.1 → pandapower-2.14.5}/pandapower/converter/cim/cim2pp/build_pp_net.py

@@ -219,7 +219,7 @@ class CimConverter:
         # fuse boundary ConnectivityNodes with their TopologicalNodes
         bus_t = self.net.bus.reset_index(level=0, drop=False)
         bus_drop = bus_t.loc[bus_t[sc['o_prf']] == 'eq_bd', ['index', sc['o_id'], 'cim_topnode']]
-        bus_drop.rename(columns={'index': 'b1'}, inplace=True)
+        bus_drop = bus_drop.rename(columns={'index': 'b1'})
         bus_drop = pd.merge(bus_drop, bus_t[['index', sc['o_id']]].rename(columns={'index': 'b2', sc['o_id']: 'o_id2'}),
                             how='inner', left_on='cim_topnode', right_on='o_id2')
         if bus_drop.index.size > 0:

{pandapower-2.14.1 → pandapower-2.14.5}/pandapower/converter/cim/cim2pp/convert_measurements.py

@@ -44,11 +44,11 @@ class CreateMeasurements:
                                       'PowerSystemResource', 'positiveFlowIn']],
             self.cim['eq']['AnalogValue'][['sensorAccuracy', 'MeasurementValueSource', 'Analog', 'value']],
             how='inner', left_on='rdfId', right_on='Analog')
-        analogs.drop(columns=['rdfId', 'Analog'], inplace=True)
+        analogs = analogs.drop(columns=['rdfId', 'Analog'])
         analogs = pd.merge(analogs, self.cim['eq']['MeasurementValueSource'], how='left',
                            left_on='MeasurementValueSource',
                            right_on='rdfId')
-        analogs.drop(columns=['rdfId', 'MeasurementValueSource'], inplace=True)
+        analogs = analogs.drop(columns=['rdfId', 'MeasurementValueSource'])
         # collect all the assets (line, trafo, trafo3w) and its connections
         assets = pd.DataFrame(None, columns=['element_type', 'side'])
         append_dict = dict({'line': {'from_bus': 'from', 'to_bus': 'to'},
@@ -61,7 +61,7 @@ class CreateMeasurements:
                 temp['element_type'] = element_type
                 temp['side'] = side
                 assets = pd.concat([assets, temp], sort=False)
-        assets.rename(columns={'index': 'element'}, inplace=True)
+        assets = assets.rename(columns={'index': 'element'})
         # now join the analogs with the assets
         psr = pd.merge(analogs, assets, how='inner', left_on='PowerSystemResource', right_on=sc['o_id'])
         # keep only entries which are associated to the terminal from the asset
@@ -96,24 +96,24 @@ class CreateMeasurements:
         sc = cim_tools.get_pp_net_special_columns_dict()
         # get the measurements from the sv profile and set the Terminal as index
         sv_powerflow = self.cim['sv']['SvPowerFlow'][['Terminal', 'p', 'q']]
-        sv_powerflow.set_index('Terminal', inplace=True)
+        sv_powerflow = sv_powerflow.set_index('Terminal')
 
         # ---------------------------------------measure: bus v---------------------------------------------------
         busses_temp = self.net.bus[['name', 'vn_kv', sc['ct']]].copy()
-        busses_temp.reset_index(level=0, inplace=True)
-        busses_temp.rename(columns={'index': 'element', sc['ct']: 'TopologicalNode'}, inplace=True)
+        busses_temp = busses_temp.reset_index(level=0)
+        busses_temp = busses_temp.rename(columns={'index': 'element', sc['ct']: 'TopologicalNode'})
         sv_sv_voltages = pd.merge(self.cim['sv']['SvVoltage'][['TopologicalNode', 'v']], busses_temp,
                                   how='left', on='TopologicalNode')
         # drop all the rows mit vn_kv == np.NaN (no measurements available for that bus)
-        sv_sv_voltages.dropna(subset=['vn_kv'], inplace=True)
+        sv_sv_voltages = sv_sv_voltages.dropna(subset=['vn_kv'])
         sv_sv_voltages.reset_index(inplace=True)
         if 'index' in sv_sv_voltages.columns:
-            sv_sv_voltages.drop(['index'], inplace=True, axis=1)
+            sv_sv_voltages = sv_sv_voltages.drop(['index'], axis=1)
         # value -> voltage ()
         sv_sv_voltages['value'] = sv_sv_voltages.v / sv_sv_voltages.vn_kv
         sv_sv_voltages['value'].replace(0, np.nan, inplace=True)
         # drop all the rows mit value == np.NaN
-        sv_sv_voltages.dropna(subset=['value'], inplace=True)
+        sv_sv_voltages = sv_sv_voltages.dropna(subset=['value'])
         sv_sv_voltages.reset_index(inplace=True)
         sv_sv_voltages['value_stddev'] = sv_sv_voltages.value * 0.001
         sv_sv_voltages['vn_kv_stddev'] = 0.1 / sv_sv_voltages.vn_kv
@@ -136,7 +136,7 @@ class CreateMeasurements:
         line_temp['q_to'] = \
             pd.merge(line_temp[sc['t_to']], sv_powerflow['q'], left_on=sc['t_to'], right_index=True)['q']
 
-        line_temp.dropna(subset=['p_from', 'p_to', 'q_from', 'q_to'], thresh=4, inplace=True)
+        line_temp = line_temp.dropna(subset=['p_from', 'p_to', 'q_from', 'q_to'], thresh=4)
 
         line_temp['stddev_line_from_p'] = abs(line_temp.p_from) * sigma_line + 1.
         line_temp['stddev_line_to_p'] = abs(line_temp.p_to) * sigma_line + 1.
@@ -181,7 +181,7 @@ class CreateMeasurements:
         trafo_temp['q_lv'] = \
             pd.merge(trafo_temp[sc['t_lv']], sv_powerflow['q'], left_on=sc['t_lv'], right_index=True)['q']
 
-        trafo_temp.dropna(subset=['p_hv', 'p_lv', 'q_hv', 'q_lv'], thresh=4, inplace=True)
+        trafo_temp = trafo_temp.dropna(subset=['p_hv', 'p_lv', 'q_hv', 'q_lv'], thresh=4)
 
         trafo_temp['stddev_trafo_hv_p'] = abs(trafo_temp.p_hv) * sigma_trafo + 1.
         trafo_temp['stddev_trafo_lv_p'] = abs(trafo_temp.p_lv) * sigma_trafo + 1.
@@ -230,7 +230,7 @@ class CreateMeasurements:
         trafo3w_temp['q_lv'] = \
             pd.merge(trafo3w_temp[sc['t_lv']], sv_powerflow['q'], left_on=sc['t_lv'], right_index=True)['q']
 
-        trafo3w_temp.dropna(subset=['p_hv', 'p_mv', 'p_lv', 'q_hv', 'q_mv', 'q_lv'], thresh=6, inplace=True)
+        trafo3w_temp = trafo3w_temp.dropna(subset=['p_hv', 'p_mv', 'p_lv', 'q_hv', 'q_mv', 'q_lv'], thresh=6)
 
         trafo3w_temp['stddev_trafo_hv_p'] = abs(trafo3w_temp.p_hv) * sigma_trafo3w + 1.
         trafo3w_temp['stddev_trafo_mv_p'] = abs(trafo3w_temp.p_mv) * sigma_trafo3w + 1.
@@ -275,7 +275,7 @@ class CreateMeasurements:
         self._copy_to_measurement(trafo3w_temp)
 
         # remove NaN values
-        self.net.measurement.dropna(subset=['value'], inplace=True)
+        self.net.measurement = self.net.measurement.dropna(subset=['value'])
         # set the element from float to default uint32
         self._set_measurement_element_datatype()
 

{pandapower-2.14.1 → pandapower-2.14.5}/pandapower/converter/cim/cim2pp/converter_classes/connectivitynodes/connectivityNodesCim16.py

@@ -29,13 +29,13 @@ class ConnectivityNodesCim16:
         # a prepared and modified copy of eqssh_terminals to use for lines, switches, loads, sgens and so on
         eqssh_terminals = eqssh_terminals[
             ['rdfId', 'ConductingEquipment', 'ConnectivityNode', 'sequenceNumber', 'connected']].copy()
-        eqssh_terminals.rename(columns={'rdfId': 'rdfId_Terminal'}, inplace=True)
-        eqssh_terminals.rename(columns={'ConductingEquipment': 'rdfId'}, inplace=True)
+        eqssh_terminals = eqssh_terminals.rename(columns={'rdfId': 'rdfId_Terminal'})
+        eqssh_terminals = eqssh_terminals.rename(columns={'ConductingEquipment': 'rdfId'})
         # buses for merging with assets:
         bus_merge = pd.DataFrame(data=self.cimConverter.net['bus'].loc[:, [sc['o_id'], 'vn_kv']])
-        bus_merge.rename(columns={'vn_kv': 'base_voltage_bus'}, inplace=True)
-        bus_merge.reset_index(level=0, inplace=True)
-        bus_merge.rename(columns={'index': 'index_bus', sc['o_id']: 'ConnectivityNode'}, inplace=True)
+        bus_merge = bus_merge.rename(columns={'vn_kv': 'base_voltage_bus'})
+        bus_merge = bus_merge.reset_index(level=0)
+        bus_merge = bus_merge.rename(columns={'index': 'index_bus', sc['o_id']: 'ConnectivityNode'})
         bus_merge = pd.merge(eqssh_terminals, bus_merge, how='left', on='ConnectivityNode')
         self.cimConverter.bus_merge = bus_merge
 
@@ -69,15 +69,15 @@ class ConnectivityNodesCim16:
             # The idea is to add the Bays and Substations to the VoltageLevels to handle them similar to (1)
             # prepare the bays (2)
             eq_bay = self.cimConverter.cim['eq']['Bay'].copy()
-            eq_bay.rename(columns={'rdfId': 'ConnectivityNodeContainer'}, inplace=True)
+            eq_bay = eq_bay.rename(columns={'rdfId': 'ConnectivityNodeContainer'})
             eq_bay = pd.merge(self.cimConverter.cim['eq']['ConnectivityNode'][['ConnectivityNodeContainer']], eq_bay,
                               how='inner', on='ConnectivityNodeContainer')
-            eq_bay.dropna(subset=['VoltageLevel'], inplace=True)
+            eq_bay = eq_bay.dropna(subset=['VoltageLevel'])
             eq_bay = pd.merge(eq_bay,
                               self.cimConverter.cim['eq']['VoltageLevel'][['rdfId', 'BaseVoltage', 'Substation']],
                               how='left', left_on='VoltageLevel', right_on='rdfId')
-            eq_bay.drop(columns=['VoltageLevel', 'rdfId'], inplace=True)
-            eq_bay.rename(columns={'ConnectivityNodeContainer': 'rdfId'}, inplace=True)
+            eq_bay = eq_bay.drop(columns=['VoltageLevel', 'rdfId'])
+            eq_bay = eq_bay.rename(columns={'ConnectivityNodeContainer': 'rdfId'})
             # now prepare the substations (3)
             # first get only the needed substation used as ConnectivityNodeContainer in ConnectivityNode
             eq_subs = pd.merge(self.cimConverter.cim['eq']['ConnectivityNode'][['ConnectivityNodeContainer']].rename(
@@ -98,18 +98,18 @@ class ConnectivityNodesCim16:
                     level=LogLevel.WARNING, code=ReportCode.WARNING_CONVERTING,
                     message="More than one VoltageLevel refers to one Substation, maybe the voltages from some buses "
                             "are incorrect, the problematic VoltageLevels and Substations:\n%s" % eq_subs_duplicates))
-            eq_subs.drop_duplicates(['rdfId'], keep='first', inplace=True)
+            eq_subs = eq_subs.drop_duplicates(['rdfId'], keep='first')
             # now merge the VoltageLevel with the ConnectivityNode
             eq_voltage_levels = self.cimConverter.cim['eq']['VoltageLevel'][['rdfId', 'BaseVoltage', 'Substation']]
             eq_voltage_levels = pd.concat([eq_voltage_levels, eq_bay], ignore_index=True, sort=False)
             eq_voltage_levels = pd.concat([eq_voltage_levels, eq_subs], ignore_index=True, sort=False)
-            eq_voltage_levels.drop_duplicates(['rdfId'], keep='first', inplace=True)
+            eq_voltage_levels = eq_voltage_levels.drop_duplicates(['rdfId'], keep='first')
             del eq_bay, eq_subs, eq_subs_duplicates
             eq_substations = self.cimConverter.cim['eq']['Substation'][['rdfId', 'name']]
-            eq_substations.rename(columns={'rdfId': 'Substation', 'name': 'name_substation'}, inplace=True)
+            eq_substations = eq_substations.rename(columns={'rdfId': 'Substation', 'name': 'name_substation'})
             eq_voltage_levels = pd.merge(eq_voltage_levels, eq_substations, how='left', on='Substation')
-            eq_voltage_levels.drop_duplicates(subset=['rdfId'], inplace=True)
-            eq_voltage_levels.rename(columns={'rdfId': 'ConnectivityNodeContainer'}, inplace=True)
+            eq_voltage_levels = eq_voltage_levels.drop_duplicates(subset=['rdfId'])
+            eq_voltage_levels = eq_voltage_levels.rename(columns={'rdfId': 'ConnectivityNodeContainer'})
 
             connectivity_nodes = pd.merge(connectivity_nodes, eq_voltage_levels, how='left',
                                           on='ConnectivityNodeContainer')
@@ -128,7 +128,7 @@ class ConnectivityNodesCim16:
                              inplace=True)
             connectivity_nodes = pd.merge(connectivity_nodes, eq_bd_cns, how='left', on='rdfId')
             connectivity_nodes['BaseVoltage'].fillna(connectivity_nodes['BaseVoltage_2'], inplace=True)
-            connectivity_nodes.drop(columns=['BaseVoltage_2'], inplace=True)
+            connectivity_nodes = connectivity_nodes.drop(columns=['BaseVoltage_2'])
             # check if there is a mix between BB and NB models
             terminals_temp = \
                 self.cimConverter.cim['eq']['Terminal'].loc[
@@ -137,9 +137,9 @@ class ConnectivityNodesCim16:
                 terminals_temp = pd.merge(terminals_temp,
                                           self.cimConverter.cim['tp']['Terminal'][['rdfId', 'TopologicalNode']],
                                           how='left', on='rdfId')
-                terminals_temp.drop(columns=['rdfId'], inplace=True)
-                terminals_temp.rename(columns={'TopologicalNode': 'rdfId'}, inplace=True)
-                terminals_temp.drop_duplicates(subset=['rdfId'], inplace=True)
+                terminals_temp = terminals_temp.drop(columns=['rdfId'])
+                terminals_temp = terminals_temp.rename(columns={'TopologicalNode': 'rdfId'})
+                terminals_temp = terminals_temp.drop_duplicates(subset=['rdfId'])
                 tp_temp = self.cimConverter.cim['tp']['TopologicalNode'][
                     ['rdfId', 'name', 'description', 'BaseVoltage']]
                 tp_temp[sc['o_prf']] = 'tp'
@@ -164,12 +164,12 @@ class ConnectivityNodesCim16:
         eq_base_voltages = pd.concat([self.cimConverter.cim['eq']['BaseVoltage'][['rdfId', 'nominalVoltage']],
                                       self.cimConverter.cim['eq_bd']['BaseVoltage'][['rdfId', 'nominalVoltage']]],
                                      ignore_index=True, sort=False)
-        eq_base_voltages.drop_duplicates(subset=['rdfId'], inplace=True)
-        eq_base_voltages.rename(columns={'rdfId': 'BaseVoltage'}, inplace=True)
+        eq_base_voltages = eq_base_voltages.drop_duplicates(subset=['rdfId'])
+        eq_base_voltages = eq_base_voltages.rename(columns={'rdfId': 'BaseVoltage'})
         # make sure that the BaseVoltage has string datatype
         connectivity_nodes['BaseVoltage'] = connectivity_nodes['BaseVoltage'].astype(str)
         connectivity_nodes = pd.merge(connectivity_nodes, eq_base_voltages, how='left', on='BaseVoltage')
-        connectivity_nodes.drop(columns=['BaseVoltage'], inplace=True)
+        connectivity_nodes = connectivity_nodes.drop(columns=['BaseVoltage'])
         eqssh_terminals = self.cimConverter.cim['eq']['Terminal'][['rdfId', 'ConnectivityNode', 'ConductingEquipment',
                                                                    'sequenceNumber']]
         eqssh_terminals = \
@@ -191,13 +191,13 @@ class ConnectivityNodesCim16:
                                 pd.concat([self.cimConverter.cim['tp']['DCTerminal'],
                                            self.cimConverter.cim['tp']['ACDCConverterDCTerminal']],
                                           ignore_index=True, sort=False), how='left', on='rdfId')
-        dc_terminals.rename(columns={'DCNode': 'ConnectivityNode', 'DCConductingEquipment': 'ConductingEquipment',
-                                     'DCTopologicalNode': 'TopologicalNode'}, inplace=True)
+        dc_terminals = dc_terminals.rename(columns={'DCNode': 'ConnectivityNode', 'DCConductingEquipment': 'ConductingEquipment',
+                                     'DCTopologicalNode': 'TopologicalNode'})
         eqssh_terminals = pd.concat([eqssh_terminals, dc_terminals], ignore_index=True, sort=False)
         # special fix for concat tp profiles
-        eqssh_terminals.drop_duplicates(subset=['rdfId', 'TopologicalNode'], inplace=True)
+        eqssh_terminals = eqssh_terminals.drop_duplicates(subset=['rdfId', 'TopologicalNode'])
         eqssh_terminals_temp = eqssh_terminals[['ConnectivityNode', 'TopologicalNode']]
-        eqssh_terminals_temp.dropna(subset=['TopologicalNode'], inplace=True)
+        eqssh_terminals_temp = eqssh_terminals_temp.dropna(subset=['TopologicalNode'])
         eqssh_terminals_temp.drop_duplicates(inplace=True)
         connectivity_nodes_size = connectivity_nodes.index.size
         if node_breaker:
@@ -210,7 +210,7 @@ class ConnectivityNodesCim16:
         # fill the column TopologicalNode for the ConnectivityNodes from the eq_bd profile if exists
         if 'TopologicalNode_2' in connectivity_nodes.columns:
             connectivity_nodes['TopologicalNode'].fillna(connectivity_nodes['TopologicalNode_2'], inplace=True)
-            connectivity_nodes.drop(columns=['TopologicalNode_2'], inplace=True)
+            connectivity_nodes = connectivity_nodes.drop(columns=['TopologicalNode_2'])
         if connectivity_nodes.index.size != connectivity_nodes_size:
             self.logger.warning("There is a problem at the busses!")
             self.cimConverter.report_container.add_log(Report(
@@ -228,17 +228,17 @@ class ConnectivityNodesCim16:
             # raise ValueError("The number of ConnectivityNodes increased after merging with Terminals, number of "
             #                  "ConnectivityNodes before merge: %s, number of ConnectivityNodes after merge: %s" %
             #                  (connectivity_nodes_size, connectivity_nodes.index.size))
-            connectivity_nodes.drop_duplicates(subset=['rdfId'], keep='first', inplace=True)
+            connectivity_nodes = connectivity_nodes.drop_duplicates(subset=['rdfId'], keep='first')
         # add the busbars
         bb = self.cimConverter.cim['eq']['BusbarSection'][['rdfId', 'name']]
-        bb.rename(columns={'rdfId': 'busbar_id', 'name': 'busbar_name'}, inplace=True)
+        bb = bb.rename(columns={'rdfId': 'busbar_id', 'name': 'busbar_name'})
         bb = pd.merge(bb, self.cimConverter.cim['eq']['Terminal'][['ConnectivityNode', 'ConductingEquipment']].rename(
             columns={'ConnectivityNode': 'rdfId', 'ConductingEquipment': 'busbar_id'}), how='left', on='busbar_id')
-        bb.drop_duplicates(subset=['rdfId'], keep='first', inplace=True)
+        bb = bb.drop_duplicates(subset=['rdfId'], keep='first')
         connectivity_nodes = pd.merge(connectivity_nodes, bb, how='left', on='rdfId')
 
-        connectivity_nodes.rename(columns={'rdfId': sc['o_id'], 'TopologicalNode': sc['ct'], 'nominalVoltage': 'vn_kv',
-                                           'name_substation': 'zone'}, inplace=True)
+        connectivity_nodes = connectivity_nodes.rename(columns={'rdfId': sc['o_id'], 'TopologicalNode': sc['ct'], 'nominalVoltage': 'vn_kv',
+                                           'name_substation': 'zone'})
         connectivity_nodes['in_service'] = True
         connectivity_nodes['type'] = 'b'
         return connectivity_nodes, eqssh_terminals

{pandapower-2.14.1 → pandapower-2.14.5}/pandapower/converter/cim/cim2pp/converter_classes/coordinates/coordinatesFromDLCim16.py

@@ -32,12 +32,12 @@ class CoordinatesFromDLCim16:
                     self.cimConverter.cim['dl']['Diagram']['name'] == diagram_name].values[0]
             dl_do = self.cimConverter.cim['dl']['DiagramObject'][
                 self.cimConverter.cim['dl']['DiagramObject']['Diagram'] == diagram_rdf_id]
-            dl_do.rename(columns={'rdfId': 'DiagramObject'}, inplace=True)
+            dl_do = dl_do.rename(columns={'rdfId': 'DiagramObject'})
         else:
             dl_do = self.cimConverter.cim['dl']['DiagramObject'].copy()
-            dl_do.rename(columns={'rdfId': 'DiagramObject'}, inplace=True)
+            dl_do = dl_do.rename(columns={'rdfId': 'DiagramObject'})
         dl_data = pd.merge(dl_do, self.cimConverter.cim['dl']['DiagramObjectPoint'], how='left', on='DiagramObject')
-        dl_data.drop(columns=['rdfId', 'Diagram', 'DiagramObject'], inplace=True)
+        dl_data = dl_data.drop(columns=['rdfId', 'Diagram', 'DiagramObject'])
         # make sure that the columns 'xPosition' and 'yPosition' are floats
         dl_data['xPosition'] = dl_data['xPosition'].astype(float)
         dl_data['yPosition'] = dl_data['yPosition'].astype(float)
@@ -45,7 +45,7 @@ class CoordinatesFromDLCim16:
         buses = self.cimConverter.net.bus.reset_index()
         buses = buses[['index', sc['o_id']]]
         bus_geo = pd.merge(dl_data, buses, how='inner', left_on='IdentifiedObject', right_on=sc['o_id'])
-        bus_geo.sort_values(by=[sc['o_id'], 'sequenceNumber'], inplace=True)
+        bus_geo = bus_geo.sort_values(by=[sc['o_id'], 'sequenceNumber'])
         bus_geo['coords'] = bus_geo[['xPosition', 'yPosition']].values.tolist()
         bus_geo['coords'] = bus_geo[['coords']].values.tolist()
         # for the buses which have more than one coordinate
@@ -53,8 +53,8 @@ class CoordinatesFromDLCim16:
         # now deal with the buses which have more than one coordinate
         for _, df_group in bus_geo_mult.groupby(by=sc['o_id'], sort=False):
             bus_geo['coords'][df_group.index.values[0]] = df_group[['xPosition', 'yPosition']].values.tolist()
-        bus_geo.drop_duplicates([sc['o_id']], keep='first', inplace=True)
-        bus_geo.sort_values(by='index', inplace=True)
+        bus_geo = bus_geo.drop_duplicates([sc['o_id']], keep='first')
+        bus_geo = bus_geo.sort_values(by='index')
         start_index_pp_net = self.cimConverter.net.bus_geodata.index.size
         self.cimConverter.net.bus_geodata = pd.concat(
             [self.cimConverter.net.bus_geodata, pd.DataFrame(None, index=bus_geo['index'].values)],
@@ -69,19 +69,19 @@ class CoordinatesFromDLCim16:
         self.cimConverter.net.bus_geodata['coords'] = self.cimConverter.net.bus_geodata.apply(
             lambda row: [row['coords'][0], row['coords'][-1]] if row['coords_length'] > 2 else row['coords'], axis=1)
         if 'coords_length' in self.cimConverter.net.bus_geodata.columns:
-            self.cimConverter.net.bus_geodata.drop(columns=['coords_length'], inplace=True)
+            self.cimConverter.net.bus_geodata = self.cimConverter.net.bus_geodata.drop(columns=['coords_length'])
 
         # the coordinates for the lines
         lines = self.cimConverter.net.line.reset_index()
         lines = lines[['index', sc['o_id']]]
         line_geo = pd.merge(dl_data, lines, how='inner', left_on='IdentifiedObject', right_on=sc['o_id'])
-        line_geo.sort_values(by=[sc['o_id'], 'sequenceNumber'], inplace=True)
+        line_geo = line_geo.sort_values(by=[sc['o_id'], 'sequenceNumber'])
         line_geo['coords'] = line_geo[['xPosition', 'yPosition']].values.tolist()
         line_geo['coords'] = line_geo[['coords']].values.tolist()
         for _, df_group in line_geo.groupby(by=sc['o_id']):
             line_geo['coords'][df_group.index.values[0]] = df_group[['xPosition', 'yPosition']].values.tolist()
-        line_geo.drop_duplicates([sc['o_id']], keep='first', inplace=True)
-        line_geo.sort_values(by='index', inplace=True)
+        line_geo = line_geo.drop_duplicates([sc['o_id']], keep='first')
+        line_geo = line_geo.sort_values(by='index')
         # now add the line coordinates
         # if there are no bus geodata in the GL profile the line geodata from DL has higher priority
         if self.cimConverter.net.line_geodata.index.size > 0 and line_geo.index.size > 0:
@@ -95,12 +95,12 @@ class CoordinatesFromDLCim16:
                         'storage', 'ward', 'xward']:
             one_ele_df = self.cimConverter.net[one_ele][[sc['o_id']]]
             one_ele_df = pd.merge(dl_data, one_ele_df, how='inner', left_on='IdentifiedObject', right_on=sc['o_id'])
-            one_ele_df.sort_values(by=[sc['o_id'], 'sequenceNumber'], inplace=True)
+            one_ele_df = one_ele_df.sort_values(by=[sc['o_id'], 'sequenceNumber'])
             one_ele_df['coords'] = one_ele_df[['xPosition', 'yPosition']].values.tolist()
             one_ele_df['coords'] = one_ele_df[['coords']].values.tolist()
             for _, df_group in one_ele_df.groupby(by=sc['o_id']):
                 one_ele_df['coords'][df_group.index.values[0]] = df_group[['xPosition', 'yPosition']].values.tolist()
-            one_ele_df.drop_duplicates([sc['o_id']], keep='first', inplace=True)
+            one_ele_df = one_ele_df.drop_duplicates([sc['o_id']], keep='first')
             # now add the coordinates
             self.cimConverter.net[one_ele]['coords'] = self.cimConverter.net[one_ele][sc['o_id']].map(
                 one_ele_df.set_index(sc['o_id']).to_dict(orient='dict').get('coords'))

{pandapower-2.14.1 → pandapower-2.14.5}/pandapower/converter/cim/cim2pp/converter_classes/coordinates/geoCoordinatesFromGLCim16.py

@@ -25,7 +25,7 @@ class GeoCoordinatesFromGLCim16:
             self.cimConverter.cim['gl']['PositionPoint'][['Location', 'xPosition', 'yPosition', 'sequenceNumber']],
             self.cimConverter.cim['gl']['Location'][['rdfId', 'PowerSystemResources']], how='left',
             left_on='Location', right_on='rdfId')
-        gl_data.drop(columns=['Location', 'rdfId'], inplace=True)
+        gl_data = gl_data.drop(columns=['Location', 'rdfId'])
         # make sure that the columns 'xPosition' and 'yPosition' are floats
         gl_data['xPosition'] = gl_data['xPosition'].astype(float)
         gl_data['yPosition'] = gl_data['yPosition'].astype(float)
@@ -34,15 +34,15 @@ class GeoCoordinatesFromGLCim16:
         cn = pd.concat([cn, self.cimConverter.cim['eq_bd']['ConnectivityNode'][['rdfId', 'ConnectivityNodeContainer']]])
         cn = pd.concat([cn, self.cimConverter.cim['tp']['TopologicalNode'][['rdfId', 'ConnectivityNodeContainer']]])
         cn = pd.concat([cn, self.cimConverter.cim['tp_bd']['TopologicalNode'][['rdfId', 'ConnectivityNodeContainer']]])
-        cn.rename(columns={'rdfId': sc['o_id'], 'ConnectivityNodeContainer': 'rdfId'}, inplace=True)
+        cn = cn.rename(columns={'rdfId': sc['o_id'], 'ConnectivityNodeContainer': 'rdfId'})
         cn = pd.merge(cn, self.cimConverter.cim['eq']['VoltageLevel'][['rdfId', 'Substation']], how='left', on='rdfId')
-        cn.drop(columns=['rdfId'], inplace=True)
+        cn = cn.drop(columns=['rdfId'])
         buses = self.cimConverter.net.bus.reset_index()
         buses = buses[['index', sc['o_id']]]
         buses = pd.merge(buses, cn, how='left', on=sc['o_id'])
         bus_geo = pd.merge(bus_geo, buses, how='inner', on='Substation')
-        bus_geo.drop(columns=['Substation'], inplace=True)
-        bus_geo.sort_values(by=[sc['o_id'], 'sequenceNumber'], inplace=True)
+        bus_geo = bus_geo.drop(columns=['Substation'])
+        bus_geo = bus_geo.sort_values(by=[sc['o_id'], 'sequenceNumber'])
         bus_geo['coords'] = bus_geo[['xPosition', 'yPosition']].values.tolist()
         bus_geo['coords'] = bus_geo[['coords']].values.tolist()
         # for the buses which have more than one coordinate
@@ -50,8 +50,8 @@ class GeoCoordinatesFromGLCim16:
         # now deal with the buses which have more than one coordinate
         for _, df_group in bus_geo_mult.groupby(by=sc['o_id'], sort=False):
             bus_geo['coords'][df_group.index.values[0]] = df_group[['xPosition', 'yPosition']].values.tolist()
-        bus_geo.drop_duplicates([sc['o_id']], keep='first', inplace=True)
-        bus_geo.sort_values(by='index', inplace=True)
+        bus_geo = bus_geo.drop_duplicates([sc['o_id']], keep='first')
+        bus_geo = bus_geo.sort_values(by='index')
         start_index_pp_net = self.cimConverter.net.bus_geodata.index.size
         self.cimConverter.net.bus_geodata = pd.concat(
             [self.cimConverter.net.bus_geodata, pd.DataFrame(None, index=bus_geo['index'].values)],
@@ -66,20 +66,20 @@ class GeoCoordinatesFromGLCim16:
         self.cimConverter.net.bus_geodata['coords'] = self.cimConverter.net.bus_geodata.apply(
             lambda row: [row['coords'][0], row['coords'][-1]] if row['coords_length'] > 2 else row['coords'], axis=1)
         if 'coords_length' in self.cimConverter.net.bus_geodata.columns:
-            self.cimConverter.net.bus_geodata.drop(columns=['coords_length'], inplace=True)
+            self.cimConverter.net.bus_geodata = self.cimConverter.net.bus_geodata.drop(columns=['coords_length'])
 
         # the geo coordinates for the lines
         lines = self.cimConverter.net.line.reset_index()
         lines = lines[['index', sc['o_id']]]
         line_geo = gl_data.rename(columns={'PowerSystemResources': sc['o_id']})
         line_geo = pd.merge(line_geo, lines, how='inner', on=sc['o_id'])
-        line_geo.sort_values(by=[sc['o_id'], 'sequenceNumber'], inplace=True)
+        line_geo = line_geo.sort_values(by=[sc['o_id'], 'sequenceNumber'])
         line_geo['coords'] = line_geo[['xPosition', 'yPosition']].values.tolist()
         line_geo['coords'] = line_geo[['coords']].values.tolist()
         for _, df_group in line_geo.groupby(by=sc['o_id']):
             line_geo['coords'][df_group.index.values[0]] = df_group[['xPosition', 'yPosition']].values.tolist()
-        line_geo.drop_duplicates([sc['o_id']], keep='first', inplace=True)
-        line_geo.sort_values(by='index', inplace=True)
+        line_geo = line_geo.drop_duplicates([sc['o_id']], keep='first')
+        line_geo = line_geo.sort_values(by='index')
         # now add the line coordinates
         start_index_pp_net = self.cimConverter.net.line_geodata.index.size
         self.cimConverter.net.line_geodata = pd.concat(
@@ -93,12 +93,12 @@ class GeoCoordinatesFromGLCim16:
             one_ele_df = self.cimConverter.net[one_ele][[sc['o_id']]]
             one_ele_df = pd.merge(gl_data.rename(columns={'PowerSystemResources': sc['o_id']}),
                                   one_ele_df, how='inner', on=sc['o_id'])
-            one_ele_df.sort_values(by=[sc['o_id'], 'sequenceNumber'], inplace=True)
+            one_ele_df = one_ele_df.sort_values(by=[sc['o_id'], 'sequenceNumber'])
             one_ele_df['coords'] = one_ele_df[['xPosition', 'yPosition']].values.tolist()
             one_ele_df['coords'] = one_ele_df[['coords']].values.tolist()
             for _, df_group in one_ele_df.groupby(by=sc['o_id']):
                 one_ele_df['coords'][df_group.index.values[0]] = df_group[['xPosition', 'yPosition']].values.tolist()
-            one_ele_df.drop_duplicates([sc['o_id']], keep='first', inplace=True)
+            one_ele_df = one_ele_df.drop_duplicates([sc['o_id']], keep='first')
             # now add the coordinates
             self.cimConverter.net[one_ele]['coords'] = self.cimConverter.net[one_ele][sc['o_id']].map(
                 one_ele_df.set_index(sc['o_id']).to_dict(orient='dict').get('coords'))

{pandapower-2.14.1 → pandapower-2.14.5}/pandapower/converter/cim/cim2pp/converter_classes/externalnetworks/externalNetworkInjectionsCim16.py

@@ -110,6 +110,6 @@ class ExternalNetworkInjectionsCim16:
         regulation_controllers = self.cimConverter.merge_eq_ssh_profile('RegulatingControl')
         regulation_controllers = regulation_controllers.loc[regulation_controllers['mode'] == 'voltage']
         regulation_controllers = regulation_controllers[['rdfId', 'targetValue', 'enabled']]
-        regulation_controllers.rename(columns={'rdfId': 'RegulatingControl'}, inplace=True)
+        regulation_controllers = regulation_controllers.rename(columns={'rdfId': 'RegulatingControl'})
         eqssh_eni = pd.merge(eqssh_eni, regulation_controllers, how='left', on='RegulatingControl')
         return eqssh_eni

{pandapower-2.14.1 → pandapower-2.14.5}/pandapower/converter/cim/cim2pp/converter_classes/generators/asynchronousMachinesCim16.py

@@ -48,11 +48,11 @@ class AsynchronousMachinesCim16:
         eq_generating_units = pd.concat([eq_generating_units, self.cimConverter.cim['eq']['NuclearGeneratingUnit']],
                                         sort=False)
         eq_generating_units['type'].fillna('Nuclear', inplace=True)
-        eq_generating_units.rename(columns={'rdfId': 'GeneratingUnit'}, inplace=True)
+        eq_generating_units = eq_generating_units.rename(columns={'rdfId': 'GeneratingUnit'})
         eqssh_asynchronous_machines = self.cimConverter.merge_eq_ssh_profile('AsynchronousMachine',
                                                                              add_cim_type_column=True)
         # prevent conflict of merging two dataframes each containing column 'name'
-        eq_generating_units.drop('name', axis=1, inplace=True)
+        eq_generating_units = eq_generating_units.drop('name', axis=1)
         eqssh_asynchronous_machines = pd.merge(eqssh_asynchronous_machines, eq_generating_units,
                                                how='left', on='GeneratingUnit')
         eqssh_asynchronous_machines = pd.merge(eqssh_asynchronous_machines, self.cimConverter.bus_merge, how='left',
@@ -66,12 +66,12 @@ class AsynchronousMachinesCim16:
         eqssh_asynchronous_machines['generator_type'] = 'async'
         eqssh_asynchronous_machines['loading_percent'] = \
             100 * eqssh_asynchronous_machines['p_mw'] / eqssh_asynchronous_machines['ratedMechanicalPower']
-        eqssh_asynchronous_machines.rename(columns={'rdfId_Terminal': sc['t'], 'rdfId': sc['o_id'],
+        eqssh_asynchronous_machines = eqssh_asynchronous_machines.rename(columns={'rdfId_Terminal': sc['t'], 'rdfId': sc['o_id'],
                                                     'connected': 'in_service', 'index_bus': 'bus',
                                                     'rxLockedRotorRatio': 'rx', 'iaIrRatio': 'lrc_pu',
                                                     'ratedPowerFactor': 'cos_phi', 'ratedU': 'vn_kv',
                                                     'efficiency': 'efficiency_n_percent',
-                                                    'ratedMechanicalPower': 'pn_mech_mw'}, inplace=True)
+                                                    'ratedMechanicalPower': 'pn_mech_mw'})
         eqssh_asynchronous_machines['scaling'] = 1
         eqssh_asynchronous_machines['efficiency_percent'] = 100
         return eqssh_asynchronous_machines