kalign 3.4.6__tar.gz

kalign-3.4.6/.github/workflows/benchmark.yml

@@ -0,0 +1,122 @@
+name: Benchmark
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'lib/**'
+      - 'python-kalign/**'
+      - 'benchmarks/**'
+      - 'CMakeLists.txt'
+      - '.github/workflows/benchmark.yml'
+  pull_request:
+    branches: [main]
+    paths:
+      - 'lib/**'
+      - 'python-kalign/**'
+      - 'benchmarks/**'
+      - 'CMakeLists.txt'
+      - '.github/workflows/benchmark.yml'
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  deployments: write
+
+jobs:
+  benchmark:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install system dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libomp-dev cmake
+
+      - name: Build C binary
+        run: |
+          mkdir -p build
+          cd build
+          cmake ..
+          make -j$(nproc)
+
+      - name: Install Python package
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -e .
+
+      - name: Cache BAliBASE dataset
+        uses: actions/cache@v4
+        with:
+          path: benchmarks/data/downloads
+          key: benchmark-datasets-balibase-v1
+
+      - name: Run benchmarks
+        run: |
+          python -m benchmarks \
+            --dataset balibase \
+            --method python_api cli \
+            --binary build/src/kalign \
+            --output benchmarks/results/latest.json \
+            -v
+
+      - name: Convert results for github-action-benchmark
+        run: |
+          python -c "
+          import json
+          with open('benchmarks/results/latest.json') as f:
+              data = json.load(f)
+          entries = []
+          for method, stats in data.get('summary', {}).items():
+              entries.append({
+                  'name': f'SP Score Mean ({method})',
+                  'unit': 'score',
+                  'value': round(stats['sp_mean'], 2),
+                  'range': f\"{stats['sp_min']:.1f}-{stats['sp_max']:.1f}\",
+              })
+              entries.append({
+                  'name': f'Total Time ({method})',
+                  'unit': 'seconds',
+                  'value': round(stats['total_time'], 2),
+              })
+          with open('benchmarks/results/benchmark_output.json', 'w') as f:
+              json.dump(entries, f, indent=2)
+          "
+
+      - name: Store benchmark result
+        if: github.ref == 'refs/heads/main'
+        uses: benchmark-action/github-action-benchmark@v1
+        with:
+          tool: 'customBiggerIsBetter'
+          output-file-path: benchmarks/results/benchmark_output.json
+          gh-pages-branch: gh-pages
+          benchmark-data-dir-path: dev/bench
+          auto-push: true
+          alert-threshold: '95%'
+          comment-on-alert: true
+          fail-on-alert: false
+
+      - name: Compare with baseline (PRs only)
+        if: github.event_name == 'pull_request'
+        uses: benchmark-action/github-action-benchmark@v1
+        with:
+          tool: 'customBiggerIsBetter'
+          output-file-path: benchmarks/results/benchmark_output.json
+          gh-pages-branch: gh-pages
+          benchmark-data-dir-path: dev/bench
+          auto-push: false
+          alert-threshold: '95%'
+          comment-on-alert: true
+          fail-on-alert: true
+
+      - name: Upload results artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: benchmark-results
+          path: benchmarks/results/

kalign-3.4.6/.github/workflows/cmake.yml

@@ -0,0 +1,96 @@
+name: CMake
+
+on:
+  push:
+    branches: [ "main", "python" ]
+    paths:
+      - 'lib/**'
+      - 'src/**'
+      - 'tests/**'
+      - 'CMakeLists.txt'
+      - '.github/workflows/cmake.yml'
+  pull_request:
+    branches: [ "main" ]
+    paths:
+      - 'lib/**'
+      - 'src/**'
+      - 'tests/**'
+      - 'CMakeLists.txt'
+      - '.github/workflows/cmake.yml'
+
+jobs:
+  build:
+    name: Build C/C++ on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        build_type: [Release, Debug]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install dependencies (Ubuntu)
+      if: runner.os == 'Linux'
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y libomp-dev cmake
+
+    - name: Install dependencies (macOS)
+      if: runner.os == 'macOS'
+      run: |
+        brew install --formula libomp cmake
+
+    - name: Configure CMake
+      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
+
+    - name: Build
+      run: cmake --build ${{github.workspace}}/build --config ${{ matrix.build_type }} --parallel 2
+
+    - name: Test
+      working-directory: ${{github.workspace}}/build
+      run: ctest -C ${{ matrix.build_type }} --output-on-failure
+
+    - name: Test kalign executable
+      run: |
+        # Create test input
+        echo ">seq1" > test.fasta
+        echo "ATCGATCGATCG" >> test.fasta
+        echo ">seq2" >> test.fasta  
+        echo "ATCGTCGATCG" >> test.fasta
+        echo ">seq3" >> test.fasta
+        echo "ATCGATCATCG" >> test.fasta
+        
+        # Test kalign executable
+        ./build/src/kalign -i test.fasta -o test_output.fasta
+        
+        # Verify output exists and is not empty
+        if [ -f test_output.fasta ] && [ -s test_output.fasta ]; then
+          echo "✓ kalign executable test passed"
+        else
+          echo "✗ kalign executable test failed"
+          exit 1
+        fi
+
+  address-sanitizer:
+    name: Address Sanitizer
+    runs-on: ubuntu-latest
+    
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Install dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y libomp-dev cmake
+        
+    - name: Configure CMake with ASAN
+      run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=ASAN
+      
+    - name: Build
+      run: cmake --build ${{github.workspace}}/build --config ASAN --parallel 2
+      
+    - name: Test with ASAN
+      working-directory: ${{github.workspace}}/build
+      run: ctest -C ASAN --output-on-failure

kalign-3.4.6/.github/workflows/codeql-analysis.yml

@@ -0,0 +1,62 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [main, python]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [main, python]
+  schedule:
+    - cron: '0 2 * * 4'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        # Override automatic language detection by changing the below list
+        # Supported options are ['c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'swift']
+        language: ['c-cpp']
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file. 
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v3
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   mkdir build && cd build
+    #   cmake ..
+    #   make
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v3
+      with:
+        category: "/language:${{matrix.language}}"

kalign-3.4.6/.github/workflows/python.yml

@@ -0,0 +1,152 @@
+name: Python
+
+on:
+  push:
+    branches: [ main, python ]
+    paths:
+      - 'python-kalign/**'
+      - 'lib/**'
+      - 'CMakeLists.txt'
+      - 'pyproject.toml'
+      - '.github/workflows/python.yml'
+  pull_request:
+    branches: [ main ]
+    paths:
+      - 'python-kalign/**'
+      - 'lib/**'
+      - 'CMakeLists.txt'
+      - 'pyproject.toml'
+      - '.github/workflows/python.yml'
+  workflow_dispatch:
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.11'
+        
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install flake8 black isort mypy
+        
+    - name: Lint with flake8
+      run: |
+        flake8 python-kalign --count --select=E9,F63,F7,F82 --show-source --statistics
+        flake8 python-kalign --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+        
+    - name: Check formatting with black
+      run: |
+        black --check --diff python-kalign/
+        
+    - name: Check import sorting with isort
+      run: |
+        isort --check-only --diff python-kalign/
+
+  test:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        python-version: ['3.9', '3.10', '3.11', '3.12', '3.13']
+        
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+        
+    - name: Install system dependencies (Ubuntu)
+      if: runner.os == 'Linux'
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y libomp-dev cmake
+        
+    - name: Install system dependencies (macOS)
+      if: runner.os == 'macOS'
+      run: |
+        brew install libomp cmake
+        
+    - name: Install Python dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install pytest pytest-cov pytest-benchmark numpy
+        
+    - name: Build and install package
+      run: |
+        python -m pip install -e .
+        
+    - name: Test with pytest
+      run: |
+        pytest tests/python/ -v --cov=kalign --cov-report=xml --cov-report=term-missing
+        
+    - name: Upload coverage to Codecov
+      if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.11'
+      uses: codecov/codecov-action@v4
+      with:
+        file: coverage.xml
+        flags: python
+        name: codecov-umbrella
+
+  build-test:
+    name: Build and test package
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.11'
+        
+    - name: Install system dependencies (Ubuntu)
+      if: runner.os == 'Linux'
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y libomp-dev cmake
+        
+    - name: Install system dependencies (macOS)
+      if: runner.os == 'macOS'
+      run: |
+        brew install libomp cmake
+        
+    - name: Install build dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install build twine
+        
+    - name: Build package
+      run: |
+        python -m build
+        
+    - name: Check package
+      run: |
+        twine check dist/*
+        
+    - name: Test installation from wheel
+      run: |
+        python -m pip install dist/*.whl
+        python -c "import kalign; print(f'kalign {kalign.__version__} installed successfully')"
+        
+    - name: Test basic functionality
+      run: |
+        python -c "
+        import kalign
+        sequences = ['ATCGATCG', 'ATCGTCG', 'ATCGATCG']
+        aligned = kalign.align(sequences, seq_type='dna')
+        assert len(aligned) == 3
+        print('✓ Basic alignment test passed')
+        "

kalign-3.4.6/.github/workflows/wheels.yml

@@ -0,0 +1,265 @@
+name: Build Python Wheels
+
+on:
+  push:
+    branches: [ main, python ]
+    tags:
+      - 'v*'
+  pull_request:
+    branches: [ main ]
+    paths:
+      - 'python-kalign/**'
+      - 'lib/**'
+      - 'CMakeLists.txt'
+      - 'pyproject.toml'
+      - '.github/workflows/wheels.yml'
+  workflow_dispatch:
+    inputs:
+      publish_target:
+        description: "Publish target (manual runs only)"
+        required: true
+        default: "none"
+        type: choice
+        options:
+          - none
+          - testpypi
+
+jobs:
+  build_wheels:
+    name: Build wheels on ${{ matrix.os }} (${{ matrix.cibw_archs }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            cibw_archs: "x86_64"
+          - os: macos-14
+            cibw_archs: "x86_64"
+          - os: macos-14
+            cibw_archs: "arm64"
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.11'
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install cibuildwheel build
+
+    - name: Build wheels
+      env:
+        CIBW_BUILD: cp39-* cp310-* cp311-* cp312-* cp313-*
+        CIBW_SKIP: "*-win32 *-manylinux_i686 *-musllinux*"
+        CIBW_ARCHS: ${{ matrix.cibw_archs }}
+        # Set minimum macOS version to match OpenMP requirements
+        CIBW_ENVIRONMENT_MACOS: >
+          CMAKE_BUILD_PARALLEL_LEVEL=2
+          OMP_NUM_THREADS=1
+          MACOSX_DEPLOYMENT_TARGET=14.0
+          CMAKE_OSX_DEPLOYMENT_TARGET=14.0
+        
+        # Linux specific settings - handle different package managers
+        CIBW_BEFORE_ALL_LINUX: >
+          (yum install -y cmake3) ||
+          (apt-get update && apt-get install -y cmake) ||
+          (apk add --no-cache cmake)
+        CIBW_REPAIR_WHEEL_COMMAND_LINUX: auditwheel repair -w {dest_dir} {wheel}
+        
+        # macOS specific settings  
+        CIBW_BEFORE_ALL_MACOS: |
+          brew install --formula cmake libomp || echo "Dependencies may already be installed"
+        CIBW_REPAIR_WHEEL_COMMAND_MACOS: >
+          delocate-wheel --require-archs {delocate_archs} -w {dest_dir} -v {wheel}
+        
+        # Environment variables for builds
+        CIBW_ENVIRONMENT: >
+          CMAKE_BUILD_PARALLEL_LEVEL=2
+          OMP_NUM_THREADS=1
+          
+        # Skip testing during wheel build to avoid cross-compilation issues
+        CIBW_TEST_SKIP: "*"
+          
+      run: |
+        python -m cibuildwheel --output-dir wheelhouse
+
+    - name: Upload wheels
+      uses: actions/upload-artifact@v4
+      with:
+        name: cibw-wheels-${{ matrix.os }}-${{ strategy.job-index }}
+        path: wheelhouse/*.whl
+
+  build_sdist:
+    name: Build source distribution
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.11'
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install build
+
+    - name: Build sdist
+      run: |
+        python -m build --sdist --outdir dist/
+
+    - name: Upload sdist
+      uses: actions/upload-artifact@v4
+      with:
+        name: cibw-sdist
+        path: dist/*.tar.gz
+
+  test_install:
+    name: Test wheel installation
+    needs: [build_wheels]
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-14]
+        python-version: ['3.9', '3.10', '3.11', '3.12']
+
+    steps:
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Download wheels
+      uses: actions/download-artifact@v4
+      with:
+        pattern: cibw-wheels-*
+        merge-multiple: true
+        path: wheelhouse/
+
+    - name: Test installation and import
+      run: |
+        # Let pip find and install the appropriate wheel
+        echo "=== Available wheels ==="
+        ls -la wheelhouse/*.whl
+        
+        # Determine the distribution name from the wheel filenames (PEP 427)
+        # e.g. kalign_test-3.4.5-...whl -> kalign-test
+        DIST_NAME="$(ls wheelhouse/*.whl | head -n 1 | xargs basename | cut -d- -f1 | tr '_' '-')"
+        echo "=== Detected dist name: ${DIST_NAME} ==="
+
+        echo "=== Installing wheel ==="
+        pip install --find-links wheelhouse/ "${DIST_NAME}" --force-reinstall
+        
+        # Check what got installed
+        echo "=== Checking installed packages ==="
+        pip list | grep -E 'kalign' || true
+        
+        # Check the kalign module structure
+        echo "=== Checking kalign module ==="
+        python -c "
+        import sys
+        print('Python version:', sys.version)
+        print('Attempting to import kalign...')
+        try:
+            import kalign
+            print('✓ kalign imported successfully')
+            print('kalign location:', kalign.__file__)
+            import os
+            kalign_dir = os.path.dirname(kalign.__file__)
+            print('kalign dir contents:', sorted(os.listdir(kalign_dir)))
+            
+            # Check for _core specifically
+            core_files = [f for f in os.listdir(kalign_dir) if '_core' in f]
+            print('_core files found:', core_files)
+        except ImportError as e:
+            print('✗ Import failed:', str(e))
+            import os
+            import site
+            print('Site packages:', site.getsitepackages())
+            for site_dir in site.getsitepackages():
+                kalign_path = os.path.join(site_dir, 'kalign')
+                if os.path.exists(kalign_path):
+                    print(f'Found kalign at {kalign_path}')
+                    print('Contents:', sorted(os.listdir(kalign_path)))
+                    break
+            sys.exit(1)
+        "
+        
+        # Test the installation
+        python -c "
+        import kalign
+        print('kalign version:', kalign.__version__)
+        
+        # Test basic functionality
+        sequences = ['ATCGATCG', 'ATCGTCG', 'ATCGATCG']
+        aligned = kalign.align(sequences, seq_type='dna')
+        print('Number of aligned sequences:', len(aligned))
+        print('Alignment lengths:', [len(seq) for seq in aligned])
+        assert len(aligned) == 3
+        assert all(len(seq) == len(aligned[0]) for seq in aligned)
+        print('✓ Basic alignment test passed')
+        
+        # Test with different sequence types
+        protein_seqs = ['MKTAYIAKQRQ', 'MKTAYIAKQ', 'MKTAYIAK'] 
+        aligned_proteins = kalign.align(protein_seqs, seq_type='protein')
+        print('✓ Protein alignment test passed')
+        
+        print('All tests passed successfully!')
+        "
+
+  upload_pypi:
+    name: Upload to PyPI
+    needs: [build_wheels, build_sdist, test_install]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')
+    permissions:
+      id-token: write
+    environment:
+      name: pypi
+    
+    steps:
+    - name: Download all artifacts
+      uses: actions/download-artifact@v4
+      with:
+        pattern: cibw-*
+        merge-multiple: true
+        path: dist/
+
+    - name: Publish to PyPI (trusted publishing)
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        packages_dir: dist/
+
+  upload_testpypi:
+    name: Upload to TestPyPI
+    needs: [build_wheels, build_sdist, test_install]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'workflow_dispatch' && inputs.publish_target == 'testpypi'
+
+    steps:
+    - name: Download all artifacts
+      uses: actions/download-artifact@v4
+      with:
+        pattern: cibw-*
+        merge-multiple: true
+        path: dist/
+
+    - name: Publish to TestPyPI (API token)
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        user: __token__
+        password: ${{ secrets.TEST_PYPI_API_TOKEN }}
+        packages_dir: dist/
+        repository-url: https://test.pypi.org/legacy/
+        verbose: true