sdk-publish.yml

---
name: Publish to PyPI

# Trigger on pushes to main or via manual dispatch. Publishing is guarded by
# the PyPI version check below, so pushes that don't bump __version__ no-op.
on:
  push:
    branches:
      - main
  workflow_dispatch:
    inputs:
      branch:
        description: 'Branch to publish from'
        required: false
        default: 'main'

concurrency:
  # Serialize publishes so a push + dispatch (or two rapid pushes) can't both
  # pass the PyPI existence check and race on `twine upload`.
  group: publish-pypi-${{ github.ref }}
  cancel-in-progress: false

permissions:
  contents: write  # For creating GitHub releases
  id-token: write  # For trusted publishing to PyPI

env:
  PYTHON_VERSION: "3.11"

jobs:
  publish:
    name: 📦 Build and Publish to PyPI
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
        with:
          ref: ${{ github.event.inputs.branch || github.ref }}
          fetch-depth: 0  # Full history for proper release notes

      - name: Set up Python
        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
        with:
          python-version: ${{ env.PYTHON_VERSION }}

      - name: Install build dependencies
        run: |
          python -m pip install --upgrade pip
          pip install build twine hatchling jq

      # === VERSION VALIDATION ===

      - name: Extract version from __init__.py
        id: get_version
        run: |
          # Extract version from source using sed (avoids import issues)
          version=$(sed -n 's/^__version__[[:space:]]*=[[:space:]]*"\([^"]*\)".*/\1/p' src/honeyhive/__init__.py)
          echo "version=$version" >> $GITHUB_OUTPUT
          echo "📦 Detected version: $version"

          # Validate version format
          if ! echo "$version" | grep -E '^[0-9]+\.[0-9]+\.[0-9]+(-rc[0-9]+|rc[0-9]+|alpha[0-9]+|beta[0-9]+)?$'; then
            echo "❌ Invalid version format: $version"
            echo "Expected format: X.Y.Z or X.Y.Z-rc# or X.Y.Zrc#"
            exit 1
          fi

          echo "✅ Version format is valid"

      - name: Check if version already published to PyPI
        id: check_pypi
        run: |
          VERSION="${{ steps.get_version.outputs.version }}"
          echo "🔍 Checking if version $VERSION exists on PyPI..."

          # Query PyPI API for package versions
          response=$(curl -s https://pypi.org/pypi/honeyhive/json || echo '{}')

          # Check if version exists in releases
          if echo "$response" | python -c \
            "import sys, json; \
            data = json.load(sys.stdin); \
            sys.exit(0 if '$VERSION' in data.get('releases', {}) else 1)"; then
            echo "exists=true" >> $GITHUB_OUTPUT
            echo "✅ Version $VERSION already published to PyPI"
            echo "SKIP_REASON=Version $VERSION already exists on PyPI" >> $GITHUB_OUTPUT
          else
            echo "exists=false" >> $GITHUB_OUTPUT
            echo "🆕 Version $VERSION is new - will publish to PyPI"
          fi

      - name: Skip publishing (version already exists)
        if: steps.check_pypi.outputs.exists == 'true'
        run: |
          echo "## ✅ Version Already Published" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY
          echo "**Version:** \`${{ steps.get_version.outputs.version }}\`" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY
          echo "This version is already available on PyPI." >> $GITHUB_STEP_SUMMARY
          echo "No action needed." >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY
          VERSION="${{ steps.get_version.outputs.version }}"
          echo "🔗 [View on PyPI](https://pypi.org/project/honeyhive/$VERSION/)" \
            >> $GITHUB_STEP_SUMMARY

          echo "✅ Workflow complete - version already published"
          exit 0

      # === BUILD AND PUBLISH (only if version is new) ===

      - name: Verify CHANGELOG updated
        if: steps.check_pypi.outputs.exists == 'false'
        run: |
          VERSION="${{ steps.get_version.outputs.version }}"

          if ! grep -q "$VERSION" CHANGELOG.md; then
            echo "⚠️ Warning: Version $VERSION not found in CHANGELOG.md"
            echo "Please update CHANGELOG.md before releasing"
            echo ""
            echo "This is a warning only - publishing will continue"
          else
            echo "✅ CHANGELOG.md contains entry for version $VERSION"
          fi

      - name: Build distribution packages
        if: steps.check_pypi.outputs.exists == 'false'
        run: |
          echo "📦 Building source distribution and wheel..."
          python -m build

          echo "📋 Package contents:"
          ls -lh dist/

      - name: Verify package integrity
        if: steps.check_pypi.outputs.exists == 'false'
        run: |
          echo "🔍 Checking package integrity..."
          python -m twine check dist/*
          echo "✅ Package integrity verified"

      - name: Test package installation
        if: steps.check_pypi.outputs.exists == 'false'
        run: |
          echo "🧪 Testing package installation..."

          # Create clean test environment
          python -m venv test-install
          source test-install/bin/activate

          # Install the wheel
          pip install dist/*.whl

          # Test imports
          python -c "
          import honeyhive
          from honeyhive import HoneyHive, HoneyHiveTracer
          from honeyhive import trace, evaluate

          print(f'✅ Package installation successful')
          print(f'HoneyHive version: {honeyhive.__version__}')

          # Verify version matches
          expected_version = '${{ steps.get_version.outputs.version }}'
          if honeyhive.__version__ != expected_version:
              print(f'❌ Version mismatch: {honeyhive.__version__} != {expected_version}')
              exit(1)

          print(f'✅ Version verified: {honeyhive.__version__}')
          "

          deactivate
          echo "✅ Installation test passed"

      - name: Publish to PyPI
        if: steps.check_pypi.outputs.exists == 'false'
        env:
          TWINE_USERNAME: __token__
          TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
        run: |
          echo "🚀 Publishing version ${{ steps.get_version.outputs.version }} to PyPI..."
          python -m twine upload dist/*
          echo "✅ Published to PyPI successfully!"

      - name: Verify publication
        if: steps.check_pypi.outputs.exists == 'false'
        run: |
          VERSION="${{ steps.get_version.outputs.version }}"

          echo "⏳ Waiting 30 seconds for PyPI to update..."
          sleep 30

          echo "🔍 Verifying package is available on PyPI..."
          max_attempts=5
          attempt=1

          while [ $attempt -le $max_attempts ]; do
            if pip index versions honeyhive | grep -q "$VERSION"; then
              echo "✅ Package verified on PyPI!"
              echo "🔗 https://pypi.org/project/honeyhive/$VERSION/"
              exit 0
            fi

            echo "Attempt $attempt/$max_attempts: Not yet available, waiting..."
            sleep 10
            attempt=$((attempt + 1))
          done

          echo "⚠️ Could not verify package on PyPI within timeout"
          echo "This may be a PyPI indexing delay - check manually"
          echo "🔗 https://pypi.org/project/honeyhive/$VERSION/"

      # === GITHUB RELEASE ===

      - name: Extract changelog for version
        if: steps.check_pypi.outputs.exists == 'false'
        id: changelog
        run: |
          VERSION="${{ steps.get_version.outputs.version }}"
          echo "📝 Extracting changelog for version $VERSION..."

          # Extract changelog section for this version
          # Matches from "## [VERSION]" until the next "## [" header
          changelog_content=$(awk -v ver="$VERSION" '
            BEGIN { found=0; content="" }
            /^## \[/ {
              if (found) exit
              if (index($0, ver) > 0) found=1
              next
            }
            found { content = content $0 "\n" }
            END { print content }
          ' CHANGELOG.md)

          # If no changelog found, use a default message
          if [ -z "$changelog_content" ]; then
            changelog_content="No changelog entry found for this version."
          fi

          # Write to file for multiline output
          echo "$changelog_content" > /tmp/changelog_content.txt
          echo "changelog_file=/tmp/changelog_content.txt" >> $GITHUB_OUTPUT
          echo "✅ Changelog extracted"

      - name: Generate release body
        if: steps.check_pypi.outputs.exists == 'false'
        id: release_body
        run: |
          VERSION="${{ steps.get_version.outputs.version }}"

          # Use Python to generate the release body (handles multiline content safely)
          python3 << 'PYTHON_EOF'
          import os

          version = os.environ.get('VERSION', '${{ steps.get_version.outputs.version }}')

          # Read changelog content
          try:
              with open('/tmp/changelog_content.txt', 'r') as f:
                  changelog_content = f.read().strip()
          except FileNotFoundError:
              changelog_content = "No changelog entry found for this version."

          # Generate release body with changelog at top
          release_body = f"""# HoneyHive Python SDK v{version}

          ## What's Changed

          {changelog_content}

          ## Installation

          ```bash
          pip install honeyhive=={version}
          ```

          ## Links

          - [PyPI Package](https://pypi.org/project/honeyhive/{version}/)
          - [Documentation](https://honeyhiveai.github.io/python-sdk/)
          - [Full Changelog](https://github.com/honeyhiveai/python-sdk/blob/main/CHANGELOG.md)
          """

          # Remove leading whitespace from each line (heredoc indentation)
          import textwrap
          release_body = textwrap.dedent(release_body)

          with open('/tmp/release_body.md', 'w') as f:
              f.write(release_body)

          print("Release body generated successfully")
          PYTHON_EOF

          echo "body_file=/tmp/release_body.md" >> $GITHUB_OUTPUT
          echo "✅ Release body generated"

      # The vX.Y.Z tag is created upstream when the release is synced to this
      # repo, so this step creates a Release against that existing tag rather
      # than cutting a new one. Uses the gh CLI directly instead of a
      # third-party action. `--verify-tag` makes the step fail loudly if the
      # tag is missing (e.g. a manual dispatch without a prior sync) rather
      # than silently cutting one at the default-branch HEAD, which could be
      # the wrong commit when dispatched from a non-default branch.
      - name: Create GitHub Release
        if: steps.check_pypi.outputs.exists == 'false'
        env:
          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          VERSION: ${{ steps.get_version.outputs.version }}
        run: |
          set -euo pipefail
          TAG="v${VERSION}"
          if [[ "$VERSION" == *rc* || "$VERSION" == *alpha* || "$VERSION" == *beta* ]]; then
            PRERELEASE_FLAG="--prerelease"
          else
            PRERELEASE_FLAG=""
          fi
          if gh release view "$TAG" >/dev/null 2>&1; then
            echo "::notice::Release $TAG already exists — skipping creation"
          else
            # shellcheck disable=SC2086
            gh release create "$TAG" \
              --verify-tag \
              --title "$TAG" \
              --notes-file /tmp/release_body.md \
              $PRERELEASE_FLAG
          fi

      # === SUMMARY ===

      - name: Generate release summary
        if: steps.check_pypi.outputs.exists == 'false'
        run: |
          echo "# 🚀 Release Published Successfully" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY
          echo "**Version:** \`${{ steps.get_version.outputs.version }}\`" >> $GITHUB_STEP_SUMMARY
          echo "**Published:** $(date -u)" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY
          VERSION="${{ steps.get_version.outputs.version }}"
          echo "## 📦 Installation" >> $GITHUB_STEP_SUMMARY
          echo "\`\`\`bash" >> $GITHUB_STEP_SUMMARY
          echo "pip install honeyhive==$VERSION" >> $GITHUB_STEP_SUMMARY
          echo "\`\`\`" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY
          echo "## 🔗 Links" >> $GITHUB_STEP_SUMMARY
          echo "- [PyPI Package](https://pypi.org/project/honeyhive/$VERSION/)" \
            >> $GITHUB_STEP_SUMMARY
          echo "- [GitHub Release]\
          (https://github.com/honeyhiveai/python-sdk/releases/tag/v$VERSION)" \
            >> $GITHUB_STEP_SUMMARY
          echo "- [Documentation](https://honeyhiveai.github.io/python-sdk/)" >> $GITHUB_STEP_SUMMARY
          echo "" >> $GITHUB_STEP_SUMMARY
          echo "## ✅ Verification" >> $GITHUB_STEP_SUMMARY
          echo "- ✅ Package built successfully" >> $GITHUB_STEP_SUMMARY
          echo "- ✅ Package integrity verified" >> $GITHUB_STEP_SUMMARY
          echo "- ✅ Installation test passed" >> $GITHUB_STEP_SUMMARY
          echo "- ✅ Published to PyPI" >> $GITHUB_STEP_SUMMARY
          echo "- ✅ GitHub release created" >> $GITHUB_STEP_SUMMARY