power-grid-model 1.12.69__py3-none-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl

power_grid_model/validation/utils.py

@@ -0,0 +1,313 @@
+# SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+#
+# SPDX-License-Identifier: MPL-2.0
+
+"""
+Utilities used for validation. Only errors_to_string() is intended for end users.
+"""
+
+import re
+from typing import Any, cast
+
+import numpy as np
+
+from power_grid_model._core.dataset_definitions import ComponentType, DatasetType
+from power_grid_model._core.power_grid_meta import power_grid_meta_data
+from power_grid_model.data_types import SingleArray, SingleComponentData, SingleDataset
+from power_grid_model.validation.errors import ValidationError
+
+
+def _eval_expression(data: np.ndarray, expression: int | float | str) -> np.ndarray:
+    """
+    Wrapper function that checks the type of the 'expression'. If the expression is a string, it is assumed to be a
+    field expression and the expression is validated. Otherwise it is assumed to be a numerical value and the value
+    is casted to a numpy 'array'.
+
+    Args:
+        data: A numpy structured array
+        expression: A numerical value, or a string, representing a (combination of) field(s)
+
+    Returns: The number or an evaluation of the field name(s) in the data, always represented as a Numpy 'array'.
+
+    Examples:
+        123 -> np.array(123)
+        123.4 -> np.array(123.4)
+        'value' -> data['value']
+        'foo/bar' -> data['foo'] / data[bar]
+
+    """
+    if isinstance(expression, str):
+        return _eval_field_expression(data, expression)
+    return np.array(expression)
+
+
+def _eval_field_expression(data: np.ndarray, expression: str) -> np.ndarray:
+    """
+    A field expression can either be the name of a field (e.g. 'field_x') in the data, or a ratio between two fields
+    (e.g. 'field_x / field_y'). The expression is checked on validity and then the fields are checked to be present in
+    the data. If the expression is a single field name, the field is returned. If it is a ratio, the ratio is
+    calculated and returned. Values divided by 0 will result in nan values without warning.
+
+    Args:
+        data: A numpy structured array
+        expression: A string, representing a (combination of) field(s)
+
+    Expression should be a combination of:
+      - field names (may contain lower case letters, numbers and underscores)
+      - a single mathematical operator /
+
+    Returns: An evaluation of the field name(s) in the data.
+
+    Examples:
+        'value' -> data['value']
+        'foo/bar' -> data['foo'] / data['bar']
+
+    """
+    # Validate the expression
+    match = re.fullmatch(r"[a-z][a-z0-9_]*(\s*/\s*[a-z][a-z0-9_]*)?", expression)
+    if not match:
+        raise ValueError(f"Invalid field expression '{expression}'")
+
+    if data.dtype.names is None:
+        raise ValueError("No attributes available in meta")
+
+    # Find all field names and check if they exist in the dataset
+    fields = [f.strip() for f in expression.split("/")]
+    for field in fields:
+        if field not in data.dtype.names:
+            raise KeyError(f"Invalid field name {field}")
+
+    if len(fields) == 1:
+        return data[fields[0]]
+
+    max_num_fields = 2
+    if len(fields) != max_num_fields:
+        raise ValueError(f"There should be exactly {max_num_fields} fields, got {len(fields)} fields")
+    zero_div = np.logical_or(np.equal(data[fields[1]], 0.0), np.logical_not(np.isfinite(data[fields[1]])))
+    if np.any(zero_div):
+        result = np.full_like(data[fields[0]], np.nan)
+        np.true_divide(data[fields[0]], data[fields[1]], out=result, where=~zero_div)
+        return result
+    return np.true_divide(data[fields[0]], data[fields[1]])
+
+
+def _update_input_data(input_data: SingleDataset, update_data: SingleDataset):
+    """
+    Update the input data using the available non-nan values in the update data.
+    """
+
+    merged_data = {component: array.copy() for component, array in input_data.items()}
+    for component in update_data:
+        _update_component_data(component, merged_data[component], update_data[component])
+    return merged_data
+
+
+def _update_component_data(
+    component: ComponentType, input_data: SingleComponentData, update_data: SingleComponentData
+) -> None:
+    """
+    Update the data in a single component data set, with another single component data set,
+    indexed on the "id" field and only non-NaN values are overwritten.
+    """
+    if isinstance(input_data, np.ndarray) and isinstance(update_data, np.ndarray):
+        return _update_component_array_data(component=component, input_data=input_data, update_data=update_data)
+
+    raise NotImplementedError  # TODO(mgovers): add support for columnar data
+
+
+def _update_component_array_data(component: ComponentType, input_data: SingleArray, update_data: SingleArray) -> None:
+    """
+    Update the data in a numpy array, with another numpy array,
+    indexed on the "id" field and only non-NaN values are overwritten.
+    """
+    batch_dataset_ndim = 2
+    if update_data.dtype.names is None:
+        raise ValueError("Invalid data format")
+
+    optional_ids_active = (
+        "id" in update_data.dtype.names
+        and np.all(update_data["id"] == np.iinfo(update_data["id"].dtype).min)
+        and len(update_data["id"]) == len(input_data["id"])
+    )
+    update_data_ids = input_data["id"] if optional_ids_active else update_data["id"]
+
+    for field in update_data.dtype.names:
+        if field == "id":
+            continue
+        nan = _nan_type(component, field, DatasetType.update)
+        mask = ~np.isnan(update_data[field]) if np.isnan(nan) else np.not_equal(update_data[field], nan)
+
+        if mask.ndim == batch_dataset_ndim:
+            for phase in range(mask.shape[1]):
+                # find indexers of to-be-updated object
+                sub_mask = mask[:, phase]
+                idx = _get_indexer(input_data["id"], update_data_ids[sub_mask])
+                # update
+                input_data[field][idx, phase] = update_data[field][sub_mask, phase]
+        else:
+            # find indexers of to-be-updated object
+            idx = _get_indexer(input_data["id"], update_data_ids[mask])
+            # update
+            input_data[field][idx] = update_data[field][mask]
+
+
+def errors_to_string(
+    errors: list[ValidationError] | dict[int, list[ValidationError]] | None,
+    name: str = "the data",
+    details: bool = False,
+    id_lookup: list[str] | dict[int, str] | None = None,
+) -> str:
+    """
+    Convert a set of errors (list or dict) to a human readable string representation.
+
+    Args:
+        errors: The error objects. List for input_data only, dict for batch data.
+        name: Human understandable name of the dataset, e.g. input_data, or update_data.
+        details: Display object ids and error specific information.
+        id_lookup: A list or dict (int->str) containing textual object ids
+
+    Returns:
+        A human readable string representation of a set of errors.
+    """
+    if errors is None or len(errors) == 0:
+        return f"{name}: OK"
+    if isinstance(errors, dict):
+        return "\n".join(errors_to_string(err, f"{name}, batch #{i}", details) for i, err in sorted(errors.items()))
+    if len(errors) == 1 and not details:
+        return f"There is a validation error in {name}:\n\t{errors[0]}"
+    if len(errors) == 1:
+        msg = f"There is a validation error in {name}:\n"
+    else:
+        msg = f"There are {len(errors)} validation errors in {name}:\n"
+    if details:
+        for error in errors:
+            msg += "\n\t" + str(error) + "\n"
+            msg += "".join(f"\t\t{k}: {v}\n" for k, v in error.get_context(id_lookup).items())
+    else:
+        msg += "\n".join(f"{i + 1:>4}. {err}" for i, err in enumerate(errors))
+    return msg
+
+
+def _nan_type(component: ComponentType, field: str, data_type: DatasetType = DatasetType.input):
+    """Helper function to retrieve the nan value for a certain field as defined in the power_grid_meta_data."""
+    return power_grid_meta_data[data_type][component].nans[field]
+
+
+def _get_indexer(source: np.ndarray, target: np.ndarray, default_value: int | None = None) -> np.ndarray:
+    """
+    Given array of values from a source and a target dataset.
+    Find the position of each value in the target dataset in the context of the source dataset.
+    This is needed to update values in the dataset by id lookup.
+    Internally this is done by sorting the input ids, then using binary search lookup.
+
+    E.g.: Find the position of each id in an update (target) dataset in the input (source) dataset
+
+    >>> input_ids = [1, 2, 3, 4, 5]
+    >>> update_ids = [3]
+    >>> assert _get_indexer(input_ids, update_ids) == np.array([2])
+
+    Args:
+        source: array of values in the source dataset
+        target: array of values in the target dataset
+        default_value (optional): the default index to provide for target values not in source
+
+    Returns:
+        np.ndarray: array of positions of the values from target dataset in the source dataset
+            if default_value is None, (source[result] == target)
+            else, ((source[result] == target) | (source[result] == default_value))
+
+    Raises:
+        IndexError: if default_value is None and there were values in target that were not in source
+    """
+
+    permutation_sort = np.argsort(source)  # complexity O(N_input * logN_input)
+    indices = np.searchsorted(source, target, sorter=permutation_sort)  # complexity O(N_update * logN_input)
+
+    if default_value is None:
+        return permutation_sort[indices]
+
+    if len(source) == 0:
+        return np.full_like(target, fill_value=default_value)
+
+    clipped_indices = np.take(permutation_sort, indices, mode="clip")
+    return np.where(source[clipped_indices] == target, permutation_sort[clipped_indices], default_value)
+
+
+def _set_default_value(
+    data: SingleDataset, component: ComponentType, field: str, default_value: int | float | np.ndarray
+):
+    """
+    This function sets the default value in the data that is to be validated, so the default values are included in the
+    validation.
+
+    Args:
+        data: The input/update data set for all components
+        component: The component of interest
+        field: The field of interest
+        default_value: Some values are not required, but will receive a default value in the C++ core. To do a proper
+        input validation, these default values should be included in the validation. It can be a fixed value for the
+        entire column (int/float) or be different for each element (np.ndarray).
+
+    Returns:
+
+    """
+    if np.isnan(_nan_type(component, field)):
+        mask = np.isnan(data[component][field])
+    else:
+        mask = data[component][field] == _nan_type(component, field)
+    if isinstance(default_value, np.ndarray):
+        data[component][field][mask] = default_value[mask]
+    else:
+        data[component][field][mask] = default_value
+
+
+def _get_valid_ids(data: SingleDataset, ref_components: ComponentType | list[ComponentType]) -> list[int]:
+    """
+    This function returns the valid IDs specified by all ref_components.
+
+    Args:
+        data: The input/update data set for all components
+        ref_components: The component or components in which we want to look for ids
+
+    Returns:
+        list[int]: the list of valid IDs
+    """
+    # For convenience, ref_component may be a string and we'll convert it to a 'list' containing that string as it's
+    # single element.
+    if isinstance(ref_components, (str, ComponentType)):
+        ref_components = cast(list[ComponentType], [ref_components])
+
+    # Create a set of ids by chaining the ids of all ref_components
+    valid_ids = set()
+    for ref_component in ref_components:
+        if ref_component in data:
+            nan = _nan_type(ref_component, "id")
+            if np.isnan(nan):
+                mask = ~np.isnan(data[ref_component]["id"])
+            else:
+                mask = np.not_equal(data[ref_component]["id"], nan)
+            valid_ids.update(data[ref_component]["id"][mask])
+
+    return list(valid_ids)
+
+
+def _get_mask(data: SingleDataset, component: ComponentType, field: str, **filters: Any) -> np.ndarray:
+    """
+    Get a mask based on the specified filters. E.g. measured_terminal_type=MeasuredTerminalType.source.
+
+    Args:
+        data: The input/update data set for all components
+        component: The component of interest
+        field: The field of interest
+        ref_components: The component or components in which we want to look for ids
+        **filters: One or more filters on the dataset. E.
+
+    Returns:
+        np.ndarray: the mask
+    """
+    values = data[component][field]
+    mask = np.ones(shape=values.shape, dtype=bool)
+    for filter_field, filter_value in filters.items():
+        mask = np.logical_and(mask, data[component][filter_field] == filter_value)
+
+    return mask

power_grid_model-1.12.69.dist-info/METADATA

@@ -0,0 +1,178 @@
+Metadata-Version: 2.4
+Name: power-grid-model
+Version: 1.12.69
+Summary: Python/C++ library for distribution power system analysis
+Author-Email: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+License-Expression: MPL-2.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: C++
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Topic :: Scientific/Engineering :: Physics
+Project-URL: Home-page, https://lfenergy.org/projects/power-grid-model/
+Project-URL: GitHub, https://github.com/PowerGridModel/power-grid-model
+Project-URL: Documentation, https://power-grid-model.readthedocs.io/en/stable/
+Project-URL: Mailing-list, https://lists.lfenergy.org/g/powergridmodel
+Project-URL: Discussion, https://github.com/orgs/PowerGridModel/discussions
+Requires-Python: >=3.11
+Requires-Dist: numpy>=2.0.0
+Provides-Extra: dev
+Requires-Dist: msgpack; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Provides-Extra: doc
+Requires-Dist: sphinx; extra == "doc"
+Requires-Dist: breathe; extra == "doc"
+Requires-Dist: myst_nb; extra == "doc"
+Requires-Dist: sphinx_rtd_theme; extra == "doc"
+Requires-Dist: readthedocs-sphinx-search; extra == "doc"
+Requires-Dist: sphinx-hoverxref; extra == "doc"
+Requires-Dist: sphinxcontrib-mermaid>=1.0.0; extra == "doc"
+Requires-Dist: sphinxcontrib-tikz; extra == "doc"
+Requires-Dist: numpydoc; extra == "doc"
+Requires-Dist: pandas; extra == "doc"
+Requires-Dist: gitpython; extra == "doc"
+Requires-Dist: pylint; extra == "doc"
+Description-Content-Type: text/markdown
+
+<!--
+SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+
+SPDX-License-Identifier: MPL-2.0
+-->
+
+[![PyPI version](https://badge.fury.io/py/power-grid-model.svg?no-cache)](https://badge.fury.io/py/power-grid-model) <!-- markdownlint-disable-line first-line-h1 line-length -->
+[![Anaconda-Server Badge](https://anaconda.org/conda-forge/power-grid-model/badges/version.svg?no-cache)](https://anaconda.org/conda-forge/power-grid-model)
+[![License: MPL2.0](https://img.shields.io/badge/License-MPL2.0-informational.svg)](https://github.com/PowerGridModel/power-grid-model/blob/main/LICENSE)
+[![Downloads](https://static.pepy.tech/badge/power-grid-model)](https://pepy.tech/project/power-grid-model)
+[![Downloads](https://static.pepy.tech/badge/power-grid-model/month)](https://pepy.tech/project/power-grid-model)
+
+[![CI Build](https://github.com/PowerGridModel/power-grid-model/actions/workflows/ci.yml/badge.svg)](https://github.com/PowerGridModel/power-grid-model/actions/workflows/ci.yml)
+[![docs](https://readthedocs.org/projects/power-grid-model/badge/)](https://power-grid-model.readthedocs.io/en/stable/)
+
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=PowerGridModel_power-grid-model&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=PowerGridModel_power-grid-model)
+[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=PowerGridModel_power-grid-model&metric=coverage)](https://sonarcloud.io/summary/new_code?id=PowerGridModel_power-grid-model)
+[![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=PowerGridModel_power-grid-model&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=PowerGridModel_power-grid-model)
+[![Reliability Rating](https://sonarcloud.io/api/project_badges/measure?project=PowerGridModel_power-grid-model&metric=reliability_rating)](https://sonarcloud.io/summary/new_code?id=PowerGridModel_power-grid-model)
+[![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=PowerGridModel_power-grid-model&metric=security_rating)](https://sonarcloud.io/summary/new_code?id=PowerGridModel_power-grid-model)
+[![Vulnerabilities](https://sonarcloud.io/api/project_badges/measure?project=PowerGridModel_power-grid-model&metric=vulnerabilities)](https://sonarcloud.io/summary/new_code?id=PowerGridModel_power-grid-model)
+
+[![Nightly build](https://github.com/PowerGridModel/power-grid-model/actions/workflows/nightly.yml/badge.svg)](https://github.com/PowerGridModel/power-grid-model/actions/workflows/nightly.yml)
+
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.8054429.svg)](https://zenodo.org/record/8054429)
+
+[![Power Grid Model logo](https://github.com/PowerGridModel/.github/blob/main/artwork/svg/color.svg)](#) <!-- markdownlint-disable-line no-empty-links line-length -->
+
+# Power Grid Model
+
+`power-grid-model` is a library for steady-state distribution power system analysis distributed for Python and C.
+The core of the library is written in C++.
+Currently, it supports the following calculations:
+
+* Power Flow
+* State Estimation
+* Short Circuit
+
+See the [power-grid-model documentation](https://power-grid-model.readthedocs.io/en/stable/) for more information.
+For various conversions to the power-grid-model, refer to the
+[power-grid-model-io](https://github.com/PowerGridModel/power-grid-model-io) repository.
+For an extended python interface to the the power-grid-model, refer to the
+[power-grid-model-ds](https://github.com/PowerGridModel/power-grid-model-ds) repository.
+
+```{note}
+Want to be updated on the latest news and releases? Subscribe to the Power Grid Model mailing list by sending an (empty)
+email to: powergridmodel+subscribe@lists.lfenergy.org
+```
+
+## Installation
+
+### Install from PyPI
+
+You can directly install the package from PyPI.
+
+```sh
+pip install power-grid-model
+```
+
+### Install from Conda
+
+If you are using `conda`, you can directly install the package from `conda-forge` channel.
+
+```sh
+conda install -c conda-forge power-grid-model
+```
+
+### Build and install from Source
+
+To install the library from source, refer to the
+[Build Guide](https://power-grid-model.readthedocs.io/en/stable/advanced_documentation/build-guide.html).
+
+## Examples
+
+Please refer to [Examples](https://github.com/PowerGridModel/power-grid-model-workshop/tree/main/examples) for more
+detailed examples for power flow and state estimation.
+Notebooks for validating the input data and exporting input/output data are also included.
+
+## License
+
+This project is licensed under the Mozilla Public License, version 2.0 - see
+[LICENSE](https://github.com/PowerGridModel/power-grid-model/blob/main/LICENSE) for details.
+
+## Licenses third-party libraries
+
+This project includes third-party libraries,
+which are licensed under their own respective Open-Source licenses.
+SPDX-License-Identifier headers are used to show which license is applicable.
+The concerning license files can be found in the
+[LICENSES](https://github.com/PowerGridModel/power-grid-model/tree/main/LICENSES) directory.
+
+## Contributing
+
+Please read [CODE_OF_CONDUCT](https://github.com/PowerGridModel/.github/blob/main/CODE_OF_CONDUCT.md),
+[CONTRIBUTING](https://github.com/PowerGridModel/.github/blob/main/CONTRIBUTING.md),
+[PROJECT GOVERNANCE](https://github.com/PowerGridModel/.github/blob/main/GOVERNANCE.md) and
+[RELEASE](https://github.com/PowerGridModel/.github/blob/main/RELEASE.md) for details on the process for submitting pull
+requests to us.
+
+Visit [Contribute](https://github.com/PowerGridModel/power-grid-model/contribute) for a list of good first issues in
+this repo.
+
+## Citations
+
+If you are using Power Grid Model in your research work, please consider citing our library using the following
+references.
+
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.8054429.svg)](https://zenodo.org/record/8054429)
+
+```bibtex
+@software{Xiang_PowerGridModel_power-grid-model,
+  author = {Xiang, Yu and Salemink, Peter and van Westering, Werner and Bharambe, Nitish and Govers, Martinus G.H. and van den Bogaard, Jonas and Stoeller, Bram and Wang, Zhen and Guo, Jerry Jinfeng and Figueroa Manrique, Santiago and Jagutis, Laurynas and Wang, Chenguang and van Raalte, Marc and {Contributors to the LF Energy project Power Grid Model}},
+  doi = {10.5281/zenodo.8054429},
+  license = {MPL-2.0},
+  title = {{PowerGridModel/power-grid-model}},
+  url = {https://github.com/PowerGridModel/power-grid-model}
+}
+@inproceedings{Xiang2023,
+  author = {Xiang, Yu and Salemink, Peter and Stoeller, Bram and Bharambe, Nitish and van Westering, Werner},
+  booktitle={27th International Conference on Electricity Distribution (CIRED 2023)},
+  title={Power grid model: a high-performance distribution grid calculation library},
+  year={2023},
+  volume={2023},
+  number={},
+  pages={1089-1093},
+  keywords={},
+  doi={10.1049/icp.2023.0633}
+}
+```
+
+## Contact
+
+Please read [SUPPORT](https://github.com/PowerGridModel/.github/blob/main/SUPPORT.md) for how to connect and get into
+contact with the Power Grid Model project.

power_grid_model-1.12.69.dist-info/RECORD

@@ -0,0 +1,65 @@
+power_grid_model/__init__.py,sha256=MCR8e5waIpbrq_7mPL7PxGxkQgfJ_Qh8de8RvfGCrc0,1379
+power_grid_model/data_types.py,sha256=F-AcNx_qBtwoNvdMg8TDds8QO-l5G7ZDb_TFBu_SJao,9909
+power_grid_model/enum.py,sha256=ZF3C3maM2RGaqR42qNbNQeKjocFxvHDALdHP3Kzn6bY,701
+power_grid_model/errors.py,sha256=EYsbYk1l8t_Fc8GiPFSuI6mKbOlaJvA4Lr4gW4etSOM,951
+power_grid_model/py.typed,sha256=_vY4oOk4Z8YqiFeJ3N6UKKXdI6MBROOBRnfAOmFNI-8,133
+power_grid_model/typing.py,sha256=sKQftXz-LbKoaGn23ijLGMvUZIwhvXHfLwYPGajGCj8,1289
+power_grid_model/utils.py,sha256=Fv360Majx-UaJa8UOiJbUMxBEkdofVR--zdLCiGGH2c,17420
+power_grid_model/_core/__init__.py,sha256=qwbj1j-Aa_yRB-E3j35pEVtF3mgH8CVIXAnog5mOry0,138
+power_grid_model/_core/buffer_handling.py,sha256=nEYYE0Hif0Vm5mwIu2A7xiUMnWjX9duXV9NtZ0s68FY,15453
+power_grid_model/_core/data_handling.py,sha256=TCnoNYoLxYn0yDMN7FPp4PH3nK5wVX_q75QaujHcSyw,6930
+power_grid_model/_core/data_types.py,sha256=KCOnBpQ6X833jZw61fbAAZ7Rwd-uSQ3J-7Y268YgaMM,4739
+power_grid_model/_core/dataset_definitions.py,sha256=HytgmDLzjqt8R6VnVO0QwuM5dGPXcWehNVLJ8sWq_-k,3305
+power_grid_model/_core/enum.py,sha256=cGRC_Ua0_S6t9w8TxRpQ8OZivQc1_vH98z30ixg4oVA,4936
+power_grid_model/_core/error_handling.py,sha256=vtZ04Q3c3CC94W4aEXgA1y9-Gps5ZUN2qz295BM_jE4,8816
+power_grid_model/_core/errors.py,sha256=1votmXwlXbHEW8GL0_DKScJACLr3X7iuj4Wnc0tnT2U,3346
+power_grid_model/_core/index_integer.py,sha256=-9xutg1yIn5lpfFl1jOofAym1922Z5xDDYoO9eqvDS8,351
+power_grid_model/_core/options.py,sha256=i__QhCgk0idg-WF1jXUXae5PZ5qh1RMIgwYe8kb4fSI,1878
+power_grid_model/_core/power_grid_core.py,sha256=sE1I6DEanAifUEnAgiVLUzMdMR1CCLO3f8jl20cpR2c,17059
+power_grid_model/_core/power_grid_dataset.py,sha256=W50zKT1IyXVQYRENqoQThtEHDPttwGjM9EMdxR3wSkU,18372
+power_grid_model/_core/power_grid_meta.py,sha256=pR1pLy_jGplTCnzaZBcm8WUSbvbwejyB8U4G-AFwflU,7758
+power_grid_model/_core/power_grid_model.py,sha256=3wZj0Kp1ypXrXl0-210UHmZ0yR9EEZD30XDYDXAlW_c,40005
+power_grid_model/_core/serialization.py,sha256=aZBr9qjYiYi1jcwfDk267euMf7WSHlMvNgcDYZ5KCBA,10049
+power_grid_model/_core/typing.py,sha256=Mt1DJ62tHS3R9SQzdvM64L6Q8tvMCPQVAKGHAt8GM0U,637
+power_grid_model/_core/utils.py,sha256=n2n2NnbwiL89kxNIg7-EBHOYNR5e9a4O2ExP5uaxz7M,31171
+power_grid_model/_core/power_grid_model_c/__init__.py,sha256=qwbj1j-Aa_yRB-E3j35pEVtF3mgH8CVIXAnog5mOry0,138
+power_grid_model/_core/power_grid_model_c/get_pgm_dll_path.py,sha256=GAgIamBAMNA40KejjE9ODny6RpFQ-9MvN3kjr_xC5fc,2161
+power_grid_model/_core/power_grid_model_c/include/power_grid_model_c.h,sha256=Z6z4vSMpgvkCT-mw0ATXnANg7qSEKM6LTs8VFCLr3S0,1704
+power_grid_model/_core/power_grid_model_c/include/power_grid_model_cpp.hpp,sha256=YoXBbYoxyBiOfbbrM1kheKZaCyobVzclTP4BREYSeOQ,655
+power_grid_model/_core/power_grid_model_c/include/power_grid_model_c/basics.h,sha256=ticq5jaRFhjCMVPs2oHk9EicI5m2Vao--OuZpLaSXL8,7514
+power_grid_model/_core/power_grid_model_c/include/power_grid_model_c/buffer.h,sha256=A-ByuDfQmPCYf5HCeOHim872DiwA66ORHcw17HnptIE,4658
+power_grid_model/_core/power_grid_model_c/include/power_grid_model_c/dataset.h,sha256=yuCnInKgUEHn77htlt4Pqq2QKsthcRIUFPCWpPeaYUM,14468
+power_grid_model/_core/power_grid_model_c/include/power_grid_model_c/dataset_definitions.h,sha256=d87mYGjzDjlk5oD_5OAsHpYhjPyiFtjbG0Gu9LHDi-Y,74571
+power_grid_model/_core/power_grid_model_c/include/power_grid_model_c/handle.h,sha256=bxHBCqdewukaqKKKfCih95zbf06hDCMKf7tnxE5-jBQ,3100
+power_grid_model/_core/power_grid_model_c/include/power_grid_model_c/meta_data.h,sha256=JacYKWKTW-x8uiKtsA76pLFLmWXEkksCQa_l3eDQPWo,6064
+power_grid_model/_core/power_grid_model_c/include/power_grid_model_c/model.h,sha256=5YvpIUdMNgI0CTiEERhwpQQy6A3yreEe3bFjSI4ZNnA,5039
+power_grid_model/_core/power_grid_model_c/include/power_grid_model_c/options.h,sha256=8H9lsT8Ho3c-2gvBJx1xTvMeOALnC4493n0Pb_dLfBQ,4546
+power_grid_model/_core/power_grid_model_c/include/power_grid_model_c/serialization.h,sha256=e72XduQwRZme-HIa01FDrjf0tcY7O9N1mBtdOMxv-5U,5196
+power_grid_model/_core/power_grid_model_c/include/power_grid_model_cpp/basics.hpp,sha256=qv3ZjkNBKj9pQT0waggWjF8TcOzq4Ib0NEb0n9DRtEA,2213
+power_grid_model/_core/power_grid_model_c/include/power_grid_model_cpp/buffer.hpp,sha256=eX1wEMFM3hPbYGQiikA58pW0zo6MArm5NeLkwSF57Gg,2397
+power_grid_model/_core/power_grid_model_c/include/power_grid_model_cpp/dataset.hpp,sha256=IkJwBbkrBix-Ef0G26RxqzEUPVQ7zrm2fENh1QYdFDc,9159
+power_grid_model/_core/power_grid_model_c/include/power_grid_model_cpp/handle.hpp,sha256=D_9HSwGKqxucesOr-VsHl5m102r5sV-XJ25t3SxGb24,4059
+power_grid_model/_core/power_grid_model_c/include/power_grid_model_cpp/meta_data.hpp,sha256=amqU0GvxKifuEvi9pxg1vsJcEtXumWZF89rd8wRKugE,3252
+power_grid_model/_core/power_grid_model_c/include/power_grid_model_cpp/model.hpp,sha256=WCQX4px3Ts6v69UD98suq-TLUdaFFyAmJdN0fxV3xrQ,2228
+power_grid_model/_core/power_grid_model_c/include/power_grid_model_cpp/options.hpp,sha256=unyQ10NEUIgP_cx2jH6w9lseEFtYfn9DTwganUT2bHg,1842
+power_grid_model/_core/power_grid_model_c/include/power_grid_model_cpp/serialization.hpp,sha256=LIkQYR3EMEOVP2RzmlZjIRBxshEvju2IcWvzCu4edLM,5488
+power_grid_model/_core/power_grid_model_c/include/power_grid_model_cpp/utils.hpp,sha256=6ChIg9Oen4T3kCGkhPbPlTaVg82ujJ28OUSfXsJlWRI,2968
+power_grid_model/_core/power_grid_model_c/lib/cmake/power_grid_model/power_grid_modelConfig.cmake,sha256=9Dg_TwOMLciG7TTk1TKehfUbAErFtJlRagTeu_QC8Vg,1243
+power_grid_model/_core/power_grid_model_c/lib/cmake/power_grid_model/power_grid_modelConfigVersion.cmake,sha256=kYVm6iShodg7gwd3HjD8CqEkAEamFSM0-80hk2rmdcg,2768
+power_grid_model/_core/power_grid_model_c/lib/cmake/power_grid_model/power_grid_modelTargets-release.cmake,sha256=D8cpmXLfyYoNR2WkROODJw0iqQ8c2MZ_ckymUw9CW_g,1010
+power_grid_model/_core/power_grid_model_c/lib/cmake/power_grid_model/power_grid_modelTargets.cmake,sha256=q8v9QYCdmb_xsFXU1A_iSJv9_-euneAsmIgKBS4dBCI,6564
+power_grid_model/_core/power_grid_model_c/lib64/libpower_grid_model_c.so,sha256=UcB3F37xp7gN9AHY0rb5o1fpFW25N8WvXe5XjnZ3LTw,2563848
+power_grid_model/_core/power_grid_model_c/lib64/libpower_grid_model_c.so.1.12.69,sha256=UcB3F37xp7gN9AHY0rb5o1fpFW25N8WvXe5XjnZ3LTw,2563848
+power_grid_model/_core/power_grid_model_c/share/LICENSE,sha256=7Pm2fWFFHHUG5lDHed1vl5CjzxObIXQglnYsEdtjo_k,14907
+power_grid_model/_core/power_grid_model_c/share/README.md,sha256=X2nGLPPQW6-7ZcyMxAw98j-69z5-gFwSoUCuFFDhjlA,588
+power_grid_model/validation/__init__.py,sha256=3k2wLJS3nkEdsM17_k4-zNMHgbflLmPOnsfR34pUPpA,818
+power_grid_model/validation/_rules.py,sha256=Bj1UTtHYEec-H0SUGkiFxS13lIhOforXLAgZuSI405I,52157
+power_grid_model/validation/_validation.py,sha256=z40DDIPAf3MUEGQmwOrZYg3YYAnp_Wq4gkCEIK0pl6g,48781
+power_grid_model/validation/assertions.py,sha256=VmbiLTU04Lu5GDywKrcjNVEQcDiGxQLoUE-hlI790_Q,4102
+power_grid_model/validation/errors.py,sha256=hpXM46rNvlELJvyr3_rLOoGeJb6MLdPx-CylFuPuRF0,20453
+power_grid_model/validation/utils.py,sha256=A5ciWb8fwM6r0uzMmgz5TPtmXhr-oJeRKrCtTO4j5TM,12784
+power_grid_model-1.12.69.dist-info/METADATA,sha256=JwLQgYSoF-lALDGNcGWMdFSuOhaHPTUVS8ATSa2jjuo,9062
+power_grid_model-1.12.69.dist-info/WHEEL,sha256=O4BEFiq2MTWo7p3DyZlV4VLDSelqndzLPZAsLfQTYz0,151
+power_grid_model-1.12.69.dist-info/entry_points.txt,sha256=KgNx7mGcOVAVuwCBeP30AH5h_8UrKf0DQA9Cs5td69w,75
+power_grid_model-1.12.69.dist-info/RECORD,,
+power_grid_model-1.12.69.dist-info/licenses/LICENSE,sha256=7Pm2fWFFHHUG5lDHed1vl5CjzxObIXQglnYsEdtjo_k,14907

power_grid_model-1.12.69.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 0.11.6
+Root-Is-Purelib: false
+Tag: py3-none-manylinux_2_26_x86_64
+Tag: py3-none-manylinux_2_28_x86_64
+

power_grid_model-1.12.69.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[cmake.root]
+power_grid_model = power_grid_model._core.power_grid_model_c
+