Using more defined and type-able data structures

[thatguy7]

Hi guys, I've been using pandapower at work more often recently and found using the pandapowerNet class somewhat cumbersome, so I was wondering what the story behind it is.

From the way I was interacting with it so far, it seems to me like it could be a well defined class. Simplified, it could be something like e.g.

from dataclasses import dataclass
import pandas as pd


@dataclass
class pandapowerNet:
    bus: pd.DataFrame
    line: pd.DataFrame

    def __getitem__(self, key):
        return getattr(self, key)

    def __setitem__(self, key, value):
        setattr(self, key, value)


net = pandapowerNet(...)
net.bus       # access as attribute
net["line"]   # access like a dict

From what I gather, in the current implementation the pandapowerNet is a subclass of dict (MutableMapping). Is there a reason for this? As a user, I would much rather prefer the net being a well defined type that I can rely on having certain attributes - which would also let my IDE provide proper hints, and even a little type checking on my side of the code.

One might even push it further: Analogously one might consider splitting of the results into their own classes with well defined structure instead of adding res_... tables to the original net e.g.

@dataclass 
class PowerflowResult:
    sucessfull: bool
    bus: pd.Dataframe
    line: pd.Dataframe

# runpp could return this thing
result = pp.runpp(net)

# but also store ts in the net the way it is done right now
result == net.result

This would be nice, but also break existing code, so the pandapowerNet would need to catch this and warn with a deprecation until it is eventually removed so net.res_<table> no longer works.

@dataclass
class pandapowerNet:
    ...

    def __getitem__(self, key: str):
        # remove eventually
        if key.startswith("res_"):
            res_table_name = key.removeprefix("res_")
            print(f"deprecated, use net.result.{res_table_name} instead of net.{key}")
            return getattr(self.result, res_table_name)

        return getattr(self, key)

    # remove eventually
    def __getattr__(self, name: str) -> Any:
        if name.startswith("res_"):
            res_table_name = name.removeprefix("res_")
            print(f"deprecated, use net.result.{res_table_name} instead of net.{name}")
            return getattr(self.result, res_table_name)

        raise AttributeError("Attribute does not exist!")


net = pandapowerNet(...)
net.res_bus is net.result.bus  # same df

Analogously one might handle res_<something>_est and any other result types. I can imagine that this would be a quite huge change, but in my opinion worth it for usability in the long run.

But whatever the details might end up being, is there a plan to move pandapower to more type-able data structures in the future?