power-grid-model-io 1.3.6__py3-none-any.whl → 1.3.7__py3-none-any.whl

power_grid_model_io/converters/pgm_json_converter.py

@@ -8,11 +8,12 @@ Power Grid Model 'Converter': Load and store power grid model data in the native
 import json
 import logging
 import warnings
+from enum import Enum
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional
 
 import numpy as np
-from power_grid_model import initialize_array
+from power_grid_model import ComponentType, DatasetType, initialize_array
 from power_grid_model.data_types import ComponentList, Dataset, SingleDataset, SinglePythonDataset
 from power_grid_model.utils import json_deserialize, json_serialize
 
@@ -44,15 +45,15 @@ class PgmJsonConverter(BaseConverter[StructuredData]):
 
     def __init__(
         self,
-        source_file: Optional[Union[Path, str]] = None,
-        destination_file: Optional[Union[Path, str]] = None,
+        source_file: Optional[Path | str] = None,
+        destination_file: Optional[Path | str] = None,
         log_level: int = logging.INFO,
     ):
         source = JsonFileStore(file_path=Path(source_file)) if source_file else None
         destination = JsonFileStore(file_path=Path(destination_file)) if destination_file else None
         super().__init__(source=source, destination=destination, log_level=log_level)
 
-    def _parse_data(self, data: StructuredData, data_type: str, extra_info: Optional[ExtraInfo]) -> Dataset:
+    def _parse_data(self, data: StructuredData, data_type: DatasetType, extra_info: Optional[ExtraInfo]) -> Dataset:
         """This function expects Structured data, which can either be a dictionary (single dataset) or a list of
         dictionaries (batch dataset). The structured dataset consists of components + attributes that exist within
         power-grid-model, but can also contain other data. If this data should be saved for later usage an extra_info
@@ -60,7 +61,8 @@ class PgmJsonConverter(BaseConverter[StructuredData]):
 
         Args:
           data: Structured data, which can either be a dictionary or a list of dictionaries
-          data_type: the data type of the dataset, i.e. "input", "update", "sym_output" or "asym_output"
+          data_type: the data type of the dataset, i.e. DatasetType.input, DatasetType.update,
+                     DatasetType.sym_output or DatasetType.asym_output
           extra_info: an optional dictionary where extra component info (that can't be specified in
         power-grid-model data) can be specified
           data: StructuredData:
@@ -69,7 +71,7 @@ class PgmJsonConverter(BaseConverter[StructuredData]):
 
         Returns:
           a dictionary containing the components as keys and their corresponding numpy arrays as values: a
-          power-grid-model "input" or "update" dataset
+          power-grid-model DatasetType.input or DatasetType.update dataset
 
         """
         self._log.debug(f"Loading PGM {data_type} data")
@@ -92,13 +94,13 @@ class PgmJsonConverter(BaseConverter[StructuredData]):
         return result
 
     def _parse_dataset(
-        self, data: SinglePythonDataset, data_type: str, extra_info: Optional[ExtraInfo]
+        self, data: SinglePythonDataset, data_type: DatasetType, extra_info: Optional[ExtraInfo]
     ) -> SingleDataset:
         """This function parses a single Python dataset and returns a power-grid-model input or update dictionary
 
         Args:
           data: a single Python dataset
-          data_type: the data type of the dataset, i.e. "input" or "update"
+          data_type: the data type of the dataset, i.e. DatasetType.input or DatasetType.update
           extra_info: an optional dictionary where extra component info (that can't be specified in
         power-grid-model data) can be specified
           data: SinglePythonDataset:
@@ -107,7 +109,7 @@ class PgmJsonConverter(BaseConverter[StructuredData]):
 
         Returns:
           a dictionary containing the components as keys and their corresponding numpy arrays as values: a
-          power-grid-model "input" or "update" dataset
+          power-grid-model DatasetType.input or DatasetType.update dataset
 
         """
         return {
@@ -119,7 +121,7 @@ class PgmJsonConverter(BaseConverter[StructuredData]):
 
     @staticmethod
     def _parse_component(
-        objects: ComponentList, component: str, data_type: str, extra_info: Optional[ExtraInfo]
+        objects: ComponentList, component: ComponentType, data_type: DatasetType, extra_info: Optional[ExtraInfo]
     ) -> np.ndarray:
         """This function generates a structured numpy array (power-grid-model native) from a structured dataset
 
@@ -127,7 +129,7 @@ class PgmJsonConverter(BaseConverter[StructuredData]):
           objects: a list with dictionaries, where each dictionary contains all attributes of a component
           component: the type of component, eg. node, line, etc. Note: it should be a valid power-grid-model
         component
-          data_type: a string specifying the data type: input/update
+          data_type: a string specifying the data type: DatasetType.input/DatasetType.update
           extra_info: an optional dictionary where extra component info (that can't be specified in
         power-grid-model data) can be specified
           objects: ComponentList:
@@ -152,13 +154,15 @@ class PgmJsonConverter(BaseConverter[StructuredData]):
                     try:
                         array[i][attribute] = value
                     except ValueError as ex:
-                        raise ValueError(f"Invalid '{attribute}' value for {component} {data_type} data: {ex}") from ex
+                        raise ValueError(
+                            f"Invalid '{attribute}' value for {component.value} {data_type.value} data: {ex}"
+                        ) from ex
 
                 # If an attribute doesn't exist, it is added to the extra_info lookup table
                 elif extra_info is not None:
                     obj_id = obj["id"]
                     if not isinstance(obj_id, int):
-                        raise ValueError(f"Invalid 'id' value for {component} {data_type} data")
+                        raise ValueError(f"Invalid 'id' value for {component.value} {data_type.value} data")
                     if obj_id not in extra_info:
                         extra_info[obj_id] = {}
                     extra_info[obj_id][attribute] = value
@@ -215,8 +219,9 @@ class PgmJsonConverter(BaseConverter[StructuredData]):
             is_sparse_batch = isinstance(array, dict) and "indptr" in array and "data" in array
             if is_batch is not None and is_batch != (is_dense_batch or is_sparse_batch):
                 raise ValueError(
-                    f"Mixed {'' if is_batch else 'non-'}batch data "
-                    f"with {'non-' if is_batch else ''}batch data ({component})."
+                    f"Mixed {'' if is_batch else 'non-'}batch data with "
+                    f"{'non-' if is_batch else ''}batch data ("
+                    f"{component.value if isinstance(component, Enum) else component})."
                 )
             is_batch = is_dense_batch or is_sparse_batch
         return bool(is_batch)

power_grid_model_io/converters/tabular_converter.py

@@ -7,13 +7,14 @@ Tabular Data Converter: Load data from multiple tables and use a mapping file to
 
 import inspect
 import logging
+from enum import Enum
 from pathlib import Path
-from typing import Any, Collection, Dict, List, Mapping, Optional, Union, cast
+from typing import Any, Collection, Dict, List, Mapping, Optional, cast
 
 import numpy as np
 import pandas as pd
 import yaml
-from power_grid_model import initialize_array
+from power_grid_model import DatasetType, initialize_array
 from power_grid_model.data_types import Dataset
 
 from power_grid_model_io.converters.base_converter import BaseConverter
@@ -89,13 +90,13 @@ class TabularConverter(BaseConverter[TabularData]):
         if "multipliers" in mapping:
             self._multipliers = MultiplierMapping(cast(Multipliers, mapping["multipliers"]), logger=self._log)
 
-    def _parse_data(self, data: TabularData, data_type: str, extra_info: Optional[ExtraInfo]) -> Dataset:
+    def _parse_data(self, data: TabularData, data_type: DatasetType, extra_info: Optional[ExtraInfo]) -> Dataset:
         """This function parses tabular data and returns power-grid-model data
 
         Args:
           data: TabularData, i.e. a dictionary with the components as keys and pd.DataFrames as values, with
         attribute names as columns and their values in the table
-          data_type: power-grid-model data type, i.e. "input" or "update"
+          data_type: power-grid-model data type, i.e. DatasetType.input or DatasetType.update
           extra_info: an optional dictionary where extra component info (that can't be specified in
         power-grid-model data) can be specified
           data: TabularData:
@@ -145,9 +146,9 @@ class TabularConverter(BaseConverter[TabularData]):
     def _convert_table_to_component(  # pylint: disable = too-many-arguments,too-many-positional-arguments
         self,
         data: TabularData,
-        data_type: str,
+        data_type: str | Enum,
         table: str,
-        component: str,
+        component: str | Enum,
         attributes: InstanceAttributes,
         extra_info: Optional[ExtraInfo],
     ) -> Optional[np.ndarray]:
@@ -157,7 +158,7 @@ class TabularConverter(BaseConverter[TabularData]):
 
         Args:
           data: The full dataset with tabular data
-          data_type: The data type, i.e. "input" or "update"
+          data_type: The data type, i.e. DatasetType.input or DatasetType.update
           table: The name of the table that should be converter
           component: the component for which a power-grid-model array should be made
           attributes: a dictionary with a mapping from the attribute names in the table to the corresponding
@@ -165,9 +166,9 @@ class TabularConverter(BaseConverter[TabularData]):
           extra_info: an optional dictionary where extra component info (that can't be specified in
         power-grid-model data) can be specified
           data: TabularData:
-          data_type: str:
+          data_type: str | Enum:
           table: str:
-          component: str:
+          component: str | Enum:
           attributes: InstanceAttributes:
           extra_info: Optional[ExtraInfo]:
 
@@ -187,13 +188,16 @@ class TabularConverter(BaseConverter[TabularData]):
 
         n_records = np.sum(table_mask) if table_mask is not None else len(data[table])
 
+        component_str = component.value if isinstance(component, Enum) else component
+        data_type_str = data_type.value if isinstance(data_type, Enum) else data_type
+
         try:
-            pgm_data = initialize_array(data_type=data_type, component_type=component, shape=n_records)
+            pgm_data = initialize_array(data_type=data_type_str, component_type=component_str, shape=n_records)
         except KeyError as ex:
-            raise KeyError(f"Invalid component type '{component}' or data type '{data_type}'") from ex
+            raise KeyError(f"Invalid component type '{component_str}' or data type '{data_type_str}'") from ex
 
         if "id" not in attributes:
-            raise KeyError(f"No mapping for the attribute 'id' for '{component}s'!")
+            raise KeyError(f"No mapping for the attribute 'id' for '{component_str}s'!")
 
         # Make sure that the "id" column is always parsed first (at least before "extra" is parsed)
         attributes_without_filter = {k: v for k, v in attributes.items() if k != "filters"}
@@ -207,7 +211,7 @@ class TabularConverter(BaseConverter[TabularData]):
                 data=data,
                 pgm_data=pgm_data,
                 table=table,
-                component=component,
+                component=component_str,
                 attr=attr,
                 col_def=col_def,
                 table_mask=table_mask,
@@ -232,7 +236,7 @@ class TabularConverter(BaseConverter[TabularData]):
         data: TabularData,
         pgm_data: np.ndarray,
         table: str,
-        component: str,
+        component: str | Enum,
         attr: str,
         col_def: Any,
         table_mask: Optional[np.ndarray],
@@ -254,7 +258,7 @@ class TabularConverter(BaseConverter[TabularData]):
           data: TabularData:
           pgm_data: np.ndarray:
           table: str:
-          component: str:
+          component: str | Enum:
           attr: str:
           col_def: Any:
           extra_info: Optional[ExtraInfo]:
@@ -265,12 +269,15 @@ 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.
+
+        component_str = component.value if isinstance(component, Enum) else component
+
         if pgm_data.dtype.names is None:
-            raise ValueError(f"pgm_data for '{component}s' has no attributes defined. (dtype.names is None)")
+            raise ValueError(f"pgm_data for '{component_str}s' has no attributes defined. (dtype.names is None)")
 
         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})")
+            raise KeyError(f"Could not find attribute '{attr}' for '{component_str}s'. (choose from: {attrs})")
 
         if attr == "extra":
             # Extra info must be linked to the object IDs, therefore the uuids should be known before extra info can
@@ -421,7 +428,7 @@ class TabularConverter(BaseConverter[TabularData]):
     def _parse_col_def_const(
         data: TabularData,
         table: str,
-        col_def: Union[int, float],
+        col_def: int | float,
         table_mask: Optional[np.ndarray] = None,
     ) -> pd.DataFrame:
         """Create a single column pandas DataFrame containing the const value.
@@ -429,8 +436,7 @@ class TabularConverter(BaseConverter[TabularData]):
         Args:
           data: TabularData:
           table: str:
-          col_def: Union[int:
-          float]:
+          col_def: int | float:
 
         Returns:
 
@@ -602,7 +608,7 @@ class TabularConverter(BaseConverter[TabularData]):
         table: str,
         ref_table: Optional[str],
         ref_name: Optional[str],
-        key_col_def: Union[str, List[str], Dict[str, str]],
+        key_col_def: str | List[str] | Dict[str, str],
         table_mask: Optional[np.ndarray],
         extra_info: Optional[ExtraInfo],
     ) -> pd.DataFrame:
@@ -845,7 +851,7 @@ class TabularConverter(BaseConverter[TabularData]):
 
         return keys.apply(get_id, axis=1).to_list()
 
-    def lookup_id(self, pgm_id: int) -> Dict[str, Union[str, Dict[str, int]]]:
+    def lookup_id(self, pgm_id: int) -> Dict[str, str | Dict[str, int]]:
         """
         Retrieve the original name / key combination of a pgm object
         Args:

power_grid_model_io/converters/vision_excel_converter.py

@@ -8,7 +8,7 @@ Vision Excel Converter: Load data from a Vision Excel export file and use a mapp
 import logging
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Mapping, Optional, Union
+from typing import Any, Mapping, Optional
 
 from power_grid_model_io.converters.tabular_converter import TabularConverter
 from power_grid_model_io.data_stores.base_data_store import LANGUAGE_EN
@@ -37,10 +37,10 @@ class VisionExcelConverter(TabularConverter):
 
     def __init__(  # pylint: disable=too-many-arguments,too-many-positional-arguments
         self,
-        source_file: Optional[Union[Path, str]] = None,
+        source_file: Optional[Path | str] = None,
         language: str = LANGUAGE_EN,
         terms_changed: Optional[dict] = None,
-        mapping_file: Optional[Union[Path, str]] = None,
+        mapping_file: Optional[Path | str] = None,
         log_level: int = logging.INFO,
     ):
         _mapping_file = Path(

power_grid_model_io/data_stores/excel_file_store.py

@@ -7,7 +7,7 @@ Excel File Store
 
 import re
 from pathlib import Path
-from typing import Dict, List, Optional, Set, Tuple, Union
+from typing import Dict, List, Optional, Set, Tuple
 
 import pandas as pd
 
@@ -185,10 +185,10 @@ class ExcelFileStore(BaseDataStore[TabularData]):
 
         return data
 
-    def _check_duplicate_values(self, sheet_name: str, data: pd.DataFrame) -> Dict[int, Union[str, Tuple[str, ...]]]:
+    def _check_duplicate_values(self, sheet_name: str, data: pd.DataFrame) -> Dict[int, str | Tuple[str, ...]]:
         grouped = self._group_columns_by_index(data=data)
 
-        to_rename: Dict[int, Union[str, Tuple[str, ...]]] = {}
+        to_rename: Dict[int, str | Tuple[str, ...]] = {}
 
         for col_name, col_idxs in grouped.items():
             # No duplicate column names
@@ -251,8 +251,8 @@ class ExcelFileStore(BaseDataStore[TabularData]):
         return data
 
     @staticmethod
-    def _group_columns_by_index(data: pd.DataFrame) -> Dict[Union[str, Tuple[str, ...]], Set[int]]:
-        grouped: Dict[Union[str, Tuple[str, ...]], Set[int]] = {}
+    def _group_columns_by_index(data: pd.DataFrame) -> Dict[str | Tuple[str, ...], Set[int]]:
+        grouped: Dict[str | Tuple[str, ...], Set[int]] = {}
         columns = data.columns.values
         for col_idx, col_name in enumerate(columns):
             if col_name[0] not in grouped:

power_grid_model_io/data_stores/json_file_store.py

@@ -105,5 +105,5 @@ class JsonFileStore(BaseDataStore[StructuredData]):
             if len(type_names) == 1:
                 type_str = type_names.pop()
             else:
-                type_str = "Union[" + ", ".join(type_names) + "]"
+                type_str = " | ".join(type_names)
             raise TypeError(f"Invalid data type for {type(self).__name__}: List[{type_str}]")

power_grid_model_io/data_types/_data_types.py

@@ -5,7 +5,7 @@
 Common data types used in the Power Grid Model project
 """
 
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List
 
 ExtraInfo = Dict[int, Any]
 """
@@ -36,7 +36,7 @@ ExtraInfoLookup = ExtraInfo
 Legacy type name; use ExtraInfo instead!
 """
 
-StructuredData = Union[Dict[str, List[Dict[str, Any]]], List[Dict[str, List[Dict[str, Any]]]]]
+StructuredData = Dict[str, List[Dict[str, Any]]] | List[Dict[str, List[Dict[str, Any]]]]
 """
 Structured data is a multi dimensional structure (component_type -> objects -> attribute -> value) or a list of those
 dictionaries:

power_grid_model_io/data_types/tabular_data.py

@@ -2,12 +2,12 @@
 #
 # SPDX-License-Identifier: MPL-2.0
 """
-The TabularData class is a wrapper around Dict[str, Union[pd.DataFrame, np.ndarray]],
+The TabularData class is a wrapper around Dict[str, pd.DataFrame | np.ndarray],
 which supports unit conversions and value substitutions
 """
 
 import logging
-from typing import Callable, Dict, Generator, Iterable, Optional, Tuple, Union
+from typing import Callable, Dict, Generator, Iterable, Optional, Tuple
 
 import numpy as np
 import pandas as pd
@@ -21,11 +21,11 @@ LazyDataFrame = Callable[[], pd.DataFrame]
 
 class TabularData:
     """
-    The TabularData class is a wrapper around Dict[str, Union[pd.DataFrame, np.ndarray]],
+    The TabularData class is a wrapper around Dict[str, pd.DataFrame | np.ndarray],
     which supports unit conversions and value substitutions
     """
 
-    def __init__(self, logger=None, **tables: Union[pd.DataFrame, np.ndarray, LazyDataFrame]):
+    def __init__(self, logger=None, **tables: pd.DataFrame | np.ndarray | LazyDataFrame):
         """
         Tabular data can either be a collection of pandas DataFrames and/or numpy structured arrays.
         The key word arguments will define the keys of the data.
@@ -48,7 +48,7 @@ class TabularData:
                     f"Invalid data type for table '{table_name}'; "
                     f"expected a pandas DataFrame or NumPy array, got {type(table_data).__name__}."
                 )
-        self._data: Dict[str, Union[pd.DataFrame, np.ndarray, LazyDataFrame]] = tables
+        self._data: Dict[str, pd.DataFrame | np.ndarray | LazyDataFrame] = tables
         self._units: Optional[UnitMapping] = None
         self._substitution: Optional[ValueMapping] = None
 
@@ -181,7 +181,7 @@ class TabularData:
         """
         return table_name in self._data
 
-    def __getitem__(self, table_name: str) -> Union[pd.DataFrame, np.ndarray]:
+    def __getitem__(self, table_name: str) -> pd.DataFrame | np.ndarray:
         """
         Mimic the dictionary [] operator. It returns the 'raw' table data as stored in memory. This can be either a
         pandas DataFrame or a numpy structured array. It is possible that some unit conversions have been applied by
@@ -206,7 +206,7 @@ class TabularData:
 
         return self._data.keys()
 
-    def items(self) -> Generator[Tuple[str, Union[pd.DataFrame, np.ndarray]], None, None]:
+    def items(self) -> Generator[Tuple[str, pd.DataFrame | np.ndarray], None, None]:
         """
         Mimic the dictionary .items() function
 

power_grid_model_io/functions/filters.py

@@ -5,7 +5,7 @@
 These functions can be used in the mapping files to apply filter functions to vision data
 """
 
-from typing import List, Union
+from typing import List
 
 import pandas as pd
 
@@ -24,7 +24,7 @@ def exclude_empty(row: pd.Series, col: str) -> bool:
     return result
 
 
-def exclude_value(row: pd.Series, col: str, value: Union[float, str]) -> bool:
+def exclude_value(row: pd.Series, col: str, value: float | str) -> bool:
     """
     filter out by match value
     """

power_grid_model_io/mappings/tabular_mapping.py

@@ -5,13 +5,13 @@
 Tabular data mapping helper class
 """
 
-from typing import Dict, Generator, List, Tuple, Union
+from typing import Dict, Generator, List, Tuple
 
 import structlog
 
-AttributeValue = Union[int, float, str, Dict, List]
+AttributeValue = int | float | str | Dict | List
 InstanceAttributes = Dict[str, AttributeValue]
-Components = Dict[str, Union[InstanceAttributes, List[InstanceAttributes]]]
+Components = Dict[str, InstanceAttributes | List[InstanceAttributes]]
 Tables = Dict[str, Components]
 
 

power_grid_model_io/mappings/value_mapping.py

@@ -5,13 +5,13 @@
 Value substitution helper class
 """
 
-from typing import Dict, Optional, Union
+from typing import Dict, Optional
 
 import structlog
 
 from power_grid_model_io.mappings.field_mapping import FieldMapping
 
-Value = Union[int, float, str, bool]
+Value = int | float | str | bool
 
 #             attr      key    value
 Values = Dict[str, Dict[Value, Value]]

power_grid_model_io/utils/auto_id.py

@@ -7,7 +7,7 @@ Automatic ID generator class
 
 import collections
 from collections.abc import Hashable
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional
 
 
 class AutoID:
@@ -94,7 +94,7 @@ class AutoID:
         # Return the numeric id
         return idx
 
-    def __contains__(self, item: Union[int, Hashable]) -> bool:
+    def __contains__(self, item: int | Hashable) -> bool:
         """
         Check if the id, or the item exists
 

power_grid_model_io/utils/download.py

@@ -29,7 +29,7 @@ import tempfile
 from dataclasses import dataclass
 from pathlib import Path
 from shutil import rmtree as remove_dir
-from typing import Optional, Union
+from typing import Optional
 from urllib import request
 
 import structlog
@@ -81,7 +81,7 @@ class DownloadProgressHook:  # pylint: disable=too-few-public-methods
 
 
 def download_and_extract(
-    url: str, dir_path: Optional[Path] = None, file_name: Optional[Union[str, Path]] = None, overwrite: bool = False
+    url: str, dir_path: Optional[Path] = None, file_name: Optional[str | Path] = None, overwrite: bool = False
 ) -> Path:
     """
     Download a file from a URL and store it locally, extract the contents and return the path to the contents.
@@ -112,7 +112,7 @@ def download_and_extract(
 
 
 def download(
-    url: str, file_name: Optional[Union[str, Path]] = None, dir_path: Optional[Path] = None, overwrite: bool = False
+    url: str, file_name: Optional[str | Path] = None, dir_path: Optional[Path] = None, overwrite: bool = False
 ) -> Path:
     """
     Download a file from a URL and store it locally
@@ -200,7 +200,7 @@ def get_response_info(url: str) -> ResponseInfo:
 
 def get_download_path(
     dir_path: Optional[Path] = None,
-    file_name: Optional[Union[str, Path]] = None,
+    file_name: Optional[str | Path] = None,
     unique_key: Optional[str] = None,
 ) -> Path:
     """

power_grid_model_io/utils/uuid_excel_cvtr.py

@@ -16,7 +16,7 @@ nieuw_bestand = convert_guid_vision_excel("vision_97_nl.xlsx", number="Nummer",
 import os
 import re
 from pathlib import Path
-from typing import Optional, Union
+from typing import Optional
 
 import pandas as pd
 
@@ -120,7 +120,7 @@ class UUID2IntCvtr:
         return self._counter
 
 
-def load_excel_file(file_name: Union[Path, str]) -> pd.ExcelFile:
+def load_excel_file(file_name: Path | str) -> pd.ExcelFile:
     """Load an excel file
 
     Args:
@@ -219,7 +219,7 @@ def save_df_to_excel(df: pd.DataFrame, file_name: str, sheet_name: str, i: int)
 
 
 def convert_guid_vision_excel(
-    excel_file: Union[Path, str],
+    excel_file: Path | str,
     number: str = VISION_EXCEL_LAN_DICT[LANGUAGE_EN][DICT_KEY_NUMBER],
     terms_changed: Optional[dict] = None,
 ) -> str:

{power_grid_model_io-1.3.6.dist-info → power_grid_model_io-1.3.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: power-grid-model-io
-Version: 1.3.6
+Version: 1.3.7
 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.3.6.dist-info → power_grid_model_io-1.3.7.dist-info}/RECORD

@@ -9,42 +9,42 @@ power_grid_model_io/config/excel/vision_en_9_7.yaml,sha256=ts_qcrO3Gd8tQwPFzGWEb
 power_grid_model_io/config/excel/vision_en_9_8.yaml,sha256=yCa4v5VUK1xCZ0PrHG2ZflpIZN-D7dNsS7PKYW8K9Ac,20938
 power_grid_model_io/config/excel/vision_nl.yaml,sha256=0IOh5Ug9QwP2dgNMsl90RARV_v-xxcA6rv8Ya0WCPuI,21426
 power_grid_model_io/converters/__init__.py,sha256=qng1-O8kfpgalPms_C_zAwBuiuKUoquf27u6JkVH-9k,487
-power_grid_model_io/converters/base_converter.py,sha256=EAtwQdj-MCi3XLm3qjKNJgXd6i3QdULaPa79jCD0vZg,6049
-power_grid_model_io/converters/pandapower_converter.py,sha256=yasj_Yibe9TsGFPT888ayWoDI0KDbMfB7kNpdpxwe0k,115806
-power_grid_model_io/converters/pgm_json_converter.py,sha256=20q4U1pZHqEbmPpktmr4ScDT1ZAxYm0u4Z7MM-pqPvc,13846
-power_grid_model_io/converters/tabular_converter.py,sha256=VqC8efgfum4GcHet_co21pfTn2HIipuDN22Qoq4Gs3s,35288
-power_grid_model_io/converters/vision_excel_converter.py,sha256=ahAhynkHp_rchDIS0xEYRj4MmcJtc5YPcQTItNXa7tI,4185
+power_grid_model_io/converters/base_converter.py,sha256=ifF-U1kmJIW9Tj9uW7d0XJlsBrmvpUZoi3WxNPAbKO4,6170
+power_grid_model_io/converters/pandapower_converter.py,sha256=ccD1zBpY2UiKealTF3f1nnwraNKeGdwNzk_cMN6RE2Y,117805
+power_grid_model_io/converters/pgm_json_converter.py,sha256=7Z1Qmoxn0qo4fkLXvmNTWNMHOJHhnyGTvxlRlcHbMLg,14210
+power_grid_model_io/converters/tabular_converter.py,sha256=XmUDVthYyJQiHXxzspVCjUo3ZGsv4XXwZ_VRQLn4bvs,35666
+power_grid_model_io/converters/vision_excel_converter.py,sha256=hiEOqXgfM3XbHDJ-ri-Os2a4Dh5lZFqF0m9_YFBaYs4,4166
 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
 power_grid_model_io/data_stores/csv_dir_store.py,sha256=H8ICXZRLDvp9OkbjkfHnoh4y7uNSXNepHAW6W53VsIw,1877
-power_grid_model_io/data_stores/excel_file_store.py,sha256=uyEwCzFzIt09QY5aI7D0ZtxBTpBhb81Yw4iOF8FMTv0,10868
-power_grid_model_io/data_stores/json_file_store.py,sha256=0njL2YZn_fImNcZqnIRpHp2UtIS6WGaQQ46TjIK8tyo,3954
+power_grid_model_io/data_stores/excel_file_store.py,sha256=W1axhUGd7l42phuPvZLU8GWyUr2SlWJEdljHD0sNYeY,10837
+power_grid_model_io/data_stores/json_file_store.py,sha256=eMEZLJa853_aUxwPmXEF4L8C_XzlB-glgxB5iE-UnUI,3938
 power_grid_model_io/data_stores/vision_excel_file_store.py,sha256=QJjT6lfqfRG4Zt8Lsm81hNwjZa5Z_6dndUfwUIyPN3Q,1060
 power_grid_model_io/data_types/__init__.py,sha256=cTHmwEVWQsjogGzMUhZ5wb79l3CaFyqa1If0_XCL65w,477
-power_grid_model_io/data_types/_data_types.py,sha256=9xH5vBGrRVUSlPh4HXmORtKo3LFEhJEy3iTQqG7wsFA,1664
-power_grid_model_io/data_types/tabular_data.py,sha256=sV6S4kqCEuQiNZTOdKS7CiA2M8Ny1oGXvtFoN-xkYBg,8582
+power_grid_model_io/data_types/_data_types.py,sha256=8kKDdYTF9BZL1BscnIEUHaz1d6B1nJipXweSqUs55RY,1651
+power_grid_model_io/data_types/tabular_data.py,sha256=3sLF3CAxwbA8GCxKf-MDMETBUakhVIZOVmaF5adIENk,8541
 power_grid_model_io/functions/__init__.py,sha256=l1PjXVh21UTlWmv3j_KvflEymTUcGNxm8BDDpt1jUYc,734
 power_grid_model_io/functions/_functions.py,sha256=tqwwZ0G8AeDza0IiS6CSMwKB0lV1hDo2D8e9-ARHXQM,2843
-power_grid_model_io/functions/filters.py,sha256=zJAGkUg8x-Ci6IJkbCwhVJuj9eKsPY-BxfjdyWMEl8A,1398
+power_grid_model_io/functions/filters.py,sha256=yF24k64r5FDFVSSgYGMpRq-JmrM6pfeTekkLeXXtnB8,1385
 power_grid_model_io/functions/phase_to_phase.py,sha256=Cufj3lcUESKa_AFHn27GsUMxjTFmF5mj0-sdFrE7V00,4495
 power_grid_model_io/mappings/__init__.py,sha256=qwbj1j-Aa_yRB-E3j35pEVtF3mgH8CVIXAnog5mOry0,138
 power_grid_model_io/mappings/field_mapping.py,sha256=YfrwKolNG06kIC1sbUYnYmxuOrbNbNo1dYtnF8rNItw,1659
 power_grid_model_io/mappings/multiplier_mapping.py,sha256=mQ112SMbuIgCZ1haMOxMtfbn2kMsaMaYSfEGv73gSGQ,910
-power_grid_model_io/mappings/tabular_mapping.py,sha256=qlD4NIU-8Ezg3jNzL3OHXJ8WQoKRMLFjaDH6mqYy-LY,1831
+power_grid_model_io/mappings/tabular_mapping.py,sha256=HH_O1wbuLmfdq-Wnbhb7-2rFq1BaMrHSs8T6aRHNwDc,1815
 power_grid_model_io/mappings/unit_mapping.py,sha256=Z6DGp5Z7f0kLbcU9oih466at1OHAGzWdYeSZF9DGpnI,2933
-power_grid_model_io/mappings/value_mapping.py,sha256=ed5fqt9RAYw_YN4yfxozVDNtyxayLV5up51CQIjoDRk,1247
+power_grid_model_io/mappings/value_mapping.py,sha256=BnO4WWFVPivnT-8FFbcv-l1R8P5OIaUA7reINK8ZOAs,1236
 power_grid_model_io/utils/__init__.py,sha256=qwbj1j-Aa_yRB-E3j35pEVtF3mgH8CVIXAnog5mOry0,138
-power_grid_model_io/utils/auto_id.py,sha256=i-furb-G7zvQVbyqQLoNT17patN45dQrxl4eXLJ-p1o,4123
+power_grid_model_io/utils/auto_id.py,sha256=eOHDAjmV-xM2RLeWVYEjVa85_dfUBIgX_dVq8SV7BMQ,4110
 power_grid_model_io/utils/dict.py,sha256=HTepnXhEnyBDfDrDm21c5DIlMEO1o5ShMSSnUGm2rDE,1015
-power_grid_model_io/utils/download.py,sha256=enEoj42ByC5j5rj_iZ1Y9we7t8Nmlwre0-9Njon-Tqg,9457
+power_grid_model_io/utils/download.py,sha256=TGExH7CRptiFGoqnhz2aJKvScJ9EzD4oDvbc1LvcIzo,9432
 power_grid_model_io/utils/excel_ambiguity_checker.py,sha256=11hkzMuJHMpTIM7uf1AH3Wcs9Q3hfjEmXORIk1IfE_s,6923
 power_grid_model_io/utils/json.py,sha256=dQDRd2Vb8pfqLU2hTuWYv2cpSIBBbFhd0LOBP21YxJI,3327
 power_grid_model_io/utils/modules.py,sha256=DJLmYKt9cV_GvqJI8wkXppNycqD4b8n5-o_87XXfQbc,929
 power_grid_model_io/utils/parsing.py,sha256=cw6d3S89BvB8dncN0SeFHDhFG7ZlDNx9iGYWjZk5fVU,4684
-power_grid_model_io/utils/uuid_excel_cvtr.py,sha256=xYAYevGDuBd-TcgqcEMJJsISg3yv3uO_9mcUd7oj1qQ,7600
+power_grid_model_io/utils/uuid_excel_cvtr.py,sha256=FFsfnvELVTkIXE_qfEPjFlphsikAr7GyjnNwsDZ-AgY,7581
 power_grid_model_io/utils/zip.py,sha256=VXHX4xWPPZbhOlZUAbMDy3MgQFzK6_l7sRvGXihNUY4,3875
-power_grid_model_io-1.3.6.dist-info/licenses/LICENSE,sha256=7Pm2fWFFHHUG5lDHed1vl5CjzxObIXQglnYsEdtjo_k,14907
-power_grid_model_io-1.3.6.dist-info/METADATA,sha256=y3wtU1iHlNjlGhGUxKz7406hXUEeGds2zH9XQRthfHQ,8195
-power_grid_model_io-1.3.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-power_grid_model_io-1.3.6.dist-info/top_level.txt,sha256=7sq9VveemMm2R0RgTBa4tH8y_xF4_1hxbufmX9OjCTo,20
-power_grid_model_io-1.3.6.dist-info/RECORD,,
+power_grid_model_io-1.3.7.dist-info/licenses/LICENSE,sha256=7Pm2fWFFHHUG5lDHed1vl5CjzxObIXQglnYsEdtjo_k,14907
+power_grid_model_io-1.3.7.dist-info/METADATA,sha256=3qhKu0mzHLs7yugF6QwwsTNP6ReWs4oZuZMbhxGy4NA,8195
+power_grid_model_io-1.3.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+power_grid_model_io-1.3.7.dist-info/top_level.txt,sha256=7sq9VveemMm2R0RgTBa4tH8y_xF4_1hxbufmX9OjCTo,20
+power_grid_model_io-1.3.7.dist-info/RECORD,,