discrete-optimization 0.3.0__tar.gz

discrete_optimization-0.3.0/.github/workflows/build-doc.yml

@@ -0,0 +1,129 @@
+name: Build doc
+
+on:
+  workflow_call:
+    inputs:
+      doc-artifact-name:
+        description: "Name of the artifact containing the built doc"
+        required: false
+        default: "doc"
+        type: string
+      doc-path:
+        description: "Path where to extract the built doc"
+        required: false
+        default: "docs/build/html"
+        type: string
+      notebooks-repo-url:
+        description: |
+          Url of the repository containing the notebooks, used to generate github and colab links.
+          By default, the current repository url.
+        required: false
+        default: ""
+        type: string
+      notebooks-branch:
+        description: |
+          Branch containing the notebooks, used to generate github and colab links.
+          By default, the current branch.
+        required: false
+        default: ""
+        type: string
+      doc-prerequisites-cmdline:
+        description: |
+          Command line to run before building doc.
+        required: false
+        default: ""
+        type: string
+
+    outputs:
+      doc-version:
+        description: "Version name of the generated doc. Correspond to the version name used by Sphinx."
+        value: ${{ jobs.build-doc.outputs.doc_version }}
+
+jobs:
+  build-doc:
+    outputs:
+      doc_version: ${{ steps.sphinx-build.outputs.doc_version }}
+    runs-on: ubuntu-latest
+    env:
+      python-version: "3.9"
+    steps:
+      - name: Set env variables for github links in doc
+        run: |
+          # notebooks source repo and branch. First try to use workflow inputs
+          AUTODOC_NOTEBOOKS_REPO_URL=${{ inputs.notebooks-repo-url }}
+          AUTODOC_NOTEBOOKS_BRANCH=${{ inputs.notebooks-branch }}
+          # use github context if not defined in inputs
+          if [[ $GITHUB_REF == refs/pull* ]];
+          then
+              if [ -z "${AUTODOC_NOTEBOOKS_REPO_URL}" ]; then
+                AUTODOC_NOTEBOOKS_REPO_URL="${GITHUB_SERVER_URL}/${{ github.event.pull_request.head.repo.full_name }}"
+              fi
+              if [ -z "${AUTODOC_NOTEBOOKS_BRANCH}" ]; then
+                AUTODOC_NOTEBOOKS_BRANCH=${GITHUB_HEAD_REF}
+              fi
+          elif [[ $GITHUB_REF == refs/heads* ]];
+          then
+              if [ -z "${AUTODOC_NOTEBOOKS_REPO_URL}" ]; then
+                AUTODOC_NOTEBOOKS_REPO_URL=${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}
+              fi
+              if [ -z "${AUTODOC_NOTEBOOKS_BRANCH}" ]; then
+                AUTODOC_NOTEBOOKS_BRANCH=${GITHUB_REF/refs\/heads\//}
+              fi
+          elif [[ $GITHUB_REF == refs/tags* ]];
+          then
+              if [ -z "${AUTODOC_NOTEBOOKS_REPO_URL}" ]; then
+                AUTODOC_NOTEBOOKS_REPO_URL=${GITHUB_SERVER_URL}/${GITHUB_REPOSITORY}
+              fi
+              if [ -z "${AUTODOC_NOTEBOOKS_BRANCH}" ]; then
+                AUTODOC_NOTEBOOKS_BRANCH=${GITHUB_REF/refs\/tags\//}
+              fi
+          fi
+          # export in GITHUB_ENV for next steps
+          echo "AUTODOC_NOTEBOOKS_REPO_URL=${AUTODOC_NOTEBOOKS_REPO_URL}" >> $GITHUB_ENV
+          echo "AUTODOC_NOTEBOOKS_BRANCH=${AUTODOC_NOTEBOOKS_BRANCH}" >> $GITHUB_ENV
+          # check computed variables
+          echo "Notebooks source: ${AUTODOC_NOTEBOOKS_REPO_URL}/tree/${AUTODOC_NOTEBOOKS_BRANCH}"
+      - uses: actions/checkout@v4
+      - name: Setup python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ env.python-version }}
+          cache: "pip"
+          cache-dependency-path: |
+            pyproject.toml
+            docs/requirements.txt
+      - name: Install doc dependencies
+        run: |
+          python -m pip install -U pip setuptools
+          pip install .
+          pip install -r docs/requirements.txt
+      - name: generate documentation
+        id: sphinx-build
+        run: |
+          # prerequisites
+          ${{ inputs.doc-prerequisites-cmdline }}
+          # move to documentation directory
+          cd docs
+          # generate api doc source files
+          sphinx-apidoc -o source/api -f -T ../discrete_optimization
+          # generate available notebooks list
+          python generate_nb_index.py
+          # build doc html pages
+          sphinx-build -M html source build
+          # specify it is a nojekyll site
+          touch build/html/.nojekyll
+          # store version name found by sphinx
+          doc_version=$(python -c '
+          import os
+          import sphinx.config
+
+          config = sphinx.config.Config.read(os.path.abspath("source"))
+          config.init_values()
+          print(config.version)
+          ')
+          echo doc_version=${doc_version} >> $GITHUB_OUTPUT
+      - name: upload as artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ inputs.doc-artifact-name }}
+          path: ${{ inputs.doc-path }}

discrete_optimization-0.3.0/.github/workflows/build.yml

@@ -0,0 +1,399 @@
+name: Build discrete-optimization
+
+env:
+  MAIN_REPO_NAME: 'airbus/discrete-optimization'
+
+on:
+  push:
+    branches:
+      - "**"
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+'
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+
+  linters:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: create requirements.txt so that pip cache with setup-python works
+        run: echo "pre-commit" > requirements_precommit.txt
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.8"
+          cache: "pip"
+          cache-dependency-path: requirements_precommit.txt
+      - name: install pre-commit
+        run: python -m pip install pre-commit
+      - name: get cached pre-commit hooks
+        uses: actions/cache@v4
+        with:
+          path: ~/.cache/pre-commit
+          key: pre-commit|${{ env.pythonLocation }}|${{ hashFiles('.pre-commit-config.yaml') }}
+      - name: pre-commit checks
+        run: pre-commit run --show-diff-on-failure --color=always --all-files
+
+  trigger:
+    # store trigger reason
+    runs-on: ubuntu-latest
+    outputs:
+      is_release: ${{ steps.reason.outputs.is_release }}
+      is_push_on_default_branch: ${{ steps.reason.outputs.is_push_on_default_branch }}
+    steps:
+      - id: reason
+        run: |
+          echo "is_release=${{ startsWith(github.ref, 'refs/tags/v') }}" >> $GITHUB_OUTPUT
+          echo "is_push_on_default_branch=${{ github.ref == format('refs/heads/{0}', github.event.repository.default_branch) }}" >> $GITHUB_OUTPUT
+
+  build:
+    runs-on: ubuntu-latest
+    needs: trigger
+    outputs:
+      do_version: ${{ steps.get_library_version.outputs.version }}
+    steps:
+      - name: Checkout source code
+        uses: actions/checkout@v4
+      - name: create requirements.txt so that pip cache with setup-python works
+        run:
+          echo "build" > requirements_build.txt
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.8"
+          cache: "pip"
+          cache-dependency-path: requirements_build.txt
+      - name: Install build dependencies
+        run: pip install -U build
+      - name: Build discrete-optimization (wheel + source code)
+        run: python -m build
+      - name: Upload as build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist
+      - name: get library version and save it
+        id: get_library_version
+        run: |
+          wheelfile=$(ls ./dist/discrete_optimization*.whl)
+          version=$(python -c "print('$wheelfile'.split('-')[1])")
+          echo "version=$version"
+          echo "version=$version" >> $GITHUB_OUTPUT
+
+  test:
+    needs: build
+    strategy:
+      fail-fast: false
+      matrix:
+        os: ["ubuntu-latest", "macos-12", "macos-latest", "windows-latest"]
+        python-version: ["3.8", "3.11"]
+        wo_gurobi: ["", "without gurobi"]
+        include:
+          - os: "ubuntu-latest"
+            minizinc_config_cmdline: export PATH=$PATH:$(pwd)/bin/squashfs-root/usr/bin; export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$(pwd)/bin/squashfs-root/usr/lib
+            minizinc_cache_path: $(pwd)/bin/squashfs-root
+            minizinc_url: https://github.com/MiniZinc/MiniZincIDE/releases/download/2.8.3/MiniZincIDE-2.8.3-x86_64.AppImage
+            minizinc_downloaded_filepath: bin/minizinc.AppImage
+            minizinc_install_cmdline: cd bin; sudo chmod +x minizinc.AppImage; sudo ./minizinc.AppImage --appimage-extract; cd ..
+            minizinc_prerequisites_cmdline: sudo apt update && sudo apt install libegl1 -y
+          - os: "macos-12"
+            minizinc_config_cmdline: export PATH=$PATH:$(pwd)/bin/MiniZincIDE.app/Contents/Resources
+            minizinc_cache_path: $(pwd)/bin/MiniZincIDE.app
+            minizinc_url: https://github.com/MiniZinc/MiniZincIDE/releases/download/2.8.3/MiniZincIDE-2.8.3-bundled.dmg
+            minizinc_downloaded_filepath: bin/minizinc.dmg
+            minizinc_install_cmdline: sudo hdiutil attach bin/minizinc.dmg; sudo cp -R /Volumes/MiniZinc*/MiniZincIDE.app bin/.
+            minizinc_prerequisites_cmdline: ""
+          - os: "macos-latest"
+            minizinc_config_cmdline: export PATH=$PATH:$(pwd)/bin/MiniZincIDE.app/Contents/Resources
+            minizinc_cache_path: $(pwd)/bin/MiniZincIDE.app
+            minizinc_url: https://github.com/MiniZinc/MiniZincIDE/releases/download/2.8.3/MiniZincIDE-2.8.3-bundled.dmg
+            minizinc_downloaded_filepath: bin/minizinc.dmg
+            minizinc_install_cmdline: sudo hdiutil attach bin/minizinc.dmg; sudo cp -R /Volumes/MiniZinc*/MiniZincIDE.app bin/.
+            minizinc_prerequisites_cmdline: ""
+          - os: "windows-latest"
+            minizinc_config_cmdline: export PATH=$PATH:~/AppData/Local/Programs/MiniZinc
+            minizinc_cache_path: ~/AppData/Local/Programs/MiniZinc
+            minizinc_url: https://github.com/MiniZinc/MiniZincIDE/releases/download/2.8.3/MiniZincIDE-2.8.3-bundled-setup-win64.exe
+            minizinc_downloaded_filepath: minizinc_setup.exe
+            minizinc_install_cmdline: cmd //c "minizinc_setup.exe /verysilent /currentuser /norestart /suppressmsgboxes /sp"
+            minizinc_prerequisites_cmdline: ""
+          - coverage: false  # generally no coverage to avoid multiple reports
+          - coverage: true  # coverage only for one entry of the matrix
+            os: "ubuntu-latest"
+            python-version: "3.11"
+            wo_gurobi: ""
+        exclude:
+          - os: "windows-latest"
+            wo_gurobi: "without gurobi"
+          - os: "macos-12"
+            wo_gurobi: "without gurobi"
+          - os: "macos-latest"
+            wo_gurobi: "without gurobi"
+          - os: "ubuntu-latest"
+            wo_gurobi: "without gurobi"
+            python-version: "3.8"
+          - os: "macos-latest"
+            python-version: "3.8"
+          - os: "macos-12"
+            python-version: "3.11"
+    runs-on: ${{ matrix.os }}
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - name: Checkout discrete-optimization source code
+        uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: "pip"
+          cache-dependency-path: pyproject.toml
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist
+      - name: Install prerelease version of pymip (only for macos arm64)
+        if: matrix.os == 'macos-latest'
+        run: |
+          python -m pip install -U pip
+          pip install mip==1.16rc0
+      - name: Install only discrete-optimization
+        run: |
+          python -m pip install -U pip
+          wheelfile=$(ls ./dist/discrete_optimization*.whl)
+          pip install ${wheelfile}
+      - name: Check import work without minizinc if DO_SKIP_MZN_CHECK set
+        run: |
+          export DO_SKIP_MZN_CHECK=1
+          python -c "import discrete_optimization"
+      - name: Check import fails without minizinc if DO_SKIP_MZN_CHECK unset
+        run: |
+          python -c "
+          try:
+            import discrete_optimization
+          except RuntimeError:
+            pass
+          else:
+            raise AssertionError('We should not be able to import discrete_optimization without minizinc being installed.')
+          "
+      - name: Create bin/
+        run: mkdir -p bin
+      - name: Minizinc prerequisites
+        run: |
+          ${{ matrix.minizinc_prerequisites_cmdline }}
+      - name: get MiniZinc path to cache
+        id: get-mzn-cache-path
+        run: |
+          echo "path=${{ matrix.minizinc_cache_path }}" >> $GITHUB_OUTPUT  # expands variables
+      - name: Restore MiniZinc cache
+        id: cache-minizinc
+        uses: actions/cache@v4
+        with:
+          path: ${{ steps.get-mzn-cache-path.outputs.path }}
+          key: ${{ matrix.minizinc_url }}
+      - name: Download MiniZinc
+        if: steps.cache-minizinc.outputs.cache-hit != 'true'
+        run: |
+          curl -o "${{ matrix.minizinc_downloaded_filepath }}" -L ${{ matrix.minizinc_url }}
+      - name: Install MiniZinc
+        if: steps.cache-minizinc.outputs.cache-hit != 'true'
+        run: |
+          ${{ matrix.minizinc_install_cmdline }}
+      - name: Test minizinc install
+        run: |
+          ${{ matrix.minizinc_config_cmdline }}
+          minizinc --version
+      - name: Check imports are working
+        run: |
+          # configure minizinc
+          ${{ matrix.minizinc_config_cmdline }}
+          # check imports
+          python tests/test_import_all_submodules.py
+      - name: Install test dependencies
+        run: |
+          wheelfile=$(ls ./dist/discrete_optimization*.whl)
+          pip install ${wheelfile}[test]
+          if [ "${{ matrix.wo_gurobi }}" != "without gurobi" ]; then
+            echo "install gurobi"
+            pip install gurobipy
+            python -c "import gurobipy"
+          fi
+      - name: Restore tests data cache
+        id: cache-data
+        uses: actions/cache@v4
+        with:
+          path: ~/discrete_optimization_data
+          key: data-${{ hashFiles('discrete_optimization/datasets.py') }}
+      - name: Fetch data for tests
+        if: steps.cache-data.outputs.cache-hit != 'true'
+        run: |
+          ${{ matrix.minizinc_config_cmdline }}
+          python -m discrete_optimization.datasets
+      - name: Test with pytest (no coverage)
+        if: ${{ !matrix.coverage }}
+        run: |
+          # configure minizinc
+          ${{ matrix.minizinc_config_cmdline }}
+          # show library path used
+          pytest -s tests/show_do_path.py
+          # run test suite
+          MPLBACKEND="agg" NUMBA_BOUNDSCHECK=1 pytest \
+            -v --durations=0 --durations-min=10 \
+            tests
+      - name: Test with pytest (with coverage)
+        if: ${{ matrix.coverage }}
+        run: |
+          # configure minizinc
+          ${{ matrix.minizinc_config_cmdline }}
+          # create a tmp directory from which running the tests
+          # so that "--cov discrete_optimization" look for package installed via the wheel
+          # instead of the source directory in the repository (which would lead to a coverage of 0%)
+          mkdir -p tmp && cd tmp
+          # show library path used
+          pytest -s ../tests/show_do_path.py
+          # run test suite
+          MPLBACKEND="agg" NUMBA_BOUNDSCHECK=1 pytest \
+            --cov discrete_optimization  \
+            --cov-report xml:coverage.xml \
+            --cov-report html:coverage_html \
+            --cov-report term \
+            -v --durations=0 --durations-min=10 \
+            ../tests
+          cd ..
+      - name: Upload coverage report as artifact
+        if: ${{ matrix.coverage }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage
+          path: |
+            tmp/coverage.xml
+            tmp/coverage_html
+
+  update-notebooks-for-colab-and-binder:
+    runs-on: ubuntu-latest
+    needs: [trigger, build]
+    outputs:
+      notebooks-branch: ${{ steps.write-output.outputs.notebooks_branch }}
+      binder-full-ref: ${{ steps.write-output.outputs.binder_full_ref }}
+    steps:
+      - name: Set default notebooks branch and binder env full ref
+        run: |
+          # default value: current branch
+          echo 'notebooks_branch="${{ github.ref_name}}"' >> $GITHUB_ENV
+          echo 'binder_full_ref="${{ github.repository }}/${{ github.ref_name}}"' >> $GITHUB_ENV
+      - uses: actions/checkout@v4
+        if: needs.trigger.outputs.is_release == 'true'
+      - name: replace d-o version to install in colab notebooks
+        if: needs.trigger.outputs.is_release == 'true'
+        run: |
+          version=${{ needs.build.outputs.do_version }}
+          old_pip_spec_pattern="\(pip.*install.*\)git+https.*egg=discrete-optimization"
+          new_pip_spec_pattern="\1discrete-optimization==$version"
+          if ${{ github.repository != env.MAIN_REPO_NAME && secrets.TEST_PYPI_API_TOKEN != '' }} == 'true'; then
+            # install from TestPypi if on a fork
+            new_pip_spec_pattern="${new_pip_spec_pattern} --extra-index-url https://test.pypi.org/simple/"
+          fi
+          shopt -s globstar  # enable **
+          sed -i -e "s|${old_pip_spec_pattern}|${new_pip_spec_pattern}|" notebooks/**/*.ipynb
+      - name: replace d-o version to install in binder environment
+        if: needs.trigger.outputs.is_release == 'true'
+        run: |
+          version=${{ needs.build.outputs.do_version }}
+          linefilter="/^name/!"
+          old_pip_spec_pattern="\(\s*\)-.*discrete-optimization.*$"
+          new_pip_spec_pattern="\1- discrete-optimization==$version"
+          if ${{ github.repository != env.MAIN_REPO_NAME && secrets.TEST_PYPI_API_TOKEN != '' }} == 'true'; then
+            # install from TestPypi if on a fork
+            new_pip_spec_pattern="${new_pip_spec_pattern}\n\1- --extra-index-url https://test.pypi.org/simple/"
+          fi
+          sed_command="${linefilter}s|${old_pip_spec_pattern}|${new_pip_spec_pattern}|"
+          echo sed -i -e ${sed_command} binder/environment.yml
+          sed -i -e "${sed_command}" binder/environment.yml
+      - name: push modifications on a dedicated tag
+        if: needs.trigger.outputs.is_release == 'true'
+        id: push-tuto-release-tag
+        run: |
+          current_tag_name=${GITHUB_REF/refs\/tags\//}  # stripping refs/tags/
+          new_tag_name="notebooks-${current_tag_name}"
+          echo ${new_tag_name}
+          git config user.name "Actions"
+          git config user.email "actions@github.com"
+          git commit binder/environment.yml notebooks -m "Install appropriate version of discrete-optimization"
+          git tag ${new_tag_name} -m "Use release ${current_tag_name} in binder and colab"
+          git push origin ${new_tag_name}
+          # store new tag name as notebooks branch
+          echo "notebooks_branch=${new_tag_name}" >> $GITHUB_ENV
+          echo "binder_full_ref=${{ github.repository }}/${new_tag_name}" >> $GITHUB_ENV
+      - name: write new notebooks branch in job outputs
+        id: write-output
+        run: |
+          echo "notebooks_branch=${notebooks_branch}" >> $GITHUB_OUTPUT
+          echo "binder_full_ref=${binder_full_ref}" >> $GITHUB_OUTPUT
+
+  build-doc:
+    needs: [update-notebooks-for-colab-and-binder]
+    uses: ./.github/workflows/build-doc.yml
+    with:
+      notebooks-branch: ${{ needs.update-notebooks-for-colab-and-binder.outputs.notebooks-branch }}
+      doc-prerequisites-cmdline: export DO_SKIP_MZN_CHECK=1
+
+  deploy:
+    # for release tags
+    runs-on: ubuntu-latest
+    needs: [trigger, test]
+    if: needs.trigger.outputs.is_release == 'true'
+    steps:
+      - name: Download wheels artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist
+      - name: Create the github release
+        uses: ncipollo/release-action@v1
+        with:
+          artifacts: dist
+          generateReleaseNotes: true
+      - name: Publish package to TestPyPI (only for forks)
+        env:
+          TEST_PYPI_API_TOKEN: ${{ secrets.TEST_PYPI_API_TOKEN }}
+        if: github.repository != env.MAIN_REPO_NAME && env.TEST_PYPI_API_TOKEN != ''
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.TEST_PYPI_API_TOKEN }}
+          repository_url: https://test.pypi.org/legacy/
+      - name: Publish package to PyPI (main repo)
+        env:
+          PYPI_API_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
+        if: github.repository == env.MAIN_REPO_NAME && env.PYPI_API_TOKEN != ''
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.PYPI_API_TOKEN }}
+
+  deploy-doc:
+    needs: [trigger, update-notebooks-for-colab-and-binder, build-doc, test, deploy]
+    # if: always()
+    #  -> trigger even if one needed job was skipped (namely deploy)
+    #  -> needed jobs successes must be checked explicitely
+    if: |
+      always()
+      && (needs.build-doc.result == 'success')
+      && (
+        (
+          (needs.trigger.outputs.is_push_on_default_branch == 'true')
+          && (needs.test.result == 'success')
+        )
+        || (
+          (needs.trigger.outputs.is_release == 'true')
+          && (needs.deploy.result == 'success')
+        )
+      )
+    uses: ./.github/workflows/deploy-doc.yml
+    with:
+      doc-version: ${{ needs.build-doc.outputs.doc-version }}
+      binder-env-fullref: ${{ needs.update-notebooks-for-colab-and-binder.outputs.binder-full-ref }}

discrete_optimization-0.3.0/.github/workflows/deploy-doc.yml

@@ -0,0 +1,90 @@
+name: Deploy doc
+
+on:
+  workflow_call:
+    inputs:
+      doc-version:
+        description: "Name of the doc version. The doc will be deployed to a subfolder with that name."
+        required: true
+        type: string
+      doc-artifact-name:
+        description: "Name of the artifact containing the built doc"
+        required: false
+        default: "doc"
+        type: string
+      doc-path:
+        description: "Path where to extract the built doc"
+        required: false
+        default: "docs/build/html"
+        type: string
+      binder-env-fullref:
+        description: "Full ref of the binder env to build. The build is triggered only if not empty."
+        required: false
+        default: ""
+        type: string
+jobs:
+  trigger-binder-build:
+    runs-on: ubuntu-latest
+    if: inputs.binder-env-fullref != ''
+    steps:
+      - uses: actions/checkout@v4  # checkout triggering branch to get scripts/trigger_binder.sh
+      - name: Trigger a build for default binder env ref on each BinderHub deployments in the mybinder.org federation
+        continue-on-error: true
+        run: |
+          binder_env_full_ref=${{ inputs.binder-env-fullref }}
+          echo Triggering binder environment build for ${binder_env_full_ref}
+          bash scripts/trigger_binder.sh https://ovh.mybinder.org/build/gh/${binder_env_full_ref}
+          bash scripts/trigger_binder.sh https://ovh2.mybinder.org/build/gh/${binder_env_full_ref}
+          bash scripts/trigger_binder.sh https://notebooks.gesis.org/binder/build/gh/${binder_env_full_ref}
+
+  deploy-doc:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: ${{ inputs.doc-artifact-name }}
+          path: ${{ inputs.doc-path }}
+      - name: Deploy documentation in a version subfolder on GH pages
+        uses: JamesIves/github-pages-deploy-action@v4
+        with:
+          branch: gh-pages # The branch the action should deploy to.
+          folder: ${{ inputs.doc-path }} # The folder the action should deploy.
+          target-folder: /${{ inputs.doc-version }} # The folder the action should deploy to.
+          commit-message: publish documentation
+          single-commit: true
+
+  update-doc-versions:
+    # update doc versions index if the doc has been deployed
+    needs: [deploy-doc]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: gh-pages
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+      - name: Generate versions.json
+        shell: python3 {0}
+        run: |
+          import json
+          from pathlib import Path
+
+          cwd = Path.cwd()
+          versions = sorted((item.name for item in cwd.iterdir()
+                             if item.is_dir() and not item.name.startswith('.')),
+                            reverse=True)
+          target_file = Path('versions.json')
+          with target_file.open('w') as f:
+              json.dump(versions, f)
+      - name: Commit versions.json
+        shell: bash
+        run: |
+          # Commit versions.json and squash it with previous commit
+          git config user.name "Actions"
+          git config user.email "actions@github.com"
+          git add versions.json
+          git commit --amend --no-edit
+          git push -f origin gh-pages

discrete_optimization-0.3.0/.gitignore

@@ -0,0 +1,24 @@
+# Mac
+.DS_Store
+
+# IDE
+.*/
+
+# Python
+__pycache__/
+.python-version
+
+# Temp files
+*.tmp
+
+# Build files
+build/
+dist/
+
+# Docs built/generated files
+docs/build
+docs/source/api/*
+!docs/source/api/modules.md
+
+# coverage
+.coverage