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

tests/test_dataset_patterns.py

@@ -1,291 +0,0 @@
-"""
-Test dataset loading and processing patterns based on examples.
-"""
-import pytest
-import json
-import tempfile
-import os
-from unittest.mock import patch, MagicMock, mock_open
-
-
-class TestDatasetPatterns:
-    """Test dataset patterns from examples."""
-
-    def test_dataset_imports(self):
-        """Test dataset class imports as shown in examples."""
-        try:
-            from omnigenome import (
-                OmniGenomeDatasetForSequenceClassification,
-                OmniGenomeDatasetForSequenceRegression,
-                OmniGenomeDatasetForTokenClassification,
-                OmniGenomeDatasetForTokenRegression,
-            )
-            assert True
-        except ImportError:
-            pytest.skip("omnigenome not available or missing dependencies")
-
-    def test_json_dataset_format(self):
-        """Test JSON dataset format used in examples."""
-        # Sample data format from toy_datasets
-        sample_data = [
-            {"seq": "AUCG", "label": "(...)"},
-            {"seq": "AUGC", "label": "(..)"},
-            {"seq": "CGAU", "label": "().."},
-        ]
-        
-        # Verify format
-        for item in sample_data:
-            assert "seq" in item
-            assert "label" in item
-            assert isinstance(item["seq"], str)
-            assert len(item["seq"]) > 0
-
-    @patch("builtins.open", new_callable=mock_open)
-    @patch("json.loads")
-    def test_dataset_loading_pattern(self, mock_json_loads, mock_file):
-        """Test dataset loading pattern from examples."""
-        # Mock data similar to examples
-        mock_data = [
-            {"seq": "AUCG", "label": "(..)"},
-            {"seq": "AUGC", "label": "()"},
-        ]
-        
-        mock_json_loads.return_value = mock_data[0]
-        mock_file.return_value.__iter__ = lambda self: iter([
-            '{"seq": "AUCG", "label": "(..)"}\n',
-            '{"seq": "AUGC", "label": "()"}\n'
-        ])
-        
-        # Pattern from examples for loading test data
-        def load_test_data(file_path):
-            """Pattern from Secondary_Structure_Prediction.py."""
-            data = []
-            with open(file_path) as f:
-                for line in f:
-                    data.append(json.loads(line))
-            return data
-        
-        # Test the pattern
-        result = load_test_data("test_file.json")
-        assert len(result) == 2
-
-    def test_config_file_structure(self):
-        """Test config.py structure from toy_datasets."""
-        # Common config patterns from examples
-        config_patterns = {
-            "max_length": [128, 256, 512, 1024],
-            "num_labels": [2, 3, 4, 5],
-            "task_type": ["classification", "regression", "token_classification"],
-        }
-        
-        for key, valid_values in config_patterns.items():
-            assert isinstance(key, str)
-            assert isinstance(valid_values, list)
-            assert len(valid_values) > 0
-
-    def test_sample_data_extraction_pattern(self):
-        """Test sample data extraction pattern from examples."""
-        import random
-        try:
-            import numpy as np
-        except ImportError:
-            pytest.skip("numpy not available")
-        
-        def sample_rna_sequence_pattern():
-            """Pattern from Secondary_Structure_Prediction.py."""
-            try:
-                # Mock data similar to toy_datasets/Archive2/test.json
-                mock_examples = [
-                    {"seq": "AUCG", "label": "(..)"},
-                    {"seq": "AUGC", "label": "().."},
-                    {"seq": "CGAU", "label": "(())"},
-                ]
-                ex = mock_examples[np.random.randint(len(mock_examples))]
-                return ex['seq'], ex.get('label', '')
-            except Exception as e:
-                return f"Error loading sample: {e}", ""
-        
-        # Test the pattern
-        seq, label = sample_rna_sequence_pattern()
-        assert isinstance(seq, str)
-        assert isinstance(label, str)
-
-    def test_data_validation_patterns(self):
-        """Test data validation patterns from examples."""
-        def validate_sequence_label_pair(seq, label):
-            """Validate sequence-label pair format."""
-            if not isinstance(seq, str) or not isinstance(label, str):
-                return False
-            if len(seq) == 0:
-                return False
-            # RNA sequence validation
-            if not all(base in "AUCG" for base in seq):
-                return False
-            # Structure validation (if applicable)
-            if label and not all(c in "()." for c in label):
-                return False
-            return True
-        
-        # Test valid pairs
-        valid_pairs = [
-            ("AUCG", "(..)"),
-            ("AUG", "..."),
-            ("AU", "()"),
-            ("A", "."),
-        ]
-        
-        for seq, label in valid_pairs:
-            assert validate_sequence_label_pair(seq, label)
-        
-        # Test invalid pairs
-        invalid_pairs = [
-            ("", ""),           # Empty sequence
-            ("AUXG", "(..)"),   # Invalid base X
-            ("AUCG", "(.)X"),   # Invalid structure char
-            (123, "(..)"),      # Non-string sequence
-            ("AUCG", 123),      # Non-string label
-        ]
-        
-        for seq, label in invalid_pairs:
-            assert not validate_sequence_label_pair(seq, label)
-
-    def test_train_test_split_patterns(self):
-        """Test train/test split patterns from examples."""
-        # Mock dataset similar to toy_datasets structure
-        mock_data = [
-            {"seq": "AUCG", "label": "(..)"},
-            {"seq": "AUGC", "label": "().."},
-            {"seq": "CGAU", "label": "(())"},
-            {"seq": "GAUC", "label": "...."},
-        ]
-        
-        def split_data_pattern(data, train_ratio=0.8):
-            """Simple train/test split pattern."""
-            import random
-            random.shuffle(data)
-            split_idx = int(len(data) * train_ratio)
-            return data[:split_idx], data[split_idx:]
-        
-        train_data, test_data = split_data_pattern(mock_data.copy())
-        
-        # Verify split
-        assert len(train_data) + len(test_data) == len(mock_data)
-        assert len(train_data) >= len(test_data)  # With 80/20 split
-
-    def test_dataset_file_patterns(self):
-        """Test dataset file naming patterns from examples."""
-        expected_files = ["train.json", "test.json", "valid.json", "config.py"]
-        
-        for filename in expected_files:
-            # Verify naming patterns
-            if filename.endswith(".json"):
-                assert filename in ["train.json", "test.json", "valid.json"]
-            elif filename.endswith(".py"):
-                assert filename == "config.py"
-
-    def test_dataset_initialization_pattern(self):
-        """Test dataset initialization pattern from examples."""
-        try:
-            from omnigenome import OmniGenomeDatasetForSequenceClassification
-        except ImportError:
-            pytest.skip("omnigenome not available")
-            
-        with patch("omnigenome.OmniGenomeDatasetForSequenceClassification") as mock_dataset:
-            mock_dataset.return_value = MagicMock()
-            
-            # Create a single mock tokenizer instance to use in both call and assertion
-            mock_tokenizer_instance = MagicMock()
-            
-            # Pattern from examples
-            dataset = OmniGenomeDatasetForSequenceClassification(
-                train_file="path/to/train.json",
-                test_file="path/to/test.json",
-                tokenizer=mock_tokenizer_instance,
-                max_length=512
-            )
-            
-            # Verify the call was made with the expected arguments
-            mock_dataset.assert_called_once()
-            call_args = mock_dataset.call_args
-            assert call_args[1]["train_file"] == "path/to/train.json"
-            assert call_args[1]["test_file"] == "path/to/test.json"
-            assert call_args[1]["max_length"] == 512
-
-    def test_benchmark_dataset_structure(self):
-        """Test benchmark dataset structure from examples."""
-        # RGB benchmark structure from examples
-        rgb_tasks = [
-            "RNA-mRNA",
-            "RNA-SNMD", 
-            "RNA-SNMR",
-            "RNA-SSP-Archive2",
-            "RNA-SSP-bpRNA",
-            "RNA-SSP-rnastralign"
-        ]
-        
-        for task in rgb_tasks:
-            assert isinstance(task, str)
-            assert "RNA" in task
-            assert len(task) > 3
-
-    def test_eterna_dataset_pattern(self):
-        """Test Eterna dataset pattern from RNA design examples."""
-        # Pattern from eterna100_vienna2.txt usage
-        def load_eterna_pattern():
-            """Mock Eterna dataset loading pattern."""
-            # This would normally read from eterna100_vienna2.txt
-            mock_eterna_data = [
-                "(((...)))",
-                "(((())))",
-                "........",
-                "((..))"
-            ]
-            return mock_eterna_data
-        
-        eterna_structures = load_eterna_pattern()
-        
-        for structure in eterna_structures:
-            assert isinstance(structure, str)
-            assert all(c in "()." for c in structure)
-
-    def test_solved_sequences_format(self):
-        """Test solved sequences format from RNA design examples."""
-        # Format from solved_sequences.json in RNA design
-        solved_format = {
-            "puzzle_1": {
-                "sequence": "AUCG",
-                "structure": "(..)",
-                "energy": -5.2
-            },
-            "puzzle_2": {
-                "sequence": "AUGC", 
-                "structure": "().",
-                "energy": -3.1
-            }
-        }
-        
-        for puzzle_id, data in solved_format.items():
-            assert isinstance(puzzle_id, str)
-            assert "sequence" in data
-            assert "structure" in data
-            assert "energy" in data
-            assert isinstance(data["energy"], (int, float))
-
-    def test_data_loading_error_handling(self):
-        """Test error handling patterns from examples."""
-        def safe_load_pattern(file_path):
-            """Safe loading pattern from examples."""
-            try:
-                # Mock successful load
-                return [{"seq": "AUCG", "label": "(..)"}]
-            except FileNotFoundError:
-                return []
-            except json.JSONDecodeError:
-                return []
-            except Exception as e:
-                print(f"Unexpected error: {e}")
-                return []
-        
-        # Test error handling
-        result = safe_load_pattern("nonexistent.json")
-        assert isinstance(result, list) 

tests/test_examples_syntax.py

@@ -1,83 +0,0 @@
-import os
-import glob
-import ast
-import py_compile
-
-import nbformat
-import pytest
-
-# Root directory of the repository (two levels up from this test file)
-ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir))
-EXAMPLES_DIR = os.path.join(ROOT_DIR, "examples")
-
-# -----------------------------------------------------------------------------
-# Helper collectors
-# -----------------------------------------------------------------------------
-
-def _collect_example_py_files():
-    """Return list of all *.py files under examples/ recursively."""
-    pattern = os.path.join(EXAMPLES_DIR, "**", "*.py")
-    return [path for path in glob.glob(pattern, recursive=True) if os.path.isfile(path)]
-
-
-def _collect_example_notebooks():
-    """Return list of all *.ipynb files under examples/ recursively."""
-    pattern = os.path.join(EXAMPLES_DIR, "**", "*.ipynb")
-    return [path for path in glob.glob(pattern, recursive=True) if os.path.isfile(path)]
-
-
-# -----------------------------------------------------------------------------
-# Tests for Python scripts
-# -----------------------------------------------------------------------------
-
-@pytest.mark.parametrize("py_path", _collect_example_py_files())
-def test_example_python_files_compile(py_path):
-    """Ensure each example Python script has valid syntax.
-
-    This uses ``py_compile`` so the file is parsed by CPython without execution
-    of the module-level code, avoiding heavy runtime dependencies.
-    """
-    # doraise=True raises a ``py_compile.PyCompileError`` on failure which
-    # pytest will treat as a test failure.
-    py_compile.compile(py_path, doraise=True)
-
-
-# -----------------------------------------------------------------------------
-# Tests for Jupyter notebooks
-# -----------------------------------------------------------------------------
-
-
-def _clean_code(source: str) -> str:
-    """Remove Jupyter magics / shell escapes so source can be parsed by ``ast``.
-
-    Lines starting with ``%`` or ``!`` are stripped because they are not valid
-    Python syntax outside a notebook environment.
-    """
-    cleaned_lines = []
-    for line in source.splitlines():
-        stripped = line.lstrip()
-        if stripped.startswith("%") or stripped.startswith("!"):
-            # Skip IPython magic or shell command
-            continue
-        cleaned_lines.append(line)
-    return "\n".join(cleaned_lines)
-
-
-@pytest.mark.parametrize("nb_path", _collect_example_notebooks())
-def test_example_notebook_cells_parse(nb_path):
-    """Validate that each code cell in the example notebooks can be parsed.
-
-    Instead of executing potentially heavy code, we parse the cleaned source of
-    each code cell with the ``ast`` module to ensure syntactic correctness.
-    """
-    nb = nbformat.read(nb_path, as_version=4)
-    for cell in nb.cells:
-        if cell.cell_type != "code":
-            continue
-        cleaned = _clean_code(cell.source)
-        if cleaned.strip() == "":
-            # Skip empty cells after cleaning
-            continue
-        # ``ast.parse`` raises ``SyntaxError`` on invalid Python code which will
-        # fail the test if encountered.
-        ast.parse(cleaned, filename=nb_path) 

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)