pandahub 0.4.2__zip → 0.4.3__zip

{pandahub-0.4.2 → pandahub-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pandahub
-Version: 0.4.2
+Version: 0.4.3
 Summary: Data hub for pandapower and pandapipes networks based on MongoDB
 Author-email: Jan Ulffers <jan.ulffers@iee.fraunhofer.de>, Leon Thurner <leon.thurner@retoflow.de>, Jannis Kupka <jannis.kupka@retoflow.de>, Mike Vogt <mike.vogt@iee.fraunhofer.de>, Joschka Thurner <joschka.thurner@retoflow.de>, Alexander Scheidler <alexander.scheidler@iee.fraunhofer.de>
 License: Copyright (c) 2022 by University of Kassel, Fraunhofer Institute for Energy Economics

{pandahub-0.4.2 → pandahub-0.4.3}/pandahub/lib/PandaHub.py

@@ -878,8 +878,8 @@ class PandaHub:
         variant=None,
         additional_filters: dict[
             str, Callable[[pp.auxiliary.pandapowerNet | pps.pandapipesNet], dict]
-        ] = {},
-    ) -> pp.auxiliary.pandapowerNet | pps.pandapipesNet:
+        ] | None = None,
+    ) -> (pp.pandapowerNet | pps.pandapipesNet) | (tuple[pp.pandapowerNet | pps.pandapipesNet, list] | None):
         self.check_permission("read")
         db = self._get_project_database()
         net_id = self._get_net_id_from_name(name, db)
@@ -908,7 +908,13 @@ class PandaHub:
         additional_filters: dict[
             str, Callable[[pp.auxiliary.pandapowerNet | pps.pandapipesNet], dict]
         ] | None = None,
-        additional_branch_node_cols: dict[str, list[str]] | None = None,
+        additional_edge_filters: dict[
+            str, tuple[
+                list[str] | tuple[str, ...] | None,
+                bool,
+                dict | None,
+                Callable[[pp.auxiliary.pandapowerNet | pps.pandapipesNet], dict] | None
+            ]] | None = None,
         *,
         return_edge_branch_nodes: bool = False
     ) -> (pp.pandapowerNet | pps.pandapipesNet) | (tuple[pp.pandapowerNet | pps.pandapipesNet, list]):
@@ -920,78 +926,26 @@ class PandaHub:
 
         if additional_filters is None:
             additional_filters = {}
-        if additional_branch_node_cols is None:
-            additional_branch_node_cols = {}
-
-        def switch_filter(bus_filter):
-            return {
-                "$and": [
-                    {"et": "b"},
-                    bus_filter,
-                ]
-            }
-
-        def get_nodes_from_element(ntw, element, nd_cols):
-            return [ntw[element][ndc].to_numpy() for ndc in nd_cols]
-
-        def get_nodes_from_switch(ntw, _, _nd_cols):
-            return [ntw.switch.bus.to_numpy(), ntw.switch.loc[ntw.switch.et == "b", "element"].to_numpy()]
+        if additional_edge_filters is None:
+            additional_edge_filters = {}
 
+        filtered_elements = set(additional_filters.keys()) | set(additional_edge_filters.keys())
         if is_power:
             net = pp.create_empty_network()
-            node_name = "bus"
-            default_branches = ["line", "trafo", "trafo3w", "switch"]
-            default_node_cols = [
-                ("from_bus", "to_bus"),
-                ("hv_bus", "lv_bus"),
-                ("hv_bus", "lv_bus", "mv_bus"),
-                ("bus", "element")
-            ]
-            special_filters = {"switch": switch_filter}
-            get_nodes_func = {br: get_nodes_from_element for br in default_branches}
-            get_nodes_func["switch"] = get_nodes_from_switch
-            # add node elements
-            node_elements = [
-                "load",
-                "asymmetric_load",
-                "sgen",
-                "asymmetric_sgen",
-                "gen",
-                "ext_grid",
-                "shunt",
-                "xward",
-                "ward",
-                "motor",
-                "storage",
-            ]
-            branch_elements = ["trafo", "line", "trafo3w", "switch", "impedance"]
-            all_elements = (
-                node_elements + branch_elements + ["bus"] + list(additional_filters.keys())
-            )
-            all_elements = list(set(all_elements) - set(ignore_elements))
+            data_func = get_subnet_filter_data_power
+            args = [filtered_elements]
         else:
             net = pps.create_empty_network()
-            node_name = "junction"
-            component_list = []
-            if "data" in meta and "component_list" in meta["data"]:
-                component_list = json.loads(
-                    meta["data"]["component_list"][11:], cls=io_pp.PPJSONDecoder,
-                    registry_class=FromSerializableRegistryPpipe
-                )
-            default_branches = []
-            default_node_cols = []
-            node_elements = []
-            all_elements = []
-            for c in component_list:
-                pps.add_new_component(net, c)
-                all_elements.append(c.table_name())
-                if issubclass(c, BranchComponent):
-                    default_branches.append(c.table_name())
-                    default_node_cols.append(c.from_to_node_cols())
-                if issubclass(c, NodeElementComponent):
-                    node_elements.append(c.table_name())
-            special_filters = dict()
-            get_nodes_func = {br: get_nodes_from_element for br in default_branches}
+            data_func = get_subnet_filter_data_pipe
+            args = [net, filtered_elements, meta]
+        (
+            node_name,
+            branch_tables,
+            branch_node_cols,
+            special_filters,
+            get_nodes_func,
+            node_elements,
+        ) = data_func(*args)
 
         if db[self._collection_name_of_element(node_name)].find_one() is None:
             net["empty"] = True
@@ -1014,14 +968,23 @@ class PandaHub:
 
         if isinstance(add_edge_branches, bool):
             if add_edge_branches:
-                add_edge_branches = default_branches
+                add_edge_branches = branch_tables
             else:
                 add_edge_branches = []
         elif not isinstance(add_edge_branches, list):
             raise ValueError("add_edge_branches must be a list or a boolean")
 
+        for tbl, (node_cols, add_edge, filter_func, node_getter) in additional_edge_filters.items():
+            branch_tables.append(tbl)
+            branch_node_cols.append(tuple(node_cols))
+            if add_edge:
+                add_edge_branches.append(tbl)
+            if filter_func is not None:
+                special_filters[tbl] = filter_func
+            get_nodes_func[tbl] = node_getter if node_getter is not None else get_nodes_from_element
+
         branch_nodes = set()
-        for branch_name, node_cols in zip(default_branches, default_node_cols):
+        for branch_name, node_cols in zip(branch_tables, branch_node_cols):
             operator = "$or" if branch_name in add_edge_branches else "$and"
             # Add branch elements connected to at least one node
             filter_ = {operator: [{b: {"$in": nodes}} for b in node_cols]}
@@ -1032,13 +995,6 @@ class PandaHub:
             get_nd_func = get_nodes_func[branch_name]
             branch_nodes.update(set(chain.from_iterable(get_nd_func(net, branch_name, node_cols))))
 
-        for branch_name, node_cols in additional_branch_node_cols.items():
-            if branch_name not in net:
-                continue
-            branch_nodes.update(
-                set(chain.from_iterable(get_nodes_from_element(net, branch_name, node_cols)))
-            )
-
         branch_nodes_outside = []
         if branch_nodes:
             # Add buses on the other side of the branches
@@ -1048,18 +1004,7 @@ class PandaHub:
             nodes = net[node_name].index.tolist()
 
         if is_power:
-            add_args["filter"] = {
-                "$or": [
-                    {"$and": [{"et": "t"}, {"element": {"$in": net.trafo.index.tolist()}}]},
-                    {"$and": [{"et": "l"}, {"element": {"$in": net.line.index.tolist()}}]},
-                    {
-                        "$and": [
-                            {"et": "t3"},
-                            {"element": {"$in": net.trafo3w.index.tolist()}},
-                        ]
-                    },
-                ]
-            }
+            add_args["filter"] = filter_switch_for_element(net)
             self._add_element_from_collection(element_type="switch", **add_args)
 
         # add all node elements that are connected to buses within the network
@@ -1079,11 +1024,10 @@ class PandaHub:
         for collection in collection_names:
             table_name = self._element_name_of_collection(collection)
             # skip all element tables that we have already added
-            if (table_name in all_elements or table_name in ignore_elements
-                or table_name in additional_filters.keys()):
+            if table_name in filtered_elements or table_name in ignore_elements:
                 continue
             # for tables that share an index with an element (e.g. load->res_load) load only relevant entries
-            for element in all_elements:
+            for element in filtered_elements:
                 if table_name.startswith(element + "_") or table_name.startswith(
                     "net_res_" + element
                 ):
@@ -3196,6 +3140,111 @@ class PandaHub:
         return self.get_net_collections(db, with_areas)
 
 
+def switch_filter(bus_filter):
+    return {
+        "$and": [
+            {"et": "b"},
+            bus_filter,
+        ]
+    }
+
+
+def filter_switch_for_element(net):
+    return {
+        "$or": [
+            {"$and": [{"et": "t"}, {"element": {"$in": net.trafo.index.tolist()}}]},
+            {"$and": [{"et": "l"}, {"element": {"$in": net.line.index.tolist()}}]},
+            {
+                "$and": [
+                    {"et": "t3"},
+                    {"element": {"$in": net.trafo3w.index.tolist()}},
+                ]
+            },
+        ]
+    }
+
+
+def get_nodes_from_element(ntw, element, nd_cols):
+    if element not in ntw:
+        return [[] for _ in nd_cols]
+    return [ntw[element][ndc].tolist() for ndc in nd_cols]
+
+
+def get_nodes_from_switch(ntw, _, _nd_cols):
+    return [ntw.switch.bus.to_numpy(), ntw.switch.loc[ntw.switch.et == "b", "element"].to_numpy()]
+
+
+def get_subnet_filter_data_power(filtered_elements):
+    node_name = "bus"
+    branch_tables = ["line", "trafo", "trafo3w", "switch"]
+    branch_node_cols = [
+        ("from_bus", "to_bus"),
+        ("hv_bus", "lv_bus"),
+        ("hv_bus", "lv_bus", "mv_bus"),
+        ("bus", "element"),
+    ]
+    special_filters = {"switch": switch_filter}
+    get_nodes_func = {br: get_nodes_from_element for br in branch_tables}
+    get_nodes_func["switch"] = get_nodes_from_switch
+    # add node elements
+    node_elements = [
+        "load",
+        "asymmetric_load",
+        "sgen",
+        "asymmetric_sgen",
+        "gen",
+        "ext_grid",
+        "shunt",
+        "xward",
+        "ward",
+        "motor",
+        "storage",
+    ]
+    branch_elements = ["trafo", "line", "trafo3w", "switch", "impedance"]
+    filtered_elements |= set(node_elements) | set(branch_elements) | {"bus"}
+    return (
+        node_name,
+        branch_tables,
+        branch_node_cols,
+        special_filters,
+        get_nodes_func,
+        node_elements,
+    )
+
+
+def get_subnet_filter_data_pipe(net, filtered_elements, metadata):
+    node_name = "junction"
+    component_list = []
+    if "data" in metadata and "component_list" in metadata["data"]:
+        component_list = json.loads(
+            metadata["data"]["component_list"][11:],
+            cls=io_pp.PPJSONDecoder,
+            registry_class=FromSerializableRegistryPpipe,
+        )
+    branch_tables = []
+    branch_node_cols = []
+    node_elements = []
+    for c in component_list:
+        pps.add_new_component(net, c)
+        filtered_elements.add(c.table_name())
+        if issubclass(c, BranchComponent):
+            branch_tables.append(c.table_name())
+            branch_node_cols.append(c.from_to_node_cols())
+        if issubclass(c, NodeElementComponent):
+            node_elements.append(c.table_name())
+    special_filters = dict()
+    get_nodes_func = {br: get_nodes_from_element for br in branch_tables}
+    return (
+        node_name,
+        branch_tables,
+        branch_node_cols,
+        special_filters,
+        get_nodes_func,
+        node_elements,
+    )
+
+
+
 if __name__ == "__main__":
     self = PandaHub()
     project_name = "test_project"

{pandahub-0.4.2 → pandahub-0.4.3}/pandahub.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pandahub
-Version: 0.4.2
+Version: 0.4.3
 Summary: Data hub for pandapower and pandapipes networks based on MongoDB
 Author-email: Jan Ulffers <jan.ulffers@iee.fraunhofer.de>, Leon Thurner <leon.thurner@retoflow.de>, Jannis Kupka <jannis.kupka@retoflow.de>, Mike Vogt <mike.vogt@iee.fraunhofer.de>, Joschka Thurner <joschka.thurner@retoflow.de>, Alexander Scheidler <alexander.scheidler@iee.fraunhofer.de>
 License: Copyright (c) 2022 by University of Kassel, Fraunhofer Institute for Energy Economics

{pandahub-0.4.2 → pandahub-0.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pandahub"
-version = "0.4.2"  # File format version '__format_version__' is tracked in __init__.py
+version = "0.4.3"  # File format version '__format_version__' is tracked in __init__.py
 authors=[
     { name = "Jan Ulffers", email = "jan.ulffers@iee.fraunhofer.de" },
     { name = "Leon Thurner", email = "leon.thurner@retoflow.de" },