Merge pull request #623 from Avaiga/feature/refactor-packaging-release

Feature/refactor packaging release

.github/workflows/build-and-release-dev.yml

@@ -0,0 +1,174 @@
+name: Build a dev version for all packages and release them
+
+on:
+  workflow_dispatch:
+
+jobs:
+  fetch-versions:
+    runs-on: ubuntu-latest
+    outputs:
+        config_VERSION: ${{ steps.version-setup.outputs.config_VERSION }}
+        core_VERSION: ${{ steps.version-setup.outputs.core_VERSION }}
+        gui_VERSION: ${{ steps.version-setup.outputs.gui_VERSION }}
+        rest_VERSION: ${{ steps.version-setup.outputs.rest_VERSION }}
+        templates_VERSION: ${{ steps.version-setup.outputs.templates_VERSION }}
+        VERSION: ${{ steps.version-setup.outputs.VERSION }}
+        NEW_VERSION: ${{ steps.version-setup.outputs.NEW_VERSION }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Dev Version
+        id: version-setup
+        run: |
+          python tools/release/setup_version.py ALL dev >> $GITHUB_OUTPUT
+
+  build-and-release-taipy-dev-packages:
+    needs: [fetch-versions]
+    timeout-minutes: 20
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        package: [config, core, gui, rest, templates]
+      max-parallel: 1
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ssh-key: ${{secrets.DEPLOY_KEY}}
+      - uses: actions/setup-python@v4
+        with:
+          python-version: 3.9
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Extract commit hash
+        shell: bash
+        run: echo "HASH=$(git rev-parse HEAD)" >> $GITHUB_OUTPUT
+        id: extract_hash
+
+      - name: Set Build Variables
+        id: set-variables
+        run: |
+          if [ "${{ matrix.package }}" == "config" ]; then
+            echo "package_version=${{needs.fetch-versions.outputs.config_VERSION}}" >> $GITHUB_OUTPUT
+            echo "package_dir=./taipy/config" >> $GITHUB_OUTPUT
+            echo "release_name=${{needs.fetch-versions.outputs.config_VERSION}}-config" >> $GITHUB_OUTPUT
+            echo "tar_path=./dist/${{ github.event.repository.name }}-config-${{needs.fetch-versions.outputs.config_VERSION}}.tar.gz" >> $GITHUB_OUTPUT
+          elif [ "${{ matrix.package }}" == "core" ]; then
+            echo "package_version=${{needs.fetch-versions.outputs.core_VERSION}}" >> $GITHUB_OUTPUT
+            echo "package_dir=./taipy/core" >> $GITHUB_OUTPUT
+            echo "release_name=${{needs.fetch-versions.outputs.core_VERSION}}-core" >> $GITHUB_OUTPUT
+            echo "tar_path=./dist/${{ github.event.repository.name }}-core-${{needs.fetch-versions.outputs.core_VERSION}}.tar.gz" >> $GITHUB_OUTPUT
+          elif [ "${{ matrix.package }}" == "gui" ]; then
+            echo "package_version=${{needs.fetch-versions.outputs.gui_VERSION}}" >> $GITHUB_OUTPUT
+            echo "package_dir=./taipy/gui" >> $GITHUB_OUTPUT
+            echo "release_name=${{needs.fetch-versions.outputs.gui_VERSION}}-gui" >> $GITHUB_OUTPUT
+            echo "tar_path=./dist/${{ github.event.repository.name }}-gui-${{needs.fetch-versions.outputs.gui_VERSION}}.tar.gz" >> $GITHUB_OUTPUT
+          elif [ "${{ matrix.package }}" == "rest" ]; then
+            echo "package_version=${{needs.fetch-versions.outputs.rest_VERSION}}" >> $GITHUB_OUTPUT
+            echo "package_dir=./taipy/rest" >> $GITHUB_OUTPUT
+            echo "release_name=${{needs.fetch-versions.outputs.rest_VERSION}}-rest" >> $GITHUB_OUTPUT
+            echo "tar_path=./dist/${{ github.event.repository.name }}-rest-${{needs.fetch-versions.outputs.rest_VERSION}}.tar.gz" >> $GITHUB_OUTPUT
+          elif [ "${{ matrix.package }}" == "templates" ]; then
+            echo "package_version=${{needs.fetch-versions.outputs.templates_VERSION}}" >> $GITHUB_OUTPUT
+            echo "package_dir=./taipy/templates" >> $GITHUB_OUTPUT
+            echo "release_name=${{needs.fetch-versions.outputs.templates_VERSION}}-templates" >> $GITHUB_OUTPUT
+            echo "tar_path=./dist/${{ github.event.repository.name }}-templates-${{needs.fetch-versions.outputs.templates_VERSION}}.tar.gz" >> $GITHUB_OUTPUT
+          fi
+        shell: bash
+
+      - name: Update setup.requirements.txt
+        run: |
+          python tools/release/update_setup_requirements.py taipy-${{ matrix.package }} \
+            ${{needs.fetch-versions.outputs.config_VERSION}} \
+            ${{needs.fetch-versions.outputs.core_VERSION}} \
+            ${{needs.fetch-versions.outputs.gui_VERSION}} \
+            ${{needs.fetch-versions.outputs.rest_VERSION}} \
+            ${{needs.fetch-versions.outputs.templates_VERSION}}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install build wheel
+
+      - name: Build package
+        working-directory: ${{ steps.set-variables.outputs.package_dir }}
+        run: python setup.py build_py && python -m build
+
+      - name: Create tag and release
+        working-directory: ${{ steps.set-variables.outputs.package_dir }}
+        run: |
+          gh release create ${{ steps.set-variables.outputs.release_name }} ${{ steps.set-variables.outputs.tar_path }} --target ${{ steps.extract_hash.outputs.HASH }} --prerelease --title ${{ steps.set-variables.outputs.release_name }} --notes "Release Draft ${{ steps.set-variables.outputs.release_name }}"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Install Package
+        working-directory: ${{ steps.set-variables.outputs.package_dir }}
+        run: |
+          pip install ${{ steps.set-variables.outputs.tar_path }}
+
+  build-and-release-taipy-dev:
+    runs-on: ubuntu-latest
+    needs: [ build-and-release-taipy-dev-packages, fetch-versions ]
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ssh-key: ${{secrets.DEPLOY_KEY}}
+      - name: Extract commit hash
+        shell: bash
+        run: echo "HASH=$(git rev-parse HEAD)" >> $GITHUB_OUTPUT
+        id: extract_hash
+
+      - name: Set Build Variables
+        id: set-variables
+        run: |
+          echo "package_version=${{needs.fetch-versions.outputs.VERSION}}" >> $GITHUB_OUTPUT
+          echo "release_name=${{needs.fetch-versions.outputs.VERSION}}" >> $GITHUB_OUTPUT
+          echo "tar_path=./dist/${{ github.event.repository.name }}-${{needs.fetch-versions.outputs.VERSION}}.tar.gz" >> $GITHUB_OUTPUT
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install build wheel
+
+      - name: Build Taipy package
+        run: python setup.py build_py && python -m build
+
+      - name: Create tag and release Taipy
+        run: |
+          gh release create ${{ steps.set-variables.outputs.release_name }} ${{ steps.set-variables.outputs.tar_path }} --target ${{ steps.extract_hash.outputs.HASH }} --prerelease --title ${{ steps.set-variables.outputs.release_name }} --notes "Release Draft ${{ steps.set-variables.outputs.release_name }}"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Install Taipy
+        run: |
+          pip install ${{ steps.set-variables.outputs.tar_path }}
+
+      - name: Check Taipy Installation
+        run: |
+          python tools/validate_taipy_install.py
+
+      - name: Download packages
+        run: |
+          gh release download ${{ needs.fetch-versions.outputs.config_VERSION }}-config --skip-existing --dir dist
+          gh release download ${{ needs.fetch-versions.outputs.core_VERSION }}-core --skip-existing --dir dist
+          gh release download ${{ needs.fetch-versions.outputs.gui_VERSION }}-gui --skip-existing --dir dist
+          gh release download ${{ needs.fetch-versions.outputs.rest_VERSION }}-rest --skip-existing --dir dist
+          gh release download ${{ needs.fetch-versions.outputs.templates_VERSION }}-templates --skip-existing --dir dist
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Bundle all packages in main release tag
+        run: |
+          find dist -type f -print0 | xargs -r0 gh release upload ${{ needs.fetch-versions.outputs.VERSION }} --clobber
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Reset changes
+        run: |
+          git reset --hard HEAD
+          git clean -fdx
+
+      - uses: stefanzweifel/git-auto-commit-action@v4
+        with:
+          commit_message: Update version to ${{ needs.fetch-versions.outputs.NEW_VERSION }}

.github/workflows/build-and-release-prod.yml

@@ -0,0 +1,171 @@
+name: Build a dev version for all packages and release them
+
+on:
+  workflow_dispatch:
+
+jobs:
+  fetch-versions:
+    runs-on: ubuntu-latest
+    outputs:
+        config_VERSION: ${{ steps.version-setup.outputs.config_VERSION }}
+        core_VERSION: ${{ steps.version-setup.outputs.core_VERSION }}
+        gui_VERSION: ${{ steps.version-setup.outputs.gui_VERSION }}
+        rest_VERSION: ${{ steps.version-setup.outputs.rest_VERSION }}
+        templates_VERSION: ${{ steps.version-setup.outputs.templates_VERSION }}
+        VERSION: ${{ steps.version-setup.outputs.VERSION }}
+        NEW_VERSION: ${{ steps.version-setup.outputs.NEW_VERSION }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Dev Version
+        id: version-setup
+        run: |
+          python tools/release/setup_version.py ALL production >> $GITHUB_OUTPUT
+
+  build-and-release-taipy-packages:
+    needs: [fetch-versions]
+    timeout-minutes: 20
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        package: [config, core, gui, rest, templates]
+      max-parallel: 1
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ssh-key: ${{secrets.DEPLOY_KEY}}
+      - uses: actions/setup-python@v4
+        with:
+          python-version: 3.9
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Extract commit hash
+        shell: bash
+        run: echo "HASH=$(git rev-parse HEAD)" >> $GITHUB_OUTPUT
+        id: extract_hash
+
+      - name: Set Build Variables
+        id: set-variables
+        run: |
+          if [ "${{ matrix.package }}" == "config" ]; then
+            echo "package_version=${{needs.fetch-versions.outputs.config_VERSION}}" >> $GITHUB_OUTPUT
+            echo "package_dir=./taipy/config" >> $GITHUB_OUTPUT
+            echo "release_name=${{needs.fetch-versions.outputs.config_VERSION}}-config" >> $GITHUB_OUTPUT
+            echo "tar_path=./dist/${{ github.event.repository.name }}-config-${{needs.fetch-versions.outputs.config_VERSION}}.tar.gz" >> $GITHUB_OUTPUT
+          elif [ "${{ matrix.package }}" == "core" ]; then
+            echo "package_version=${{needs.fetch-versions.outputs.core_VERSION}}" >> $GITHUB_OUTPUT
+            echo "package_dir=./taipy/core" >> $GITHUB_OUTPUT
+            echo "release_name=${{needs.fetch-versions.outputs.core_VERSION}}-core" >> $GITHUB_OUTPUT
+            echo "tar_path=./dist/${{ github.event.repository.name }}-core-${{needs.fetch-versions.outputs.core_VERSION}}.tar.gz" >> $GITHUB_OUTPUT
+          elif [ "${{ matrix.package }}" == "gui" ]; then
+            echo "package_version=${{needs.fetch-versions.outputs.gui_VERSION}}" >> $GITHUB_OUTPUT
+            echo "package_dir=./taipy/gui" >> $GITHUB_OUTPUT
+            echo "release_name=${{needs.fetch-versions.outputs.gui_VERSION}}-gui" >> $GITHUB_OUTPUT
+            echo "tar_path=./dist/${{ github.event.repository.name }}-gui-${{needs.fetch-versions.outputs.gui_VERSION}}.tar.gz" >> $GITHUB_OUTPUT
+          elif [ "${{ matrix.package }}" == "rest" ]; then
+            echo "package_version=${{needs.fetch-versions.outputs.rest_VERSION}}" >> $GITHUB_OUTPUT
+            echo "package_dir=./taipy/rest" >> $GITHUB_OUTPUT
+            echo "release_name=${{needs.fetch-versions.outputs.rest_VERSION}}-rest" >> $GITHUB_OUTPUT
+            echo "tar_path=./dist/${{ github.event.repository.name }}-rest-${{needs.fetch-versions.outputs.rest_VERSION}}.tar.gz" >> $GITHUB_OUTPUT
+          elif [ "${{ matrix.package }}" == "templates" ]; then
+            echo "package_version=${{needs.fetch-versions.outputs.templates_VERSION}}" >> $GITHUB_OUTPUT
+            echo "package_dir=./taipy/templates" >> $GITHUB_OUTPUT
+            echo "release_name=${{needs.fetch-versions.outputs.templates_VERSION}}-templates" >> $GITHUB_OUTPUT
+            echo "tar_path=./dist/${{ github.event.repository.name }}-templates-${{needs.fetch-versions.outputs.templates_VERSION}}.tar.gz" >> $GITHUB_OUTPUT
+          fi
+        shell: bash
+
+      - name: Update setup.requirements.txt
+        run: |
+          python tools/release/update_setup_requirements.py taipy-${{ matrix.package }} \
+            ${{needs.fetch-versions.outputs.config_VERSION}} \
+            ${{needs.fetch-versions.outputs.core_VERSION}} \
+            ${{needs.fetch-versions.outputs.gui_VERSION}} \
+            ${{needs.fetch-versions.outputs.rest_VERSION}} \
+            ${{needs.fetch-versions.outputs.templates_VERSION}} \
+            dev
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install build wheel
+
+      - name: Build package
+        working-directory: ${{ steps.set-variables.outputs.package_dir }}
+        run: python setup.py build_py && python -m build
+
+      - name: Create tag and release
+        working-directory: ${{ steps.set-variables.outputs.package_dir }}
+        run: |
+          gh release create ${{ steps.set-variables.outputs.release_name }} ${{ steps.set-variables.outputs.tar_path }} --target ${{ steps.extract_hash.outputs.HASH }} --title ${{ steps.set-variables.outputs.release_name }} --notes "Release ${{ steps.set-variables.outputs.release_name }}"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Install Package
+        working-directory: ${{ steps.set-variables.outputs.package_dir }}
+        run: |
+          pip install ${{ steps.set-variables.outputs.tar_path }}
+
+  build-and-release-taipy:
+    runs-on: ubuntu-latest
+    needs: [ build-and-release-taipy-dev-packages, fetch-versions ]
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ssh-key: ${{secrets.DEPLOY_KEY}}
+      - name: Extract commit hash
+        shell: bash
+        run: echo "HASH=$(git rev-parse HEAD)" >> $GITHUB_OUTPUT
+        id: extract_hash
+
+      - name: Set Build Variables
+        id: set-variables
+        run: |
+          echo "package_version=${{needs.fetch-versions.outputs.VERSION}}" >> $GITHUB_OUTPUT
+          echo "release_name=${{needs.fetch-versions.outputs.VERSION}}" >> $GITHUB_OUTPUT
+          echo "tar_path=./dist/${{ github.event.repository.name }}-${{needs.fetch-versions.outputs.VERSION}}.tar.gz" >> $GITHUB_OUTPUT
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install build wheel
+
+      - name: Build Taipy package
+        run: python setup.py build_py && python -m build
+
+      - name: Create tag and release Taipy
+        run: |
+          gh release create ${{ steps.set-variables.outputs.release_name }} ${{ steps.set-variables.outputs.tar_path }} --target ${{ steps.extract_hash.outputs.HASH }} --title ${{ steps.set-variables.outputs.release_name }} --notes "Release ${{ steps.set-variables.outputs.release_name }}"
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Install Taipy
+        run: |
+          pip install ${{ steps.set-variables.outputs.tar_path }}
+
+      - name: Check Taipy Installation
+        run: |
+          python tools/validate_taipy_install.py
+
+      - name: Download packages
+        run: |
+          gh release download ${{ needs.fetch-versions.outputs.config_VERSION }}-config --skip-existing --dir dist
+          gh release download ${{ needs.fetch-versions.outputs.core_VERSION }}-core --skip-existing --dir dist
+          gh release download ${{ needs.fetch-versions.outputs.gui_VERSION }}-gui --skip-existing --dir dist
+          gh release download ${{ needs.fetch-versions.outputs.rest_VERSION }}-rest --skip-existing --dir dist
+          gh release download ${{ needs.fetch-versions.outputs.templates_VERSION }}-templates --skip-existing --dir dist
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Bundle all packages in main release tag
+        run: |
+          find dist -type f -print0 | xargs -r0 gh release upload ${{ needs.fetch-versions.outputs.VERSION }} --clobber
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Reset changes
+        run: |
+          git reset --hard HEAD
+          git clean -fdx

.github/workflows/packaging.yml

@@ -36,19 +36,9 @@ jobs:
         run: |
           pip install .
           rm -rf taipy
-
-          python -c "import taipy as tp; tp.Scenario"
-          python -c "import taipy as tp; tp.gui"
-          python -c "import taipy as tp; tp.rest"
-
-          echo """
-          import taipy
-          from pathlib import Path
-          taipy_gui_core_path = Path(taipy.__file__).absolute().parent / 'gui_core' / 'lib' / 'taipy-gui-core.js'
-          if not taipy_gui_core_path.exists():
-              raise FileNotFoundError(f'taipy-gui-core.js not found in {taipy_gui_core_path}')
-          """ > ${{ runner.temp }}/verify_gui_core.py
-          python ${{ runner.temp }}/verify_gui_core.py
+      - name: Check Taipy Installation
+        run: |
+          python tools/validate_taipy_install.py
 
       - name: Notify user if failed
         if: failure()

.github/workflows/publish.yml

@@ -21,34 +21,15 @@ jobs:
         id: vars
         run: echo "tag=${GITHUB_REF#refs/*/}" >> $GITHUB_OUTPUT
 
-      - name: Ensure package version is properly set
-        run: |
-          echo """
-          import json, sys, os
-          with open(f\"taipy{os.sep}version.json\") as version_file:
-            version_o = json.load(version_file)
-          version = f'{version_o.get(\"major\")}.{version_o.get(\"minor\")}.{version_o.get(\"patch\")}'
-          if vext := version_o.get(\"ext\"):
-            version = f'{version}.{vext}'
-          if version != sys.argv[1]:
-            raise ValueError(f\"Invalid version {version} / {sys.argv[1]}\")
-          if sys.argv[1] != sys.argv[2]:
-            raise ValueError(f\"Invalid tag version {sys.argv[2]} with package version {sys.argv[1]}\")
-          """ > ${{ runner.temp }}/check.py
-          python ${{ runner.temp }}/check.py "${{ github.event.inputs.version }}" "${{ steps.vars.outputs.tag }}"
-
       - name: Download assets from github release tag
         run: |
           gh release download ${{ github.event.inputs.version }} --dir dist
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Verify there is a release asset
+      - name: Verify if all releases exist
         run: |
-          if [ ! -f dist/${{ github.event.repository.name }}-${{ github.event.inputs.version }}.tar.gz ]; then
-            echo "No release asset found"
-            exit 1
-          fi
+          python tools/release/check_releases.py
 
   publish-to-pypi:
     needs: [test-package]
@@ -98,15 +79,4 @@ jobs:
         run: |
           pip install --upgrade pip
           pip install --no-cache-dir ${{ github.event.repository.name }}==${{ github.event.inputs.version }}
-          python -c "import taipy as tp; tp.Scenario"
-          python -c "import taipy as tp; tp.gui"
-          python -c "import taipy as tp; tp.rest"
-
-          echo """
-          import taipy
-          from pathlib import Path
-          taipy_gui_core_path = Path(taipy.__file__).absolute().parent / 'gui_core' / 'lib' / 'taipy-gui-core.js'
-          if not taipy_gui_core_path.exists():
-              raise FileNotFoundError(f'taipy-gui-core.js not found in {taipy_gui_core_path}')
-          """ > ${{ runner.temp }}/verify_gui_core.py
-          python ${{ runner.temp }}/verify_gui_core.py
+          python tools/validate_taipy_install.py

.github/workflows/release-dev.yml

@@ -1,173 +0,0 @@
-name: Create Github Dev Release
-
-on:
-  workflow_dispatch:
-    inputs:
-      taipy-gui-version:
-        description: "The taipy-gui version to use (ex: 2.3.0.dev0)"
-        required: true
-      taipy-rest-version:
-        description: "The taipy-rest version to use (ex: 2.3.0.dev0)"
-      taipy-templates-version:
-        description: "The taipy-templates version to use (ex: 2.3.0.dev0)"
-
-jobs:
-  release-dev-package:
-    timeout-minutes: 20
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          ssh-key: ${{secrets.DEPLOY_KEY}}
-      - uses: actions/setup-python@v4
-        with:
-          python-version: 3.11
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-
-      - name: Ensure package version has 'dev' suffix
-        run: |
-          echo """
-          import json, sys, os
-          SUFFIX = 'dev'
-          with open(f\"taipy{os.sep}version.json\") as version_file:
-              version_o = json.load(version_file)
-          version = f'{version_o.get(\"major\")}.{version_o.get(\"minor\")}.{version_o.get(\"patch\")}'
-          if vext := version_o.get(\"ext\"):
-              version = f'{version}.{vext}'
-          if SUFFIX not in version:
-              raise ValueError(f\"version {version} does not contain suffix {SUFFIX}\")
-          """ > ${{ runner.temp }}/check1.py
-          python ${{ runner.temp }}/check1.py
-
-      - name: Extract package version
-        id: current-version
-        run: |
-          echo """
-          import json, os
-          with open(f\"taipy{os.sep}version.json\") as version_file:
-              version_o = json.load(version_file)
-          version = f'{version_o.get(\"major\")}.{version_o.get(\"minor\")}.{version_o.get(\"patch\")}'
-          if vext := version_o.get(\"ext\"):
-              version = f'{version}.{vext}'
-          print(f'VERSION={version}')
-          """ > ${{ runner.temp }}/check2.py
-          python ${{ runner.temp }}/check2.py >> $GITHUB_OUTPUT
-
-      - name: Check taipy-gui dependencies
-        run: |
-          curl https://pypi.org/simple/taipy-gui/ | grep -o ">taipy-gui-${{ github.event.inputs.taipy-gui-version }}\.tar\.gz<"
-
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install build wheel
-          pip install "taipy-gui==${{ github.event.inputs.taipy-gui-version }}"
-
-      - name: Check dependencies are available
-        if: github.event.inputs.taipy-rest-version != '' && github.event.inputs.taipy-templates-version != ''
-        run: |
-          curl https://pypi.org/simple/taipy-rest/ | grep -o ">taipy-rest-${{ github.event.inputs.taipy-rest-version }}\.tar\.gz<"
-          curl https://pypi.org/simple/taipy-templates/ | grep -o ">taipy-templates-${{ github.event.inputs.taipy-templates-version }}\.tar\.gz<"
-
-      - name: Update setup.py locally
-        if: github.event.inputs.taipy-gui-version != '' && github.event.inputs.taipy-rest-version != '' && github.event.inputs.taipy-templates-version != ''
-        run: |
-          mv setup.py setup.taipy.py
-          echo """
-          import sys
-          with open('setup.taipy.py', mode='r') as setup_r, open('setup.py', mode='w') as setup_w:
-              in_requirements = False
-              looking = True
-              for line in setup_r:
-                  if looking:
-                      if line.lstrip().startswith('requirements') and line.rstrip().endswith('['):
-                          in_requirements = True
-                      elif in_requirements:
-                          if line.strip() == ']':
-                              looking = False
-                          else:
-                              if line.lstrip().startswith('\"taipy-gui@git+https'):
-                                  start = line.find('\"taipy-gui')
-                                  end = line.rstrip().find(',')
-                                  line = f'{line[:start]}\"taipy-gui=={sys.argv[1]}\"{line[end:]}'
-                              elif line.lstrip().startswith('\"taipy-rest@git+https'):
-                                  start = line.find('\"taipy-rest')
-                                  end = line.rstrip().find(',')
-                                  line = f'{line[:start]}\"taipy-rest=={sys.argv[2]}\"{line[end:]}'
-                              elif line.lstrip().startswith('\"taipy-templates@git+https'):
-                                  start = line.find('\"taipy-templates')
-                                  end = line.rstrip().find(',')
-                                  line = f'{line[:start]}\"taipy-templates=={sys.argv[3]}\"{line[end:]}'
-                  setup_w.write(line)
-          """ > ${{ runner.temp }}/write_setup_taipy.py
-          python ${{ runner.temp }}/write_setup_taipy.py "${{ github.event.inputs.taipy-gui-version }}" "${{ github.event.inputs.taipy-rest-version }}" "${{ github.event.inputs.taipy-templates-version }}"
-
-      - name: Build package
-        run: python setup.py build_py && python -m build
-
-      - name: Install the package and test it
-        run: |
-          # Install package
-          echo "Installing package..."
-          pip install ./dist/${{ github.event.repository.name }}-${{ steps.current-version.outputs.VERSION }}.tar.gz
-
-          # Run tests
-          python -c "import taipy as tp; tp.Scenario"
-          python -c "import taipy as tp; tp.gui"
-          python -c "import taipy as tp; tp.rest"
-
-          echo """
-          import taipy
-          from pathlib import Path
-          taipy_gui_core_path = Path(taipy.__file__).absolute().parent / 'gui_core' / 'lib' / 'taipy-gui-core.js'
-          if not taipy_gui_core_path.exists():
-              raise FileNotFoundError(f'taipy-gui-core.js not found in {taipy_gui_core_path}')
-          """ > ${{ runner.temp }}/verify_gui_core.py
-          python ${{ runner.temp }}/verify_gui_core.py
-
-      - name: Extract commit hash
-        shell: bash
-        run: echo "HASH=$(git rev-parse HEAD)" >> $GITHUB_OUTPUT
-        id: extract_hash
-
-      - name: Create/update release and tag
-        run: |
-          echo "Creating release ${{ steps.current-version.outputs.VERSION }}"
-          gh release create ${{ steps.current-version.outputs.VERSION }} ./dist/${{ github.event.repository.name }}-${{ steps.current-version.outputs.VERSION }}.tar.gz --target ${{ steps.extract_hash.outputs.HASH }} --prerelease --title ${{ steps.current-version.outputs.VERSION }} --notes "Release Draft ${{ steps.current-version.outputs.VERSION }}"
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Reset changes
-        run: |
-          git reset --hard HEAD
-          git clean -fdx
-
-      - name: Increase dev version
-        id: new-version
-        run: |
-          echo """
-          import json, os
-          with open(f'taipy{os.sep}version.json') as version_file:
-              version_o = json.load(version_file)
-              if version_o is None or 'dev' not in version_o['ext']:
-                  raise ValueError('Invalid version file. Version must contain dev suffix.')
-              prev_version = version_o['ext']
-              new_version = 'dev' + str(int(version_o['ext'].replace('dev', '')) + 1)
-              with open(f'taipy{os.sep}version.json') as r:
-                  text = r.read().replace(prev_version, new_version)
-              with open(f'taipy{os.sep}version.json', mode='w') as w:
-                  w.write(text)
-              with open(f\"taipy{os.sep}version.json\") as version_file:
-                  version_o = json.load(version_file)
-              version = f'{version_o.get(\"major\")}.{version_o.get(\"minor\")}.{version_o.get(\"patch\")}'
-              if vext := version_o.get(\"ext\"):
-                  version = f'{version}.{vext}'
-              print(f'VERSION={version}')
-          """ > ${{ runner.temp }}/increase_dev_version.py
-          python ${{ runner.temp }}/increase_dev_version.py >> $GITHUB_OUTPUT
-
-      - uses: stefanzweifel/git-auto-commit-action@v4
-        with:
-          commit_message: Update version to ${{ steps.new-version.outputs.VERSION }}

.github/workflows/release.yml

@@ -1,106 +0,0 @@
-name: Create Github Release
-
-on:
-  workflow_dispatch:
-    inputs:
-      version:
-        description: "The release/package version to create (ex: 1.0.0)"
-        required: true
-
-jobs:
-  release-package:
-    timeout-minutes: 20
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-python@v4
-        with:
-          python-version: 3.11
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '20'
-
-      - name: Extract branch name
-        shell: bash
-        run: echo "branch=${GITHUB_REF#refs/heads/}" >> $GITHUB_OUTPUT
-        id: extract_branch
-
-      - name: Ensure package version is properly set
-        run: |
-          echo """
-          import json, sys, os
-          with open(f\"taipy{os.sep}version.json\") as version_file:
-              version_o = json.load(version_file)
-          version = f'{version_o.get(\"major\")}.{version_o.get(\"minor\")}.{version_o.get(\"patch\")}'
-          if vext := version_o.get(\"ext\"):
-              version = f'{version}.{vext}'
-          if version != sys.argv[1]:
-              raise ValueError(f\"Invalid version {version} / {sys.argv[1]}\")
-          """ > ${{ runner.temp }}/check1.py
-          python ${{ runner.temp }}/check1.py "${{ github.event.inputs.version }}"
-
-      - name: Validate branch name
-        run: |
-          echo """
-          import json, sys, os
-          with open(f\"taipy{os.sep}version.json\") as version_file:
-              version = json.load(version_file)
-          if f'release/{version.get(\"major\")}.{version.get(\"minor\")}' != sys.argv[1]:
-              raise ValueError(f'Branch name mismatch: release/{version.get(\"major\")}.{version.get(\"minor\")} != {sys.argv[1]}')
-          """ > ${{ runner.temp }}/check2.py
-          python ${{ runner.temp }}/check2.py "${{ steps.extract_branch.outputs.branch }}"
-
-      - name: Modify README image file path
-        run: |
-          cp tools/modify_readme.py ${{ runner.temp }}
-          python ${{ runner.temp }}/modify_readme.py "${{ github.event.repository.name }}" "${{ steps.extract_branch.outputs.branch }}"
-
-      - name: Get taipy-gui version from setup.py
-        id: taipy_gui_version
-        run: |
-          echo """
-          with open('setup.py') as f:
-              for line in f:
-                  if 'taipy-gui' in line:
-                      start = line.find('taipy-gui')
-                      end = line.rstrip().find('\",')
-                      print(f'VERSION={line[start:end]}')
-                      break
-          """ > ${{ runner.temp }}/get_gui_version.py
-          python ${{ runner.temp }}/get_gui_version.py >> $GITHUB_OUTPUT
-
-      - name: Install dependencies
-        run: |
-          python -m pip install --upgrade pip
-          pip install build wheel
-          # install taipy-gui from based on setup.py version
-          pip install "${{ steps.taipy_gui_version.outputs.VERSION }}"
-
-      - name: Build and test the package
-        run: |
-          python setup.py build_py && python -m build
-          rm -rf taipy
-          pip install dist/*.tar.gz
-          python -c "import taipy as tp; tp.Scenario"
-          python -c "import taipy as tp; tp.gui"
-          python -c "import taipy as tp; tp.rest"
-
-          echo """
-          import taipy
-          from pathlib import Path
-          taipy_gui_core_path = Path(taipy.__file__).absolute().parent / 'gui_core' / 'lib' / 'taipy-gui-core.js'
-          if not taipy_gui_core_path.exists():
-              raise FileNotFoundError(f'taipy-gui-core.js not found in {taipy_gui_core_path}')
-          """ > ${{ runner.temp }}/verify_gui_core.py
-          python ${{ runner.temp }}/verify_gui_core.py
-
-      - name: Extract commit hash
-        shell: bash
-        run: echo "HASH=$(git rev-parse HEAD)" >> $GITHUB_OUTPUT
-        id: extract_hash
-
-      - name: Create/update release and tag
-        run: |
-            gh release create ${{ github.event.inputs.version }} ./dist/${{ github.event.repository.name }}-${{ github.event.inputs.version }}.tar.gz --target ${{ steps.extract_hash.outputs.HASH }} --title ${{ github.event.inputs.version }}
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

MANIFEST.in

@@ -0,0 +1,14 @@
+recursive-include tools *
+include taipy/core/*.json
+include taipy/core/config/*.json
+include taipy/*.json
+include taipy/gui_core/*.json
+include taipy/gui_core/lib/*.js
+recursive-include taipy/gui/webapp *
+include taipy/gui/version.json
+include taipy/gui/viselements.json
+include taipy/gui/*.pyi
+include taipy/config/*.pyi
+include taipy/config/*.json
+recursive-include taipy/templates *
+include taipy/rest/*.json

setup.py

@@ -11,7 +11,7 @@
 
 """The setup script."""
 
-
+import os
 import json
 import platform
 import subprocess
@@ -25,14 +25,14 @@ root_folder = Path(__file__).parent
 readme = (root_folder / "README.md").read_text("UTF-8")
 
 # get current version
-with open(root_folder / "taipy" / "version.json") as version_file:
+with open(os.path.join("taipy", "version.json")) as version_file:
     version = json.load(version_file)
     version_string = f'{version.get("major", 0)}.{version.get("minor", 0)}.{version.get("patch", 0)}'
     if vext := version.get("ext"):
         version_string = f"{version_string}.{vext}"
 
 # build MANIFEST.in from tools/packages/taipy*/MANIFEST.in
-with open(root_folder / "MANIFEST.in", "w") as man:
+with open(os.path.join(root_folder, "MANIFEST.in"), "a") as man:
     for pman in [
         dir / "MANIFEST.in"
         for dir in (root_folder / "tools" / "packages").iterdir()

taipy/config/MANIFEST.in

@@ -1,2 +1,2 @@
-include taipy/config/*.pyi
-include taipy/config/*.json
+include *.pyi
+include *.json

taipy/config/setup.py

@@ -20,7 +20,9 @@ from setuptools import find_namespace_packages, find_packages, setup
 with open("README.md") as readme_file:
     readme = readme_file.read()
 
-with open(f"src{os.sep}taipy{os.sep}config{os.sep}version.json") as version_file:
+version_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "version.json")
+
+with open(version_path) as version_file:
     version = json.load(version_file)
     version_string = f'{version.get("major", 0)}.{version.get("minor", 0)}.{version.get("patch", 0)}'
     if vext := version.get("ext"):
@@ -47,13 +49,12 @@ setup(
     install_requires=requirements,
     long_description=readme,
     long_description_content_type="text/markdown",
-    include_package_data=True,
     license="Apache License 2.0",
     keywords="taipy-config",
     name="taipy-config",
-    package_dir={"": "src"},
-    packages=find_namespace_packages(where="src")
+    packages=find_namespace_packages(where=".")
     + find_packages(include=["taipy", "taipy.config", "taipy.config.*", "taipy.logger", "taipy.logger.*"]),
+    include_package_data=True,
     test_suite="tests",
     tests_require=test_requirements,
     url="https://github.com/avaiga/taipy-config",

taipy/core/MANIFEST.in

@@ -1,2 +1,2 @@
-include taipy/core/*.json
-include taipy/core/config/*.json
+include *.json
+include config/*.json

taipy/core/setup.py

@@ -20,7 +20,8 @@ from setuptools import find_namespace_packages, find_packages, setup
 with open("README.md") as readme_file:
     readme = readme_file.read()
 
-with open(f"src{os.sep}taipy{os.sep}core{os.sep}version.json") as version_file:
+version_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "version.json")
+with open(version_path) as version_file:
     version = json.load(version_file)
     version_string = f'{version.get("major", 0)}.{version.get("minor", 0)}.{version.get("patch", 0)}'
     if vext := version.get("ext"):
@@ -67,8 +68,7 @@ setup(
     license="Apache License 2.0",
     keywords="taipy-core",
     name="taipy-core",
-    package_dir={"": "src"},
-    packages=find_namespace_packages(where="src") + find_packages(include=["taipy", "taipy.core", "taipy.core.*"]),
+    packages=find_namespace_packages(where=".") + find_packages(include=["taipy", "taipy.core", "taipy.core.*"]),
     include_package_data=True,
     test_suite="tests",
     tests_require=test_requirements,

taipy/gui/MANIFEST.in

@@ -1,4 +1,4 @@
-recursive-include taipy/gui/webapp *
-include taipy/gui/version.json
-include taipy/gui/viselements.json
-include taipy/gui/*.pyi
+recursive-include webapp *
+include version.json
+include viselements.json
+include *.pyi

taipy/gui/setup.py

@@ -22,7 +22,8 @@ from setuptools.command.build_py import build_py
 
 readme = Path("README.md").read_text()
 
-with open(f"src{os.sep}taipy{os.sep}gui{os.sep}version.json") as version_file:
+version_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "version.json")
+with open(version_path) as version_file:
     version = json.load(version_file)
     version_string = f'{version.get("major", 0)}.{version.get("minor", 0)}.{version.get("patch", 0)}'
     if vext := version.get("ext"):
@@ -94,8 +95,7 @@ setup(
     include_package_data=True,
     keywords="taipy-gui",
     name="taipy-gui",
-    package_dir={"": "src"},
-    packages=find_namespace_packages(where="src") + find_packages(include=["taipy", "taipy.gui", "taipy.gui.*"]),
+    packages=find_namespace_packages(where=".") + find_packages(include=["taipy", "taipy.gui", "taipy.gui.*"]),
     test_suite="tests",
     tests_require=test_requirements,
     url="https://github.com/avaiga/taipy-gui",

taipy/rest/MANIFEST.in

@@ -1 +1 @@
-include src/taipy/rest/*.json
+include *.json

taipy/rest/setup.py

@@ -16,7 +16,8 @@ from setuptools import find_namespace_packages, find_packages, setup
 with open("README.md") as readme_file:
     readme = readme_file.read()
 
-with open(f"src{os.sep}taipy{os.sep}rest{os.sep}version.json") as version_file:
+version_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "version.json")
+with open(version_path) as version_file:
     version = json.load(version_file)
     version_string = f'{version.get("major", 0)}.{version.get("minor", 0)}.{version.get("patch", 0)}'
     if vext := version.get("ext"):
@@ -29,8 +30,7 @@ setup(
     python_requires=">=3.8",
     version=version_string,
     author_email="dev@taipy.io",
-    packages=find_namespace_packages(where="src") + find_packages(include=["taipy", "taipy.rest"]),
-    package_dir={"": "src"},
+    packages=find_namespace_packages(where=".") + find_packages(include=["taipy", "taipy.rest"]),
     include_package_data=True,
     long_description=readme,
     long_description_content_type="text/markdown",

taipy/templates/MANIFEST.in

@@ -1 +1,2 @@
 recursive-include taipy/templates *
+include *.json

taipy/templates/setup.py

@@ -19,7 +19,8 @@ from setuptools import find_namespace_packages, find_packages, setup
 with open("README.md", "rb") as readme_file:
     readme = readme_file.read().decode("UTF-8")
 
-with open(f"src{os.sep}taipy{os.sep}templates{os.sep}version.json") as version_file:
+version_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "version.json")
+with open(version_path) as version_file:
     version = json.load(version_file)
     version_string = f'{version.get("major", 0)}.{version.get("minor", 0)}.{version.get("patch", 0)}'
     if vext := version.get("ext"):
@@ -47,8 +48,7 @@ setup(
     long_description_content_type="text/markdown",
     keywords="taipy-templates",
     name="taipy-templates",
-    package_dir={"": "src"},
-    packages=find_namespace_packages(where="src") + find_packages(include=["taipy"]),
+    packages=find_namespace_packages(where=".") + find_packages(include=["taipy"]),
     include_package_data=True,
     test_suite="tests",
     url="https://github.com/avaiga/taipy-templates",

tools/release/check_releases.py

@@ -0,0 +1,20 @@
+import os
+import sys
+
+if __name__ == "__main__":
+    _path = sys.argv[1]
+    _version = sys.argv[2]
+
+    packages = [
+        f"taipy-{_version}.tar.gz",
+        f"taipy-config-{_version}.tar.gz",
+        f"taipy-core-{_version}.tar.gz",
+        f"taipy-rest-{_version}.tar.gz",
+        f"taipy-gui-{_version}.tar.gz",
+        f"taipy-templates-{_version}.tar.gz",
+    ]
+
+    for package in packages:
+        if not os.path.exists(os.path.join(_path, package)):
+            print(f"Package {package} does not exist")  # noqa: T201
+            sys.exit(1)

tools/release/extract_from_setup.py

@@ -0,0 +1,15 @@
+import sys
+
+
+def extract_gui_version(base_path: str) -> None:
+    with open("setup.py") as f:
+        for line in f:
+            if "taipy-gui" in line:
+                start = line.find("taipy-gui")
+                end = line.rstrip().find('",')
+                print(f"VERSION={line[start:end]}")  # noqa: T201
+                break
+
+
+if __name__ == "__main__":
+    extract_gui_version(sys.argv[1])

tools/release/setup_version.py

@@ -0,0 +1,115 @@
+import json
+import os
+import re
+import sys
+from dataclasses import asdict, dataclass
+from typing import Optional
+
+
+@dataclass
+class Version:
+    major: str
+    minor: str
+    patch: str
+    ext: str
+
+    def bump_ext_version(self) -> None:
+        if not self.ext:
+            return
+        reg = re.compile(r"[0-9]+$")
+        num = reg.findall(self.ext)[0]
+
+        self.ext = self.ext.replace(num, str(int(num) + 1))
+
+    def validate_suffix(self, suffix="dev"):
+        if suffix not in self.ext:
+            raise Exception(f"Version does not contain suffix {suffix}")
+
+    @property
+    def name(self) -> str:
+        """returns a string representation of a version"""
+        return f"{self.major}.{self.minor}.{self.patch}"
+
+    @property
+    def dev_name(self) -> str:
+        """returns a string representation of a version"""
+        return f"{self.name}.{self.ext}"
+
+    def __str__(self) -> str:
+        """returns a string representation of a version"""
+        version_str = f"{self.major}.{self.minor}.{self.patch}"
+        if self.ext:
+            version_str = f"{version_str}.{self.ext}"
+        return version_str
+
+
+def __load_version_from_path(base_path: str) -> Version:
+    """Load version.json file from base path."""
+    with open(os.path.join(base_path, "version.json")) as version_file:
+        data = json.load(version_file)
+        return Version(**data)
+
+
+def __write_version_to_path(base_path: str, version: Version) -> None:
+    with open(os.path.join(base_path, "version.json"), "w") as version_file:
+        json.dump(asdict(version), version_file)
+
+
+def extract_version(base_path: str) -> Version:
+    """
+    Load version.json file from base path and return the version string.
+    """
+    return __load_version_from_path(base_path)
+
+
+def __setup_dev_version(
+    version: Version, _base_path: str, name: Optional[str] = None, bump_dev_version: bool = False
+) -> None:
+    version.validate_suffix()
+
+    name = f"{name}_VERSION" if name else "VERSION"
+    print(f"{name}={version.dev_name}")  # noqa: T201
+
+    version.bump_ext_version()
+
+    __write_version_to_path(_base_path, version)
+    print(f"NEW_{name}={version.dev_name}")  # noqa: T201
+
+
+def __setup_prod_version(version: Version, target_version: str, branch_name: str, name: str = None) -> None:
+    if str(version) != target_version:
+        raise ValueError(f"Current version={version} does not match target version={target_version}")
+
+    if target_branch_name := f"release/{version.major}.{version.minor}" != branch_name:
+        raise ValueError(
+            f"Branch name mismatch branch={branch_name} does not match target branch name={target_branch_name}"
+        )
+
+    name = f"{name}_VERSION" if name else "VERSION"
+    print(f"{name}={version.name}")  # noqa: T201
+
+
+if __name__ == "__main__":
+    paths = (
+        [sys.argv[1]]
+        if sys.argv[1] != "ALL"
+        else [
+            f"taipy{os.sep}config",
+            f"taipy{os.sep}core",
+            f"taipy{os.sep}rest",
+            f"taipy{os.sep}gui",
+            f"taipy{os.sep}templates",
+            "taipy",
+        ]
+    )
+    _environment = sys.argv[2]
+
+    for _path in paths:
+        _version = extract_version(_path)
+        _name = None if _path == "taipy" else _path.split(os.sep)[-1]
+
+        if _environment == "dev":
+            __setup_dev_version(_version, _path, _name)
+
+        if _environment == "production":
+            __setup_prod_version(_version, sys.argv[3], sys.argv[4], _name)

tools/release/update_setup.py

@@ -0,0 +1,32 @@
+import sys
+
+
+def update_setup() -> None:
+    with open("setup.taipy.py", mode="r") as setup_r, open("setup.py", mode="w") as setup_w:
+        in_requirements = False
+        looking = True
+        for line in setup_r:
+            if looking:
+                if line.lstrip().startswith("requirements") and line.rstrip().endswith("["):
+                    in_requirements = True
+                elif in_requirements:
+                    if line.strip() == "]":
+                        looking = False
+                    else:
+                        if line.lstrip().startswith('"taipy-gui@git+https'):
+                            start = line.find('"taipy-gui')
+                            end = line.rstrip().find(",")
+                            line = f'{line[:start]}"taipy-gui=={sys.argv[1]}"{line[end:]}'
+                        elif line.lstrip().startswith('"taipy-rest@git+https'):
+                            start = line.find('"taipy-rest')
+                            end = line.rstrip().find(",")
+                            line = f'{line[:start]}"taipy-rest=={sys.argv[2]}"{line[end:]}'
+                        elif line.lstrip().startswith('"taipy-templates@git+https'):
+                            start = line.find('"taipy-templates')
+                            end = line.rstrip().find(",")
+                            line = f'{line[:start]}"taipy-templates=={sys.argv[3]}"{line[end:]}'
+            setup_w.write(line)
+
+
+if __name__ == "__main__":
+    update_setup()

tools/release/update_setup_requirements.py

@@ -0,0 +1,35 @@
+import os
+import sys
+from typing import Dict
+
+BASE_PATH = "./tools/packages"
+
+
+def __build_taipy_package_line(line: str, version: str) -> str:
+    return f"{line.strip()} @ https://github.com/Avaiga/taipy/releases/download/{version}/{version}.tar.gz\n"
+
+
+def update_setup_requirements(package: str, versions: Dict) -> None:
+    _path = os.path.join(BASE_PATH, package, "setup.requirements.txt")
+    lines = []
+    with open(_path, mode="r") as req:
+        for line in req:
+            if v := versions.get(line.strip()):
+                line = __build_taipy_package_line(line, v)
+            lines.append(line)
+
+    with open(_path, 'w') as file:
+        file.writelines(lines)
+
+
+if __name__ == "__main__":
+    _package = sys.argv[1]
+    _versions = {
+        "taipy-config": sys.argv[2],
+        "taipy-core": sys.argv[3],
+        "taipy-gui": sys.argv[4],
+        "taipy-rest": sys.argv[5],
+        "taipy-templates": sys.argv[6],
+    }
+
+    update_setup_requirements(_package, _versions)

tools/validate_taipy_install.py

@@ -0,0 +1,56 @@
+import logging
+import os
+import sys
+
+
+def test_import_taipy_packages() -> bool:
+    """
+    Import taipy package and call gui, Scenario and rest attributes.
+    """
+    import taipy as tp
+
+    valid_install = True
+    if not hasattr(tp, "gui"):
+        logging.error("Taipy installation has no attribute gui")
+        valid_install = False
+    if not hasattr(tp, "Scenario"):
+        logging.error("Taipy installation has no attribute Scenario")
+        valid_install = False
+    if not hasattr(tp, "rest"):
+        logging.error("Taipy installation has no attribute rest")
+        valid_install = False
+
+    return valid_install
+
+
+def is_taipy_gui_install_valid() -> bool:
+    from pathlib import Path
+
+    import taipy
+
+    taipy_gui_core_path = Path(taipy.__file__).absolute().parent / "gui_core" / "lib" / "taipy-gui-core.js"
+    if not taipy_gui_core_path.exists():
+        logging.error("File taipy-gui-core.js not found in taipy installation path")
+        return False
+
+    taipy_gui_webapp_path = Path(taipy.__file__).absolute().parent / "gui" / "webapp"
+
+    if not os.path.exists(taipy_gui_webapp_path):
+        return False
+
+    if not any(fname.endswith('.js') for fname in os.listdir(taipy_gui_webapp_path)):
+        logging.error("Missing js files inside taipy gui webapp folder")
+        return False
+
+    return True
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO)
+
+    logging.info("Trying to import taipy and verify it's main attributes")
+    if not test_import_taipy_packages() or not is_taipy_gui_install_valid():
+        sys.exit(1)
+
+    logging.info("Taipy installation Validated")
+    sys.exit(0)