spot-planner 0.1.0__tar.gz

spot_planner-0.1.0/.github/SETUP.md

@@ -0,0 +1,130 @@
+# GitHub Actions Setup Guide
+
+This guide explains how to set up the GitHub Actions workflow for building and publishing `spot-planner` to PyPI.
+
+## Prerequisites
+
+1. **PyPI Account**: You need a PyPI account to publish packages
+2. **PyPI Project**: The project must be registered on PyPI
+3. **GitHub Repository**: The code must be in a GitHub repository
+
+## Setup Steps
+
+### 1. Configure PyPI OIDC Trusted Publishing
+
+1. Go to [PyPI](https://pypi.org) and log in
+2. Navigate to Account Settings → API tokens
+3. Click "Add API token"
+4. Select "Create a token for trusted publishing"
+5. Configure the trusted publisher:
+   - **PyPI project name**: `spot-planner`
+   - **Owner**: Your GitHub username or organization
+   - **Repository name**: `spot-planner`
+   - **Workflow filename**: `publish.yml`
+   - **Environment name**: `pypi` (optional)
+6. Click "Add token"
+
+**Note**: The workflow includes the required `id-token: write` permission for OIDC authentication.
+
+### 2. Create PyPI Environment
+
+1. Go to your GitHub repository
+2. Navigate to Settings → Environments
+3. Click "New environment"
+4. Name: `pypi`
+5. Click "Configure environment"
+
+**Optional Environment Protection:**
+
+- **Required reviewers**: Add team members who must approve PyPI releases
+- **Wait timer**: Add a delay before publishing (useful for rollback)
+- **Deployment branches**: Restrict which branches can trigger publishing
+
+### 3. Test the Workflow
+
+The workflow will automatically run on:
+
+- **Every push to master branch**: Builds wheels and runs tests
+- **Tagged commits**: Builds wheels, runs tests, AND publishes to PyPI
+
+To test publishing:
+
+```bash
+# Create and push a tag
+git tag v0.1.0
+git push origin v0.1.0
+
+# Or push to master to trigger build-only
+git push origin master
+```
+
+## Workflow Details
+
+### Jobs Overview
+
+1. **check-tag**: Determines if the current commit is tagged
+2. **build-wheels**: Builds native wheels for AMD64 and ARM64 Linux
+3. **publish**: Publishes to PyPI (only for tagged releases)
+4. **test-build**: Runs tests on every push to master
+
+### Supported Platforms
+
+- **AMD64 Linux** (`x86_64-unknown-linux-gnu`): Standard x86_64 systems
+- **ARM64 Linux** (`aarch64-unknown-linux-gnu`): Raspberry Pi 4/5, ARM servers
+
+### Version Management
+
+The workflow automatically updates version numbers from git tags:
+
+- Tag `v1.2.3` → Version `1.2.3`
+- Tag `1.2.3` → Version `1.2.3`
+- Updates both `pyproject.toml` and `Cargo.toml`
+
+### Artifacts
+
+Each build creates:
+
+- **Wheel files**: `spot_planner-{version}-cp3*-{platform}.whl`
+- **Source distribution**: `spot-planner-{version}.tar.gz`
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Build fails on ARM64**:
+
+   - Check that cross-compilation dependencies are installed
+   - Verify linker settings in the workflow
+
+2. **Publishing fails**:
+
+   - Verify `PYPI_API_TOKEN` secret is set correctly
+   - Check that the version doesn't already exist on PyPI
+   - Ensure the tag format is correct
+
+3. **Tests fail**:
+   - Check that all dependencies are installed
+   - Verify the Rust module builds correctly
+
+### Manual Publishing
+
+If you need to publish manually:
+
+```bash
+# Build wheels locally
+maturin build --release --target x86_64-unknown-linux-gnu
+maturin build --release --target aarch64-unknown-linux-gnu
+
+# Build source distribution
+uv build --sdist
+
+# Upload to PyPI (requires API token for manual upload)
+uv publish dist/*
+```
+
+## Security Notes
+
+- **OIDC Authentication**: No long-lived tokens stored in GitHub secrets
+- **Trusted Publishing**: PyPI verifies the GitHub Actions workflow and environment
+- **Automatic Rotation**: OIDC tokens are short-lived and automatically rotated
+- **Least Privilege**: Only the specific repository and workflow can publish

spot_planner-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,249 @@
+name: Build and Publish
+
+on:
+  push:
+    branches: [master]
+  workflow_dispatch:
+
+permissions:
+  id-token: write
+  contents: read
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  check-tag:
+    runs-on: ubuntu-latest
+    outputs:
+      is_tagged: ${{ steps.check.outputs.is_tagged }}
+      tag: ${{ steps.check.outputs.tag }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # Fetch full history for tag detection
+
+      - name: Check if this is a tagged release
+        id: check
+        run: |
+          if git describe --exact-match --tags HEAD 2>/dev/null; then
+            echo "is_tagged=true" >> $GITHUB_OUTPUT
+            echo "tag=$(git describe --exact-match --tags HEAD)" >> $GITHUB_OUTPUT
+          else
+            echo "is_tagged=false" >> $GITHUB_OUTPUT
+          fi
+
+  build-wheels:
+    needs: check-tag
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu]
+        include:
+          - target: x86_64-unknown-linux-gnu
+            platform: linux-x86_64
+          - target: aarch64-unknown-linux-gnu
+            platform: linux-aarch64
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
+
+      - name: Cache cargo registry
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            ~/.cargo/bin
+          key: ${{ runner.os }}-cargo-${{ matrix.target }}-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-${{ matrix.target }}-
+            ${{ runner.os }}-cargo-
+
+      - name: Cache maturin
+        uses: actions/cache@v4
+        with:
+          path: ~/.cargo/bin/maturin
+          key: ${{ runner.os }}-maturin-1.9.5
+          restore-keys: |
+            ${{ runner.os }}-maturin-
+
+      - name: Install cross-compilation dependencies (ARM)
+        if: matrix.target == 'aarch64-unknown-linux-gnu'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y gcc-aarch64-linux-gnu
+          rustup target add aarch64-unknown-linux-gnu
+
+      - name: Install maturin
+        run: |
+          # Check if maturin is already cached
+          if command -v maturin &> /dev/null; then
+            echo "maturin already installed, skipping installation"
+            maturin --version
+          else
+            echo "Installing maturin..."
+            # Use a specific version and add timeout to avoid cancellation
+            timeout 600 cargo install maturin --version 1.9.5 --locked --force
+          fi
+
+      - name: Update version from tag
+        if: needs.check-tag.outputs.is_tagged == 'true'
+        run: |
+          TAG_VERSION=${{ needs.check-tag.outputs.tag }}
+          # Remove 'v' prefix if present
+          TAG_VERSION=${TAG_VERSION#v}
+          echo "Updating version to $TAG_VERSION"
+
+          # Update pyproject.toml
+          sed -i "s/^version = \".*\"/version = \"$TAG_VERSION\"/" pyproject.toml
+
+          # Update Cargo.toml
+          sed -i "s/^version = \".*\"/version = \"$TAG_VERSION\"/" Cargo.toml
+
+          echo "Updated version to $TAG_VERSION"
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          version: "latest"
+
+      - name: Build wheel
+        env:
+          TARGET: ${{ matrix.target }}
+        run: |
+          if [ "$TARGET" = "x86_64-unknown-linux-gnu" ]; then
+            maturin build --release --target $TARGET --out dist
+          else
+            # For ARM64, we need to set the linker and use uv's Python
+            export CC_aarch64_unknown_linux_gnu=aarch64-linux-gnu-gcc
+            export CXX_aarch64_unknown_linux_gnu=aarch64-linux-gnu-g++
+            export AR_aarch64_unknown_linux_gnu=aarch64-linux-gnu-ar
+            export RANLIB_aarch64_unknown_linux_gnu=aarch64-linux-gnu-ranlib
+            
+            # Create a virtual environment with uv and activate it
+            uv venv --python 3.13
+            source .venv/bin/activate
+            
+            # Get the Python interpreter path from the venv
+            PYTHON_PATH=$(which python)
+            echo "Using Python at: $PYTHON_PATH"
+            python --version
+            
+            # Create a symlink with the expected name for maturin
+            sudo ln -sf "$PYTHON_PATH" /usr/local/bin/python3.13
+            
+            # Set up cargo config for cross-compilation
+            mkdir -p .cargo
+            echo '[target.aarch64-unknown-linux-gnu]' > .cargo/config.toml
+            echo 'linker = "aarch64-linux-gnu-gcc"' >> .cargo/config.toml
+            echo 'ar = "aarch64-linux-gnu-ar"' >> .cargo/config.toml
+            
+            # Build with the interpreter name maturin expects for cross-compilation
+            maturin build --release --target $TARGET --out dist -i python3.13
+          fi
+
+      - name: Upload wheel artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheel-${{ matrix.platform }}
+          path: dist/*.whl
+
+  publish:
+    needs: [check-tag, build-wheels]
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/master' && needs.check-tag.outputs.is_tagged == 'true'
+    environment: pypi
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Download all wheel artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: dist
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          version: "latest"
+
+      - name: Build source distribution
+        run: uv build --sdist
+
+      - name: Publish to PyPI
+        run: |
+          # Upload all wheels and source distribution using OIDC
+          uv publish dist/*
+
+  test-build:
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/master'
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache cargo registry
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            ~/.cargo/bin
+          key: ${{ runner.os }}-cargo-test-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-test-
+            ${{ runner.os }}-cargo-
+
+      - name: Cache maturin
+        uses: actions/cache@v4
+        with:
+          path: ~/.cargo/bin/maturin
+          key: ${{ runner.os }}-maturin-1.9.5
+          restore-keys: |
+            ${{ runner.os }}-maturin-
+
+      - name: Install maturin
+        run: |
+          # Check if maturin is already cached
+          if command -v maturin &> /dev/null; then
+            echo "maturin already installed, skipping installation"
+            maturin --version
+          else
+            echo "Installing maturin..."
+            # Use a specific version and add timeout to avoid cancellation
+            timeout 600 cargo install maturin --version 1.9.5 --locked --force
+          fi
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          version: "latest"
+
+      - name: Install Python dependencies
+        run: uv sync --dev
+
+      - name: Build in development mode
+        run: |
+          # Activate the virtual environment created by uv
+          source .venv/bin/activate
+          maturin develop --release
+
+      - name: Run tests
+        run: uv run pytest tests/ -v
+
+      - name: Test import
+        run: |
+          uv run python -c "from spot_planner import get_cheapest_periods; print('Import successful')"

spot_planner-0.1.0/.gitignore

@@ -0,0 +1,15 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+*.so
+
+# Rust build artifacts
+target/

spot_planner-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13