Robustified python API

Author: TimoLassmann

python-kalign/__init__.py

@@ -108,14 +108,48 @@ def align(
     <class 'skbio.alignment._tabular_msa.TabularMSA'>
     """
 
+    # Input validation - replicate C CLI robustness
     if not sequences:
-        raise ValueError("Empty sequence list provided")
-
+        raise ValueError("No sequences were found in the input")
+    
+    if len(sequences) < 2:
+        if len(sequences) == 0:
+            raise ValueError("No sequences were found in the input")
+        elif len(sequences) == 1:
+            raise ValueError("Only 1 sequence was found in the input - at least 2 sequences are required for alignment")
+    
     if not all(isinstance(seq, str) for seq in sequences):
         raise ValueError("All sequences must be strings")
 
-    if not all(seq.strip() for seq in sequences):
-        raise ValueError("All sequences must be non-empty")
+    # Check for empty or whitespace-only sequences
+    empty_sequences = []
+    for i, seq in enumerate(sequences):
+        if not seq or not seq.strip():
+            empty_sequences.append(i)
+    
+    if empty_sequences:
+        if len(empty_sequences) == 1:
+            raise ValueError(f"Sequence at index {empty_sequences[0]} is empty or contains only whitespace")
+        else:
+            raise ValueError(f"Sequences at indices {empty_sequences} are empty or contain only whitespace")
+    
+    # Check for valid sequence characters (basic validation)
+    for i, seq in enumerate(sequences):
+        # Remove common whitespace and check if anything remains
+        cleaned_seq = ''.join(seq.split())
+        if len(cleaned_seq) == 0:
+            raise ValueError(f"Sequence at index {i} contains only whitespace characters")
+        
+        # Check for obviously invalid characters (control characters, etc)
+        if any(ord(char) < 32 for char in cleaned_seq if char not in '\t\n\r'):
+            raise ValueError(f"Sequence at index {i} contains invalid control characters")
+    
+    # Warn about very short sequences (like C CLI warnings)
+    very_short_sequences = [i for i, seq in enumerate(sequences) if len(seq.strip()) < 3]
+    if very_short_sequences and len(very_short_sequences) > len(sequences) * 0.5:
+        import warnings
+        warnings.warn(f"Many sequences are very short (< 3 characters). This may affect alignment quality.", 
+                     UserWarning, stacklevel=2)
 
     # Convert string sequence types to integers
     seq_type_map = {
@@ -137,21 +171,39 @@ def align(
     else:
         seq_type_int = seq_type
 
-    # Use defaults if not specified
+    # Parameter validation and defaults
     if gap_open is None:
         gap_open = -1.0
+    elif not isinstance(gap_open, (int, float)):
+        raise ValueError("gap_open must be a number")
+    elif gap_open > 0:
+        raise ValueError("gap_open must be negative or zero (penalty values)")
+    
     if gap_extend is None:
         gap_extend = -1.0
+    elif not isinstance(gap_extend, (int, float)):
+        raise ValueError("gap_extend must be a number")
+    elif gap_extend > 0:
+        raise ValueError("gap_extend must be negative or zero (penalty values)")
+    
     if terminal_gap_extend is None:
         terminal_gap_extend = -1.0
+    elif not isinstance(terminal_gap_extend, (int, float)):
+        raise ValueError("terminal_gap_extend must be a number")
+    elif terminal_gap_extend > 0:
+        raise ValueError("terminal_gap_extend must be negative or zero (penalty values)")
 
     # Handle thread count
     if n_threads is None:
         n_threads = get_num_threads()
-
-    # Validate thread count
-    if n_threads < 1:
+    elif not isinstance(n_threads, int):
+        raise ValueError("n_threads must be an integer")
+    elif n_threads < 1:
         raise ValueError("n_threads must be at least 1")
+    elif n_threads > 1024:  # reasonable upper limit
+        import warnings
+        warnings.warn(f"Very high thread count ({n_threads}) may not improve performance and could cause issues.", 
+                     UserWarning, stacklevel=2)
 
     # Call the C++ binding for core alignment
     try:

tests/python/test_basic_alignment.py

@@ -3,6 +3,7 @@
 """
 
 import pytest
+import sys
 import kalign
 from conftest import assert_valid_alignment, assert_alignment_preserves_characters
 
@@ -57,20 +58,8 @@ def test_empty_sequence_list(self):
             kalign.align([])
 
     def test_single_sequence(self):
-        """Test alignment with single sequence should raise error or handle gracefully."""
+        """Test alignment with single sequence should raise error."""
         single_seq = ["ATCGATCG"]
         # Kalign requires at least 2 sequences for alignment
-        # The expected behavior is to raise RuntimeError, but we handle platform differences
-        try:
-            result = kalign.align(single_seq, seq_type="dna")
-            # If it somehow succeeds, the result should be sensible
-            assert isinstance(result, list)
-            assert len(result) == 1
-            assert result[0] == single_seq[0]  # Should return original sequence
-        except RuntimeError as e:
-            # This is the expected behavior
-            assert "alignment failed" in str(e).lower() or "only 1 sequences found" in str(e).lower()
-        except Exception as e:
-            # Log unexpected exceptions but don't fail the test due to platform differences
-            print(f"Unexpected exception type: {type(e).__name__}: {e}")
-            pytest.skip(f"Platform-specific handling difference: {type(e).__name__}")
+        with pytest.raises(ValueError, match="At least 2 sequences are required"):
+            kalign.align(single_seq, seq_type="dna")