pandahub 0.3.17__zip → 0.4.1__zip

{pandahub-0.3.17 → pandahub-0.4.1}/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Change Log
 
+## [0.4.0]
+    - IMPROVED: pandapower 3.0 support
+
 ## [0.3.13]
     - FIXED: fetching integer index on empty collection
     - IMPROVED: context manager for mongo client /database / collection

{pandahub-0.3.17 → pandahub-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pandahub
-Version: 0.3.17
+Version: 0.4.1
 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.3.17 → pandahub-0.4.1}/pandahub/lib/PandaHub.py

@@ -4,28 +4,29 @@ import json
 import logging
 import time
 import warnings
-from inspect import signature, _empty
 from collections.abc import Callable
+from functools import reduce
+from inspect import signature, _empty
+from itertools import chain
+from operator import getitem
 from types import NoneType
 from typing import Optional, Union, TypeVar
+from uuid import UUID
 
 import numpy as np
+import pandapipes as pps
+import pandapower as pp
+import pandapower.io_utils as io_pp
 import pandas as pd
 from bson.errors import InvalidId
 from bson.objectid import ObjectId
-from functools import reduce
-from operator import getitem
-from uuid import UUID
+from pandapipes import from_json_string as from_json_pps, FromSerializableRegistryPpipe, BranchComponent
+from pandapipes.component_models import NodeElementComponent
 from pymongo import MongoClient, ReplaceOne
-from pymongo.database import Database
 from pymongo.collection import Collection
+from pymongo.database import Database
 from pymongo.errors import ServerSelectionTimeoutError, DuplicateKeyError
 
-import pandapipes as pps
-from pandapipes import from_json_string as from_json_pps, FromSerializableRegistryPpipe
-import pandapower as pp
-import pandapower.io_utils as io_pp
-
 from pandahub.api.internal.settings import MONGODB_URL, MONGODB_USER, MONGODB_PASSWORD, MONGODB_GLOBAL_DATABASE_URL, \
     MONGODB_GLOBAL_DATABASE_USER, MONGODB_GLOBAL_DATABASE_PASSWORD, CREATE_INDEXES_WITH_PROJECT, PANDAHUB_GLOBAL_DB_CLIENT
 from pandahub.lib.database_toolbox import (
@@ -77,6 +78,20 @@ def validate_variant_type(variant: int | None):
         msg = f"variant must be int or None, but got {variant} of type {type(variant)}"
         raise ValueError(msg)
 
+
+def re_arg(kwarg_map: dict[str, str]) -> Callable:
+    def decorator(func: Callable) -> Callable:
+        def wrapped(*args, **kwargs):
+            new_kwargs = {}
+            for k, v in kwargs.items():
+                if k in kwarg_map:
+                    print(f"DEPRECATION WARNING: keyword argument '{k}' is no longer valid. Use '{kwarg_map[k]}' instead.")
+                new_kwargs[kwarg_map.get(k, k)] = v
+            return func(*args, **new_kwargs)
+        return wrapped
+    return decorator
+
+
 class PandaHub:
     permissions = {
         "read": ["owner", "developer", "guest"],
@@ -856,15 +871,15 @@ class PandaHub:
     def get_subnet_by_name(
         self,
         name,
-        bus_filter=None,
+        node_filter=None,
         include_results=True,
         add_edge_branches=True,
         geo_mode="string",
         variant=None,
         additional_filters: dict[
-            str, Callable[[pp.auxiliary.pandapowerNet], dict]
+            str, Callable[[pp.auxiliary.pandapowerNet | pps.pandapipesNet], dict]
         ] = {},
-    ):
+    ) -> pp.auxiliary.pandapowerNet | pps.pandapipesNet:
         self.check_permission("read")
         db = self._get_project_database()
         net_id = self._get_net_id_from_name(name, db)
@@ -872,7 +887,7 @@ class PandaHub:
             return None
         return self.get_subnet(
             net_id,
-            bus_filter=bus_filter,
+            node_filter=node_filter,
             include_results=include_results,
             add_edge_branches=add_edge_branches,
             geo_mode=geo_mode,
@@ -880,221 +895,192 @@ class PandaHub:
             additional_filters=additional_filters,
         )
 
+    @re_arg({"bus_filter": "node_filter"})
     def get_subnet(
         self,
         net_id,
-        bus_filter=None,
+        node_filter=None,
         include_results=True,
         add_edge_branches=True,
         geo_mode="string",
         variant=None,
-        ignore_elements=[],
+        ignore_elements=tuple([]),
         additional_filters: dict[
-            str, Callable[[pp.auxiliary.pandapowerNet], dict]
-        ] = {},
-    ) -> pp.pandapowerNet:
+            str, Callable[[pp.auxiliary.pandapowerNet | pps.pandapipesNet], dict]
+        ] | None = None,
+        additional_branch_node_cols: dict[str, list[str]] | None = None,
+        *,
+        return_edge_branch_nodes: bool = False
+    ) -> (pp.pandapowerNet | pps.pandapipesNet) | (tuple[pp.pandapowerNet | pps.pandapipesNet, list]):
         db = self._get_project_database()
         meta = self._get_network_metadata(db, net_id)
-        dtypes = db["_networks"].find_one({"_id": net_id}, projection={"dtypes"})
+        dtypes = meta["dtypes"]
+        sector = meta["sector"]
+        is_power = sector == "power"
 
-        net = pp.create_empty_network()
+        if additional_filters is None:
+            additional_filters = {}
+        if additional_branch_node_cols is None:
+            additional_branch_node_cols = {}
 
-        if db[self._collection_name_of_element("bus")].find_one() is None:
+        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 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))
+        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}
+
+        if db[self._collection_name_of_element(node_name)].find_one() is None:
             net["empty"] = True
 
+        add_args = {
+            "net": net,
+            "db": db,
+            "net_id": net_id,
+            "include_results": include_results,
+            "geo_mode": geo_mode,
+            "variant": variant,
+            "dtypes": dtypes,
+            "filter": node_filter,
+        }
+
         # Add buses with filter
-        if bus_filter is not None:
-            self._add_element_from_collection(
-                net,
-                db,
-                "bus",
-                net_id,
-                bus_filter,
-                geo_mode=geo_mode,
-                variant=variant,
-                dtypes=dtypes,
-            )
-        buses = net.bus.index.tolist()
+        if node_filter is not None:
+            self._add_element_from_collection(element_type=node_name, **add_args)
+        nodes = net[node_name].index.tolist()
 
         if isinstance(add_edge_branches, bool):
             if add_edge_branches:
-                add_edge_branches = ["line", "trafo", "switch"]
+                add_edge_branches = default_branches
             else:
                 add_edge_branches = []
         elif not isinstance(add_edge_branches, list):
             raise ValueError("add_edge_branches must be a list or a boolean")
-        line_operator = "$or" if "line" in add_edge_branches else "$and"
-        # Add branch elements connected to at least one bus
-        self._add_element_from_collection(
-            net,
-            db,
-            "line",
-            net_id,
-            {
-                line_operator: [
-                    {"from_bus": {"$in": buses}},
-                    {"to_bus": {"$in": buses}},
-                ]
-            },
-            geo_mode=geo_mode,
-            variant=variant,
-            dtypes=dtypes,
-        )
-        trafo_operator = "$or" if "trafo" in add_edge_branches else "$and"
-        self._add_element_from_collection(
-            net,
-            db,
-            "trafo",
-            net_id,
-            {trafo_operator: [{"hv_bus": {"$in": buses}}, {"lv_bus": {"$in": buses}}]},
-            geo_mode=geo_mode,
-            variant=variant,
-            dtypes=dtypes,
-        )
-        self._add_element_from_collection(
-            net,
-            db,
-            "trafo3w",
-            net_id,
-            {
-                trafo_operator: [
-                    {"hv_bus": {"$in": buses}},
-                    {"mv_bus": {"$in": buses}},
-                    {"lv_bus": {"$in": buses}},
-                ]
-            },
-            geo_mode=geo_mode,
-            variant=variant,
-            dtypes=dtypes,
-        )
-        switch_operator = "$or" if "switch" in add_edge_branches else "$and"
-        self._add_element_from_collection(
-            net,
-            db,
-            "switch",
-            net_id,
-            {
-                "$and": [
-                    {"et": "b"},
+
+        # Add elements for which the user has provided a filter function
+        for element, filter_func in additional_filters.items():
+            if element in ignore_elements:
+                continue
+            add_args["filter"] = filter_func(net)
+            self._add_element_from_collection(element_type=element, **add_args)
+
+        branch_nodes = set()
+        for branch_name, node_cols in zip(default_branches, default_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]}
+            if branch_name in special_filters:
+                filter_ = special_filters[branch_name](filter_)
+            add_args["filter"] = filter_
+            self._add_element_from_collection(element_type=branch_name, **add_args)
+            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
+            branch_nodes_outside = list(map(int, branch_nodes - set(nodes)))
+            add_args["filter"] = {"index": {"$in": branch_nodes_outside}}
+            self._add_element_from_collection(element_type=node_name, **add_args)
+            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()}}]},
                     {
-                        switch_operator: [
-                            {"bus": {"$in": buses}},
-                            {"element": {"$in": buses}},
+                        "$and": [
+                            {"et": "t3"},
+                            {"element": {"$in": net.trafo3w.index.tolist()}},
                         ]
                     },
                 ]
-            },
-            geo_mode=geo_mode,
-            variant=variant,
-            dtypes=dtypes,
-        )
-        if add_edge_branches:
-            # Add buses on the other side of the branches
-            branch_buses = (
-                set(net.trafo.hv_bus.values)
-                | set(net.trafo.lv_bus.values)
-                | set(net.line.from_bus)
-                | set(net.line.to_bus)
-                | set(net.trafo3w.hv_bus.values)
-                | set(net.trafo3w.mv_bus.values)
-                | set(net.trafo3w.lv_bus.values)
-                | set(net.switch.bus)
-                | set(net.switch.element)
-            )
-            branch_buses_outside = [int(b) for b in branch_buses - set(buses)]
-            self._add_element_from_collection(
-                net,
-                db,
-                "bus",
-                net_id,
-                geo_mode=geo_mode,
-                variant=variant,
-                filter={"index": {"$in": branch_buses_outside}},
-                dtypes=dtypes,
-            )
-            buses = net.bus.index.tolist()
-
-        switch_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()}},
-                    ]
-                },
-            ]
-        }
-        self._add_element_from_collection(
-            net,
-            db,
-            "switch",
-            net_id,
-            switch_filter,
-            geo_mode=geo_mode,
-            variant=variant,
-            dtypes=dtypes,
-        )
-
-        # 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))
+            }
+            self._add_element_from_collection(element_type="switch", **add_args)
 
         # add all node elements that are connected to buses within the network
         for element in node_elements:
-            element_filter = {"bus": {"$in": buses}}
-            self._add_element_from_collection(
-                net,
-                db,
-                element,
-                net_id,
-                filter=element_filter,
-                geo_mode=geo_mode,
-                include_results=include_results,
-                variant=variant,
-                dtypes=dtypes,
-            )
-
-        # Add elements for which the user has provided a filter function
-        for element, filter_func in additional_filters.items():
-            if element in ignore_elements:
-                continue
-            element_filter = filter_func(net)
-            self._add_element_from_collection(
-                net,
-                db,
-                element,
-                net_id,
-                filter=element_filter,
-                geo_mode=geo_mode,
-                include_results=include_results,
-                variant=variant,
-                dtypes=dtypes,
-            )
+            add_args["filter"] = {node_name: {"$in": nodes}}
+            self._add_element_from_collection(element_type=element, **add_args)
 
         # add all other collections
         collection_names = self.get_net_collections(db)
         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:
+            if (table_name in all_elements or table_name in ignore_elements
+                or table_name in additional_filters.keys()):
                 continue
             # for tables that share an index with an element (e.g. load->res_load) load only relevant entries
             for element in all_elements:
@@ -1106,18 +1092,11 @@ class PandaHub:
             else:
                 # all other tables (e.g. std_types) are loaded without filter
                 element_filter = None
-            self._add_element_from_collection(
-                net,
-                db,
-                table_name,
-                net_id,
-                filter=element_filter,
-                geo_mode=geo_mode,
-                include_results=include_results,
-                variant=variant,
-                dtypes=dtypes,
-            )
+            add_args["filter"] = element_filter
+            self._add_element_from_collection(element_type=table_name, **add_args)
         self.deserialize_and_update_data(net, meta)
+        if return_edge_branch_nodes:
+            return net, branch_nodes_outside
         return net
 
     def _collection_name_of_element(self, element):
@@ -3217,7 +3196,6 @@ class PandaHub:
         return self.get_net_collections(db, with_areas)
 
 
-
 if __name__ == "__main__":
     self = PandaHub()
     project_name = "test_project"

{pandahub-0.3.17 → pandahub-0.4.1}/pandahub/lib/datatypes.py

@@ -7,7 +7,7 @@ DATATYPES = {
         "zone": str,
         "in_service": bool,
         "max_vm_pu": float,
-        "min_vm_pu": float
+        "min_vm_pu": float,
     },
     "load": {
         "name": str,
@@ -95,7 +95,7 @@ DATATYPES = {
         "type": str,
         "in_service": bool,
         "max_loading_percent": float,
-        "std_type": str
+        "std_type": str,
     },
     "trafo": {
         "name": str,
@@ -306,12 +306,4 @@ DATATYPES = {
         'initial_run': bool,
         "recycle": str
     },
-    "line_geodata": {
-        "coords": object
-    },
-    "bus_geodata": {
-        "x": float,
-        "y": float,
-        "coords": object
-    },
 }

{pandahub-0.3.17 → pandahub-0.4.1}/pandahub/lib/mongo_client.py

@@ -1,5 +1,5 @@
 from contextlib import contextmanager
-from typing import Iterator
+from typing import Generator, overload
 
 from pymongo import MongoClient
 from pymongo.synchronous.collection import Collection
@@ -7,6 +7,7 @@ from pymongo.synchronous.database import Database
 
 from pandahub.api.internal.settings import PANDAHUB_GLOBAL_DB_CLIENT, MONGODB_URL, MONGODB_USER, MONGODB_PASSWORD
 
+
 def _get_mongo_client(connection_url: str = MONGODB_URL, connection_user: str = MONGODB_USER,
                      connection_password: str = MONGODB_PASSWORD) -> MongoClient:
     mongo_client_args = {
@@ -27,8 +28,20 @@ else:
     _global_mongo_client = None
 
 
+
+
+@overload
+def get_mongo_client(database: None = None, collection: None = None,
+                     connection_url: str = ..., connection_user: str = ..., connection_password: str = ...) -> MongoClient: ...
+@overload
+def get_mongo_client(database: str, collection: None=None,
+                     connection_url: str = ..., connection_user: str = ..., connection_password: str = ...) -> Database: ...
+@overload
+def get_mongo_client(database: str, collection: str,
+                     connection_url: str = ..., connection_user: str = ..., connection_password: str = ...) -> Collection: ...
+
 def get_mongo_client(database: str | None = None, collection: str | None = None, connection_url: str = MONGODB_URL, connection_user: str = MONGODB_USER,
-                     connection_password: str = MONGODB_PASSWORD) -> Iterator[MongoClient | Database | Collection]:
+                     connection_password: str = MONGODB_PASSWORD) -> MongoClient | Database | Collection:
     if collection is not None and database is None:
         raise ValueError("Must specify database to access a collection!")
     if _global_mongo_client is None:
@@ -40,7 +53,7 @@ def get_mongo_client(database: str | None = None, collection: str | None = None,
 
 @contextmanager
 def mongo_client(database: str | None = None, collection: str | None = None, connection_url: str = MONGODB_URL,
-                 connection_user: str = MONGODB_USER, connection_password: str = MONGODB_PASSWORD) -> Iterator[MongoClient | Database | Collection]:
+                 connection_user: str = MONGODB_USER, connection_password: str = MONGODB_PASSWORD) -> Generator[MongoClient | Database | Collection, None, None]:
     """Contextmanager for pymongo MongoClient / Database / Collection with close after use.
 
     Parameters
@@ -69,7 +82,7 @@ def mongo_client(database: str | None = None, collection: str | None = None, con
         client.close()
 
 
-def _get_db_or_coll(client: MongoClient, database: str | None = None, collection: str | None = None) -> Iterator[MongoClient | Database | Collection]:
+def _get_db_or_coll(client: MongoClient, database: str | None = None, collection: str | None = None) -> MongoClient | Database | Collection:
     if database is not None and collection is not None:
         return client[database][collection]
     elif database is not None:

{pandahub-0.3.17 → pandahub-0.4.1}/pandahub.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pandahub
-Version: 0.3.17
+Version: 0.4.1
 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.3.17 → pandahub-0.4.1}/pandahub.egg-info/requires.txt

@@ -2,7 +2,7 @@ uvicorn>=0.24.0
 fastapi-users[beanie]>=12.0
 fastapi>=0.104.0
 fastapi-mail>=1.4.1
-pandapower~=2.14
+pandapower>=3.0
 pandapipes>=0.7.0
 pymongo>=4.9
 pydantic

{pandahub-0.3.17 → pandahub-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pandahub"
-version = "0.3.17"  # File format version '__format_version__' is tracked in __init__.py
+version = "0.4.1"  # 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" },

{pandahub-0.3.17 → pandahub-0.4.1}/requirements.txt

@@ -2,7 +2,7 @@ uvicorn>=0.24.0
 fastapi-users[beanie]>=12.0
 fastapi>=0.104.0
 fastapi-mail>=1.4.1
-pandapower~=2.14
+pandapower>=3.0
 pandapipes>=0.7.0
 pymongo>=4.9
 pydantic

{pandahub-0.3.17 → pandahub-0.4.1}/test/performance_test.py

@@ -46,7 +46,7 @@ def load_test_subnet_from_mongodb(project_name):
     buses = list(range(1000))
     t0 = time.time()
     subnet = ph.get_subnet_by_name("test_net",
-                                   bus_filter={"index": {"$in": buses}})
+                                   node_filter={"index": {"$in": buses}})
     t1 = time.time()
     print("LOADED NET IN %.2fs"%(t1-t0))
     return subnet

{pandahub-0.3.17 → pandahub-0.4.1}/test/test_networks.py

@@ -90,20 +90,20 @@ def test_load_subnetwork(ph):
         net = nw_pp.mv_oberrhein()
         ph.write_network_to_db(net, name)
 
-    subnet = ph.get_subnet_by_name(name, bus_filter={"vn_kv": 110})
+    subnet = ph.get_subnet_by_name(name, node_filter={"vn_kv": 110})
     expected_sizes = [("bus", 4), ("line", 0), ("trafo", 2), ("ext_grid", 2)]
 
     for element, size in expected_sizes:
         assert len(subnet[element]) == size
         assert len(subnet["res_" + element]) == size
 
-    subnet = ph.get_subnet_by_name(name, bus_filter={"vn_kv": 110},
+    subnet = ph.get_subnet_by_name(name, node_filter={"vn_kv": 110},
                                    include_results=False)
     for element, size in expected_sizes:
         assert len(subnet[element]) == size
         assert len(subnet["res_" + element]) == 0
 
-    subnet = ph.get_subnet_by_name(name, bus_filter={"vn_kv": 110},
+    subnet = ph.get_subnet_by_name(name, node_filter={"vn_kv": 110},
                                    add_edge_branches=False)
     expected_sizes = [("bus", 2), ("line", 0), ("trafo", 0), ("ext_grid", 2)]