gridoxide 0.0.2__tar.gz → 0.2.0__tar.gz

gridoxide-0.2.0/.cargo/config.toml

@@ -0,0 +1,25 @@
+# Environment for `cargo build`/`run`/`test` in this workspace.
+
+[env]
+# **Only needed by the `opf-ipopt` feature, and only because of how Debian and
+# Ubuntu package IPOPT.** Harmless otherwise — nothing else in this crate loads
+# OpenMPI.
+#
+# `libipopt.so` there is built against MUMPS, which is built against OpenMPI,
+# so `libmpi.so.40` and `libscalapack-openmpi` come along. OpenMPI runs its
+# transport discovery in a **load-time initializer**, and in an environment
+# without the network and shared-memory facilities it probes for, that
+# discovery hangs. The result is a process that hangs before `main` — before
+# any Rust code runs at all, so no amount of care inside the binding can catch
+# it or work around it. A plain C program that merely links `-lipopt` and calls
+# nothing hangs identically, which is how this was pinned on the package rather
+# than on the binding.
+#
+# Restricting the byte transport layer to loopback skips the probe. `self` is
+# sufficient: MUMPS is used single-process here, so there is no inter-rank
+# communication to carry. (`^tcp` and `^openib,tcp` — excluding transports
+# rather than restricting to one — do *not* help; the discovery still runs.)
+#
+# Not forced, so anyone who has a working OpenMPI setup and sets their own
+# value keeps it.
+OMPI_MCA_btl = "self"

gridoxide-0.2.0/.github/workflows/build.yml

@@ -0,0 +1,117 @@
+name: Rust build and test
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    # The OPF tests and tests/injection_hessian_test.rs read the pglib-opf
+    # cases from benchmark-grids and convert them with numpy
+    # (tests/data/pglib_opf.py). CGMES-Test-Configurations stays unfetched.
+    - name: Fetch benchmark-grids
+      run: git submodule update --init --depth 1 tests/data/benchmark-grids
+    - uses: actions/setup-python@v5
+      with:
+        python-version: "3.12"
+    - name: Install numpy
+      run: pip install numpy
+    # Dependencies and the previous run's build, keyed on Cargo.lock. Without
+    # it every run compiles every crate from scratch, once per profile.
+    - uses: Swatinem/rust-cache@v2
+
+    # **Each feature set CI covers is compiled on its own, and tested once,
+    # together.** Testing them one at a time ran the default suite eight times
+    # over and relinked every test binary for each feature set; what the
+    # separate builds actually guard is a missing or wrong `#[cfg]`, which a
+    # compile check — `--all-targets`, so tests and examples included — finds
+    # just as well, with no codegen and no link.
+    #
+    # Not here at all: `klu` (a C compiler and libclang), `pardiso` (a
+    # separately-licensed Intel oneMKL, `MKLROOT` set — not on hosted runners;
+    # see docs/src/solvers/backends.md), `opf-highs` and `opf-ipopt` (system
+    # libraries no runner has, so `tests/opf_cross_test.rs`, which holds HiGHS
+    # against the in-house solver, runs where HiGHS is installed), and
+    # `smallsignal-arpack`. Everything below is pure Rust or fetched by cargo:
+    #
+    # - `opf`: the interior-point QP solver in `src/opf/ipm.rs`, and `opf::bnb`
+    #   branching over it for the mixed-integer path.
+    # - `ucte`: fixed-column text, no dependency. Its suite checks that each
+    #   network solves to pypowsybl's answer, committed as JSON under
+    #   `tests/data/ucte/`, so the runner needs no pypowsybl.
+    # - `iidm`: one crate (quick-xml). Checked with `ucte` too, because its
+    #   strongest test reads the same network through both parsers.
+    # - `dynamics`: pure Rust on this crate's sparse backends; small-signal
+    #   analysis rides along on it.
+    # - `rao`: serde, which the crate already has. Its external gate,
+    #   `tests/rao_cucumber_test.rs`, reads powsybl-open-rao's own Cucumber
+    #   suite from benchmark-grids and needs no Java.
+    # - `capi`: pure Rust plus cbindgen.
+    # - `matpower`: plain text, no dependency. Its suite reads the cases in
+    #   benchmark-grids and checks each solution against the case's own
+    #   equations.
+    - name: Check each feature set on its own
+      run: |
+        for features in "" opf ucte iidm iidm,ucte dynamics dynamics,iidm \
+                        rao rao,ucte,iidm capi matpower; do
+          echo "::group::cargo check --features '$features'"
+          cargo check --all-targets --features "$features"
+          echo "::endgroup::"
+        done
+    # Feature *unification* is its own failure mode, which the checks above
+    # cannot see: `iidm` and `cgmes` share quick-xml, and cimmodel enables its
+    # `encoding` feature — which changes the shape of a public type. That
+    # combination compiled in no single-feature step and broke in the one
+    # nobody ran. This is that step.
+    - name: Check every CI-covered feature together
+      run: cargo check --all-targets --features cgmes,ucte,iidm,opf,rao,dynamics,capi,matpower
+    # Tested on the union, *less `cgmes`*: its tests read
+    # CGMES-Test-Configurations (158 MB), which CI does not fetch, and nine of
+    # them fail rather than skip without it. CI has never run them; fetching
+    # the submodule and adding `cgmes` here is what would change that.
+    #
+    # The integration tests are one binary (`tests/all.rs`), so this links once.
+    - name: Test every CI-covered feature together
+      run: cargo test --features ucte,iidm,opf,rao,dynamics,capi,matpower
+    # The library is split into crates (see crates/), and a plain `cargo test`
+    # at the root tests only the root package. The others' own unit tests —
+    # the KLU port's among them — run here.
+    - name: Test the workspace's other crates
+      run: cargo test --workspace --exclude gridoxide
+    - name: Build the dynamics scaling examples
+      run: |
+        cargo build --release --features dynamics --example dynamics_scale
+        cargo build --release --features dynamics --example smallsignal_scale
+    # The two example programs are the part `cargo test` cannot cover. They are
+    # what proves the generated header actually parses as C11 and C++17, that
+    # the `#[repr(C)]` layouts agree with what a real compiler computes, and
+    # that the exported symbols link — none of which a Rust test can check,
+    # since it never sees the header at all.
+    - name: Compile and run the C and C++ examples
+      run: |
+        cargo build --release --features capi
+        cc  -std=c11   -Wall -Wextra -Werror -Iinclude \
+            capi/examples/powerflow.c   target/release/libgridoxide.a \
+            -o /tmp/powerflow_c   -lpthread -ldl -lm
+        c++ -std=c++17 -Wall -Wextra -Werror -Iinclude \
+            capi/examples/powerflow.cpp target/release/libgridoxide.a \
+            -o /tmp/powerflow_cpp -lpthread -ldl -lm
+        python tests/data/pglib_opf.py /tmp/pglib-opf
+        /tmp/powerflow_c   /tmp/pglib-opf/pglib_opf_case14_ieee.json
+        /tmp/powerflow_cpp /tmp/pglib-opf/pglib_opf_case14_ieee.json
+    # The header is committed so a prebuilt-artifact consumer needs no Rust
+    # toolchain. Nothing keeps it in step with the code unless something checks,
+    # and building with `capi` regenerates it — so a diff here means a
+    # contributor changed the ABI without committing the regenerated header.
+    - name: Check the committed header is not stale
+      run: git diff --exit-code -- include/gridoxide.h

gridoxide-0.2.0/.github/workflows/publish.yml

@@ -0,0 +1,111 @@
+name: Publish to crates.io
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+    inputs:
+      dry_run:
+        description: 'Package and verify everything without uploading'
+        type: boolean
+        default: true
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  publish:
+    name: Publish to crates.io
+    runs-on: ubuntu-latest
+    # Same tag trigger as pypi.yml, so one `v*` tag cuts both the wheels and
+    # the crate. Nothing here depends on that workflow, though: a PyPI failure
+    # shouldn't hold back the crate or vice versa.
+    #
+    # Holds the CARGO_REGISTRY_TOKEN secret, which is the point of the
+    # environment — scoping the token to this one job, and letting a required
+    # reviewer be added later without touching this file.
+    environment: crate-release
+    steps:
+      # No `submodules:` — the two git submodules under tests/data/ hold only
+      # test fixtures, and Cargo.toml's `exclude` keeps that whole directory
+      # out of the packaged .crate anyway.
+      - uses: actions/checkout@v4
+
+      - uses: dtolnay/rust-toolchain@stable
+
+      - uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-publish-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: ${{ runner.os }}-cargo-publish-
+
+      # A version published to crates.io can never be replaced, so catch a
+      # mistyped tag here rather than by burning the wrong version number.
+      # Skipped on workflow_dispatch, which has no tag to compare against.
+      - name: Check tag matches crate version
+        if: startsWith(github.ref, 'refs/tags/')
+        run: |
+          set -euo pipefail
+          version=$(cargo metadata --no-deps --format-version 1 | jq -r '.packages[] | select(.name == "gridoxide") | .version')
+          tag="${GITHUB_REF_NAME#v}"
+          if [ "$tag" != "$version" ]; then
+            echo "::error::Tag $GITHUB_REF_NAME does not match Cargo.toml version $version"
+            exit 1
+          fi
+          echo "Tag $GITHUB_REF_NAME matches Cargo.toml version $version"
+
+      # Catches the two ways a .crate can be broken without any local build
+      # noticing: a file the package needs that `exclude` dropped, and a
+      # dependency that resolves locally but not from the registry.
+      #
+      # `--workspace` packages the other workspace crates too, and
+      # verifies each crate against the others it just packaged rather than
+      # against crates.io, where this version does not exist yet. Verifies on
+      # default features only, matching build.yml — `klu`/`pardiso` need a C
+      # toolchain, libclang, or a local oneMKL install. That's a limit on what
+      # this job *compiles*, not on what ships: the crate is source-only, so
+      # every feature's source is published either way.
+      - name: Package
+        run: cargo package --workspace
+
+      # The `cgmes` feature is the one whose dependencies come from outside
+      # this repo (cimoxide's `cimoxide-model`), so build it from the packaged
+      # .crate rather than the working tree — that is what a crates.io
+      # consumer actually gets. Pure Rust, so unlike `klu` it needs
+      # nothing extra on the runner.
+      - name: Check the packaged crate builds with --features cgmes
+        run: |
+          set -euo pipefail
+          version=$(cargo metadata --no-deps --format-version 1 | jq -r '.packages[] | select(.name == "gridoxide") | .version')
+          # Every workspace crate's .crate, unpacked side by side.
+          for crate in target/package/*-$version.crate; do
+            tar xzf "$crate" -C target/package
+          done
+          # This version of the workspace's other crates is not on crates.io
+          # until the step below, so point the extracted gridoxide at the
+          # extracted crates — again, exactly what a consumer gets.
+          patches=()
+          for dir in target/package/gridoxide-*-$version/; do
+            name=$(basename "$dir" "-$version")
+            patches+=(--config "patch.crates-io.$name.path='$PWD/$dir'")
+          done
+          cargo build --features cgmes \
+            --manifest-path "target/package/gridoxide-$version/Cargo.toml" "${patches[@]}"
+
+      # Everything above is the dry run: a `workflow_dispatch` with dry_run
+      # left on exercises the whole packaging path and stops here, without
+      # spending a version number.
+      #
+      # `--no-verify` because the `cargo package` step above already built the
+      # very same .crates; re-verifying would just compile faer twice.
+      # `--workspace` publishes in dependency order, gridoxide-sparse first
+      # and gridoxide last.
+      - name: Publish
+        if: ${{ github.event_name != 'workflow_dispatch' || !inputs.dry_run }}
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+        run: cargo publish --workspace --no-verify

{gridoxide-0.0.2 → gridoxide-0.2.0}/.github/workflows/pypi.yml

@@ -114,10 +114,49 @@ jobs:
           name: wheels-sdist
           path: dist
 
+  # gridoxide-mcp: the `gridmcp` binary as a wheel (maturin `bindings = "bin"`),
+  # so MCP clients can start it with `uvx --from gridoxide-mcp gridmcp`. Wheels
+  # only, for the platforms the bindings ship. No submodules: the binary is
+  # built from source alone.
+  mcp:
+    name: gridoxide-mcp ${{ matrix.name }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - { name: linux-x86_64, os: ubuntu-latest, target: x86_64 }
+          - { name: windows-x64, os: windows-latest, target: x64 }
+          - { name: macos-aarch64, os: macos-latest, target: aarch64 }
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: dtolnay/rust-toolchain@stable
+
+      - uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-cargo-mcp-${{ matrix.target }}-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: ${{ runner.os }}-cargo-mcp-${{ matrix.target }}-
+
+      - uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          working-directory: crates/gridoxide-mcp
+          args: --release --out ../../dist
+          manylinux: auto
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-mcp-${{ matrix.name }}
+          path: dist
+
   publish:
     name: Publish to PyPI
     if: startsWith(github.ref, 'refs/tags/')
-    needs: [linux, windows, macos, sdist]
+    needs: [linux, windows, macos, sdist, mcp]
     runs-on: ubuntu-latest
     environment: pypi
     permissions:

{gridoxide-0.0.2 → gridoxide-0.2.0}/.github/workflows/python.yml

@@ -13,6 +13,10 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
+      # test_matpower_opf.py converts the pglib-opf cases in benchmark-grids.
+      - name: Fetch benchmark-grids
+        run: git submodule update --init --depth 1 tests/data/benchmark-grids
+
       - name: Install Rust (stable)
         uses: dtolnay/rust-toolchain@stable
 

gridoxide-0.2.0/.github/workflows/release.yml

@@ -0,0 +1,104 @@
+name: Release
+
+# A GitHub release per `v*` tag with the `gridoxide` CLI for each platform
+# attached. The MCP server is not attached: it ships on PyPI and inside the
+# VS Code extension (vscode.yml).
+
+on:
+  push:
+    tags:
+      - 'v*'
+  # Attaches binaries to a tag pushed before this workflow existed, or re-runs
+  # a release that failed half-way. Without `tag` it only builds.
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: 'Tag to build and release, e.g. v0.1.0'
+        type: string
+        default: ''
+
+env:
+  TAG: ${{ inputs.tag || github.ref_name }}
+
+jobs:
+  build:
+    name: Build ${{ matrix.artifact }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          # musl: a static binary runs on any Linux distribution.
+          - os: ubuntu-latest
+            rust_target: x86_64-unknown-linux-musl
+            exe: gridoxide
+            artifact: gridoxide-linux-x64
+          - os: windows-latest
+            rust_target: x86_64-pc-windows-msvc
+            exe: gridoxide.exe
+            artifact: gridoxide-windows-x64.exe
+          - os: macos-latest
+            rust_target: aarch64-apple-darwin
+            exe: gridoxide
+            artifact: gridoxide-macos-arm64
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.tag || github.ref }}
+
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.rust_target }}
+
+      - name: Install musl tools
+        if: contains(matrix.rust_target, 'musl')
+        run: sudo apt-get update && sudo apt-get install -y musl-tools
+
+      - uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-${{ matrix.rust_target }}-cargo-release-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: ${{ runner.os }}-${{ matrix.rust_target }}-cargo-release-
+
+      # Every feature that needs no system library; klu, pardiso, opf-highs,
+      # opf-ipopt and smallsignal-arpack each link one, so they stay off.
+      - name: Build gridoxide
+        run: >
+          cargo build --release --bin gridoxide --target ${{ matrix.rust_target }}
+          --features cgmes,ucte,iidm,matpower,opf,rao,dynamics
+
+      - name: Stage artifact
+        shell: bash
+        run: cp target/${{ matrix.rust_target }}/release/${{ matrix.exe }} ${{ matrix.artifact }}
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.artifact }}
+          path: ${{ matrix.artifact }}
+
+  release:
+    name: Create GitHub release
+    if: startsWith(github.ref, 'refs/tags/') || inputs.tag != ''
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          merge-multiple: true
+
+      # A release made by hand before the run finished only gets the binaries.
+      - name: Create release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          if gh release view "$TAG" --repo ${{ github.repository }} >/dev/null 2>&1; then
+            gh release upload "$TAG" --clobber --repo ${{ github.repository }} gridoxide-*
+          else
+            gh release create "$TAG" --generate-notes \
+              --repo ${{ github.repository }} gridoxide-*
+          fi

gridoxide-0.2.0/.github/workflows/vscode.yml

@@ -0,0 +1,127 @@
+name: VS Code extension
+
+# One VSIX per platform, each bundling its own `gridmcp`, published to the
+# Visual Studio Marketplace and Open VSX. Needs VSCE_PAT (Azure DevOps token with
+# Marketplace › Manage) and OVSXAT (open-vsx.org access token) in the `vscode-release`
+# environment. --skip-duplicate lets a run that failed half-way be re-run as-is.
+
+on:
+  push:
+    tags:
+      - 'v*'
+  workflow_dispatch:
+    inputs:
+      publish:
+        description: 'Publish the packages (otherwise only build them)'
+        type: boolean
+        default: false
+
+jobs:
+  package:
+    name: Package ${{ matrix.vsce_target }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          # musl: a static binary runs on any Linux distribution.
+          - os: ubuntu-latest
+            rust_target: x86_64-unknown-linux-musl
+            vsce_target: linux-x64
+            exe: gridmcp
+          - os: windows-latest
+            rust_target: x86_64-pc-windows-msvc
+            vsce_target: win32-x64
+            exe: gridmcp.exe
+          - os: macos-latest
+            rust_target: aarch64-apple-darwin
+            vsce_target: darwin-arm64
+            exe: gridmcp
+
+    steps:
+      - uses: actions/checkout@v4
+
+      # The smoke test lists case14 from benchmark-grids.
+      - name: Fetch benchmark-grids
+        if: runner.os == 'Linux'
+        run: git submodule update --init --depth 1 tests/data/benchmark-grids
+
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.rust_target }}
+
+      - name: Install musl tools
+        if: contains(matrix.rust_target, 'musl')
+        run: sudo apt-get update && sudo apt-get install -y musl-tools
+
+      - uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: ${{ runner.os }}-${{ matrix.rust_target }}-cargo-vscode-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: ${{ runner.os }}-${{ matrix.rust_target }}-cargo-vscode-
+
+      - name: Build gridmcp
+        run: cargo build --release -p gridoxide-mcp --target ${{ matrix.rust_target }}
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Check extension version matches the workspace
+        shell: bash
+        run: |
+          crate=$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -1)
+          ext=$(node -p "require('./editors/vscode/package.json').version")
+          if [ "$crate" != "$ext" ]; then
+            echo "editors/vscode/package.json is $ext, the workspace is $crate" >&2
+            exit 1
+          fi
+
+      - name: Package
+        shell: bash
+        working-directory: editors/vscode
+        run: |
+          mkdir -p server
+          cp ../../target/${{ matrix.rust_target }}/release/${{ matrix.exe }} server/
+          npm ci
+          npx vsce package --target ${{ matrix.vsce_target }}
+
+      # The extension in a running VS Code (test/suite.ts): a failure here
+      # fails the job, so nothing is published.
+      - name: Smoke test
+        if: runner.os == 'Linux'
+        working-directory: editors/vscode
+        run: xvfb-run -a npm test
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: vsix-${{ matrix.vsce_target }}
+          path: editors/vscode/*.vsix
+
+  publish:
+    name: Publish
+    needs: package
+    if: startsWith(github.ref, 'refs/tags/') || inputs.publish
+    runs-on: ubuntu-latest
+    environment: vscode-release
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: vsix-*
+          merge-multiple: true
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Publish to the Visual Studio Marketplace
+        env:
+          VSCE_PAT: ${{ secrets.VSCE_PAT }}
+        run: npx --yes @vscode/vsce@3 publish --skip-duplicate --packagePath *.vsix
+
+      - name: Publish to Open VSX
+        env:
+          OVSX_PAT: ${{ secrets.OVSXAT }}
+        run: npx --yes ovsx@0 publish --skip-duplicate --packagePath *.vsix