main.yml

name: Py 3.10, 3.11, 3.12 | Windows Mac Linux

on:
  push:
    branches:
      - master
      - develop
  pull_request:
    branches:
      - master
      - develop

jobs:
  set-os:
    runs-on: ubuntu-latest
    outputs:
      matrix_os: ${{ steps.set-matrix.outputs.matrix_os }}
    steps:
      - id: set-matrix
        run: |
          if [[ "${{ github.event_name }}" == "pull_request" && "${{ github.base_ref }}" == "develop" ]]; then
            echo "matrix_os=[ \"ubuntu-latest\"]" >> $GITHUB_OUTPUT
          else
            echo "matrix_os=[\"windows-latest\", \"ubuntu-latest\", \"macos-latest\"]" >> $GITHUB_OUTPUT
          fi

  check-changes:
    runs-on: ubuntu-latest
    outputs:
      wave_io_hindcast_changed: ${{ steps.changes.outputs.wave_io_hindcast }}
      should-run-hindcast: ${{ steps.hindcast-logic.outputs.should-run-hindcast }}
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Check for changes in wave/io/hindcast
        id: changes
        uses: dorny/paths-filter@v3
        with:
          filters: |
            wave_io_hindcast:
              - 'mhkit/wave/io/hindcast/**'
              - 'mhkit/tests/wave/io/hindcast/**'

      - id: hindcast-logic
        run: |
          if [[ "${{ github.event.pull_request.base.ref }}" == "master" || "${{ steps.changes.outputs.wave_io_hindcast }}" == "true" ]]; then
            echo "should-run-hindcast=true" >> "$GITHUB_OUTPUT"
          else
            echo "should-run-hindcast=false" >> "$GITHUB_OUTPUT"
          fi

  prepare-nonhindcast-cache:
    runs-on: ubuntu-latest
    env:
      PYTHON_VER: 3.11
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Setup Miniconda
        uses: conda-incubator/setup-miniconda@v3
        with:
          miniconda-version: 'latest'
          auto-update-conda: true
          python-version: ${{ env.PYTHON_VER }}
          activate-environment: TESTconda
          use-only-tar-bz2: true

      - name: Create MHKiT Conda environment
        shell: bash -l {0}
        run: |
          conda env create -f environment.yml
          conda activate mhkit-env

      - name: Install testing dependencies
        shell: bash -l {0}
        run: |
          conda activate mhkit-env
          conda install -y pytest coverage coveralls

      - name: Install mhkit
        shell: bash -l {0}
        run: |
          conda activate mhkit-env
          pip install -e . --no-deps

      - name: Prepare non-hindcast API data
        shell: bash -l {0}
        run: |
          conda activate mhkit-env
          pytest mhkit/tests/river/test_io_usgs.py
          pytest mhkit/tests/tidal/test_io.py
          pytest mhkit/tests/wave/io/test_cdip.py

      - name: Upload data as artifact
        uses: actions/upload-artifact@v4
        with:
          name: data
          path: ~/.cache/mhkit

  prepare-wave-hindcast-cache:
    needs: [check-changes]
    runs-on: ubuntu-latest
    env:
      PYTHON_VER: 3.11
    if: (needs.check-changes.outputs.should-run-hindcast == 'true')
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Setup Miniconda
        uses: conda-incubator/setup-miniconda@v3
        with:
          miniconda-version: 'latest'
          auto-update-conda: true
          activate-environment: TEST
          python-version: ${{ env.PYTHON_VER }}
          use-only-tar-bz2: true

      - name: Create MHKiT Conda environment
        shell: bash -l {0}
        run: |
          conda env create -f environment.yml
          conda activate mhkit-env

      - name: Install testing dependencies
        shell: bash -l {0}
        run: |
          conda activate mhkit-env
          conda install -y pytest coverage coveralls

      - name: Install mhkit
        shell: bash -l {0}
        run: |
          conda activate mhkit-env
          pip install -e . --no-deps

      - name: Prepare Wave Hindcast data
        shell: bash -l {0}
        run: |
          conda activate mhkit-env
          pytest mhkit/tests/wave/io/hindcast/test_hindcast.py

      - name: Upload Wave Hindcast data as artifact
        uses: actions/upload-artifact@v4
        with:
          name: wave-hindcast-data
          path: ~/.cache/mhkit

  prepare-wind-hindcast-cache:
    needs: [check-changes, prepare-wave-hindcast-cache]
    runs-on: ubuntu-latest
    env:
      PYTHON_VER: 3.11
    if: (needs.check-changes.outputs.should-run-hindcast == 'true')
    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Setup Miniconda
        uses: conda-incubator/setup-miniconda@v3
        with:
          miniconda-version: 'latest'
          auto-update-conda: true
          activate-environment: TEST
          python-version: ${{ env.PYTHON_VER }}
          use-only-tar-bz2: true

      - name: Create MHKiT Conda environment
        shell: bash -l {0}
        run: |
          conda env create -f environment.yml
          conda activate mhkit-env

      - name: Install testing dependencies
        shell: bash -l {0}
        run: |
          conda activate mhkit-env
          conda install -y pytest coverage coveralls

      - name: Install mhkit
        shell: bash -l {0}
        run: |
          conda activate mhkit-env
          pip install -e . --no-deps

      - name: Prepare Wind Hindcast data
        shell: bash -l {0}
        run: |
          conda activate mhkit-env
          pytest mhkit/tests/wave/io/hindcast/test_wind_toolkit.py

      - name: Upload Wind Hindcast data as artifact
        uses: actions/upload-artifact@v4
        with:
          name: wind-hindcast-data
          path: ~/.cache/mhkit

  conda-build:
    name: conda-${{ matrix.os }}/${{ matrix.python-version }}
    needs: [set-os, prepare-nonhindcast-cache]
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
        os: ${{fromJson(needs.set-os.outputs.matrix_os)}}
        python-version: ['3.10', '3.11', '3.12']
    env:
      PYTHON_VER: ${{ matrix.python-version }}

    steps:
      - uses: actions/checkout@v4

      - name: Setup Miniconda
        uses: conda-incubator/setup-miniconda@v3
        with:
          miniconda-version: 'latest'
          auto-update-conda: true
          environment-file: environment.yml
          activate-environment: TEST
          python-version: ${{ matrix.python-version }}
          use-only-tar-bz2: false

      - name: Create MHKiT Conda environment
        shell: bash -l {0}
        run: |
          conda env create -f environment.yml
          conda activate mhkit-env

      - name: Install testing dependencies
        shell: bash -l {0}
        run: |
          conda activate mhkit-env
          conda install -y pytest coverage coveralls

      - name: Install mhkit
        shell: bash -l {0}
        run: |
          conda activate mhkit-env
          pip install -e . --no-deps

      - name: Run pytest & generate coverage report
        shell: bash -l {0}
        run: |
          conda activate mhkit-env
          coverage run --rcfile=.github/workflows/.coveragerc --source=./mhkit/ -m pytest -c .github/workflows/pytest.ini
          coverage lcov

      - name: Upload coverage data to coveralls.io
        uses: coverallsapp/github-action@master
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          flag-name: conda-${{ runner.os }}-py${{ matrix.python-version }}
          parallel: true
          path-to-lcov: ./coverage.lcov

  pip-build:
    name: pip-${{ matrix.os }}/${{ matrix.python-version }}
    needs: [set-os, prepare-nonhindcast-cache]
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
        os: ${{fromJson(needs.set-os.outputs.matrix_os)}}
        python-version: ['3.10', '3.11', '3.12']

    steps:
      - uses: conda-incubator/setup-miniconda@v3

      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}

      - name: Set up Git repository
        uses: actions/checkout@v4

      - name: Download data from artifact
        uses: actions/download-artifact@v4
        with:
          name: data
          path: ~/.cache/mhkit

      - name: Update and install packages
        shell: bash -l {0}
        run: |
          python -m pip install --upgrade pip wheel
          pip install coverage pytest coveralls .

      - name: Install setuptools for Python 3.12
        if: matrix.python-version == '3.12'
        run: pip install setuptools

      - name: Run pytest & generate coverage report
        shell: bash -l {0}
        run: |
          coverage run --rcfile=.github/workflows/.coveragerc --source=./mhkit/ -m pytest -c .github/workflows/pytest.ini
          coverage lcov

      - name: Upload coverage data to coveralls.io
        uses: coverallsapp/github-action@master
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          flag-name: pip-${{ runner.os }}-py${{ matrix.python-version }}
          parallel: true
          path-to-lcov: ./coverage.lcov

  hindcast-calls:
    name: hindcast-${{ matrix.os }}/${{ matrix.python-version }}
    needs:
      [
        check-changes,
        prepare-wave-hindcast-cache,
        prepare-wind-hindcast-cache,
        set-os,
      ]
    if: (needs.check-changes.outputs.should-run-hindcast == 'true')

    runs-on: ${{ matrix.os }}
    strategy:
      max-parallel: 1
      fail-fast: false
      matrix:
        os: ${{fromJson(needs.set-os.outputs.matrix_os)}}
        python-version: ['3.10', '3.11', '3.12']

    steps:
      - uses: actions/checkout@v4

      - name: Setup Miniconda
        uses: conda-incubator/setup-miniconda@v3
        with:
          miniconda-version: 'latest'
          auto-update-conda: true
          environment-file: environment.yml
          activate-environment: TEST
          python-version: ${{ matrix.python-version }}
          use-only-tar-bz2: false

      - name: Create MHKiT Conda environment
        shell: bash -l {0}
        run: |
          conda env create -f environment.yml
          conda activate mhkit-env

      - name: Install testing dependencies
        shell: bash -l {0}
        run: |
          conda activate mhkit-env
          conda install -y pytest coverage coveralls

      - name: Install mhkit
        shell: bash -l {0}
        run: |
          conda activate mhkit-env
          pip install -e . --no-deps

      - name: Download Wave Hindcast data from artifact
        uses: actions/download-artifact@v4
        with:
          name: wave-hindcast-data
          path: ~/.cache/mhkit/wave-hindcast

      - name: Download Wind Hindcast data from artifact
        uses: actions/download-artifact@v4
        with:
          name: wind-hindcast-data
          path: ~/.cache/mhkit/wind-hindcast

      - name: Consolidate hindcast data
        run: |
          mkdir -p ~/.cache/mhkit/hindcast
          mv ~/.cache/mhkit/wave-hindcast/hindcast/* ~/.cache/mhkit/hindcast/
          mv ~/.cache/mhkit/wind-hindcast/hindcast/* ~/.cache/mhkit/hindcast/
        shell: bash

      - name: Run hindcast pytest
        shell: bash -l {0}
        run: |
          conda activate mhkit-env
          coverage run --rcfile=.github/workflows/.coveragehindcastrc -m pytest -c .github/workflows/pytest-hindcast.ini
          coverage lcov

      - name: Upload coverage data to coveralls.io
        uses: coverallsapp/github-action@master
        with:
          github-token: ${{ secrets.GITHUB_TOKEN }}
          flag-name: hindcast-${{ runner.os }}-py${{ matrix.python-version }}
          parallel: true
          path-to-lcov: ./coverage.lcov

  notebook-matrix:
    runs-on: ubuntu-latest
    needs:
      [
        check-changes,
        prepare-nonhindcast-cache,
        prepare-wave-hindcast-cache,
        prepare-wind-hindcast-cache,
      ]
    if: |
      always() &&
      (
        (
          needs.prepare-nonhindcast-cache.result == 'success' &&
          needs.prepare-wave-hindcast-cache.result == 'skipped' &&
          needs.prepare-wind-hindcast-cache.result == 'skipped' &&
          needs.check-changes.outputs.should-run-hindcast == 'false'    
        ) ||
        (
          needs.prepare-nonhindcast-cache.result == 'success' &&
          needs.prepare-wave-hindcast-cache.result == 'success' &&
          needs.prepare-wind-hindcast-cache.result == 'success' &&
          needs.check-changes.outputs.should-run-hindcast == 'true' 
        )
      )
    outputs:
      matrix: ${{ steps.set-matrix.outputs.matrix }}
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v2
        with:
          python-version: '3.11'

      - name: Generate matrix
        id: set-matrix
        run: |
          matrix_json=$(python .github/workflows/generate_notebook_matrix.py)
          echo "$matrix_json" >> $GITHUB_OUTPUT

  test-notebooks:
    needs:
      [
        notebook-matrix,
        check-changes,
        prepare-nonhindcast-cache,
        prepare-wave-hindcast-cache,
        prepare-wind-hindcast-cache,
      ]
    strategy:
      matrix: ${{ fromJson(needs.notebook-matrix.outputs.matrix) }}
    if: |
      always()
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Set up Miniconda
        uses: conda-incubator/setup-miniconda@v3
        with:
          miniconda-version: 'latest'
          auto-update-conda: true
          python-version: '3.11'
          activate-environment: TESTconda
          use-only-tar-bz2: true

      - name: Create MHKiT Conda environment
        shell: bash -l {0}
        run: |
          conda env create -f environment.yml
          conda activate mhkit-env

      - name: Install notebook testing dependencies
        shell: bash -l {0}
        run: |
          conda activate mhkit-env
          conda install -y pytest coverage coveralls nbval jupyter utm folium

      - name: Install mhkit
        shell: bash -l {0}
        run: |
          conda activate mhkit-env
          pip install -e . --no-deps

      - name: Download non-hindcast data
        uses: actions/download-artifact@v4
        with:
          name: data
          path: ~/.cache/mhkit

      - name: Download Wave Hindcast data (if available)
        if: (needs.check-changes.outputs.should-run-hindcast == 'true')
        uses: actions/download-artifact@v4
        with:
          name: wave-hindcast-data
          path: ~/.cache/mhkit/wave-hindcast

      - name: Download Wind Hindcast data (if available)
        if: (needs.check-changes.outputs.should-run-hindcast == 'true')
        uses: actions/download-artifact@v4
        with:
          name: wind-hindcast-data
          path: ~/.cache/mhkit/wind-hindcast

      - name: Consolidate hindcast data
        if: (needs.check-changes.outputs.should-run-hindcast == 'true')
        run: |
          mkdir -p ~/.cache/mhkit/hindcast
          mv ~/.cache/mhkit/wave-hindcast/hindcast/* ~/.cache/mhkit/hindcast/
          mv ~/.cache/mhkit/wind-hindcast/hindcast/* ~/.cache/mhkit/hindcast/
        shell: bash

      - name: Copy .hscfg file to examples directory
        shell: bash -l {0}
        run: |
          cp .hscfg examples/

      - name: Run notebook
        shell: bash -l {0}
        run: |
          conda activate mhkit-env
          if [[ "${{ matrix.notebook }}" == "examples/metocean_example.ipynb" || "${{ matrix.notebook }}" == "examples/WPTO_hindcast_example.ipynb" ]]; then
            if [[ "${{ needs.check-changes.outputs.should-run-hindcast }}" == 'true' ]]; then
              jupyter nbconvert --to notebook --execute --inplace --ExecutePreprocessor.timeout=${{ matrix.timeout }} "${{ matrix.notebook }}"
            else
              echo "Skipping ${{ matrix.notebook }}"
            fi
          else
            jupyter nbconvert --to notebook --execute --inplace --ExecutePreprocessor.timeout=${{ matrix.timeout }} "${{ matrix.notebook }}"
          fi

  coveralls:
    name: Indicate completion to coveralls.io
    needs:
      [
        prepare-wave-hindcast-cache,
        prepare-wind-hindcast-cache,
        conda-build,
        pip-build,
        hindcast-calls,
      ]
    if: |
      always() &&
      (
        (
          needs.conda-build.result == 'success' &&
          needs.pip-build.result == 'success' &&
          needs.prepare-wave-hindcast-cache.result == 'skipped' &&
          needs.prepare-wind-hindcast-cache.result == 'skipped' &&
          needs.hindcast-calls.result == 'skipped'
        ) ||
        (
          needs.conda-build.result == 'success' &&
          needs.pip-build.result == 'success' &&
          needs.prepare-wave-hindcast-cache.result == 'success' &&
          needs.prepare-wind-hindcast-cache.result == 'success' &&
          needs.hindcast-calls.result == 'success'
        )
      )
    runs-on: ubuntu-latest
    container: python:3-slim
    steps:
      - name: Coveralls Finished
        uses: coverallsapp/github-action@master
        with:
          parallel-finished: true
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}