diracx 0.0.1a44__tar.gz → 0.0.1a46__tar.gz

diracx-0.0.1a46/.coveragerc

@@ -0,0 +1,33 @@
+[run]
+omit =
+    tests/*
+    */tests/*
+    **/diracx/client/_generated/*
+    **/diracx/testing/*
+    **/gubbins/testing/*
+    **/gubbins/client/_generated/*
+
+[paths]
+source =
+    src/
+    */src/
+    */site-packages/
+    /diracx_source/*/src/
+    /diracx_source/*/*/src/
+
+[report]
+include_namespace_packages = true
+exclude_lines =
+    # Have to re-enable the standard pragma
+    pragma: no cover
+
+    # Don't complain if tests don't hit defensive assertion code:
+    raise NotImplementedError
+
+    # Ignore the default implementation of abstract methods
+    ^\s*\.\.\.$
+
+    if TYPE_CHECKING:
+omit =
+    **/diracx/client/*
+    **/diracx/testing/*

diracx-0.0.1a46/.gitattributes

@@ -0,0 +1,2 @@
+# SCM syntax highlighting & preventing 3-way merges
+pixi.lock merge=binary linguist-language=YAML linguist-generated=true

diracx-0.0.1a46/.github/dependabot.yml

@@ -0,0 +1,11 @@
+version: 2
+updates:
+  # Maintain dependencies for GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    groups:
+      actions:
+        patterns:
+          - "*"

diracx-0.0.1a46/.github/workflows/deployment.yml

@@ -0,0 +1,221 @@
+name: Deployment
+
+on:
+  push:
+  pull_request:
+  schedule:
+    - cron: '0 10 * * *'
+  workflow_dispatch:
+    inputs:
+      check-ci:
+        description: "Require the CI to have passed for this commit"
+        required: true
+        default: "yes"
+      version:
+        description: "Override the release version number (e.g. 8.0.0a5)"
+
+jobs:
+  deploy-pypi:
+    name: PyPI deployment
+    runs-on: "ubuntu-latest"
+    if: github.event_name != 'push' || github.repository == 'DIRACGrid/diracx'
+    outputs:
+      new-version: ${{ steps.check-tag.outputs.new-version }}
+      create-release: ${{ steps.check-tag.outputs.create-release }}
+    permissions:
+      id-token: write  # IMPORTANT: this permission is mandatory for trusted publishing on pypi
+      actions: write
+      checks: write
+      contents: write
+      deployments: write
+      discussions: write
+      issues: write
+      packages: write
+      pages: write
+      pull-requests: write
+      repository-projects: write
+      security-events: write
+      statuses: write
+    defaults:
+      run:
+        # We need extglob for REFERENCE_BRANCH substitution
+        shell: bash -l -O extglob {0}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          token: ${{ github.token }}
+      - run: |
+          git fetch --prune --unshallow
+          git config --global user.email "ci@diracgrid.org"
+          git config --global user.name "DIRACGrid CI"
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - name: Installing dependencies
+        run: |
+          python -m pip install \
+              build \
+              python-dateutil \
+              pytz \
+              readme_renderer[md] \
+              requests \
+              setuptools_scm
+      - name: Validate README for PyPI
+        run: |
+          python -m readme_renderer README.md -o /tmp/README.html
+      - name: Prepare release notes
+        run: |
+          set -xeuo pipefail
+          IFS=$'\n\t'
+          # Needed for the advanced pattern matching used in REFERENCE_BRANCH
+          PREV_VERSION=$(git describe --tags --abbrev=0)
+          # In case of manual trigger,
+          # GITHUB_REF is of the form refs/heads/main -> we want main
+          # In case of PR it is of the form refs/pull/59/merge -> we want pull/59/merge
+          REFERENCE_BRANCH=${GITHUB_REF##refs*(/heads)/}
+          echo "Making release notes for ${REFERENCE_BRANCH} since ${PREV_VERSION}"
+          (git log ${PREV_VERSION}...${REFERENCE_BRANCH} --oneline --no-merges --) > release.notes.new
+          cat release.notes.new
+      - name: Create tag if required
+        id: check-tag
+        run: |
+          set -xeuo pipefail
+          IFS=$'\n\t'
+          # Only do a real release for workflow_dispatch events
+          if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
+            echo "Will create a real release"
+            export NEW_VERSION="v${{ github.event.inputs.version }}"
+            if [[ "${NEW_VERSION}" == "v" ]]; then
+              # If version wasn't given as an input to the workflow, use setuptools_scm to guess while removing "dev" portion of the version number
+              NEW_VERSION=v$(python -m setuptools_scm | sed 's@Guessed Version @@g' | sed -E 's@(\.dev|\+g).+@@g')
+              export NEW_VERSION
+            fi
+            echo "Release will be named $NEW_VERSION"
+            # Validate the version
+            # Ensure the version doesn't look like a PEP-440 "dev release" (which might happen if the automatic version bump has issues)
+            python -c $'from packaging.version import Version; v = Version('"'$NEW_VERSION'"$')\nif v.is_devrelease:\n    raise ValueError(v)'
+            # Make sure we always only create pre-releases
+            python -c $'from packaging.version import Version; v = Version('"'$NEW_VERSION'"$')\nif not v.is_prerelease:\n    raise ValueError("integration should only be used for pre-releases")'
+            # Commit the release notes
+            mv release.notes release.notes.old
+            cat release.notes.old
+            (echo -e "[${NEW_VERSION}]" &&  cat release.notes.new release.notes.old) > release.notes
+            ###################3
+            # TODO: we should add the release notes somewhere at some point
+            # now we just don't do it because main branch is protected
+            # and we can't push directly from the CI
+            #git add release.notes
+            #git commit -m "docs: Add release notes for $NEW_VERSION"
+            # Stash is mandatory not to leave the repo dirty
+            git stash
+            ########################
+            git show
+            # Create the tag
+            git tag "$NEW_VERSION"
+            echo "create-release=true" >> $GITHUB_OUTPUT
+            echo "new-version=$NEW_VERSION" >> $GITHUB_OUTPUT
+          fi
+      - name: Build distributions
+        run: |
+          for pkg_dir in $PWD/diracx-*; do
+            echo "Building $pkg_dir"
+            python -m build --outdir $PWD/dist $pkg_dir
+          done
+          # Also build the diracx metapackage
+          python -m build --outdir $PWD/dist .
+      - name: 'Upload Artifact'
+        uses: actions/upload-artifact@v4
+        with:
+          name: diracx-whl
+          path: dist/diracx*.whl
+          retention-days: 5
+      - name: Make release on GitHub
+        if: steps.check-tag.outputs.create-release == 'true'
+        run: |
+          set -e
+          export NEW_VERSION=${{ steps.check-tag.outputs.new-version }}
+          REFERENCE_BRANCH=${GITHUB_REF##refs*(/heads)/}
+          echo "Pushing tagged release notes to ${REFERENCE_BRANCH}"
+          git push "origin" "${REFERENCE_BRANCH}"
+          echo "Making GitHub release for ${NEW_VERSION}"
+          .github/workflows/make_release.py \
+            --repo="${{ github.repository }}" \
+            --token="${{ secrets.GITHUB_TOKEN }}" \
+            --version="${NEW_VERSION}" \
+            --rev="$(git rev-parse HEAD)" \
+            --release-notes-fn="release.notes.new"
+      # Use trusted publisher for pypi
+      # https://docs.pypi.org/trusted-publishers/
+      - name: Publish package on PyPI
+        if: steps.check-tag.outputs.create-release == 'true'
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+  docker:
+    needs: deploy-pypi
+    timeout-minutes:  30
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      - name: Login to GitHub container registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Download diracx wheels
+        uses: actions/download-artifact@v4
+        with:
+            name: diracx-whl
+      - name: "Find wheels"
+        id: find_wheel
+        run: |
+          # We need to copy them there to be able to access them in the RUN --mount
+          cp diracx*.whl containers/client/
+          cp diracx*.whl containers/services/
+          for wheel_fn in *.whl; do
+            pkg_name=$(basename "${wheel_fn}" | cut -d '-' -f 1)
+            echo "${pkg_name}-wheel-name=$(ls "${pkg_name}"-*.whl)" >> $GITHUB_OUTPUT
+          done
+
+      - name: Build and push client (release)
+        uses: docker/build-push-action@v6
+        if: ${{ needs.deploy-pypi.outputs.create-release == 'true' }}
+        with:
+          context: containers/client/
+          push: ${{ needs.deploy-pypi.outputs.create-release == 'true' }}
+          tags: "ghcr.io/diracgrid/diracx/client:${{ needs.deploy-pypi.outputs.new-version }}"
+          platforms: linux/amd64,linux/arm64
+          build-args: EXTRA_PACKAGES_TO_INSTALL=DIRAC~=9.0.0a1
+      - name: Build and push services (release)
+        uses: docker/build-push-action@v6
+        if: ${{ needs.deploy-pypi.outputs.create-release == 'true' }}
+        with:
+          context: containers/services/
+          push: ${{ needs.deploy-pypi.outputs.create-release == 'true' }}
+          tags: "ghcr.io/diracgrid/diracx/services:${{ needs.deploy-pypi.outputs.new-version }}"
+          platforms: linux/amd64,linux/arm64
+          build-args: EXTRA_PACKAGES_TO_INSTALL=DIRAC~=9.0.0a1
+
+      - name: Build and push client (dev)
+        uses: docker/build-push-action@v6
+        with:
+          context: containers/client/
+          push: ${{ github.event_name != 'pull_request' && github.repository == 'DIRACGrid/diracx' && github.ref_name == 'main' }}
+          tags: ghcr.io/diracgrid/diracx/client:dev
+          platforms: linux/amd64,linux/arm64
+          build-args: |
+            EXTRA_PACKAGES_TO_INSTALL=git+https://github.com/DIRACGrid/DIRAC.git@integration
+      - name: Build and push services (dev)
+        uses: docker/build-push-action@v6
+        with:
+          context: containers/services/
+          push: ${{ github.event_name != 'pull_request' && github.repository == 'DIRACGrid/diracx' && github.ref_name == 'main' }}
+          tags: ghcr.io/diracgrid/diracx/services:dev
+          platforms: linux/amd64,linux/arm64
+          build-args: |
+            EXTRA_PACKAGES_TO_INSTALL=git+https://github.com/DIRACGrid/DIRAC.git@integration

diracx-0.0.1a46/.github/workflows/integration.yml

@@ -0,0 +1,76 @@
+name: Integration Tests
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+defaults:
+  run:
+    shell: bash -el {0}
+
+jobs:
+  dirac-integration-tests:
+    name: DIRAC Integration tests
+    if: github.repository == 'DIRACGrid/diracx'
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        dirac-branch:
+          - integration
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - name: Build wheels
+        run: |
+          pip install build
+          for pkg_dir in $PWD/diracx-* .; do
+            echo "Building $pkg_dir"
+            python -m build --outdir "${GITHUB_WORKSPACE}/dist" $pkg_dir
+          done
+      - name: Clone DIRAC
+        run: |
+          pip install typer pyyaml gitpython packaging
+          git clone https://github.com/DIRACGrid/DIRAC.git -b "${{ matrix.dirac-branch }}" /tmp/DIRACRepo
+          echo "Current revision: $(git -C /tmp/DIRACRepo rev-parse HEAD)"
+          # We need to cd in the directory for the integration_tests.py to work
+      - name: Prepare environment
+        run: cd /tmp/DIRACRepo && ./integration_tests.py prepare-environment "TEST_DIRACX=Yes"  --diracx-dist-dir "${GITHUB_WORKSPACE}/dist"
+      - name: Install server
+        run:  cd /tmp/DIRACRepo && ./integration_tests.py install-server
+      - name: Install client
+        run: cd /tmp/DIRACRepo && ./integration_tests.py install-client
+      - name: Install pilot
+        run: cd /tmp/DIRACRepo && ./integration_tests.py install-pilot
+      - name: Server tests
+        run: cd /tmp/DIRACRepo && ./integration_tests.py test-server || touch server-tests-failed
+      - name: Client tests
+        run: cd /tmp/DIRACRepo && ./integration_tests.py test-client || touch client-tests-failed
+      - name: Pilot tests
+        run: cd /tmp/DIRACRepo && ./integration_tests.py test-pilot || touch pilot-tests-failed
+      - name: Check test status
+        run: |
+          has_error=0
+          # TODO: set has_error=1 when we are ready to really run the tests
+          if [ -f server-tests-failed ]; then has_error=0; echo "Server tests failed"; fi
+          if [ -f client-tests-failed ]; then has_error=0; echo "Client tests failed"; fi
+          if [ -f pilot-tests-failed ]; then has_error=0; echo "Pilot tests failed"; fi
+          if [ ${has_error} = 1 ]; then exit 1; fi
+      - name: diracx logs
+        if: ${{ failure() }}
+        run: |
+          mkdir -p /tmp/service-logs
+          docker logs diracx 2>&1 | tee /tmp/service-logs/diracx.log
+          cd /tmp/DIRACRepo
+          ./integration_tests.py logs --no-follow --lines 1000 2>&1 | tee /tmp/service-logs/dirac.log
+      - uses: actions/upload-artifact@v4
+        if: ${{ failure() }}
+        with:
+          name: service-logs-${{ github.job }}
+          path: /tmp/service-logs/

diracx-0.0.1a46/.github/workflows/main.yml

@@ -0,0 +1,241 @@
+name: Basic Tests
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+
+  shellcheck:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - uses: prefix-dev/setup-pixi@v0.8.11
+        with:
+          run-install: false
+          post-cleanup: false
+      - name: Apply workarounds
+        run: |
+          # Workaround for https://github.com/prefix-dev/pixi/issues/3762
+          sed -i.bak 's@editable = true@editable = false@g' pixi.toml
+          rm pixi.toml.bak
+          # Add annotations to github actions
+          pixi add --no-install --pypi --feature diracx-core pytest-github-actions-annotate-failures
+          # Show any changes
+          git diff
+      - uses: prefix-dev/setup-pixi@v0.8.11
+        with:
+          cache: false
+          environments: shellcheck
+      - name: Run shellcheck
+        run: pixi run shellcheck
+
+  unittest:
+    name: Unit test - ${{ matrix.package }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        package:
+          - diracx-core
+          - diracx-db
+          - diracx-logic
+          - diracx-routers
+          - diracx-client
+          - diracx-api
+          - diracx-cli
+          - gubbins-core
+          - gubbins-db
+          - gubbins-logic
+          - gubbins-routers
+          - gubbins-client
+          - gubbins-api
+          - gubbins-cli
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - uses: prefix-dev/setup-pixi@v0.8.11
+        with:
+          run-install: false
+          post-cleanup: false
+      - name: Apply workarounds
+        run: |
+          # Workaround for https://github.com/prefix-dev/pixi/issues/3762
+          sed -i.bak 's@editable = true@editable = false@g' pixi.toml
+          rm pixi.toml.bak
+          # Add annotations to github actions
+          pixi add --no-install --pypi --feature diracx-core pytest-github-actions-annotate-failures
+          # Show any changes
+          git diff
+      - uses: prefix-dev/setup-pixi@v0.8.11
+        with:
+          cache: false
+          environments: ${{ matrix.package }}
+      - name: Run pytest
+        run: pixi run pytest-${{ matrix.package }} --cov-report=xml:coverage.xml --junitxml=report.xml
+      - name: Upload coverage report
+        uses: codecov/codecov-action@v5.4.3
+
+  pytest-integration:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        extension:
+          - diracx
+          - gubbins
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - uses: prefix-dev/setup-pixi@v0.8.11
+        with:
+          run-install: false
+          post-cleanup: false
+      - name: Apply workarounds
+        run: |
+          # Workaround for https://github.com/prefix-dev/pixi/issues/3762
+          sed -i.bak 's@editable = true@editable = false@g' pixi.toml
+          rm pixi.toml.bak
+          # Add annotations to github actions
+          pixi add --no-install --pypi --feature diracx-core pytest-github-actions-annotate-failures
+          # Show any changes
+          git diff
+      - uses: prefix-dev/setup-pixi@v0.8.11
+        with:
+          cache: false
+          environments: ${{ matrix.extension == 'diracx' && 'default' || 'default-gubbins' }}
+      - name: Build gubbins wheels
+        if: ${{ matrix.extension == 'gubbins' }}
+        run: |
+          for pkg_dir in $PWD/diracx-*; do
+            echo "Building $pkg_dir"
+            pixi exec python-build --outdir $PWD/extensions/containers/services/ $pkg_dir
+          done
+          # Also build the diracx metapackage
+          pixi exec python-build --outdir $PWD/extensions/containers/services/ .
+          # And build the gubbins package
+          for pkg_dir in $PWD/extensions/gubbins/gubbins-*; do
+            # Skip the testing package
+            if [[ "${pkg_dir}" =~ .*testing.* ]];
+            then
+              echo "Do not build ${pkg_dir}";
+              continue;
+            fi
+            echo "Building $pkg_dir"
+            pixi exec python-build --outdir $PWD/extensions/containers/services/ $pkg_dir
+          done
+      - name: Set up Docker Buildx
+        if: ${{ matrix.extension == 'gubbins' }}
+        uses: docker/setup-buildx-action@v3
+      - name: Build container for gubbins
+        if: ${{ matrix.extension == 'gubbins' }}
+        uses: docker/build-push-action@v6
+        with:
+          context: extensions/containers/services
+          tags: gubbins/services:dev
+          outputs: type=docker,dest=/tmp/gubbins_services_image.tar
+          build-args: |
+            EXTENSION_CUSTOM_SOURCES_TO_INSTALL=/bindmount/gubbins_db*.whl,/bindmount/gubbins_logic*.whl,/bindmount/gubbins_routers*.whl,/bindmount/gubbins_client*.whl
+      - name: Load image
+        if: ${{ matrix.extension == 'gubbins' }}
+        run: |
+          docker load --input /tmp/gubbins_services_image.tar
+          docker image ls -a
+      - name: Start demo
+        run: |
+          git clone https://github.com/DIRACGrid/diracx-charts.git ../diracx-charts
+
+          declare -a demo_args=()
+          demo_args+=("--enable-open-telemetry")
+          demo_args+=("--enable-coverage")
+          demo_args+=("--exit-when-done")
+          demo_args+=("--set-value" "developer.autoReload=false")
+          demo_args+=("--ci-values" "../diracx-charts/demo/ci_values.yaml")
+
+          declare -a demo_source_dirs=("$PWD")
+
+          if [ ${{ matrix.extension }} == 'gubbins' ]; then
+            # We have to copy the code to another directory
+            # and make it a git repository by itself because otherwise the
+            # root in the pyproject to do not make sense once mounted
+            # in the containers.
+            cp -r ./extensions/gubbins /tmp/
+            sed -i 's@../..@.@g' /tmp/gubbins/pyproject.toml
+            sed -i 's@../../@@g' /tmp/gubbins/gubbins-*/pyproject.toml
+            git init /tmp/gubbins/
+
+            demo_args+=("--ci-values" "./extensions/gubbins_values.yaml")
+            demo_args+=("--load-docker-image" "gubbins/services:dev")
+            demo_source_dirs+=("/tmp/gubbins/")
+          elif [ ${{ matrix.extension }} != 'diracx' ]; then
+            echo "Unknown extension: ${{ matrix.extension }}"
+            exit 1
+          fi
+
+          # Run the demo with the provided arguments
+          set -x
+          ../diracx-charts/run_demo.sh "${demo_args[@]}" "${demo_source_dirs[@]}"
+      - name: Debugging information
+        run: |
+          DIRACX_DEMO_DIR=$PWD/../diracx-charts/.demo
+          export KUBECONFIG=${DIRACX_DEMO_DIR}/kube.conf
+          export PATH=${DIRACX_DEMO_DIR}:$PATH
+          kubectl get pods
+          for pod_name in $(kubectl get pods -o json | jq -r '.items[] | .metadata.name' | grep -vE '(dex|minio|mysql|rabbitmq|opensearch)'); do
+            echo "${pod_name}"
+            kubectl describe pod/"${pod_name}" || true
+            for container_name in $(kubectl get pods $pod_name -o jsonpath='{.spec.initContainers[*].name} {.spec.containers[*].name}'); do
+              echo $pod_name $container_name
+              kubectl logs "${pod_name}" -c "${container_name}" || true
+            done
+          done
+          if [ ! -f "${DIRACX_DEMO_DIR}/.success" ]; then
+            cat "${DIRACX_DEMO_DIR}/.failed"
+            exit 1
+          fi
+      - name: Run pytest
+        run: |
+          pixi run pytest-${{ matrix.extension }} --demo-dir="$PWD/../diracx-charts/" --cov-report=xml:coverage-pytest.xml --junitxml=report.xml
+      - name: Collect demo coverage
+        run: |
+          pixi run -e ${{ matrix.extension == 'diracx' && 'default' || 'default-gubbins' }} python -m diracx.testing coverage collect-demo --demo-dir=../diracx-charts/.demo
+      - name: Upload coverage report
+        uses: codecov/codecov-action@v5.4.3
+        with:
+          files: ./coverage-pytest.xml,./coverage-demo.xml
+
+  client-generation:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        package: [diracx, gubbins]
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - uses: prefix-dev/setup-pixi@v0.8.11
+        with:
+          run-install: false
+          post-cleanup: false
+      - name: Apply workarounds
+        run: |
+          # Add annotations to github actions
+          pixi add --no-install --pypi --feature diracx-core pytest-github-actions-annotate-failures
+          # Show any changes
+          git diff
+      - uses: prefix-dev/setup-pixi@v0.8.11
+        with:
+          cache: false
+          locked: false
+          environments: ${{ matrix.package }}-generate-client
+      - name: Run autorest
+        run: pixi run -e ${{ matrix.package }}-generate-client generate-client

diracx-0.0.1a46/.github/workflows/make_release.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import requests
+from packaging.version import Version
+
+
+def make_release(version, commit_hash, release_notes=""):
+    """Create a new GitHub release using the given data.
+
+    This function always makes a pre-release first to ensure the "latest" release never corresponds
+    to one without artifacts uploaded. If the new version number is not a pre-release, as
+    determined by PEP-440, it is promoted to at full release after the uploads have completed
+    successfully.
+
+    :param str version: The version of the new release
+    :param str commit_hash: Git revision used for the release
+    :param str release_notes: Release notes
+    """
+    # Create a draft release
+    r = requests.post(
+        f"{api_root}/releases",
+        json={
+            "tag_name": version,
+            "target_commitish": commit_hash,
+            "body": release_notes,
+            "draft": True,
+            "prerelease": Version(version).is_prerelease,
+        },
+        headers=headers,
+        timeout=60,
+    )
+    r.raise_for_status()
+    release_data = r.json()
+    print(f"Created draft release at: {release_data['html_url']}")
+
+    # Publish the release
+    r = requests.patch(
+        release_data["url"],
+        json={
+            "draft": False,
+        },
+        headers=headers,
+        timeout=60,
+    )
+    r.raise_for_status()
+    release_data = r.json()
+    print(f"Published release at: {release_data['html_url']}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--token", required=True)
+    parser.add_argument("--repo", default="DIRACGrid/DIRAC")
+    parser.add_argument("--version", required=True)
+    parser.add_argument("--rev", required=True)
+    parser.add_argument("--release-notes-fn", required=True)
+    args = parser.parse_args()
+
+    token = args.token
+    headers = {
+        "Accept": "application/vnd.github.v3+json",
+        "Authorization": f"token {token}",
+    }
+    api_root = f"https://api.github.com/repos/{args.repo}"
+    release_notes = Path(args.release_notes_fn).read_text()
+
+    if not args.version.startswith("v"):
+        raise ValueError('For consistency versions must start with "v"')
+
+    make_release(args.version, args.rev, release_notes=release_notes)