debase 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

debase/_version.py

@@ -1,3 +1,3 @@
 """Version information."""
 
-__version__ = "0.6.0"
+__version__ = "0.6.2"

debase/campaign_utils.py

@@ -0,0 +1,146 @@
+"""Utilities for handling campaign information across extractors.
+
+This module provides functions to load and use campaign information
+to improve extraction accuracy by providing context about model substrates,
+products, and data locations.
+"""
+
+import json
+import logging
+from pathlib import Path
+from typing import List, Dict, Optional, Any
+
+logger = logging.getLogger(__name__)
+
+
+def load_campaigns_from_file(campaign_file: Path) -> List[Dict[str, Any]]:
+    """Load campaign information from a JSON file.
+    
+    Args:
+        campaign_file: Path to campaigns.json file
+        
+    Returns:
+        List of campaign dictionaries
+    """
+    if not campaign_file.exists():
+        logger.warning(f"Campaign file not found: {campaign_file}")
+        return []
+        
+    try:
+        with open(campaign_file, 'r') as f:
+            campaigns = json.load(f)
+        logger.info(f"Loaded {len(campaigns)} campaigns from {campaign_file}")
+        return campaigns
+    except Exception as e:
+        logger.error(f"Failed to load campaigns from {campaign_file}: {e}")
+        return []
+
+
+def find_campaign_by_id(campaigns: List[Dict[str, Any]], campaign_id: str) -> Optional[Dict[str, Any]]:
+    """Find a specific campaign by ID.
+    
+    Args:
+        campaigns: List of campaign dictionaries
+        campaign_id: Campaign ID to search for
+        
+    Returns:
+        Campaign dictionary if found, None otherwise
+    """
+    for campaign in campaigns:
+        if campaign.get('campaign_id') == campaign_id:
+            return campaign
+    return None
+
+
+def get_campaign_context(campaign: Dict[str, Any]) -> str:
+    """Generate context string for prompts from campaign information.
+    
+    Args:
+        campaign: Campaign dictionary
+        
+    Returns:
+        Formatted context string for inclusion in prompts
+    """
+    context_parts = []
+    
+    # Basic campaign info
+    context_parts.append(f"Campaign: {campaign.get('campaign_name', 'Unknown')}")
+    context_parts.append(f"Description: {campaign.get('description', '')}")
+    
+    # Model reaction info
+    if campaign.get('model_substrate'):
+        context_parts.append(f"Model Substrate: {campaign['model_substrate']} (ID: {campaign.get('substrate_id', 'unknown')})")
+    if campaign.get('model_product'):
+        context_parts.append(f"Model Product: {campaign['model_product']} (ID: {campaign.get('product_id', 'unknown')})")
+    
+    # Data locations
+    if campaign.get('data_locations'):
+        locations = ', '.join(campaign['data_locations'])
+        context_parts.append(f"Key Data Locations: {locations}")
+    
+    # Lineage hint if available
+    if campaign.get('lineage_hint'):
+        context_parts.append(f"Evolution Pathway: {campaign['lineage_hint']}")
+    
+    # Additional notes
+    if campaign.get('notes'):
+        context_parts.append(f"Notes: {campaign['notes']}")
+    
+    return '\n'.join(context_parts)
+
+
+def get_location_hints_for_campaign(campaign: Dict[str, Any]) -> List[str]:
+    """Extract specific location hints from campaign data.
+    
+    Args:
+        campaign: Campaign dictionary
+        
+    Returns:
+        List of location strings (e.g., ["Figure 2a", "Table S4"])
+    """
+    return campaign.get('data_locations', [])
+
+
+def enhance_prompt_with_campaign(prompt: str, campaign: Optional[Dict[str, Any]], 
+                                 section_name: str = "CAMPAIGN CONTEXT") -> str:
+    """Enhance a prompt with campaign context information.
+    
+    Args:
+        prompt: Original prompt
+        campaign: Campaign dictionary (optional)
+        section_name: Section header for the campaign context
+        
+    Returns:
+        Enhanced prompt with campaign context
+    """
+    if not campaign:
+        return prompt
+    
+    context = get_campaign_context(campaign)
+    locations = get_location_hints_for_campaign(campaign)
+    
+    campaign_section = f"\n\n{section_name}:\n{'-' * 50}\n{context}"
+    
+    if locations:
+        campaign_section += f"\n\nIMPORTANT: Focus particularly on these locations: {', '.join(locations)}"
+    
+    campaign_section += f"\n{'-' * 50}\n"
+    
+    # Insert campaign context early in the prompt
+    # Look for a good insertion point after initial instructions
+    lines = prompt.split('\n')
+    insert_idx = 0
+    
+    # Find a good place to insert (after first paragraph or instruction block)
+    for i, line in enumerate(lines):
+        if i > 5 and (not line.strip() or line.startswith('Given') or line.startswith('You')):
+            insert_idx = i
+            break
+    
+    if insert_idx == 0:
+        # Fallback: just prepend
+        return campaign_section + prompt
+    else:
+        # Insert at found position
+        lines.insert(insert_idx, campaign_section)
+        return '\n'.join(lines)

debase/caption_pattern.py

@@ -0,0 +1,44 @@
+"""Universal caption pattern for all DEBase extractors.
+
+This module provides a consistent caption pattern that handles various
+formats found in scientific papers, including:
+- Standard formats: Figure 1, Fig. 1, Table 1
+- Supplementary formats: Supplementary Figure 1, Supp. Table 1
+- Extended data: Extended Data Figure 1, ED Fig. 1
+- Other types: Scheme 1, Chart 1
+- Page headers: S14 Table 5
+- Various punctuation: Figure 1. Figure 1: Figure 1 |
+- Inline captions: ...text Table 1. Caption text...
+"""
+
+import re
+
+# Universal caption pattern that handles all common formats
+# Now includes both start-of-line and inline caption patterns
+UNIVERSAL_CAPTION_PATTERN = re.compile(
+    r"""
+    (?:                                    # Non-capturing group for position
+        ^[^\n]{0,20}?                      # Start of line with up to 20 chars before
+    |                                      # OR
+        (?<=[a-zA-Z0-9\s])                # Look-behind for alphanumeric or space (for inline)
+    )
+    (                                      # Start capture group
+        (?:Extended\s+Data\s+)?           # Optional "Extended Data" prefix
+        (?:ED\s+)?                        # Optional "ED" prefix
+        (?:Supplementary|Supp\.?|Suppl\.?)?\s*  # Optional supplementary prefixes
+        (?:Table|Fig(?:ure)?|Scheme|Chart)      # Main caption types
+    )                                      # End capture group
+    (?:                                    # Non-capturing group for what follows
+        \s*                               # Optional whitespace
+        (?:S?\d+[A-Za-z]?|[IVX]+)        # Number (with optional S prefix or roman)
+        (?:[.:|]|\s+\|)?                  # Optional punctuation (. : or |)
+    |                                      # OR
+        \.                                # Just a period (for "Fig." without number)
+    )
+    """,
+    re.I | re.X | re.M
+)
+
+def get_universal_caption_pattern():
+    """Get the universal caption pattern for use in extractors."""
+    return UNIVERSAL_CAPTION_PATTERN

debase/cleanup_sequence.py

@@ -1016,13 +1016,38 @@ Return ONLY valid JSON with information about the SINGLE BEST seed enzyme.
                         
                         if source_enzyme_id:
                             # Find the source enzyme's sequence in the dataframe
+                            # Prefer sequences from OTHER campaigns (not the current empty campaign)
                             source_rows = df[df['enzyme_id'] == source_enzyme_id]
                             if source_rows.empty:
                                 log.warning(f"Source enzyme {source_enzyme_id} not found in dataframe")
                             else:
-                                source_sequence = str(source_rows.iloc[0]['protein_sequence']).strip()
-                                if not source_sequence or source_sequence.lower() in ["nan", "none", ""]:
-                                    log.warning(f"Source enzyme {source_enzyme_id} has no sequence")
+                                # Look for a row with a sequence, preferring other campaigns
+                                source_sequence = None
+                                source_row_idx = None
+                                
+                                # First, try to find a row with sequence from a different campaign
+                                for idx, row in source_rows.iterrows():
+                                    seq = str(row['protein_sequence']).strip()
+                                    if seq and seq.lower() not in ["nan", "none", ""]:
+                                        # Check if this is from a different campaign
+                                        if row['campaign_id'] != campaign_id:
+                                            source_sequence = seq
+                                            source_row_idx = idx
+                                            log.info(f"Found source sequence for {source_enzyme_id} from campaign {row['campaign_id']}")
+                                            break
+                                
+                                # If not found in other campaigns, try any row with sequence
+                                if not source_sequence:
+                                    for idx, row in source_rows.iterrows():
+                                        seq = str(row['protein_sequence']).strip()
+                                        if seq and seq.lower() not in ["nan", "none", ""]:
+                                            source_sequence = seq
+                                            source_row_idx = idx
+                                            log.info(f"Found source sequence for {source_enzyme_id} from same campaign {row['campaign_id']}")
+                                            break
+                                
+                                if not source_sequence:
+                                    log.warning(f"Source enzyme {source_enzyme_id} has no sequence in any campaign")
                                 else:
                                     # Find the target enzyme in our empty list
                                     seed_found = False
@@ -1031,7 +1056,8 @@ Return ONLY valid JSON with information about the SINGLE BEST seed enzyme.
                                             if relationship_type == "EXACT_MATCH":
                                                 # Exact match - copy sequence directly
                                                 df.at[entry['idx'], 'protein_sequence'] = source_sequence
-                                                df.at[entry['idx'], 'flag'] = df.at[entry['idx'], 'flag'] + " gemini_cross_campaign_seed_exact"
+                                                current_flag = str(df.at[entry['idx'], 'flag']) if pd.notna(df.at[entry['idx'], 'flag']) else ""
+                                                df.at[entry['idx'], 'flag'] = current_flag + " gemini_cross_campaign_seed_exact"
                                                 log.info(f"Set seed sequence for {target_enzyme_id} from exact match {source_enzyme_id} (length: {len(source_sequence)})")
                                                 seed_found = True
                                                 
@@ -1045,7 +1071,8 @@ Return ONLY valid JSON with information about the SINGLE BEST seed enzyme.
                                                     
                                                     if success:
                                                         df.at[entry['idx'], 'protein_sequence'] = mutated_sequence
-                                                        df.at[entry['idx'], 'flag'] = df.at[entry['idx'], 'flag'] + " gemini_cross_campaign_seed_parent"
+                                                        current_flag = str(df.at[entry['idx'], 'flag']) if pd.notna(df.at[entry['idx'], 'flag']) else ""
+                                                        df.at[entry['idx'], 'flag'] = current_flag + " gemini_cross_campaign_seed_parent"
                                                         log.info(f"Set seed sequence for {target_enzyme_id} by applying mutations {target_mutations} to parent {source_enzyme_id} (length: {len(mutated_sequence)})")
                                                         seed_found = True
                                                     else:
@@ -1053,7 +1080,8 @@ Return ONLY valid JSON with information about the SINGLE BEST seed enzyme.
                                                 else:
                                                     # No mutations - use parent sequence directly
                                                     df.at[entry['idx'], 'protein_sequence'] = source_sequence
-                                                    df.at[entry['idx'], 'flag'] = df.at[entry['idx'], 'flag'] + " gemini_cross_campaign_seed_parent_no_mutations"
+                                                    current_flag = str(df.at[entry['idx'], 'flag']) if pd.notna(df.at[entry['idx'], 'flag']) else ""
+                                                    df.at[entry['idx'], 'flag'] = current_flag + " gemini_cross_campaign_seed_parent_no_mutations"
                                                     log.info(f"Set seed sequence for {target_enzyme_id} from parent {source_enzyme_id} (no mutations, length: {len(source_sequence)})")
                                                     seed_found = True
                                             break