lcfm-shapefiles 0.9.33__tar.gz

lcfm_shapefiles-0.9.33/.gitattributes

@@ -0,0 +1,3 @@
+*.fgb filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.ipynb linguist-vendored

lcfm_shapefiles-0.9.33/.github/copilot-instructions.md

@@ -0,0 +1,114 @@
+# LCFM Shapefiles - AI Coding Agent Instructions
+
+## Project Overview
+Python package providing wrapper functionality around FlatGeobuf (`.fgb`) shapefiles for the Land Cover Fraction Map (LCFM) project. The package handles downloading versioned shapefiles from S3 CloudFerro storage with MD5-based caching and provides product specifications in the form of classes. Product classes contain names, layers, data types, etc. and allow generation of metadata for LCFM datasets.
+
+**Key pattern**: FlatGeobuf files are NOT stored in the repository due to size. Instead, they are stored in S3 (CloudFerro WAW4-1) with Git LFS pointers in the VM at `/vitodata/vegteam/auxdata/LCFM/shapefiles-lfs`. The package downloads them on-demand with version-based caching.
+
+## Architecture & Core Components
+
+### 1. Shapefile Management (`shapefiles.py`)
+**Singleton pattern**: `ShapefileCacheManager` manages all shapefile downloads and caching
+- **Cache location hierarchy**: `LCFM_SHAPEFILES_CACHE_HOME` → `XDG_CACHE_HOME/lcfm_shapefiles` → `~/.cache/lcfm_shapefiles`
+- **Version-based caching**: Cache organized by package version (`~/.cache/lcfm_shapefiles/0.8.16/`)
+- **Metadata driven**: `keys_metadata.json` contains S3 metadata (ETags for MD5 verification, version IDs, sizes)
+- **S3 URI pattern**: `https://vito-lcf-shapefiles-waw4-1.s3.waw4-1.cloudferro.com/<filename>?versionId=<version_id>`
+- **Integrity checks**: MD5 checksums verify downloaded files match expected ETags
+
+**Typical usage pattern**:
+```python
+from lcfm_shapefiles import get_filepath
+import geopandas as gpd
+
+fp = get_filepath("LCFM_1p_S2-tiles.fgb")  # Downloads if needed
+gdf = gpd.read_file(fp)
+```
+
+### 2. Product Abstraction (`products.py`)
+**Registry pattern**: Products register themselves via `@Product.register_product()` decorator
+- **Product hierarchy**: `Product` (abstract) → `LOSProduct`, `LSFProduct`, `LSCProduct`, `LCM10Product`, `LCM100Product`, etc.
+- **Band-based routing**: Products register with band prefixes (e.g., `"LCM10:MAP"` for categorical map data)
+- **Factory method**: `Product.create_product(product_name, version, band, year)` routes to correct subclass
+- **Tile coordinate systems**: UTM zones determined from Sentinel-2 MGRS tile IDs (e.g., `34UCV` → EPSG:32634)
+
+**Key functions**:
+- `tile_to_epsg(tile)`: Convert S2 tile ID to EPSG code (row letter determines hemisphere)
+- `utm_to_epsg(utm)`: Convert UTM zone string to EPSG code
+
+### 3. Label Definitions (`labels.py`)
+Enums defining land cover class labels, colors, and names for visualization
+- `LCM10LabelsColors`: 10-meter resolution land cover classes (tree, shrub, grass, crop, wetland, etc.)
+- Color schemes use normalized RGB arrays for matplotlib compatibility
+
+### 4. Antimeridian Handling (`fix_antimeridian.py`)
+Utility to split polygons crossing longitude ±180°
+- `intersects_antimeridian()`: Detects large longitude jumps (>100° threshold)
+- `fix_antimeridian_split()`: Splits into MultiPolygon with normalized coordinates
+
+## Development Workflow
+
+### Environment Setup
+```bash
+uv sync                    # Build venv with dependencies
+uv run pytest             # Run tests
+uv run ruff format .      # Format code (not ruff check!)
+```
+
+**Important**: Use `uv` (not pip/conda) for all dependency management. Dev dependencies include geopandas, pandas[pyarrow], pytest, ruff.
+
+### Testing
+- Tests in `tests/` validate shapefile downloads (`test_shapefiles.py`), product creation (`test_products.py`), and labels (`test_labels.py`)
+- Tests use `tmp_path` fixture and set `LCFM_SHAPEFILES_CACHE_HOME` to isolate cache
+- **Critical**: Tests verify checksum validation and cached file integrity
+- **When adding new Product classes**: Add corresponding tests to `tests/test_file.py`
+
+### Deploying New/Updated Shapefiles
+1. Add/update `.fgb` files in `src/lcfm_shapefiles/data/`
+2. Update tests accordingly
+3. Bump version in `pyproject.toml` → `src/lcfm_shapefiles/_version.py`
+4. Push to `master` → if build passes, trigger promotion job
+5. Auto-sync workflow uploads to S3 and updates VM cache
+
+## Project-Specific Conventions
+
+### File Naming
+**Shapefiles**: `LCFM_<percent>_<grid/AOI>-<granularity>_v<version>.fgb`
+- Example: `LCFM_100p_S2-tiles.fgb`, `LCFM_10p_latlon-3deg-TCD.fgb`
+- Version tags removed in package to avoid conflicts with semantic versioning
+
+### Version String Format
+Products expect version as `vXXX` (3 digits), e.g., `v001`, `v127`. Constructor warns if format violated.
+
+### Scripts Directory
+`scripts/` contains data processing utilities (not part of package distribution):
+- Block extraction/manipulation (`add_blocks.py`, `extract_block.py`)
+- Tile selection/comparison (`check_tiles.py`, `select_tiles.py`)
+- File format conversion (`compare_fgb_parquet_columns.py`)
+
+These scripts often import from package: `from lcfm_shapefiles import get_filepath`
+
+### Parquet Blocks
+Since `v0.8.7`: Parquet-format grid blocks in `src/lcfm_shapefiles/data/blocks_parquet/`
+- Source: `/vitodata/vegteam/auxdata/grid/blocks_global/` on Terrascope
+
+### Blocks Grid Structure
+`blocks_global.fgb` and `blocks_global.parquet` are **not** one row per tile — they contain one row per **block** (sub-tile subdivision), ~1.4M rows total.
+- The unique `tile` column values in blocks files must match the tile IDs in `LCFM_100p_S2-tiles.fgb` exactly (currently **18,422 tiles** each)
+- Columns: `tile_block_id`, `tile`, `block_id`, `epsg`, `landtype`, `antimeridian`, `xmin`, `ymin`, `xmax`, `ymax`
+- `blocks_global.parquet` has no geometry column; `blocks_global.fgb` has geometry
+- To verify consistency: compare `set(blocks['tile'])` against `set(s2_tiles['tile'])` — row counts will differ by design
+
+## Critical Gotchas
+
+1. **FGB files excluded from wheel**: `pyproject.toml` excludes `*.fgb` from built wheel to reduce package size
+2. **Git LFS required**: On Terrascope VM, Git LFS pulls actual files; elsewhere package downloads from S3
+3. **Cache invalidation**: Cache organized by package version; upgrading package creates new cache directory
+4. **EPSG code logic**: S2 tile rows C-M are southern hemisphere (326XX), N-X are northern (327XX)
+5. **Product registry**: Subclasses must define `product_name` ClassVar or `@register()` raises ValueError
+6. **Metadata updates**: Call `update_cache_metadata()` to refresh `keys_metadata.json` from S3
+
+## External Dependencies
+
+- **S3 bucket**: `vito-lcf-shapefiles-waw4-1` on CloudFerro WAW4-1 (Warsaw region)
+- **Artifactory**: `https://artifactory.vgt.vito.be/artifactory/api/pypi/python-packages-public/`
+- **Terrascope paths**: `/vitodata/vegteam/auxdata/LCFM/shapefiles-lfs`, `/vitodata/vegteam_vol2/data/lcfm/shapefiles`

lcfm_shapefiles-0.9.33/.github/workflows/auto-sync-github.yml

@@ -0,0 +1,133 @@
+name: Auto-Sync LFS Files Github
+
+on:
+  push:
+    branches:
+      - master  # Change this to your default branch if different
+    paths:
+      - 'src/lcfm_shapefiles/data/**'  # Only trigger when files in this path change
+  workflow_dispatch:  # Allows manual triggering of the workflow
+
+env:
+  SHAPEFILES_BUCKET: vito-lcf-shapefiles-waw4-1
+
+jobs:
+  sync:
+    name: Sync repository on VM cluster and S3
+    runs-on: ubuntu-latest  # This will use your self-hosted runner
+    environment: CF_S3_ACCESS
+    env:
+      AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
+      AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+      AWS_ENDPOINT_URL: ${{vars.AWS_ENDPOINT_URL}}
+      AWS_REGION: ${{vars.AWS_REGION}}
+    permissions:
+      contents: write
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          lfs: true
+          path: src/lcfm_shapefiles/data
+
+      - name: Configure AWS CLI for single-part uploads
+        run: |
+          # Set multipart threshold to 5GB to ensure files are uploaded as single objects
+          # This preserves MD5 ETags for integrity validation
+          aws configure set default.s3.multipart_threshold 5GB
+          aws configure set default.s3.multipart_chunksize 5GB
+
+      - name: push_s3
+        id: push_s3
+        working-directory: src/lcfm_shapefiles/data
+        run: |
+          
+          echo "Starting intelligent S3 sync with ETag comparison..."
+          
+          # Flag file to track if any uploads occurred (needed because while loop runs in subshell)
+          UPLOAD_FLAG=$(mktemp)
+          
+          # Function to calculate MD5 hash of local file
+          calculate_local_etag() {
+            local file="$1"
+            md5sum "$file" | cut -d' ' -f1
+          }
+          
+          # Function to get S3 object ETag
+          get_s3_etag() {
+            local s3_key="$1"
+            aws s3api head-object --bucket ${{ env.SHAPEFILES_BUCKET }} --key "$s3_key" --query 'ETag' --output text 2>/dev/null | tr -d '"' || echo ""
+          }
+          
+          # Counters for statistics
+          uploaded_count=0
+          skipped_count=0
+          total_count=0
+          
+          # Find all files to sync (excluding hidden files and directories)
+          find src/lcfm_shapefiles/data -type f ! -path '*/.*' ! -name 'keys_metadata.json' | while read -r file; do
+            # Extract s3_key as path relative to src/lcfm_shapefiles/data/
+            s3_key="${file#src/lcfm_shapefiles/data/}"
+            
+            total_count=$((total_count + 1))
+            
+            echo "Processing: $s3_key"
+            
+            # Calculate local file ETag
+            local_etag=$(calculate_local_etag "$file")
+            
+            # Get S3 object ETag
+            s3_etag=$(get_s3_etag "$s3_key")
+            
+            if [ -z "$s3_etag" ]; then
+              echo "  → File doesn't exist in S3, uploading..."
+              aws s3 cp "$file" "s3://${{ env.SHAPEFILES_BUCKET }}/$s3_key"
+              echo "uploaded" >> "$UPLOAD_FLAG"
+              echo "  ✓ Uploaded"
+            elif [ "$local_etag" != "$s3_etag" ]; then
+              echo "  → ETags differ (local: $local_etag, S3: $s3_etag), uploading..."
+              aws s3 cp "$file" "s3://${{ env.SHAPEFILES_BUCKET }}/$s3_key"
+              echo "uploaded" >> "$UPLOAD_FLAG"
+              echo "  ✓ Updated"
+            else
+              echo "  → ETags match, skipping upload"
+              echo "  ⏭ Skipped"
+            fi
+          done
+        
+          # Set output flag based on whether any files were uploaded
+          if [ -s "$UPLOAD_FLAG" ]; then
+            echo "files_uploaded=true" >> $GITHUB_OUTPUT
+            echo "Files were uploaded - metadata update required"
+          else
+            echo "files_uploaded=false" >> $GITHUB_OUTPUT
+            echo "No files uploaded - skipping metadata update"
+          fi
+          rm -f "$UPLOAD_FLAG"
+
+      - name: Update S3 metadata and commit
+        if: steps.push_s3.outputs.files_uploaded == 'true'
+        working-directory: src/lcfm_shapefiles/data
+        run: |
+          echo "Fetching S3 metadata for latest object versions..."
+          
+          # Get all object versions from S3 and filter for latest versions only
+          aws s3api list-object-versions \
+            --endpoint-url ${{ vars.AWS_ENDPOINT_URL }} \
+            --bucket ${{ env.SHAPEFILES_BUCKET }} \
+            --query 'Versions[?IsLatest==`true`]' \
+            --output json > src/lcfm_shapefiles/data/keys_metadata.json
+          
+          # Configure git identity for the commit
+          git config --local user.email "actions@github.com"
+          git config --local user.name "GitHub Actions"
+          
+          # Commit and push the updated metadata file if there are changes
+          git add src/lcfm_shapefiles/data/keys_metadata.json
+          git commit -m "Update S3 keys metadata [skip ci]"
+          git push origin ${{ github.ref_name }}
+          echo "✓ Updated keys_metadata.json with latest S3 object versions"
+          aws s3 cp src/lcfm_shapefiles/data/keys_metadata.json "s3://${{ env.SHAPEFILES_BUCKET }}/keys_metadata.json"
+          echo "✓ Pushed keys_metadata.json to s3://${{ env.SHAPEFILES_BUCKET }}/keys_metadata.json"
+
+          echo "Metadata sync completed at $(date)"

lcfm_shapefiles-0.9.33/.github/workflows/auto-sync.yml

@@ -0,0 +1,148 @@
+name: Auto-Sync LFS Files Terrascope
+
+on:
+  workflow_dispatch:  # Allows manual triggering of the workflow
+
+env:
+  SHAPEFILES_BUCKET: vito-lcf-shapefiles-waw4-1
+  TERRASCOPE_PATH: /vitodata/vegteam/auxdata/LCFM/shapefiles-lfs/src/lcfm_shapefiles/data
+
+jobs:
+  sync:
+    name: Sync repository on VM cluster and S3
+    runs-on: self-hosted  # This will use your self-hosted runner
+    steps:
+      - name: Pull latest changes
+        run: |
+          eval "$(ssh-agent -s)"
+          ssh-add ~/Private/runner/.ssh/github_deploy_key
+
+          cd /vitodata/vegteam/auxdata/LCFM/shapefiles-lfs
+          git checkout ${{ github.ref_name }}  # Change this to your default branch if different
+
+          git remote set-url origin git@github.com:VITO-RS-Vegetation/lcfm-shapefiles.git
+          git fetch origin
+          git pull origin ${{ github.ref_name }}  # Change this to your default branch if different
+          
+          # If using LFS, also pull LFS objects
+          if [ -f ".gitattributes" ] && grep -q "filter=lfs" .gitattributes; then
+            git lfs pull
+          fi
+          
+          echo "Repository successfully synced at $(date)"
+
+      - name: push_s3
+        env:
+          AWS_CLI_S3_MULTIPART_THRESHOLD: 5GB
+        run: |
+          cd ${{ env.TERRASCOPE_PATH }}
+          
+          echo "Starting intelligent S3 sync with ETag comparison..."
+          
+          # Function to calculate MD5 hash of local file
+          calculate_local_etag() {
+            local file="$1"
+            md5sum "$file" | cut -d' ' -f1
+          }
+          
+          # Function to get S3 object ETag
+          get_s3_etag() {
+            local s3_key="$1"
+            aws s3api head-object --profile cf --bucket ${{ env.SHAPEFILES_BUCKET }} --key "$s3_key" --query 'ETag' --output text 2>/dev/null | tr -d '"' || echo ""
+          }
+          
+          # Counters for statistics
+          uploaded_count=0
+          skipped_count=0
+          total_count=0
+          
+          # Find all files to sync (excluding hidden files and directories)
+          find . -type f \( ! -path '*/.*' -o -path './blocks_parquet/*' \) | while read -r file; do
+            # Remove leading ./ from file path
+            relative_path="${file#./}"
+            s3_key="$relative_path"
+            
+            total_count=$((total_count + 1))
+            
+            echo "Processing: $relative_path"
+            
+            # Calculate local file ETag
+            local_etag=$(calculate_local_etag "$file")
+            
+            # Get S3 object ETag
+            s3_etag=$(get_s3_etag "$s3_key")
+            
+            if [ -z "$s3_etag" ]; then
+              echo "  → File doesn't exist in S3, uploading..."
+              aws s3 cp --profile cf "$file" "s3://${{ env.SHAPEFILES_BUCKET }}/$s3_key"
+              uploaded_count=$((uploaded_count + 1))
+              echo "  ✓ Uploaded"
+            elif [ "$local_etag" != "$s3_etag" ]; then
+              echo "  → ETags differ (local: $local_etag, S3: $s3_etag), uploading..."
+              aws s3 cp --profile cf "$file" "s3://${{ env.SHAPEFILES_BUCKET }}/$s3_key"
+              uploaded_count=$((uploaded_count + 1))
+              echo "  ✓ Updated"
+            else
+              echo "  → ETags match, skipping upload"
+              skipped_count=$((skipped_count + 1))
+              echo "  ⏭ Skipped"
+            fi
+          done
+          
+          # Also sync the file_timestamps.json specifically
+          timestamps_file="file_timestamps.json"
+          if [ -f "$timestamps_file" ]; then
+            echo "Processing timestamps file: $timestamps_file"
+            local_etag=$(calculate_local_etag "$timestamps_file")
+            s3_etag=$(get_s3_etag "$timestamps_file")
+            
+            if [ -z "$s3_etag" ] || [ "$local_etag" != "$s3_etag" ]; then
+              echo "  → Uploading timestamps file..."
+              aws s3 cp --profile cf "$timestamps_file" "s3://${{ env.SHAPEFILES_BUCKET }}/$timestamps_file"
+              echo "  ✓ Timestamps file uploaded"
+            else
+              echo "  → Timestamps file unchanged, skipping"
+            fi
+          fi
+          
+          echo ""
+          echo "=== Sync Summary ==="
+          echo "Files uploaded: $uploaded_count"
+          echo "Files skipped: $skipped_count"
+          echo "Total files processed: $total_count"
+          echo "Bucket: ${{ env.SHAPEFILES_BUCKET }}"
+          echo "Sync completed at $(date)"
+
+      - name: Update S3 metadata and commit
+        run: |
+          eval "$(ssh-agent -s)"
+          ssh-add ~/Private/runner/.ssh/github_deploy_key
+
+          cd /vitodata/vegteam/auxdata/LCFM/shapefiles-lfs
+          
+          echo "Fetching S3 metadata for latest object versions..."
+          
+          # Get all object versions from S3 and filter for latest versions only
+          aws s3api list-object-versions \
+            --profile cf \
+            --endpoint-url https://s3.waw4-1.cloudferro.com \
+            --bucket ${{ env.SHAPEFILES_BUCKET }} \
+            --query 'Versions[?IsLatest==`true`]' \
+            --output json > ${{ env.TERRASCOPE_PATH}}/keys_metadata.json
+          
+          # Configure git identity for the commit
+          git config --local user.email "actions@github.com"
+          git config --local user.name "GitHub Actions"
+          
+          # Commit and push the updated metadata file if there are changes
+          git add src/lcfm_shapefiles/data/keys_metadata.json
+          if ! git diff --quiet --staged; then
+            git commit -m "Update S3 keys metadata [skip ci]"
+            git push origin ${{ github.ref_name }}
+            echo "✓ Updated keys_metadata.json with latest S3 object versions"
+          else
+            echo "→ No changes to keys_metadata.json"
+          fi
+          
+          echo "Metadata sync completed at $(date)"
+

lcfm_shapefiles-0.9.33/.github/workflows/format_test.yml

@@ -0,0 +1,39 @@
+name: vegorg workflow
+
+on:  #add your hook triggers in the array [push, pull, merge]
+  push:  # Trigger only on push events
+    branches:
+      - dev    # Trigger only on pushes to the 'main' branch
+      - master
+  pull_request:  # Trigger only on pull request events
+    branches:
+      - dev
+      - master    # Trigger only on pull requests targeting the 'main' branch
+  workflow_dispatch:  # Allow manual triggering of the workflow
+
+env:
+  token: ${{ secrets.GITHUB_TOKEN }}  # Use the built-in GITHUB_TOKEN for authentication
+  UV_INDEX_VITO_ARTIFACTORY_USERNAME: ${{ secrets.ARTIFACTORY_USERNAME }}
+  UV_INDEX_VITO_ARTIFACTORY_PASSWORD: ${{ secrets.ARTIFACTORY_PASSWORD }}
+
+jobs:
+  format-lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/ruff-action@v3
+        with:
+          args: "format --check --diff"
+
+    
+  check-uv-lock:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          version: "0.8.x"
+          python-version: "3.11"
+      - name: Check uv lock
+        run: uv lock --check
+      

lcfm_shapefiles-0.9.33/.github/workflows/integration_tests.yml

@@ -0,0 +1,28 @@
+name: integration tests
+
+on:  #add your hook triggers in the array [push, pull, merge]
+  pull_request:  # Trigger only on pull request events
+    branches:
+      - master
+  workflow_dispatch:  # Allow manual triggering of the workflow
+
+env:
+  token: ${{ secrets.GITHUB_TOKEN }}  # Use the built-in GITHUB_TOKEN for authentication
+  UV_INDEX_VITO_ARTIFACTORY_USERNAME: ${{ secrets.ARTIFACTORY_USERNAME }}
+  UV_INDEX_VITO_ARTIFACTORY_PASSWORD: ${{ secrets.ARTIFACTORY_PASSWORD }}
+
+jobs:
+  integration-tests:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+      with:
+        lfs: true
+
+    - name: Setup build environment
+      uses: VITO-RS-Vegetation/veg-template@v2  # Reuse the composite action
+      with:
+        uv-args: "--all-groups -vv"
+    - name: Run tests
+      run: uv run pytest tests -m "not s3"

lcfm_shapefiles-0.9.33/.github/workflows/publish_pypi.yml

@@ -0,0 +1,53 @@
+# Publishes lcfm-shapefiles to the public PyPI (pypi.org).
+# Separate from publish_wheel.yml (Artifactory) - manual trigger only.
+name: Publish to PyPI
+on:
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  release-build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup build environment
+        uses: VITO-RS-Vegetation/veg-template@v2
+        with:
+          uv-args: "--all-groups -vv"
+
+      - name: Build release distributions
+        run: uv build --wheel --sdist
+
+      - name: Upload distributions
+        uses: actions/upload-artifact@v4
+        with:
+          name: pypi-dists
+          path: dist/
+
+  pypi-publish:
+    runs-on: ubuntu-latest
+    needs:
+      - release-build
+    environment:
+      name: pypi
+    permissions:
+      id-token: write  # required for trusted publishing (OIDC), no token secrets needed
+
+    steps:
+      - name: Retrieve release distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: pypi-dists
+          path: dist/
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          version: "0.8.x"
+
+      - name: Publish to PyPI
+        run: uv publish --trusted-publishing automatic

lcfm_shapefiles-0.9.33/.github/workflows/publish_wheel.yml

@@ -0,0 +1,68 @@
+# Uploads veg-workflows wheel to vito public artifactory
+
+name: Publish Wheel
+on:
+  release:
+    types: [published]
+
+  workflow_dispatch:  # Allow manual triggering of the workflow (optional)
+
+permissions:
+  contents: read
+
+env:
+  token: ${{ secrets.GITHUB_TOKEN }}  # Use the built-in GITHUB_TOKEN for authentication
+  UV_INDEX_VITO_ARTIFACTORY_USERNAME: ${{ secrets.ARTIFACTORY_USERNAME }}
+  UV_INDEX_VITO_ARTIFACTORY_PASSWORD: ${{ secrets.ARTIFACTORY_PASSWORD }}
+
+jobs:
+  release-build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup build environment
+        uses: VITO-RS-Vegetation/veg-template@v2  # Reuse the composite action
+        with:
+          uv-args: "--all-groups -vv"
+
+      - name: Build release distributions
+        run: |
+          # NOTE: put your own distribution build steps here.
+          uv build --wheel
+
+      - name: Upload distributions
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+  public-artifactory-publish:
+    env:
+      UV_PUBLISH_USERNAME: ${{ secrets.ARTIFACTORY_USERNAME }}
+      UV_PUBLISH_PASSWORD: ${{ secrets.ARTIFACTORY_PASSWORD }}
+      UV_PUBLISH_URL: ${{ vars.UV_PUBLISH_URL }}
+    permissions:
+      contents: read
+      id-token: write
+
+    runs-on: ubuntu-latest
+    needs:
+      - release-build
+
+    steps:
+      - name: Retrieve release distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: release-dists
+          path: dist/
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+            version: "0.8.x"
+
+      - name: Publish to vito-artifactory-public
+        run: uv publish
+