power-grid-model-io 1.2.95__tar.gz → 1.2.97__tar.gz

{power_grid_model_io-1.2.95 → power_grid_model_io-1.2.97}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: power-grid-model-io
-Version: 1.2.95
+Version: 1.2.97
 Summary: Power Grid Model Input/Output
 Author-email: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
 License: MPL-2.0

power_grid_model_io-1.2.97/PYPI_VERSION

@@ -0,0 +1 @@
+1.2.97

{power_grid_model_io-1.2.95 → power_grid_model_io-1.2.97}/pyproject.toml

@@ -80,7 +80,7 @@ power_grid_model_io = ["config/**/*.yaml"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests/unit"]
-addopts = ["--cov=power_grid_model_io", "--cov-report=term", "--cov-report=html:cov_html", "--cov-fail-under=99"]
+addopts = ["--cov=power_grid_model_io", "--cov-report=term", "--cov-report=html:cov_html", "--cov-fail-under=98.5"]
 
 [tool.black]
 line-length = 120

{power_grid_model_io-1.2.95 → power_grid_model_io-1.2.97}/src/power_grid_model_io/converters/pandapower_converter.py

@@ -12,7 +12,15 @@ from typing import Dict, List, MutableMapping, Optional, Tuple, Type, Union
 import numpy as np
 import pandas as pd
 import structlog
-from power_grid_model import Branch3Side, BranchSide, LoadGenType, WindingType, initialize_array, power_grid_meta_data
+from power_grid_model import (
+    Branch3Side,
+    BranchSide,
+    DatasetType,
+    LoadGenType,
+    WindingType,
+    initialize_array,
+    power_grid_meta_data,
+)
 from power_grid_model.data_types import Dataset, SingleDataset
 
 from power_grid_model_io.converters.base_converter import BaseConverter
@@ -113,10 +121,10 @@ class PandaPowerConverter(BaseConverter[PandaPowerData]):
             self._extra_info_to_pgm_input_data(extra_info)
 
         # Convert
-        def pgm_output_dtype_checker(check_type: str) -> bool:
+        def pgm_output_dtype_checker(check_type: DatasetType | str) -> bool:
             return all(
                 (
-                    comp_array.dtype == power_grid_meta_data[check_type][component]
+                    comp_array.dtype == power_grid_meta_data[DatasetType[check_type]][component]
                     for component, comp_array in self.pgm_output_data.items()
                 )
             )
@@ -248,7 +256,10 @@ class PandaPowerConverter(BaseConverter[PandaPowerData]):
         nan = np.iinfo(dtype).min
         all_other_cols = ["i_n"]
         for component, data in self.pgm_output_data.items():
-            input_cols = power_grid_meta_data["input"][component].dtype.names
+            input_cols = power_grid_meta_data[DatasetType.input][component].dtype.names
+            if input_cols is None:
+                input_cols = tuple()
+
             node_cols = [col for col in input_cols if is_node_ref(col)]
             other_cols = [col for col in input_cols if col in all_other_cols]
             if not node_cols + other_cols:
@@ -747,8 +758,12 @@ class PandaPowerConverter(BaseConverter[PandaPowerData]):
         pgm_transformers["sn"] = sn_mva * parallel * 1e6
         pgm_transformers["uk"] = vk_percent * 1e-2
         pgm_transformers["pk"] = vkr_percent * sn_mva * parallel * (1e6 * 1e-2)
-        pgm_transformers["i0"] = i_no_load * 1e-2
         pgm_transformers["p0"] = pfe * parallel * 1e3
+        pgm_transformers["i0"] = i_no_load * 1e-2
+        i0_min_threshold = pgm_transformers["p0"] / pgm_transformers["sn"]
+        if any(np.less(pgm_transformers["i0"], i0_min_threshold)):
+            logger.warning("Minimum value of i0_percent is clipped to p0/sn")
+            pgm_transformers["i0"] = np.clip(pgm_transformers["i0"], a_min=i0_min_threshold, a_max=None)
         pgm_transformers["clock"] = clocks
         pgm_transformers["winding_from"] = winding_types["winding_from"]
         pgm_transformers["winding_to"] = winding_types["winding_to"]
@@ -875,8 +890,12 @@ class PandaPowerConverter(BaseConverter[PandaPowerData]):
         pgm_3wtransformers["pk_13"] = vkr_lv_percent * np.minimum(sn_hv_mva, sn_lv_mva) * (1e-2 * 1e6)
         pgm_3wtransformers["pk_23"] = vkr_mv_percent * np.minimum(sn_mv_mva, sn_lv_mva) * (1e-2 * 1e6)
 
-        pgm_3wtransformers["i0"] = self._get_pp_attr("trafo3w", "i0_percent", expected_type="f8") * 1e-2
         pgm_3wtransformers["p0"] = self._get_pp_attr("trafo3w", "pfe_kw", expected_type="f8") * 1e3
+        pgm_3wtransformers["i0"] = self._get_pp_attr("trafo3w", "i0_percent", expected_type="f8") * 1e-2
+        i0_min_threshold = pgm_3wtransformers["p0"] / pgm_3wtransformers["sn_1"]
+        if any(np.less(pgm_3wtransformers["i0"], i0_min_threshold)):
+            logger.warning("Minimum value of i0_percent is clipped to p0/sn_1")
+            pgm_3wtransformers["i0"] = np.clip(pgm_3wtransformers["i0"], a_min=i0_min_threshold, a_max=None)
         pgm_3wtransformers["clock_12"] = clocks_12
         pgm_3wtransformers["clock_13"] = clocks_13
         pgm_3wtransformers["winding_1"] = winding_types["winding_1"]
@@ -1594,9 +1613,11 @@ class PandaPowerConverter(BaseConverter[PandaPowerData]):
         # Combine all branch bus, current and et in one dataframe
         all_i_df = pd.concat(
             [
-                join_currents(table, bus_name, i_name)
-                if not rest_switches_absent[table]
-                else pd.DataFrame(columns=["bus", "element", "et", "i_ka"])
+                (
+                    join_currents(table, bus_name, i_name)
+                    if not rest_switches_absent[table]
+                    else pd.DataFrame(columns=["bus", "element", "et", "i_ka"])
+                )
                 for table, attr_names in switch_attrs.items()
                 for bus_name, i_name in attr_names.items()
             ]

{power_grid_model_io-1.2.95 → power_grid_model_io-1.2.97}/src/power_grid_model_io/converters/pgm_json_converter.py

@@ -151,9 +151,12 @@ class PgmJsonConverter(BaseConverter[StructuredData]):
 
                 # If an attribute doesn't exist, it is added to the extra_info lookup table
                 elif extra_info is not None:
-                    if obj["id"] not in extra_info:
-                        extra_info[obj["id"]] = {}
-                    extra_info[obj["id"]][attribute] = value
+                    obj_id = obj["id"]
+                    if not isinstance(obj_id, int):
+                        raise ValueError(f"Invalid 'id' value for {component} {data_type} data")
+                    if obj_id not in extra_info:
+                        extra_info[obj_id] = {}
+                    extra_info[obj_id][attribute] = value
         return array
 
     def _serialize_data(self, data: Dataset, extra_info: Optional[ExtraInfo]) -> StructuredData:
@@ -271,7 +274,7 @@ class PgmJsonConverter(BaseConverter[StructuredData]):
                 self._extract_extra_component_info(component, entry, reserialized_data, extra_info)
 
     def _extract_extra_component_info(
-        self, component: str, attributes: Dict[str, Any], reserialized_data: SingleDataset, extra_info: ExtraInfo
+        self, component: str, attributes: Dict[str, Any], reserialized_data: SinglePythonDataset, extra_info: ExtraInfo
     ):
         entry_id = attributes["id"]
         reserialized_entry = self._get_first_by(reserialized_data[component], "id", entry_id)

{power_grid_model_io-1.2.95 → power_grid_model_io-1.2.97}/src/power_grid_model_io/converters/tabular_converter.py

@@ -180,6 +180,8 @@ class TabularConverter(BaseConverter[TabularData]):
 
         if "filters" in attributes:
             table_mask = self._parse_table_filters(data=data, table=table, filtering_functions=attributes["filters"])
+            if table_mask is not None and not table_mask.any():
+                return None
         else:
             table_mask = None
 
@@ -219,7 +221,7 @@ class TabularConverter(BaseConverter[TabularData]):
         for filtering_fn in filtering_functions:
             for fn_name, kwargs in filtering_fn.items():
                 fn_ptr = get_function(fn_name)
-                table_mask &= data[table].apply(fn_ptr, axis=1, **kwargs).values
+                table_mask &= cast(pd.DataFrame, data[table]).apply(fn_ptr, axis=1, **kwargs).values
         return table_mask
 
     # pylint: disable = too-many-arguments

{power_grid_model_io-1.2.95 → power_grid_model_io-1.2.97}/src/power_grid_model_io.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: power-grid-model-io
-Version: 1.2.95
+Version: 1.2.97
 Summary: Power Grid Model Input/Output
 Author-email: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
 License: MPL-2.0

{power_grid_model_io-1.2.95 → power_grid_model_io-1.2.97}/tests/unit/converters/test_pandapower_converter_input.py

@@ -822,6 +822,7 @@ def test_create_pgm_input_shunts(mock_init_array: MagicMock, two_pp_objs, conver
 
 @patch("power_grid_model_io.converters.pandapower_converter.initialize_array")
 @patch("power_grid_model_io.converters.pandapower_converter.np.round", new=lambda x: x)
+@patch("power_grid_model_io.converters.pandapower_converter.np.less", new=lambda x, _, **kwargs: x)
 @patch("power_grid_model_io.converters.pandapower_converter.np.divide", new=lambda x, _, **kwargs: x)
 @patch("power_grid_model_io.converters.pandapower_converter.np.bitwise_and", new=lambda x, _: x)
 @patch("power_grid_model_io.converters.pandapower_converter.np.logical_and", new=lambda x, _: x)
@@ -1031,7 +1032,14 @@ def test_create_pgm_input_sym_gens(mock_init_array: MagicMock, two_pp_objs, conv
 
 @pytest.mark.parametrize(
     "kwargs",
-    [{"vk0_percent": 2}, {"vkr0_percent": 1}, {"mag0_percent": 5}, {"mag0_rx": 0.2}, {"si0_hv_partial": 0.3}],
+    [
+        {"pfe_kw": 2},
+        {"vk0_percent": 2},
+        {"vkr0_percent": 1},
+        {"mag0_percent": 5},
+        {"mag0_rx": 0.2},
+        {"si0_hv_partial": 0.3},
+    ],
 )
 @patch(
     "power_grid_model_io.converters.pandapower_converter.PandaPowerConverter.get_switch_states",
@@ -1049,11 +1057,14 @@ def test_create_pgm_input_sym_gens(mock_init_array: MagicMock, two_pp_objs, conv
     "power_grid_model_io.converters.pandapower_converter.PandaPowerConverter._get_pgm_ids",
     new=MagicMock(return_value=pd.Series([0])),
 )
-def test_create_pgm_input_transformers__zero_sequence(kwargs) -> None:
+def test_create_pgm_input_transformers__warnings(kwargs) -> None:
     # Arrange
     pp_net: pp.pandapowerNet = pp.create_empty_network()
     pp.create_bus(net=pp_net, vn_kv=0.0)
     args = [0, 0, 0, 0, 0, 0, 0, 0, 0]
+    if "pfe_kw" in kwargs:
+        args[-2] = kwargs["pfe_kw"]
+        kwargs = {}
     pp.create_transformer_from_parameters(pp_net, *args, **kwargs)
 
     converter = PandaPowerConverter()
@@ -1387,6 +1398,7 @@ def test_create_pgm_input_transformers3w__default() -> None:
 @pytest.mark.parametrize(
     "kwargs",
     [
+        {"pfe_kw": 2},
         {"vk0_hv_percent": 1},
         {"vkr0_hv_percent": 2},
         {"vk0_mv_percent": 3},
@@ -1411,11 +1423,14 @@ def test_create_pgm_input_transformers3w__default() -> None:
     "power_grid_model_io.converters.pandapower_converter.PandaPowerConverter._get_pgm_ids",
     new=MagicMock(return_value=pd.Series([0])),
 )
-def test_create_pgm_input_transformers3w__zero_sequence(kwargs) -> None:
+def test_create_pgm_input_transformers3w__warnings(kwargs) -> None:
     # Arrange
     pp_net: pp.pandapowerNet = pp.create_empty_network()
     pp.create_bus(net=pp_net, vn_kv=0.0)
     args = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+    if "pfe_kw" in kwargs:
+        args[-2] = kwargs["pfe_kw"]
+        kwargs = {}
     pp.create_transformer3w_from_parameters(pp_net, *args, **kwargs)
 
     converter = PandaPowerConverter()

{power_grid_model_io-1.2.95 → power_grid_model_io-1.2.97}/tests/unit/converters/test_tabular_converter.py

@@ -51,16 +51,16 @@ def tabular_data():
     )
     lines = pd.DataFrame(data=[[1, 100], [2, 200]], columns=["id_number", "from_node_side"])
     loads = pd.DataFrame(data=[[1, 1, 1], [2, 2, 0]], columns=["id_number", "node_id", "switching_status"])
-    tabular_data = TabularData(nodes=nodes, lines=lines, loads=loads)
-    return tabular_data
+    sources = pd.DataFrame(columns=["id_number", "node_side"])
+    return TabularData(nodes=nodes, lines=lines, loads=loads, sources=sources)
 
 
 @pytest.fixture
 def tabular_data_no_units_no_substitutions():
     nodes = pd.DataFrame(data=[[1, 10.5e3], [2, 400.0]], columns=["id_number", "u_nom"])
     lines = pd.DataFrame(data=[[1, 2], [3, 1]], columns=["id_number", "from_node_side"])
-    tabular_data = TabularData(nodes=nodes, lines=lines)
-    return tabular_data
+    sources = pd.DataFrame(columns=["id_number", "node_side"])
+    return TabularData(nodes=nodes, lines=lines, sources=sources)
 
 
 def test_set_mapping_file(converter: TabularConverter):
@@ -175,6 +175,31 @@ def test_convert_table_to_component__filters(
     )
 
 
+def test_convert_table_to_component__filters_all_false(
+    converter: TabularConverter, tabular_data_no_units_no_substitutions: TabularData
+):
+    converter._convert_col_def_to_attribute = MagicMock()
+    converter._parse_table_filters = MagicMock()
+    converter._parse_table_filters.side_effect = np.array([False, False])
+    node_attributes_with_filter = {"id": "id_number", "u_rated": "u_nom", "filters": [{"test_fn": {}}]}
+    actual = converter._convert_table_to_component(
+        data=tabular_data_no_units_no_substitutions,
+        data_type="input",
+        table="nodes",
+        component="node",
+        attributes=node_attributes_with_filter,
+        extra_info=None,
+    )
+
+    assert actual is None
+    converter._parse_table_filters.assert_called_once_with(
+        data=tabular_data_no_units_no_substitutions,
+        table="nodes",
+        filtering_functions=node_attributes_with_filter["filters"],
+    )
+    converter._convert_col_def_to_attribute.assert_not_called()
+
+
 def test_convert_col_def_to_attribute(
     converter: TabularConverter,
     tabular_data_no_units_no_substitutions: TabularData,

power_grid_model_io-1.2.95/PYPI_VERSION

@@ -1 +0,0 @@
-1.2.95