kohakuclip 1.0.0__tar.gz

kohakuclip-1.0.0/.github/workflows/auto-patch-release.yml

@@ -0,0 +1,79 @@
+name: Auto Patch Release
+
+on:
+  schedule:
+    # 05:00 UTC weekly, Monday
+    - cron: "0 5 * * 1"
+  workflow_dispatch:
+    inputs:
+      dry_run:
+        description: "Evaluate and report, do not tag"
+        required: false
+        default: true
+        type: boolean
+      min_commits:
+        description: "Commits on main since the last tag before a patch is cut"
+        required: false
+        default: "3"
+
+permissions:
+  contents: write
+  actions: write
+
+jobs:
+  patch:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: main
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Decide whether a patch is due
+        id: decide
+        shell: bash
+        run: |
+          current=$(python scripts/ci/version.py read)
+          last=$(git describe --tags --abbrev=0 --match 'v*' 2>/dev/null || echo "")
+          span=${last:+${last}..HEAD}
+          count=$(git rev-list --count --no-merges ${span:-HEAD})
+          min="${{ inputs.min_commits || 3 }}"
+          echo "current=${current} last=${last:-none} commits=${count} min=${min}"
+          if [ "${count}" -ge "${min}" ] && [ "v${current}" = "${last:-}" ]; then
+            echo "release=true" >> "$GITHUB_OUTPUT"
+          else
+            # Either nothing has landed, or pyproject is already ahead of the
+            # last tag — which means a human is mid-release; stay out of it.
+            echo "release=false" >> "$GITHUB_OUTPUT"
+          fi
+          echo "next=$(python scripts/ci/version.py bump patch)" >> "$GITHUB_OUTPUT"
+
+      - name: Report only
+        if: steps.decide.outputs.release != 'true' || inputs.dry_run
+        run: |
+          echo "release=${{ steps.decide.outputs.release }}"
+          echo "would cut ${{ steps.decide.outputs.next }}"
+
+      - name: Stamp, tag and push
+        if: steps.decide.outputs.release == 'true' && !inputs.dry_run
+        shell: bash
+        run: |
+          next="${{ steps.decide.outputs.next }}"
+          python scripts/ci/version.py write "${next}"
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git commit -am "bump to version ${next}"
+          git tag "v${next}"
+          git push origin main --follow-tags
+
+      # The tag push above cannot start another workflow (GITHUB_TOKEN pushes
+      # do not trigger `on: push`), so Release is dispatched explicitly.
+      - name: Dispatch the release workflow
+        if: steps.decide.outputs.release == 'true' && !inputs.dry_run
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: gh workflow run release.yml -f ref="v${{ steps.decide.outputs.next }}"

kohakuclip-1.0.0/.github/workflows/ci.yml

@@ -0,0 +1,124 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  # Formatting and the breakage-only ruff set (pyproject pins which rules block); rustfmt.
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+      - run: pip install black ruff
+      - run: black --check src/ tests/ benchmarks/ examples/ scripts/
+      - run: ruff check src/ tests/ benchmarks/ examples/ scripts/
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt
+      - run: cargo fmt --check
+
+  # Builds against conda-forge's FFmpeg (the GPL build: the tests encode H.264 with x264 too),
+  # then clippy, the Rust unit tests and the end-to-end suite on CPU torch.
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.13", "3.14"]
+    defaults:
+      run:
+        shell: bash -el {0}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: mamba-org/setup-micromamba@v2
+        with:
+          environment-name: kohakuclip
+          create-args: >-
+            python=${{ matrix.python-version }}
+            ffmpeg=8.1.*=gpl*
+            libclang=18
+            clang=18
+          cache-environment: true
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy
+      - name: Build environment
+        run: |
+          {
+            echo "FFMPEG_INCLUDE_DIR=$CONDA_PREFIX/include"
+            echo "FFMPEG_LIBS_DIR=$CONDA_PREFIX/lib"
+            echo "FFMPEG_LINK_MODE=dynamic"
+            echo "LIBCLANG_PATH=$CONDA_PREFIX/lib"
+            echo "BINDGEN_EXTRA_CLANG_ARGS=-I$CONDA_PREFIX/lib/clang/18/include -I/usr/include/x86_64-linux-gnu -I/usr/include"
+            echo "RUSTFLAGS=-C link-arg=-Wl,-rpath,$CONDA_PREFIX/lib"
+          } >> "$GITHUB_ENV"
+      - run: cargo clippy --release --all-targets -- -D warnings
+      - run: cargo test --release --lib
+      - name: Install
+        run: |
+          pip install maturin
+          pip install torch --index-url https://download.pytorch.org/whl/cpu
+          pip install av numpy pytest
+          maturin develop --release
+      - run: pytest tests -v --tb=short
+
+  # The release build, end to end: a manylinux_2_35 wheel with FFmpeg bundled, installed
+  # into a clean venv with no FFmpeg around, then used to encode, pack and read a shard.
+  package-check:
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+      - uses: mamba-org/setup-micromamba@v2
+        with:
+          environment-name: ffmpeg
+          # the same packages as the test job's environment (whose bindings build), with the
+          # LGPL FFmpeg
+          create-args: >-
+            python=3.13
+            ffmpeg=8.1.*=lgpl*
+            libclang=18
+            clang=18
+      - uses: dtolnay/rust-toolchain@stable
+      # Steps after this one run outside the activated environment: CLANG_PATH keeps the
+      # bindings on the environment's clang (the runner's own clang has other headers).
+      - name: Build environment (the LGPL FFmpeg, clang 18 for the bindings)
+        shell: bash -el {0}
+        run: |
+          {
+            echo "FFMPEG_INCLUDE_DIR=$CONDA_PREFIX/include"
+            echo "FFMPEG_LIBS_DIR=$CONDA_PREFIX/lib"
+            echo "FFMPEG_LINK_MODE=dynamic"
+            echo "LIBCLANG_PATH=$CONDA_PREFIX/lib"
+            echo "CLANG_PATH=$CONDA_PREFIX/bin/clang"
+            echo "BINDGEN_EXTRA_CLANG_ARGS=-I$CONDA_PREFIX/lib/clang/18/include -I/usr/include/x86_64-linux-gnu -I/usr/include"
+            echo "RUSTFLAGS=-Ctarget-cpu=x86-64-v3 -Clink-arg=-Wl,--as-needed -Clink-arg=-Wl,-rpath,$CONDA_PREFIX/lib"
+          } >> "$GITHUB_ENV"
+      # conda-forge's FFmpeg dependencies (ICU, shaderc) need GLIBCXX 3.4.30: the wheels are
+      # manylinux_2_35 (glibc 2.35, e.g. Ubuntu 22.04+), built on this Ubuntu 22.04 runner
+      # and repaired by maturin, which bundles FFmpeg and its libraries into the wheel
+      # (found through the extension's rpath; LD_LIBRARY_PATH would hand the env's
+      # libpython to every Python on the runner).
+      - name: Build wheels
+        run: |
+          pip install "maturin[patchelf]"
+          maturin build --release --strip \
+            --compatibility manylinux_2_35 -i python3.13 -o dist
+      - name: Install the wheel into a clean venv
+        run: |
+          python -m venv .venv-wheel
+          . .venv-wheel/bin/activate
+          pip install dist/*.whl
+          python scripts/ci/wheel_smoke.py

kohakuclip-1.0.0/.github/workflows/nightly.yml

@@ -0,0 +1,96 @@
+name: Nightly
+
+on:
+  schedule:
+    # 03:00 UTC, once a day. This is the only automatic trigger: nothing about
+    # a nightly is per-push, so a commit landing at noon waits for tomorrow.
+    - cron: "0 3 * * *"
+  workflow_dispatch:
+    inputs:
+      force:
+        description: "Build even when the gate says there is nothing new"
+        required: false
+        default: false
+        type: boolean
+
+# Serialised, and never cancelled: a second run has to see the tags the first
+# one pushed, or both would decide the same commit is unbuilt.
+concurrency:
+  group: nightly
+  cancel-in-progress: false
+
+permissions:
+  contents: read
+  actions: write
+
+jobs:
+  # Decides only. Release is the sole workflow that builds or uploads, so PyPI
+  # needs exactly one trusted publisher.
+  dispatch:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: main
+          fetch-depth: 0
+          # Release cuts its tag through `gh release create`, so the tags are
+          # the record of what has been published and the gate below reads
+          # them; a shallow clone without them would rebuild every night.
+          fetch-tags: true
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+
+      - name: Decide whether a nightly is due
+        id: gate
+        shell: bash
+        run: |
+          head=$(git rev-parse HEAD)
+          today=$(date -u +%Y%m%d)
+
+          # Every release, stable or nightly, leaves a v* tag on the commit it
+          # was cut from. A tag already sitting on HEAD means main has not
+          # moved since the last one, and a rebuild would only differ by its
+          # timestamp — a duplicate under a new PyPI filename.
+          published=$(git tag --points-at HEAD --list 'v*' | head -n1)
+
+          # Second belt: the nightly version carries the UTC date it was cut
+          # on, so an extra dispatch or a re-run cannot cut a second nightly
+          # for the same day even if main did move.
+          already_today=$(git tag --list "v*.dev${today}*" | head -n1)
+
+          if [ "${{ inputs.force }}" = "true" ]; then
+            reason="forced"
+            build=true
+          elif [ -n "${published}" ]; then
+            reason="${head} is already released as ${published}"
+            build=false
+          elif [ -n "${already_today}" ]; then
+            reason="${already_today} was already cut today"
+            build=false
+          else
+            reason="main is at ${head}, unreleased"
+            build=true
+          fi
+
+          echo "build=${build}" >> "$GITHUB_OUTPUT"
+          echo "${reason}" | tee -a "$GITHUB_STEP_SUMMARY"
+
+      # Computed after the gate so the stamp names the moment of the build.
+      - name: Compute the nightly version
+        id: compute
+        if: steps.gate.outputs.build == 'true'
+        shell: bash
+        run: |
+          version=$(python scripts/ci/version.py nightly)
+          echo "version=${version}" >> "$GITHUB_OUTPUT"
+          echo "nightly ${version}" | tee -a "$GITHUB_STEP_SUMMARY"
+
+      - name: Dispatch the release workflow
+        if: steps.gate.outputs.build == 'true'
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh workflow run release.yml \
+            -f ref=main \
+            -f version="${{ steps.compute.outputs.version }}"

kohakuclip-1.0.0/.github/workflows/release.yml

@@ -0,0 +1,214 @@
+name: Release
+
+on:
+  # Cutting a release in the GitHub UI, or pushing the tag, both publish.
+  release:
+    types: [published]
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+    inputs:
+      ref:
+        description: "Tag, branch or sha to release"
+        required: false
+        default: ""
+      version:
+        description: "Stamp this version before building (nightlies pass X.Y.Z.devN)"
+        required: false
+        default: ""
+
+permissions:
+  contents: write
+  id-token: write
+
+# The only workflow that builds or uploads, so PyPI needs one trusted publisher:
+# this file (release.yml), environment `pypi`.
+jobs:
+  version:
+    name: Resolve version
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.version.outputs.version }}
+      prerelease: ${{ steps.version.outputs.prerelease }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref || github.ref }}
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+      - id: version
+        shell: bash
+        run: |
+          if [ -n "${{ inputs.version }}" ]; then
+            python scripts/ci/version.py write "${{ inputs.version }}"
+          fi
+          version=$(python scripts/ci/version.py read)
+          case "${version}" in
+            *dev*|*a*|*b*|*rc*) pre=true ;;
+            *) pre=false ;;
+          esac
+          {
+            echo "version=${version}"
+            echo "prerelease=${pre}"
+          } >> "$GITHUB_OUTPUT"
+          echo "releasing ${version} (prerelease=${pre})"
+
+      # A tag that disagrees with pyproject is a mis-cut release: stop before anything is
+      # uploaded, since a PyPI filename cannot be reused.
+      - name: Tag must match pyproject
+        if: startsWith(github.ref, 'refs/tags/v') || github.event_name == 'release'
+        shell: bash
+        run: |
+          tag="${GITHUB_REF_NAME#v}"
+          test "${tag}" = "${{ steps.version.outputs.version }}" \
+            || { echo "tag ${tag} != pyproject ${{ steps.version.outputs.version }}"; exit 1; }
+
+  # manylinux wheels with an LGPL FFmpeg (libdav1d, SVT-AV1, aom, openh264) bundled by
+  # auditwheel: `pip install kohakuclip` needs nothing else. Source builds against your own
+  # FFmpeg go through the sdist (see README, Build).
+  # manylinux_2_35 wheels with an LGPL FFmpeg (libdav1d, SVT-AV1, aom, openh264) bundled:
+  # `pip install kohakuclip` needs nothing else. Source builds against your own FFmpeg go
+  # through the sdist (see README, Install and build).
+  wheels:
+    name: Wheels
+    needs: [version]
+    runs-on: ubuntu-22.04
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref || github.ref }}
+      - uses: actions/setup-python@v5
+        with:
+          python-version: |
+            3.14
+            3.13
+      - name: Stamp the version
+        if: inputs.version != ''
+        run: python scripts/ci/version.py write "${{ inputs.version }}"
+      - uses: mamba-org/setup-micromamba@v2
+        with:
+          environment-name: ffmpeg
+          # the same packages as the test job's environment (whose bindings build), with the
+          # LGPL FFmpeg
+          create-args: >-
+            python=3.13
+            ffmpeg=8.1.*=lgpl*
+            libclang=18
+            clang=18
+      - uses: dtolnay/rust-toolchain@stable
+      # Steps after this one run outside the activated environment: CLANG_PATH keeps the
+      # bindings on the environment's clang (the runner's own clang has other headers).
+      - name: Build environment (the LGPL FFmpeg, clang 18 for the bindings)
+        shell: bash -el {0}
+        run: |
+          {
+            echo "FFMPEG_INCLUDE_DIR=$CONDA_PREFIX/include"
+            echo "FFMPEG_LIBS_DIR=$CONDA_PREFIX/lib"
+            echo "FFMPEG_LINK_MODE=dynamic"
+            echo "LIBCLANG_PATH=$CONDA_PREFIX/lib"
+            echo "CLANG_PATH=$CONDA_PREFIX/bin/clang"
+            echo "BINDGEN_EXTRA_CLANG_ARGS=-I$CONDA_PREFIX/lib/clang/18/include -I/usr/include/x86_64-linux-gnu -I/usr/include"
+            echo "RUSTFLAGS=-Ctarget-cpu=x86-64-v3 -Clink-arg=-Wl,--as-needed -Clink-arg=-Wl,-rpath,$CONDA_PREFIX/lib"
+          } >> "$GITHUB_ENV"
+      # conda-forge's FFmpeg dependencies (ICU, shaderc) need GLIBCXX 3.4.30: the wheels are
+      # manylinux_2_35 (glibc 2.35, e.g. Ubuntu 22.04+), built on this Ubuntu 22.04 runner
+      # and repaired by maturin, which bundles FFmpeg and its libraries into the wheel
+      # (found through the extension's rpath; LD_LIBRARY_PATH would hand the env's
+      # libpython to every Python on the runner).
+      - name: Build wheels
+        run: |
+          pip install "maturin[patchelf]"
+          maturin build --release --strip \
+            --compatibility manylinux_2_35 -i python3.13 -i python3.14 -o dist
+      - name: Smoke test the wheel in a clean venv
+        run: |
+          python3.13 -m venv .venv-wheel
+          . .venv-wheel/bin/activate
+          pip install dist/*cp313*.whl
+          python scripts/ci/wheel_smoke.py
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels
+          path: dist/*.whl
+          if-no-files-found: error
+          retention-days: 7
+
+  sdist:
+    name: Source distribution
+    needs: [version]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref || github.ref }}
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+      - name: Stamp the version
+        if: inputs.version != ''
+        run: python scripts/ci/version.py write "${{ inputs.version }}"
+      - uses: PyO3/maturin-action@v1
+        with:
+          command: sdist
+          args: -o dist
+      - run: pip install twine && twine check dist/*
+      - uses: actions/upload-artifact@v4
+        with:
+          name: sdist
+          path: dist/*.tar.gz
+          if-no-files-found: error
+          retention-days: 7
+
+  publish-pypi:
+    name: Publish distributions to PyPI
+    needs: [wheels, sdist]
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/kohakuclip
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          path: dist/
+          merge-multiple: true
+      - uses: pypa/gh-action-pypi-publish@release/v1
+
+  publish-github:
+    name: Publish the GitHub release
+    needs: [version, publish-pypi]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref || github.ref }}
+          fetch-depth: 0
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.13"
+      - uses: actions/download-artifact@v4
+        with:
+          path: dist/
+          merge-multiple: true
+      - name: Create or update the release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          version="${{ needs.version.outputs.version }}"
+          tag="v${version}"
+          flag=""
+          if [ "${{ needs.version.outputs.prerelease }}" = "true" ]; then
+            flag="--prerelease"
+          fi
+          notes=$(python scripts/ci/release_notes.py --version "${version}")
+          if ! gh release view "${tag}" >/dev/null 2>&1; then
+            gh release create "${tag}" --title "KohakuClip ${version}" \
+              --notes "${notes}" ${flag} --target "$(git rev-parse HEAD)"
+          else
+            gh release edit "${tag}" --title "KohakuClip ${version}" \
+              --notes "${notes}" ${flag}
+          fi
+          for f in dist/*; do gh release upload "${tag}" "$f" --clobber; done