powerio 0.6.3

Case parsing, conversion, matrices, and language bindings for power system data

PowerIO

PowerIO is compiler infrastructure for power systems. Case files from a dozen transmission and distribution formats parse into typed intermediate representations (IR). Once parsed, you can perform explicit, recorded operations, like normalization, validation, and lowering. You can compile/write the case back into any supported target format, sparse matrix families, and ML model formats.

The .pio.json document carries one model JSON object under declared schema versions, with metadata that records where the data came from and how it maps back to the original source file. It also contains structured diagnostics, validation, and replayable operating points.

Data fidelity and interoperability is the primary goal of the PowerIO project. Writing a parsed file back to its own format returns the original text when the reader kept it. Converting to another format writes the modeled electrical data and reports every field the target cannot carry in Conversion::warnings.

The core of PowerIO is written in Rust. The Rust version is used to create the Python package and the command line interface, both of which sit in this repo. The Rust implementation also enables the creation of a C ABI, which exposes PowerIO capabilities to C, C++, Julia, and other foreign function interfaces (FFIs).

Overview

PowerIO is a community infrastructure project intended to serve all developers working on electric power systems. Everyone is welcome to use, build upon, and contribute to the PowerIO infrastructure project.

Formats

Supported formats:

• MATPOWER .m
• PSS/E .raw revisions 33, 34, and 35
• PowerWorld .aux, plus read only .pwb binary cases; .pwd display files parse through the separate display API. Behavior and limits are in the format fidelity guide.
• GE PSLF .epc power flow cases
• PowerModels.jl network data JSON
• egret ModelData JSON
• pandapower pandapowerNet JSON
• PyPSA static CSV folders
• ARPA-E GO Competition Challenge 3 JSON input data
• surge .surge.json
• GridFM .parquet

Distribution networks are supported in wire coordinates via powerio-dist:

• OpenDSS .dss
• PowerModelsDistribution.jl ENGINEERING data JSON
• The (draft) BMOPF JSON spec and schema of the IEEE BMOPF task force .json

Other formats are planned; see the GitHub issues. If a format you need is missing, open an issue or a pull request. All are welcome to contribute to this community project.

Packages

This repository contains multiple packages.

powerio          # parser, Network model, source retaining writers, converters
powerio-matrix   # sparse matrices, DC sensitivity factors, graph representations
powerio-dist     # multiconductor distribution model, dss/PMD/BMOPF converters
powerio-pkg      # .pio.json document metadata and model JSON
powerio-cli      # the `powerio` command and ratatui TUI
powerio-py       # PyO3 extension for the Python `powerio` package
powerio-capi     # C ABI for C, C++, Julia, and other foreign function interfaces
PowerIO.jl       # Julia bindings over the C ABI

The core powerio Rust crate keeps parsing and conversion separate from matrix, TUI, and data frame dependencies. The Python package imports with no required third party packages; matrix and graph helpers live behind extras.

Docs site: https://powerio.dev. Language API map: languages guide.

Install

cargo add powerio
cargo add powerio-matrix
cargo install powerio-cli

pip install powerio
pip install 'powerio[all]'     # scipy, numpy, networkx, polars extras
pip install 'powerio[gridfm]'  # polars for Parquet inspection
pip install 'powerio[pandas]'  # pandas, pyarrow compatibility reads (Python 3.10+)

julia -e 'using Pkg; Pkg.add(url="https://github.com/eigenergy/PowerIO.jl")'

Use

Rust

use powerio::{TargetFormat, parse_file};

let parsed = parse_file("case14.m", None)?;
let net = parsed.network;
let conv = net.to_format(TargetFormat::PowerModelsJson)?;

for warning in &conv.warnings {
    eprintln!("conversion warning: {warning}");
}

std::fs::write("case14.json", conv.text)?;

Python

import powerio as pio

case = pio.parse_file("case9.m")
bprime = case.bprime()            # MATPOWER Bp, scipy.sparse, needs powerio[matrix]
display = pio.parse_display_file("case.pwd")
raw, warnings = pio.convert_file("case9.m", "psse")

Julia

using PowerIO

case = parse_file("case9.m")
text = to_matpower(case)
json, warnings = to_format(case, "powermodels-json")

Command line interface (CLI)

powerio convert tests/data/case14.m --to psse35 -o case14.raw
powerio convert tests/data/case14.m --to pandapower-json -o case14.pp.json
powerio convert tests/data/case14.m --to pypsa-csv -o pypsa_case
powerio convert pypsa_case --from pypsa-csv --to matpower -o case14.m
powerio convert case.epc --from pslf --to matpower -o case.m
powerio convert case.surge.json --from surge-json --to matpower -o case.m
powerio convert goc3_case.json --from goc3-json --to matpower -o case.m
powerio package tests/data/case14.m -o case14.pio.json
powerio package goc3_case.json --from goc3-json -o goc3_case.pio.json
powerio verify tests/data/case30.m --kind bdoubleprime
powerio dcopf tests/data/case30.m -o out
powerio sensitivities tests/data/case30.m -o out --solver auto --drop-tolerance 1e-10
powerio gridfm tests/data/case14.m -o out
powerio

Features

Current Format Fidelity

Every network reader lowers to Network. The table separates writing back to the original file type from converting to a different file type.

file type	read	write	writing back to the original file type	converting to another file type
MATPOWER .m	yes	yes	byte exact retained source	canonical MATPOWER blocks; warnings for fields MATPOWER cannot carry
PowerModels JSON	yes	yes	byte exact retained source	per unit structured data checked against PowerModels.jl
PSS/E .raw	yes	yes	byte exact only when writing the source revision	power flow core; revision downgrade and unsupported records are warned
PowerWorld .aux	yes	yes	byte exact retained source	power flow core; PowerWorld only fields are projected or warned
PowerWorld .pwb	yes	no	n/a	read only binary case; decoded core converts through every text writer
PSLF .epc	yes	yes	byte exact retained source	power flow core; unsupported EPC sections are read warnings
egret JSON	yes	yes	byte exact retained source	ModelData shape checked against egret and PowerModels.jl
pandapower JSON	yes	yes	byte exact retained source	pandapower import validator checks counts and Y_bus
PyPSA CSV folder	yes	yes	directory output, not text echo	PyPSA import validator checks the exported static components
GO Challenge 3 JSON	yes	source echo only	byte exact retained source	first interval maps to the static power flow core; .pio.json documents retain time series as operating points
Surge JSON	yes	yes	byte exact retained source	versioned JSON network body; unsupported source sections stay in retained source or warnings
GridFM Parquet	yes	yes	directory output, deliberately lossy read	recovers the power flow core for conversion back to classical formats

PowerWorld .pwd is display data, not a network case, so it is outside this conversion table and uses parse_display_file / parse_display_bytes. The decoded vintages and per field evidence are maintainer notes at powerio/src/format/powerworld/FORMAT.md.

The distribution matrix (dss, PMD JSON, BMOPF JSON, per fixture) is generated under powerio-dist/docs/. Vendored test data keeps its own licenses next to the fixtures under tests/data/dist/.

Known limits for every format are documented in the format fidelity guide.

Matrices

The powerio-matrix Rust crate derives an IndexedNetwork with dense bus indices. It enables you to build common power system matrices with minimal dependencies:

• MATPOWER Bp/Bpp FDPF matrices
• DC bus susceptance matrix L = A diag(b) A^T and flow map matrices
• Nodal admittance matrix
• LACPF block matrix
• Signed incidence matrix
• PTDF and LODF sensitivity matrices, with dense and iterative solver paths
• Streamed CLI PTDF/LODF writes for iterative sensitivity exports
• Adjacency matrix and petgraph graph output
• Matrix Market bundles for OPF solvers
• KKT operators for OPF solvers (experimental)

Current conventions for signs, taps, phase shifts, per unit scaling, reference buses, and line parameters are documented in the matrices guide.

Normalized Form

Network::to_normalized derives a post processed copy of a case for solvers:

• powers are in per unit,
• voltage phase angles are in radians,
• inactive elements are removed,
• tap == 0 replaced with 1,
• surviving buses keep their source bus ids, and
• bus types are made consistent with generator placement and reference buses.

The normalized copy carries no retained source text, so writing it emits the derived model rather than the original file.

Python exposes the normalized form as case.to_normalized(), the C ABI as pio_normalize, and Julia as to_normalized(case).

C ABI

powerio-capi exposes parse, query, conversion, JSON transport, normalization, .pio.json document handles, and numeric table extraction through pio_* functions. The public header is powerio-capi/include/powerio.h. Build with --features arrow to enable pio_to_arrow over the Arrow C Data Interface, and add --features matrix for sparse matrix COO tables. Matrix Arrow ABI v1 is COO plus explicit matrix_bus and matrix_branch axis map tables; language bindings assemble native sparse matrix types on their side.

PowerAgent

PowerIO is part of the PowerAgent community. The Python package includes an optional MCP server with tools for conversion, saving, summaries, parsing, normalization, matrix outputs, and display data.

pip install 'powerio[mcp]'
powerio-mcp

MCP clients can keep a case in .pio.json document JSON through the package transport:

parsed = parse(path="case9.m", transport="package")
pkg = parsed["package_json"]
summary(package_json=pkg)
matrix("bprime", package_json=pkg)
save(out_path="case9.raw", to_format="psse", package_json=pkg)
diagnostics(pkg)

The PowerMCP bundle in PowerMCP uses the same PowerIO tool surface alongside simulator servers and bridge tools.

.pio.json Documents

.pio.json documents carry one balanced or multiconductor model JSON object with metadata: provenance, source maps, diagnostics, validation, summaries, lowering history, optional derived metadata, and optional operating_points. A GO Challenge 3 document stores the static first interval in model and the full replayable time series in operating_points; materializing one point returns a static document with the updates applied and the series cleared.

Rust uses powerio_pkg::NetworkPackage, Python uses the powerio.Package class, the C ABI uses pio_package_*, and the CLI writes documents with powerio package.

GridFM (experimental)

PowerIO writes datasets for the LF Energy open Grid Foundation Model (GridFM) project. In the command line:

powerio gridfm <case> -o <dir>

This writes the Parquet tables gridfm-datakit and gridfm-graphkit consume under <dir>/<case>/raw/; several compatible cases stack by scenario id.

The gridfm feature also supports reading a .parquet dataset back into a Network (read_gridfm_dataset in powerio-matrix, pio.read_gridfm in Python), so a perturbed training scenario or a GNN predicted state can be extracted and converted back out in any classical format:

powerio convert out/case14/raw --from gridfm --to matpower -o case14.m

The --from gridfm read path is lossy. What it recovers, what it drops, and its warning behavior are in the format fidelity guide.

Validation

The Rust test suite covers parsers, writers, format conversion, matrix builders, and normalization; the C ABI crate carries its own tests, and pytest covers the Python bindings. The benchmark validation suite compares selected outputs against PowerModels.jl, egret, ExaPowerIO.jl, and pandapower, and imports PowerIO's PyPSA CSV folders with PyPSA. Install the oracle stack from benchmarks/requirements.txt into the same Python 3.11+ venv that holds the local powerio wheel.

cargo fmt --all --check
cargo test
cargo test -p powerio-capi
bash scripts/ci-clippy.sh
pytest python/tests
bash benchmarks/run_validation.sh

Benchmark method, environment, and current tables are documented in the performance guide.

License

PowerIO is distributed under either of:

• Apache License, Version 2.0
• MIT license