power-grid-model-io 1.2.85__py3-none-any.whl → 1.2.87__py3-none-any.whl

power_grid_model_io/config/excel/vision_en.yaml

@@ -424,6 +424,11 @@ grid:
       extra:
         - ID
         - Name
+      filters:
+        - power_grid_model_io.functions.filters.exclude_all_columns_empty_or_zero:
+            cols: 
+              - Load.P
+              - Load.Q
     sym_gen:
       - id:
           auto_id:
@@ -444,6 +449,11 @@ grid:
         extra:
           - ID
           - Name
+        filters:
+          - power_grid_model_io.functions.filters.exclude_all_columns_empty_or_zero:
+             cols: 
+              - Generation.P
+              - Generation.Q
       - id:
           auto_id:
             name: pv_generation
@@ -466,6 +476,10 @@ grid:
         extra:
           - ID
           - Name
+        filters:
+          - power_grid_model_io.functions.filters.exclude_all_columns_empty_or_zero:
+             cols: 
+              - PV.Pnom
   Sources:
     source:
       id:

power_grid_model_io/config/excel/vision_en_9_7.yaml

@@ -425,6 +425,11 @@ grid:
       extra:
         - ID
         - Name
+      filters:
+        - power_grid_model_io.functions.filters.exclude_all_columns_empty_or_zero:
+            cols: 
+            - Load.P
+            - Load.Q
     sym_gen:
       - id:
           auto_id:
@@ -445,6 +450,11 @@ grid:
         extra:
           - ID
           - Name
+        filters:
+          - power_grid_model_io.functions.filters.exclude_all_columns_empty_or_zero:
+              cols: 
+              - Generation.P
+              - Generation.Q
       - id:
           auto_id:
             name: pv_generation
@@ -467,6 +477,10 @@ grid:
         extra:
           - ID
           - Name
+        filters:
+          - power_grid_model_io.functions.filters.exclude_all_columns_empty_or_zero:
+              cols: 
+              - PV.Pnom
   Sources:
     source:
       id:

power_grid_model_io/config/excel/vision_nl.yaml

@@ -415,6 +415,11 @@ grid:
       extra:
         - ID
         - Naam
+      filters:
+        - power_grid_model_io.functions.filters.exclude_all_columns_empty_or_zero:
+            cols: 
+            - Belasting.P
+            - Belasting.Q
     sym_gen:
       - id:
           auto_id:
@@ -435,6 +440,11 @@ grid:
         extra:
           - ID
           - Naam
+        filters:
+          - power_grid_model_io.functions.filters.exclude_all_columns_empty_or_zero:
+              cols: 
+              - Opwekking.P
+              - Opwekking.Q
       - id:
           auto_id:
             name: pv_generation
@@ -457,6 +467,10 @@ grid:
         extra:
           - ID
           - Naam
+        filters:
+          - power_grid_model_io.functions.filters.exclude_all_columns_empty_or_zero:
+              cols: 
+              - PV.Pnom
   Netvoedingen:
     source:
       id:

power_grid_model_io/converters/tabular_converter.py

@@ -178,7 +178,12 @@ class TabularConverter(BaseConverter[TabularData]):
         if table not in data:
             return None
 
-        n_records = len(data[table])
+        if "filters" in attributes:
+            table_mask = self._parse_table_filters(data=data, table=table, filtering_functions=attributes["filters"])
+        else:
+            table_mask = None
+
+        n_records = np.sum(table_mask) if table_mask is not None else len(data[table])
 
         try:
             pgm_data = initialize_array(data_type=data_type, component_type=component, shape=n_records)
@@ -189,7 +194,8 @@ class TabularConverter(BaseConverter[TabularData]):
             raise KeyError(f"No mapping for the attribute 'id' for '{component}s'!")
 
         # Make sure that the "id" column is always parsed first (at least before "extra" is parsed)
-        sorted_attributes = sorted(attributes.items(), key=lambda x: "" if x[0] == "id" else x[0])
+        attributes_without_filter = {k: v for k, v in attributes.items() if k != "filters"}
+        sorted_attributes = sorted(attributes_without_filter.items(), key=lambda x: "" if x[0] == "id" else x[0])
 
         for attr, col_def in sorted_attributes:
             self._convert_col_def_to_attribute(
@@ -199,11 +205,23 @@ class TabularConverter(BaseConverter[TabularData]):
                 component=component,
                 attr=attr,
                 col_def=col_def,
+                table_mask=table_mask,
                 extra_info=extra_info,
             )
 
         return pgm_data
 
+    def _parse_table_filters(self, data: TabularData, table: str, filtering_functions: Any) -> Optional[np.ndarray]:
+        if not isinstance(data[table], pd.DataFrame):
+            return None
+
+        table_mask = np.ones(len(data[table]), dtype=bool)
+        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
+        return table_mask
+
     # pylint: disable = too-many-arguments
     def _convert_col_def_to_attribute(
         self,
@@ -213,6 +231,7 @@ class TabularConverter(BaseConverter[TabularData]):
         component: str,
         attr: str,
         col_def: Any,
+        table_mask: Optional[np.ndarray],
         extra_info: Optional[ExtraInfo],
     ):
         """This function updates one of the attributes of pgm_data, based on the corresponding table/column in a tabular
@@ -242,7 +261,7 @@ class TabularConverter(BaseConverter[TabularData]):
         """
         # To avoid mistakes, the attributes in the mapping should exist. There is one extra attribute called
         # 'extra' in which extra information can be captured.
-        if attr not in pgm_data.dtype.names and attr != "extra":
+        if attr not in pgm_data.dtype.names and attr not in ["extra", "filters"]:
             attrs = ", ".join(pgm_data.dtype.names)
             raise KeyError(f"Could not find attribute '{attr}' for '{component}s'. (choose from: {attrs})")
 
@@ -250,12 +269,19 @@ class TabularConverter(BaseConverter[TabularData]):
             # Extra info must be linked to the object IDs, therefore the uuids should be known before extra info can
             # be parsed. Before this for loop, it is checked that "id" exists and it is placed at the front.
             self._handle_extra_info(
-                data=data, table=table, col_def=col_def, uuids=pgm_data["id"], extra_info=extra_info
+                data=data,
+                table=table,
+                col_def=col_def,
+                uuids=pgm_data["id"],
+                table_mask=table_mask,
+                extra_info=extra_info,
             )
             # Extra info should not be added to the numpy arrays, so let's continue to the next attribute
             return
 
-        attr_data = self._parse_col_def(data=data, table=table, col_def=col_def, extra_info=extra_info)
+        attr_data = self._parse_col_def(
+            data=data, table=table, table_mask=table_mask, col_def=col_def, extra_info=extra_info
+        )
 
         if len(attr_data.columns) != 1:
             raise ValueError(f"DataFrame for {component}.{attr} should contain a single column ({attr_data.columns})")
@@ -268,6 +294,7 @@ class TabularConverter(BaseConverter[TabularData]):
         table: str,
         col_def: Any,
         uuids: np.ndarray,
+        table_mask: Optional[np.ndarray],
         extra_info: Optional[ExtraInfo],
     ) -> None:
         """This function can extract extra info from the tabular data and store it in the extra_info dict
@@ -292,7 +319,9 @@ class TabularConverter(BaseConverter[TabularData]):
         if extra_info is None:
             return
 
-        extra = self._parse_col_def(data=data, table=table, col_def=col_def, extra_info=None).to_dict(orient="records")
+        extra = self._parse_col_def(
+            data=data, table=table, table_mask=table_mask, col_def=col_def, extra_info=None
+        ).to_dict(orient="records")
         for i, xtr in zip(uuids, extra):
             xtr = {
                 k[0] if isinstance(k, tuple) else k: v
@@ -339,7 +368,12 @@ class TabularConverter(BaseConverter[TabularData]):
         return TabularData(logger=self._log, **data)
 
     def _parse_col_def(
-        self, data: TabularData, table: str, col_def: Any, extra_info: Optional[ExtraInfo]
+        self,
+        data: TabularData,
+        table: str,
+        col_def: Any,
+        table_mask: Optional[np.ndarray],
+        extra_info: Optional[ExtraInfo],
     ) -> pd.DataFrame:
         """Interpret the column definition and extract/convert/create the data as a pandas DataFrame.
 
@@ -353,17 +387,21 @@ class TabularConverter(BaseConverter[TabularData]):
 
         """
         if isinstance(col_def, (int, float)):
-            return self._parse_col_def_const(data=data, table=table, col_def=col_def)
+            return self._parse_col_def_const(data=data, table=table, col_def=col_def, table_mask=table_mask)
         if isinstance(col_def, str):
-            return self._parse_col_def_column_name(data=data, table=table, col_def=col_def)
+            return self._parse_col_def_column_name(data=data, table=table, col_def=col_def, table_mask=table_mask)
         if isinstance(col_def, dict):
-            return self._parse_col_def_filter(data=data, table=table, col_def=col_def, extra_info=extra_info)
+            return self._parse_col_def_filter(
+                data=data, table=table, table_mask=table_mask, col_def=col_def, extra_info=extra_info
+            )
         if isinstance(col_def, list):
-            return self._parse_col_def_composite(data=data, table=table, col_def=col_def)
+            return self._parse_col_def_composite(data=data, table=table, col_def=col_def, table_mask=table_mask)
         raise TypeError(f"Invalid column definition: {col_def}")
 
     @staticmethod
-    def _parse_col_def_const(data: TabularData, table: str, col_def: Union[int, float]) -> pd.DataFrame:
+    def _parse_col_def_const(
+        data: TabularData, table: str, col_def: Union[int, float], table_mask: Optional[np.ndarray] = None
+    ) -> pd.DataFrame:
         """Create a single column pandas DataFrame containing the const value.
 
         Args:
@@ -376,9 +414,15 @@ class TabularConverter(BaseConverter[TabularData]):
 
         """
         assert isinstance(col_def, (int, float))
-        return pd.DataFrame([col_def] * len(data[table]))
-
-    def _parse_col_def_column_name(self, data: TabularData, table: str, col_def: str) -> pd.DataFrame:
+        const_df = pd.DataFrame([col_def] * len(data[table]))
+        if table_mask is not None:
+            # Required to retain indices before filter
+            return const_df[table_mask]
+        return const_df
+
+    def _parse_col_def_column_name(
+        self, data: TabularData, table: str, col_def: str, table_mask: Optional[np.ndarray] = None
+    ) -> pd.DataFrame:
         """Extract a column from the data. If the column doesn't exist, check if the col_def is a special float value,
         like 'inf'. If that's the case, create a single column pandas DataFrame containing the const value.
 
@@ -391,13 +435,18 @@ class TabularConverter(BaseConverter[TabularData]):
 
         """
         assert isinstance(col_def, str)
+
         table_data = data[table]
+        if table_mask is not None:
+            table_data = table_data[table_mask]
 
         # If multiple columns are given in col_def, return the first column that exists in the dataset
         columns = [col_name.strip() for col_name in col_def.split("|")]
         for col_name in columns:
             if col_name in table_data or col_name == "index":
                 col_data = data.get_column(table_name=table, column_name=col_name)
+                if table_mask is not None:
+                    col_data = col_data[table_mask]
                 col_data = self._apply_multiplier(table=table, column=col_name, data=col_data)
                 return pd.DataFrame(col_data)
 
@@ -408,7 +457,7 @@ class TabularConverter(BaseConverter[TabularData]):
             columns_str = " and ".join(f"'{col_name}'" for col_name in columns)
             raise KeyError(f"Could not find column {columns_str} on table '{table}'")
 
-        return self._parse_col_def_const(data=data, table=table, col_def=const_value)
+        return self._parse_col_def_const(data=data, table=table, col_def=const_value, table_mask=table_mask)
 
     def _apply_multiplier(self, table: str, column: str, data: pd.Series) -> pd.Series:
         if self._multipliers is None:
@@ -421,7 +470,14 @@ class TabularConverter(BaseConverter[TabularData]):
             return data
 
     def _parse_reference(
-        self, data: TabularData, table: str, other_table: str, query_column: str, key_column: str, value_column: str
+        self,
+        data: TabularData,
+        table: str,
+        other_table: str,
+        query_column: str,
+        key_column: str,
+        value_column: str,
+        table_mask: Optional[np.ndarray],
     ) -> pd.DataFrame:
         """
         Find and extract a column from a different table.
@@ -437,15 +493,20 @@ class TabularConverter(BaseConverter[TabularData]):
         Returns:
 
         """
-        queries = self._parse_col_def_column_name(data=data, table=table, col_def=query_column)
-        keys = self._parse_col_def_column_name(data=data, table=other_table, col_def=key_column)
-        values = self._parse_col_def_column_name(data=data, table=other_table, col_def=value_column)
+        queries = self._parse_col_def_column_name(data=data, table=table, col_def=query_column, table_mask=table_mask)
+        keys = self._parse_col_def_column_name(data=data, table=other_table, col_def=key_column, table_mask=None)
+        values = self._parse_col_def_column_name(data=data, table=other_table, col_def=value_column, table_mask=None)
         other = pd.concat([keys, values], axis=1)
         result = queries.merge(other, how="left", left_on=query_column, right_on=key_column)
         return result[[value_column]]
 
     def _parse_col_def_filter(
-        self, data: TabularData, table: str, col_def: Dict[str, Any], extra_info: Optional[ExtraInfo]
+        self,
+        data: TabularData,
+        table: str,
+        col_def: Dict[str, Any],
+        table_mask: Optional[np.ndarray],
+        extra_info: Optional[ExtraInfo],
     ) -> pd.DataFrame:
         """
         Parse column filters like 'auto_id', 'reference', 'function', etc
@@ -464,6 +525,7 @@ class TabularConverter(BaseConverter[TabularData]):
                 col_data = self._parse_auto_id(
                     data=data,
                     table=table,
+                    table_mask=table_mask,
                     ref_table=sub_def.get("table"),
                     ref_name=sub_def.get("name"),
                     key_col_def=sub_def["key"],
@@ -481,15 +543,20 @@ class TabularConverter(BaseConverter[TabularData]):
                 return self._parse_reference(
                     data=data,
                     table=table,
+                    table_mask=table_mask,
                     other_table=sub_def["other_table"],
                     query_column=sub_def["query_column"],
                     key_column=sub_def["key_column"],
                     value_column=sub_def["value_column"],
                 )
             elif isinstance(sub_def, list):
-                col_data = self._parse_pandas_function(data=data, table=table, fn_name=name, col_def=sub_def)
+                col_data = self._parse_pandas_function(
+                    data=data, table=table, table_mask=table_mask, fn_name=name, col_def=sub_def
+                )
             elif isinstance(sub_def, dict):
-                col_data = self._parse_function(data=data, table=table, function=name, col_def=sub_def)
+                col_data = self._parse_function(
+                    data=data, table=table, table_mask=table_mask, function=name, col_def=sub_def
+                )
             else:
                 raise TypeError(f"Invalid {name} definition: {sub_def}")
             data_frames.append(col_data)
@@ -502,6 +569,7 @@ class TabularConverter(BaseConverter[TabularData]):
         ref_table: Optional[str],
         ref_name: Optional[str],
         key_col_def: Union[str, List[str], Dict[str, str]],
+        table_mask: Optional[np.ndarray],
         extra_info: Optional[ExtraInfo],
     ) -> pd.DataFrame:
         """
@@ -535,7 +603,9 @@ class TabularConverter(BaseConverter[TabularData]):
         else:
             raise TypeError(f"Invalid key definition type '{type(key_col_def).__name__}': {key_col_def}")
 
-        col_data = self._parse_col_def(data=data, table=table, col_def=key_col_def, extra_info=None)
+        col_data = self._parse_col_def(
+            data=data, table=table, table_mask=table_mask, col_def=key_col_def, extra_info=None
+        )
 
         def auto_id(row: np.ndarray):
             key = dict(zip(key_names, row))
@@ -558,7 +628,9 @@ class TabularConverter(BaseConverter[TabularData]):
 
         return col_data.apply(auto_id, axis=1, raw=True)
 
-    def _parse_pandas_function(self, data: TabularData, table: str, fn_name: str, col_def: List[Any]) -> pd.DataFrame:
+    def _parse_pandas_function(
+        self, data: TabularData, table: str, fn_name: str, col_def: List[Any], table_mask: Optional[np.ndarray]
+    ) -> pd.DataFrame:
         """Special vectorized functions.
 
         Args:
@@ -576,7 +648,7 @@ class TabularConverter(BaseConverter[TabularData]):
         if fn_name == "multiply":
             fn_name = "prod"
 
-        col_data = self._parse_col_def(data=data, table=table, col_def=col_def, extra_info=None)
+        col_data = self._parse_col_def(data=data, table=table, col_def=col_def, table_mask=table_mask, extra_info=None)
 
         try:
             fn_ptr = getattr(col_data, fn_name)
@@ -599,7 +671,9 @@ class TabularConverter(BaseConverter[TabularData]):
 
         return pd.DataFrame(fn_ptr(axis=1))
 
-    def _parse_function(self, data: TabularData, table: str, function: str, col_def: Dict[str, Any]) -> pd.DataFrame:
+    def _parse_function(
+        self, data: TabularData, table: str, function: str, col_def: Dict[str, Any], table_mask: Optional[np.ndarray]
+    ) -> pd.DataFrame:
         """Import the function by name and apply it to each row.
 
         Args:
@@ -616,7 +690,7 @@ class TabularConverter(BaseConverter[TabularData]):
         fn_ptr = get_function(function)
         key_words = list(col_def.keys())
         sub_def = list(col_def.values())
-        col_data = self._parse_col_def(data=data, table=table, col_def=sub_def, extra_info=None)
+        col_data = self._parse_col_def(data=data, table=table, col_def=sub_def, table_mask=table_mask, extra_info=None)
 
         if col_data.empty:
             raise ValueError(f"Cannot apply function {function} to an empty DataFrame")
@@ -624,7 +698,9 @@ class TabularConverter(BaseConverter[TabularData]):
         col_data = col_data.apply(lambda row, fn=fn_ptr: fn(**dict(zip(key_words, row))), axis=1, raw=True)
         return pd.DataFrame(col_data)
 
-    def _parse_col_def_composite(self, data: TabularData, table: str, col_def: list) -> pd.DataFrame:
+    def _parse_col_def_composite(
+        self, data: TabularData, table: str, col_def: list, table_mask: Optional[np.ndarray]
+    ) -> pd.DataFrame:
         """Select multiple columns (each is created from a column definition) and return them as a new DataFrame.
 
         Args:
@@ -636,7 +712,10 @@ class TabularConverter(BaseConverter[TabularData]):
 
         """
         assert isinstance(col_def, list)
-        columns = [self._parse_col_def(data=data, table=table, col_def=sub_def, extra_info=None) for sub_def in col_def]
+        columns = [
+            self._parse_col_def(data=data, table=table, col_def=sub_def, table_mask=table_mask, extra_info=None)
+            for sub_def in col_def
+        ]
         return pd.concat(columns, axis=1)
 
     def _get_id(self, table: str, key: Mapping[str, int], name: Optional[str]) -> int:

power_grid_model_io/functions/filters.py

@@ -0,0 +1,40 @@
+# SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+"""
+These functions can be used in the mapping files to apply filter functions to vision data
+"""
+
+from typing import List, Union
+
+import pandas as pd
+
+from power_grid_model_io.functions import has_value
+
+
+def exclude_empty(row: pd.Series, col: str) -> bool:
+    """
+    filter out empty
+    """
+    result = has_value(row[col])
+    if isinstance(result, pd.Series):
+        return result.item()
+    return result
+
+
+def exclude_value(row: pd.Series, col: str, value: Union[float, str]) -> bool:
+    """
+    filter out by match value
+    """
+    result = row[col] != value
+    if isinstance(result, pd.Series):
+        return result.item()
+    return result
+
+
+def exclude_all_columns_empty_or_zero(row: pd.Series, cols: List[str]) -> bool:
+    """
+    filter out empty or zero values in multiple columns.
+    This is same as not all(not exclude_value or not exclude_empty)
+    """
+    return any(exclude_value(row, col, 0) and exclude_empty(row, col) for col in cols)

{power_grid_model_io-1.2.85.dist-info → power_grid_model_io-1.2.87.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: power-grid-model-io
-Version: 1.2.85
+Version: 1.2.87
 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.85.dist-info → power_grid_model_io-1.2.87.dist-info}/RECORD

@@ -3,14 +3,14 @@ power_grid_model_io/config/__init__.py,sha256=qwbj1j-Aa_yRB-E3j35pEVtF3mgH8CVIXA
 power_grid_model_io/config/examples/__init__.py,sha256=qwbj1j-Aa_yRB-E3j35pEVtF3mgH8CVIXAnog5mOry0,138
 power_grid_model_io/config/examples/multipliers.yaml,sha256=UjsxWmxqLrTLGE0GI--9fKDqTkn3jY8n5KSYlwzh2o4,227
 power_grid_model_io/config/excel/__init__.py,sha256=qwbj1j-Aa_yRB-E3j35pEVtF3mgH8CVIXAnog5mOry0,138
-power_grid_model_io/config/excel/vision_en.yaml,sha256=a6BtSeMzGumsUSoDqzZHyx2cpv0P0X32c9FrsD1Y_nE,19018
-power_grid_model_io/config/excel/vision_en_9_7.yaml,sha256=SM7FAN1GTqYi5gT53VcoAzt4dUTtVV23ajb13TwD5p8,19033
-power_grid_model_io/config/excel/vision_nl.yaml,sha256=ps-vKUvYcIev7fxx5rIQqHe1ukP_WjHZvqF3AcLswd8,19226
+power_grid_model_io/config/excel/vision_en.yaml,sha256=1EHPFqle3mpiPL8NZ-tQvi8YYww-8lylxwANpB2CPJk,19507
+power_grid_model_io/config/excel/vision_en_9_7.yaml,sha256=mmLteTc-IcGIetrxz7W10tQF3YmNM2IojRYdsKN73co,19520
+power_grid_model_io/config/excel/vision_nl.yaml,sha256=BZvpt78tst7S7UG3C-AcGA4XrZjmtDgcVy8RTCBMP6M,19721
 power_grid_model_io/converters/__init__.py,sha256=kmbjFW6kVr30fmHb6mAoD7DQAqmbrsOuF1ewd8b0Q3M,408
 power_grid_model_io/converters/base_converter.py,sha256=TICEXyG7PtimAUvhAmpSoZUqwa0shiDdwbWpiM2Ur7o,6048
 power_grid_model_io/converters/pandapower_converter.py,sha256=6gY-mvbVLlKKBxGOM1024pekCtmMeGUxQunN19nYHio,113935
 power_grid_model_io/converters/pgm_json_converter.py,sha256=uqsDGhf4hilzUQdQXZEfOYXWJnUpMQqTNHXnWQUY-So,13158
-power_grid_model_io/converters/tabular_converter.py,sha256=_nTfAg88nxuHGqzYZRv0V8ZqUsQW8oKA4GwD15XTkXY,30760
+power_grid_model_io/converters/tabular_converter.py,sha256=eaBIqI2HOb5uwR1eVYDji5exNRd7aRFL0r38vEZIEzg,33398
 power_grid_model_io/converters/vision_excel_converter.py,sha256=PSvbA5jKO-w7R7KIEstvx2pBjTgULoFU7SBG8MkAmSo,4129
 power_grid_model_io/data_stores/__init__.py,sha256=qwbj1j-Aa_yRB-E3j35pEVtF3mgH8CVIXAnog5mOry0,138
 power_grid_model_io/data_stores/base_data_store.py,sha256=DJfLtRwvx_tXKnpjtBdfbMqPjWc324Eo5WeKTXjWXqc,1706
@@ -23,6 +23,7 @@ power_grid_model_io/data_types/_data_types.py,sha256=9xH5vBGrRVUSlPh4HXmORtKo3LF
 power_grid_model_io/data_types/tabular_data.py,sha256=sV6S4kqCEuQiNZTOdKS7CiA2M8Ny1oGXvtFoN-xkYBg,8582
 power_grid_model_io/functions/__init__.py,sha256=pamhvKX5c_5fkVMRrUp6zhHWex2R63otRJk1Sfsw6y0,495
 power_grid_model_io/functions/_functions.py,sha256=tqwwZ0G8AeDza0IiS6CSMwKB0lV1hDo2D8e9-ARHXQM,2843
+power_grid_model_io/functions/filters.py,sha256=ZkUD6VaTrWLxsVqOvsUNXMzPtpTLKrsH9NdX2F_JxVU,1105
 power_grid_model_io/functions/phase_to_phase.py,sha256=zbaDXIj8S4cLO42LjkpcQoUrEW1frzBUj1OmKu-xkTg,4459
 power_grid_model_io/mappings/__init__.py,sha256=qwbj1j-Aa_yRB-E3j35pEVtF3mgH8CVIXAnog5mOry0,138
 power_grid_model_io/mappings/field_mapping.py,sha256=YfrwKolNG06kIC1sbUYnYmxuOrbNbNo1dYtnF8rNItw,1659
@@ -39,8 +40,8 @@ power_grid_model_io/utils/modules.py,sha256=a4IdozSL-sOZcmIQON_aQS7-cpnCyt-3p7zs
 power_grid_model_io/utils/parsing.py,sha256=XB1QSHnslIieFJBKFXZCtiydqpOqQBiX_CXDbItXgAQ,4522
 power_grid_model_io/utils/uuid_excel_cvtr.py,sha256=H1iWhW_nluJBUJ3hK-Gc0xJjGnH5e35WrBz_fA3YXZs,7626
 power_grid_model_io/utils/zip.py,sha256=VXHX4xWPPZbhOlZUAbMDy3MgQFzK6_l7sRvGXihNUY4,3875
-power_grid_model_io-1.2.85.dist-info/LICENSE,sha256=7Pm2fWFFHHUG5lDHed1vl5CjzxObIXQglnYsEdtjo_k,14907
-power_grid_model_io-1.2.85.dist-info/METADATA,sha256=Z6P-K7J1T-aivXn8g9YQBN6P9b77cACfmnbF98AOFrI,8041
-power_grid_model_io-1.2.85.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-power_grid_model_io-1.2.85.dist-info/top_level.txt,sha256=7sq9VveemMm2R0RgTBa4tH8y_xF4_1hxbufmX9OjCTo,20
-power_grid_model_io-1.2.85.dist-info/RECORD,,
+power_grid_model_io-1.2.87.dist-info/LICENSE,sha256=7Pm2fWFFHHUG5lDHed1vl5CjzxObIXQglnYsEdtjo_k,14907
+power_grid_model_io-1.2.87.dist-info/METADATA,sha256=RHNOY4JKrEpEtX6hiq-uEjlkJQE27tePkidA3Oqo2wI,8041
+power_grid_model_io-1.2.87.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
+power_grid_model_io-1.2.87.dist-info/top_level.txt,sha256=7sq9VveemMm2R0RgTBa4tH8y_xF4_1hxbufmX9OjCTo,20
+power_grid_model_io-1.2.87.dist-info/RECORD,,

{power_grid_model_io-1.2.85.dist-info → power_grid_model_io-1.2.87.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (70.1.1)
 Root-Is-Purelib: true
 Tag: py3-none-any