omnigenome 0.3.0a0__py3-none-any.whl → 0.3.1a0__py3-none-any.whl

tests/test_model_loading.py

@@ -1,183 +0,0 @@
-"""
-Test model loading functionality based on examples.
-"""
-import pytest
-import tempfile
-import os
-from unittest.mock import patch, MagicMock
-
-try:
-    import torch
-except ImportError:
-    torch = None
-
-# Skip heavy model loading tests by default - can be run with --run-slow
-pytestmark = pytest.mark.slow
-
-
-class TestModelLoading:
-    """Test model loading similar to examples."""
-
-    @pytest.fixture
-    def mock_model_config(self):
-        """Mock model config to avoid downloading real models."""
-        config = MagicMock()
-        config.hidden_size = 768
-        config.num_labels = 2
-        return config
-
-    @pytest.fixture
-    def mock_tokenizer(self):
-        """Mock tokenizer for testing."""
-        tokenizer = MagicMock()
-        tokenizer.encode.return_value = [1, 2, 3, 4, 5]
-        tokenizer.decode.return_value = "AUGC"
-        tokenizer.convert_ids_to_tokens.return_value = ["A", "U", "G", "C"]
-        return tokenizer
-
-    def test_model_import_structure(self):
-        """Test that model classes can be imported as shown in examples."""
-        try:
-            from omnigenome import (
-                OmniModelForSequenceClassification,
-                OmniModelForTokenClassification,
-                OmniModelForSequenceRegression,
-                OmniModelForTokenRegression,
-            )
-            # If import succeeds, test passes
-            assert True
-        except ImportError:
-            pytest.skip("omnigenome not available or missing dependencies")
-
-    def test_embedding_model_import(self):
-        """Test embedding model import as shown in RNA_Embedding_Tutorial.ipynb."""
-        try:
-            from omnigenome import OmniGenomeModelForEmbedding
-            assert True
-        except ImportError:
-            pytest.skip("omnigenome not available or missing dependencies")
-
-    def test_pooling_import(self):
-        """Test pooling import as shown in classification.ipynb."""
-        try:
-            from omnigenome import OmniModel, OmniPooling
-            assert True
-        except ImportError:
-            pytest.skip("omnigenome not available or missing dependencies")
-
-    def test_base_model_loading_pattern(self, mock_tokenizer):
-        """Test the base model loading pattern from classification.ipynb."""
-        try:
-            from transformers import AutoTokenizer, AutoModel
-        except ImportError:
-            pytest.skip("transformers not available")
-        
-        with patch('transformers.AutoTokenizer.from_pretrained') as mock_auto_tokenizer, \
-             patch('transformers.AutoModel.from_pretrained') as mock_auto_model:
-            
-            # Mock the returns
-            mock_auto_tokenizer.return_value = mock_tokenizer
-            mock_auto_model.return_value = MagicMock()
-
-            # This pattern is from examples/custom_finetuning/classification.ipynb
-            model_name = "yangheng/OmniGenome-52M"
-            base_model = AutoModel.from_pretrained(model_name, trust_remote_code=True)
-            base_tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
-
-            # Verify the calls were made correctly
-            mock_auto_model.assert_called_once_with(model_name, trust_remote_code=True)
-            mock_auto_tokenizer.assert_called_once_with(model_name, trust_remote_code=True)
-
-    def test_embedding_model_initialization_pattern(self):
-        """Test embedding model initialization pattern from RNA_Embedding_Tutorial.ipynb."""
-        if torch is None:
-            pytest.skip("torch not available")
-            
-        try:
-            from omnigenome import OmniGenomeModelForEmbedding
-        except ImportError:
-            pytest.skip("omnigenome not available")
-            
-        with patch('omnigenome.OmniGenomeModelForEmbedding') as mock_embedding_model:
-            mock_instance = MagicMock()
-            mock_instance.to.return_value = mock_instance
-            mock_embedding_model.return_value = mock_instance
-
-            model_name = "yangheng/OmniGenome-52M"
-            embedding_model = OmniGenomeModelForEmbedding(model_name, trust_remote_code=True).to(torch.device("cuda:0")).to(torch.float16)
-
-            # Verify initialization pattern
-            mock_embedding_model.assert_called_once_with(model_name, trust_remote_code=True)
-            assert mock_instance.to.call_count == 2  # Called twice for device and dtype
-
-    def test_model_parameter_patterns(self):
-        """Test that common model parameters are recognized."""
-        # These are patterns seen across examples
-        common_model_names = [
-            "yangheng/OmniGenome-52M",
-            "yangheng/OmniGenome-186M",
-            "anonymous8/OmniGenome-186M",
-            "anonymous8/OmniGenome-52M"
-        ]
-        
-        for model_name in common_model_names:
-            # Just verify the string patterns are valid
-            assert isinstance(model_name, str)
-            assert "/" in model_name
-            assert "OmniGenome" in model_name
-
-    def test_classification_model_initialization_pattern(self, mock_tokenizer):
-        """Test classification model init pattern from examples."""
-        try:
-            from omnigenome import OmniModelForSequenceClassification
-        except ImportError:
-            pytest.skip("omnigenome not available")
-            
-        with patch('omnigenome.OmniModelForSequenceClassification') as mock_model_class:
-            mock_model_class.return_value = MagicMock()
-
-            # Pattern from classification.ipynb
-            model_name = "test_model"
-            tokenizer = mock_tokenizer
-            
-            model = OmniModelForSequenceClassification(
-                config_or_model=model_name,
-                tokenizer=tokenizer,
-                num_labels=3,
-            )
-
-            mock_model_class.assert_called_once_with(
-                config_or_model=model_name,
-                tokenizer=tokenizer,
-                num_labels=3,
-            )
-
-    def test_rna_sequence_patterns(self):
-        """Test RNA sequence patterns used in examples."""
-        # Patterns from RNA_Embedding_Tutorial.ipynb
-        rna_sequences = [
-            "AUGGCUACG",
-            "CGGAUACGGC", 
-            "UGGCCAAGUC",
-            "AUGCUGCUAUGCUA"
-        ]
-        
-        for seq in rna_sequences:
-            # Basic validation of RNA sequence format
-            assert isinstance(seq, str)
-            assert len(seq) > 0
-            assert all(base in "AUCG" for base in seq)
-
-    def test_device_patterns(self):
-        """Test device usage patterns from examples."""
-        if torch is None:
-            pytest.skip("torch not available")
-            
-        # Pattern from examples: torch.device("cuda:0")
-        device = torch.device("cuda:0")
-        assert str(device) == "cuda:0"
-        
-        # Alternative pattern
-        if torch.cuda.is_available():
-            device = torch.device("cuda")
-            assert "cuda" in str(device) 

tests/test_rna_functions.py

@@ -1,255 +0,0 @@
-"""
-Test RNA-specific functionality based on examples.
-"""
-import pytest
-import tempfile
-import os
-from unittest.mock import patch, MagicMock
-
-
-class TestRNAFunctions:
-    """Test RNA functionality based on examples."""
-
-    def test_rna_sequence_validity_checker(self):
-        """Test ss_validity_loss function from Secondary_Structure_Prediction.py."""
-        # Recreate the function from the example
-        def ss_validity_loss(rna_strct: str) -> float:
-            left = right = 0
-            dots = rna_strct.count('.')
-            for c in rna_strct:
-                if c == '(':
-                    left += 1
-                elif c == ')':
-                    if left:
-                        left -= 1
-                    else:
-                        right += 1
-                elif c != '.':
-                    raise ValueError(f"Invalid char {c}")
-            return (left + right) / (len(rna_strct) - dots + 1e-8)
-
-        # Test valid structures
-        assert ss_validity_loss("(())") == 0.0
-        assert ss_validity_loss("((..))") == 0.0
-        assert ss_validity_loss("....") == 0.0
-        
-        # Test invalid structures
-        assert ss_validity_loss("(((") > 0.0  # Unmatched left
-        assert ss_validity_loss(")))") > 0.0  # Unmatched right
-        assert ss_validity_loss("())(") > 0.0  # Mixed unmatched
-
-        # Test error case
-        with pytest.raises(ValueError, match="Invalid char"):
-            ss_validity_loss("((X))")
-
-    def test_find_invalid_positions(self):
-        """Test find_invalid_positions function from Secondary_Structure_Prediction.py."""
-        # Recreate the function from the example
-        def find_invalid_positions(struct: str) -> list:
-            stack, invalid = [], []
-            for i, c in enumerate(struct):
-                if c == '(': 
-                    stack.append(i)
-                elif c == ')':
-                    if stack:
-                        stack.pop()
-                    else:
-                        invalid.append(i)
-            invalid.extend(stack)
-            return invalid
-
-        # Test valid structures
-        assert find_invalid_positions("(())") == []
-        assert find_invalid_positions("((..))") == []
-        assert find_invalid_positions("....") == []
-
-        # Test invalid structures
-        assert find_invalid_positions("(((") == [0, 1, 2]  # All unmatched left
-        assert find_invalid_positions(")))") == [0, 1, 2]  # All unmatched right
-        assert find_invalid_positions("())(") == [2, 3]   # One unmatched right, one left
-
-    def test_rna_structure_formats(self):
-        """Test RNA structure format validation."""
-        valid_structures = [
-            "(())",
-            "((()))",
-            ".((.))",
-            "....",
-            "",
-            "((..))",
-        ]
-        
-        invalid_structures = [
-            "((X))",  # Invalid character
-            "(()",    # Unmatched
-            "())",    # Unmatched
-            ")(",     # Wrong order
-        ]
-        
-        def is_valid_structure_format(struct: str) -> bool:
-            """Check if structure contains only valid characters."""
-            return all(c in "()." for c in struct)
-        
-        for struct in valid_structures:
-            assert is_valid_structure_format(struct), f"Should be valid: {struct}"
-            
-        for struct in invalid_structures:
-            if any(c not in "()." for c in struct):
-                assert not is_valid_structure_format(struct), f"Should be invalid: {struct}"
-
-    def test_sequence_replacement_patterns(self):
-        """Test U/T replacement patterns from examples."""
-        # Pattern from web_rna_design.py
-        def rna_to_dna_pattern(sequence):
-            return sequence.replace("U", "T")
-        
-        def dna_to_rna_pattern(sequence):
-            return sequence.replace("T", "U")
-        
-        # Test RNA to DNA
-        assert rna_to_dna_pattern("AUCG") == "ATCG"
-        assert rna_to_dna_pattern("UUUU") == "TTTT"
-        assert rna_to_dna_pattern("ACGU") == "ACGT"
-        
-        # Test DNA to RNA
-        assert dna_to_rna_pattern("ATCG") == "AUCG"
-        assert dna_to_rna_pattern("TTTT") == "UUUU"
-        assert dna_to_rna_pattern("ACGT") == "ACGU"
-
-    def test_random_base_generation_patterns(self):
-        """Test random base generation patterns from RNA design examples."""
-        import random
-        
-        def generate_random_rna_base():
-            """Pattern from easy_rna_design_emoo.py."""
-            return random.choice(["A", "U", "G", "C"])
-        
-        def generate_random_dna_base():
-            """Pattern from easy_rna_design_emoo.py."""
-            return random.choice(["A", "T", "G", "C"])
-        
-        # Test multiple generations to ensure valid bases
-        for _ in range(10):
-            rna_base = generate_random_rna_base()
-            assert rna_base in ["A", "U", "G", "C"]
-            
-            dna_base = generate_random_dna_base()
-            assert dna_base in ["A", "T", "G", "C"]
-
-    def test_sequence_mutation_pattern(self):
-        """Test sequence mutation pattern from mlm_mutate function."""
-        try:
-            import numpy as np
-        except ImportError:
-            pytest.skip("numpy not available")
-        
-        def mutate_sequence_pattern(sequence, mutation_rate=0.1):
-            """Simplified version of mutation pattern from examples."""
-            sequence_array = np.array(list(sequence), dtype=np.str_)
-            probability_matrix = np.full(sequence_array.shape, mutation_rate)
-            masked_indices = np.random.rand(*sequence_array.shape) < probability_matrix
-            sequence_array[masked_indices] = "$"  # Mask token
-            return "".join(sequence_array.tolist())
-        
-        # Test mutation with 0% rate
-        original = "AUCG"
-        mutated_zero = mutate_sequence_pattern(original, 0.0)
-        assert mutated_zero == original
-        
-        # Test mutation with 100% rate
-        mutated_full = mutate_sequence_pattern(original, 1.0)
-        assert mutated_full == "$$$$"
-        
-        # Test with moderate rate - should have some masks
-        np.random.seed(42)  # For reproducible test
-        mutated_partial = mutate_sequence_pattern("AUCGAUCGAUCG", 0.5)
-        assert "$" in mutated_partial
-
-    @patch('tempfile.mkdtemp')
-    def test_temp_directory_pattern(self, mock_mkdtemp):
-        """Test temp directory usage pattern from Secondary_Structure_Prediction.py."""
-        from pathlib import Path
-        
-        mock_mkdtemp.return_value = "/tmp/test_dir"
-        
-        # Pattern from Secondary_Structure_Prediction.py
-        TEMP_DIR = Path(tempfile.mkdtemp())
-        
-        mock_mkdtemp.assert_called_once()
-        assert isinstance(TEMP_DIR, Path)
-
-    def test_rna_embedding_sequence_validation(self):
-        """Test RNA sequence validation for embedding examples."""
-        # RNA sequences from RNA_Embedding_Tutorial.ipynb
-        rna_sequences = [
-            "AUGGCUACG",
-            "CGGAUACGGC",
-            "UGGCCAAGUC",
-            "AUGCUGCUAUGCUA"
-        ]
-        
-        def validate_rna_sequence(seq):
-            """Validate RNA sequence format."""
-            return all(base in "AUCG" for base in seq) and len(seq) > 0
-        
-        for seq in rna_sequences:
-            assert validate_rna_sequence(seq), f"Invalid RNA sequence: {seq}"
-
-    def test_structure_prediction_mock_pattern(self):
-        """Test structure prediction pattern without ViennaRNA dependency."""
-        def mock_predict_structure_single(sequence):
-            """Mock version of predict_structure_single from examples."""
-            # Return a mock structure and energy
-            return "." * len(sequence), -10.0
-        
-        # Test the pattern
-        seq = "AUCG"
-        struct, energy = mock_predict_structure_single(seq)
-        
-        assert len(struct) == len(seq)
-        assert isinstance(energy, float)
-        assert struct == "...."
-
-    def test_base64_encoding_pattern(self):
-        """Test base64 encoding pattern from SVG generation."""
-        import base64
-        
-        def create_mock_svg_datauri(content="test"):
-            """Mock version of SVG data URI creation."""
-            svg_content = f'<svg>{content}</svg>'
-            b64 = base64.b64encode(svg_content.encode()).decode('utf-8')
-            return f"data:image/svg+xml;base64,{b64}"
-        
-        uri = create_mock_svg_datauri("test")
-        assert uri.startswith("data:image/svg+xml;base64,")
-        
-        # Decode and verify
-        _, b64_part = uri.split(",", 1)
-        decoded = base64.b64decode(b64_part).decode('utf-8')
-        assert decoded == "<svg>test</svg>"
-
-    def test_longest_bp_span_function(self):
-        """Test longest_bp_span function from easy_rna_design_emoo.py."""
-        def longest_bp_span(structure):
-            """Function from easy_rna_design_emoo.py."""
-            stack = []
-            max_span = 0
-
-            for i, char in enumerate(structure):
-                if char == '(':
-                    stack.append(i)
-                elif char == ')':
-                    if stack:
-                        left_index = stack.pop()
-                        current_span = i - left_index
-                        max_span = max(max_span, current_span)
-
-            return max_span
-
-        # Test cases
-        assert longest_bp_span("(())") == 3  # Outer pair spans 3 positions
-        assert longest_bp_span("((()))") == 5  # Outer pair spans 5 positions
-        assert longest_bp_span("()()") == 1   # Each pair spans 1 position
-        assert longest_bp_span("....") == 0   # No pairs
-        assert longest_bp_span("") == 0       # Empty structure
-        assert longest_bp_span("((.))") == 4  # Outer pair spans 4 positions