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

debase/substrate_scope_extractor.py

@@ -28,6 +28,13 @@ import re
 import json
 import time
 import logging
+
+# Import universal caption pattern
+try:
+    from .caption_pattern import get_universal_caption_pattern
+except ImportError:
+    # Fallback if running as standalone script
+    from caption_pattern import get_universal_caption_pattern
 import subprocess
 from pathlib import Path
 from dataclasses import dataclass, field
@@ -183,13 +190,8 @@ except ImportError as exc:  # pragma: no cover
 
 from base64 import b64encode
 
-# Improved caption prefix regex - captures most journal variants
-# Simplified pattern: match any line starting with Table, Figure, Scheme, Chart, etc.
-# This catches all variations including "Table S 2", "Figure.", etc.
-_CAPTION_PREFIX_RE = re.compile(
-    r"^(Table|Figure|Fig|Scheme|Chart|Extended\s+Data\s+Fig|ED\s+Fig|Supplementary\s+(?:Table|Figure)).*",
-    re.I | re.M
-)
+# Use universal caption pattern
+_CAPTION_PREFIX_RE = get_universal_caption_pattern()
 
 def _open_doc(pdf_path: str | Path | bytes):
     if isinstance(pdf_path, (str, Path)):
@@ -294,12 +296,14 @@ def limited_caption_concat(*pdf_paths: str | Path, max_chars: int = MAX_CHARS) -
     
     return "\n".join(chunks)
 
-def extract_figure_image(pdf_paths: List[Path], figure_ref: str) -> Optional[str]:
+def extract_figure_image(pdf_paths: List[Path], figure_ref: str, caption_hint: Optional[str] = None, document_hint: Optional[str] = None) -> Optional[str]:
     """Extract figure as a page region when embedded images aren't available.
     
     Args:
         pdf_paths: List of PDF paths to search
         figure_ref: Figure reference to search for (e.g., "Figure 3" or "Figure 3(a)")
+        caption_hint: Optional caption text to help identify the exact figure
+        document_hint: Optional hint about which document to search ("manuscript" or "supplementary")
         
     Returns:
         Base64-encoded PNG string or None if not found
@@ -316,8 +320,20 @@ def extract_figure_image(pdf_paths: List[Path], figure_ref: str) -> Optional[str
         log.info("Extracting entire figure '%s' from reference '%s'", base_figure_ref, figure_ref)
     else:
         base_figure_ref = figure_ref
+    
+    # Determine search order based on document hint
+    search_paths = list(pdf_paths)  # Create a copy
+    if document_hint and len(pdf_paths) > 1:
+        if document_hint.lower() == "manuscript":
+            # Prioritize manuscript (first PDF)
+            search_paths = [pdf_paths[0]] + pdf_paths[1:]
+            log.info("Prioritizing manuscript document for '%s' (hint: %s)", figure_ref, document_hint)
+        elif document_hint.lower() == "supplementary":
+            # Prioritize SI (second PDF if available)
+            search_paths = [pdf_paths[1], pdf_paths[0]] if len(pdf_paths) > 1 else pdf_paths
+            log.info("Prioritizing supplementary document for '%s' (hint: %s)", figure_ref, document_hint)
         
-    for pdf_path in pdf_paths:
+    for pdf_path in search_paths:
         doc = _open_doc(pdf_path)
         try:
             for page_num in range(doc.page_count):
@@ -331,26 +347,38 @@ def extract_figure_image(pdf_paths: List[Path], figure_ref: str) -> Optional[str
                 # Extract figure number (e.g., "Figure 3" -> "3", "Figure S3" -> "S3")
                 figure_num = base_figure_ref.replace('Figure ', '').replace('figure ', '')
                 
-                # Look for actual figure captions using regex patterns
-                caption_patterns = [
-                    rf"^Figure\s+{re.escape(figure_num)}\.",  # "Figure 3." at start of line
-                    rf"^Figure\s+{re.escape(figure_num)}:",   # "Figure 3:" at start of line
-                    rf"^Figure\s+{re.escape(figure_num)}\s+[A-Z]",  # "Figure 3 Substrate scope"
-                    rf"Figure\s+{re.escape(figure_num)}\s*\.",  # "Figure 3." anywhere
-                    rf"Figure\s+{re.escape(figure_num)}\s*:",  # "Figure 3:" anywhere
-                ]
-                
-                for pattern in caption_patterns:
-                    matches = re.search(pattern, page_text, re.MULTILINE | re.IGNORECASE)
-                    if matches:
-                        # Found actual figure caption, get its position
-                        caption_text = matches.group(0)
-                        caption_instances = page.search_for(caption_text, quads=False)
+                # First try to find using caption hint if provided
+                if caption_hint and len(caption_hint) > 10:
+                    # Try to find the exact caption text
+                    caption_snippet = caption_hint[:100]  # Use first 100 chars
+                    if caption_snippet in page_text:
+                        caption_instances = page.search_for(caption_snippet, quads=False)
                         if caption_instances:
                             caption_rect = caption_instances[0]
                             found = True
-                            log.info("Found actual figure caption '%s' on page %d", caption_text, page_num + 1)
-                            break
+                            log.info("Found figure using caption hint on page %d", page_num + 1)
+                
+                # If not found with hint, look for actual figure captions using regex patterns
+                if not found:
+                    caption_patterns = [
+                        rf"^Figure\s+{re.escape(figure_num)}\.",  # "Figure 3." at start of line
+                        rf"^Figure\s+{re.escape(figure_num)}:",   # "Figure 3:" at start of line
+                        rf"^Figure\s+{re.escape(figure_num)}\s+[A-Z]",  # "Figure 3 Substrate scope"
+                        rf"Figure\s+{re.escape(figure_num)}\s*\.",  # "Figure 3." anywhere
+                        rf"Figure\s+{re.escape(figure_num)}\s*:",  # "Figure 3:" anywhere
+                    ]
+                    
+                    for pattern in caption_patterns:
+                        matches = re.search(pattern, page_text, re.MULTILINE | re.IGNORECASE)
+                        if matches:
+                            # Found actual figure caption, get its position
+                            caption_text = matches.group(0)
+                            caption_instances = page.search_for(caption_text, quads=False)
+                            if caption_instances:
+                                caption_rect = caption_instances[0]
+                                found = True
+                                log.info("Found actual figure caption '%s' on page %d", caption_text, page_num + 1)
+                                break
                 
                 if not found:
                     continue
@@ -485,61 +513,134 @@ def extract_scheme_image(pdf_paths: List[Path], scheme_ref: str) -> Optional[str
     return None
 
 
-def _extract_text_around_reference(pdf_paths: List[Path], ref: str, context_chars: int = 2000) -> str:
-    """Extract text around a specific reference (e.g., 'Figure 3')."""
-    import re
-    extracted_sections = []
-    
-    # Try to extract base figure/table reference
-    base_ref_match = re.match(r'((?:Figure|Fig|Table)\s*\d+)', ref, re.IGNORECASE)
-    base_ref = base_ref_match.group(1) if base_ref_match else ref
+def _build_caption_index(pdf_paths: List[Path]) -> Dict[str, Dict[str, Any]]:
+    """Build an index of all captions for quick lookup."""
+    cap_pattern = get_universal_caption_pattern()
+    caption_index = {}
     
-    for pdf_path in pdf_paths:
+    for pdf_idx, pdf_path in enumerate(pdf_paths):
         doc = _open_doc(pdf_path)
+        source = "manuscript" if pdf_idx == 0 else "supplementary"
+        
         try:
             for page_num in range(doc.page_count):
                 page = doc.load_page(page_num)
                 page_text = page.get_text()
                 
-                # Try different variations of the reference
-                ref_variations = [
-                    ref,  # Original (e.g., "Figure 3(a)")
-                    base_ref,  # Base reference (e.g., "Figure 3")
-                    ref.replace("(", " ").replace(")", ""),  # "Figure 3 a"
-                    ref.replace("(", "").replace(")", ""),    # "Figure 3a"
-                    ref.replace("Figure", "Fig"),  # "Fig 3(a)"
-                    base_ref.replace("Figure", "Fig"),  # "Fig 3"
-                ]
-                
-                # Find the reference in the page
-                found = False
-                pos = -1
-                used_ref = ref
-                
-                for ref_var in ref_variations:
-                    if ref_var.lower() in page_text.lower():
-                        pos = page_text.lower().find(ref_var.lower())
-                        used_ref = ref_var
-                        found = True
-                        break
-                
-                if found and pos >= 0:
-                    # Extract context around it
-                    start = max(0, pos - context_chars)
-                    end = min(len(page_text), pos + len(used_ref) + context_chars)
+                for match in cap_pattern.finditer(page_text):
+                    caption_text = match.group(0).strip()
+                    caption_lower = caption_text.lower()
                     
-                    section = page_text[start:end]
-                    extracted_sections.append(
-                        f"\n=== Context around '{ref}' (found as '{used_ref}') in {pdf_path.name}, page {page_num + 1} ===\n{section}"
-                    )
-                    log.debug("Found '%s' as '%s' on page %d of %s", ref, used_ref, page_num + 1, pdf_path.name)
+                    # Store caption info
+                    caption_info = {
+                        'full_caption': caption_text,
+                        'page_text': page_text,
+                        'page_num': page_num + 1,
+                        'pdf_path': pdf_path,
+                        'source': source,
+                        'match_start': match.start(),
+                        'doc': doc  # Keep doc reference for page extraction
+                    }
+                    
+                    # Create multiple keys for flexible matching
+                    # Key 1: Full caption text (first 100 chars)
+                    key1 = caption_text[:100].lower().strip()
+                    caption_index[key1] = caption_info
+                    
+                    # Key 2: Simplified reference (e.g., "table 5", "figure s3")
+                    ref_match = re.search(r'(table|figure|fig|scheme)\s*s?(\d+[a-z]?)', caption_lower)
+                    if ref_match:
+                        key2 = f"{ref_match.group(1)} {ref_match.group(2)}"
+                        caption_index[key2] = caption_info
+                        
+                        # Also store with 's' prefix if in SI
+                        if source == "supplementary" and 's' not in key2:
+                            key3 = f"{ref_match.group(1)} s{ref_match.group(2)}"
+                            caption_index[key3] = caption_info
         finally:
             doc.close()
     
+    return caption_index
+
+def _extract_text_around_reference(pdf_paths: List[Path], ref: str, context_chars: int = 2000) -> str:
+    """Extract text around a specific reference using caption index."""
+    import re
+    
+    # Build caption index if not already built
+    if not hasattr(_extract_text_around_reference, '_caption_index'):
+        _extract_text_around_reference._caption_index = _build_caption_index(pdf_paths)
+    
+    caption_index = _extract_text_around_reference._caption_index
+    ref_lower = ref.lower().strip()
+    
+    # Try multiple matching strategies
+    matches = []
+    
+    # Strategy 1: Direct key lookup
+    if ref_lower in caption_index:
+        matches.append(caption_index[ref_lower])
+    
+    # Strategy 2: Normalized reference lookup
+    ref_match = re.match(r'(table|figure|fig|scheme)\s*s?(\d+[a-z]?)', ref_lower, re.I)
+    if ref_match:
+        ref_type, ref_num = ref_match.groups()
+        if ref_type == 'fig':
+            ref_type = 'figure'
+        
+        # Try different key formats
+        keys_to_try = [
+            f"{ref_type} {ref_num}",
+            f"{ref_type} s{ref_num}",
+            f"table {ref_num}",
+            f"fig {ref_num}",
+            f"figure {ref_num}"
+        ]
+        
+        for key in keys_to_try:
+            if key in caption_index and caption_index[key] not in matches:
+                matches.append(caption_index[key])
+    
+    # Strategy 3: Fuzzy matching
+    if not matches and ref_match:
+        for key, info in caption_index.items():
+            if ref_num in key and any(t in key for t in ['table', 'figure', 'fig', 'scheme']):
+                if info not in matches:
+                    matches.append(info)
+    
+    # Extract text from matches
+    extracted_sections = []
+    for match in matches:
+        page_text = match['page_text']
+        caption_start = match['match_start']
+        
+        # Extract context around the caption
+        start = max(0, caption_start - context_chars // 2)
+        end = min(len(page_text), caption_start + context_chars)
+        
+        section = page_text[start:end]
+        source_label = f"{match['source'].upper()} page {match['page_num']}"
+        extracted_sections.append(f"\n[From {source_label}]\n{section}")
+    
     if not extracted_sections:
-        log.warning("Could not find reference '%s' or base reference '%s' in any PDF", ref, base_ref)
+        log.warning(f"No matches found for reference '{ref}'")
+        # Fallback to old approach
+        for pdf_path in pdf_paths:
+            doc = _open_doc(pdf_path)
+            try:
+                for page_num in range(doc.page_count):
+                    page = doc.load_page(page_num)
+                    page_text = page.get_text()
+                    
+                    if ref_lower in page_text.lower():
+                        pos = page_text.lower().find(ref_lower)
+                        start = max(0, pos - context_chars // 2)
+                        end = min(len(page_text), pos + context_chars)
+                        extracted_sections.append(page_text[start:end])
+                        break
+            finally:
+                doc.close()
     
-    return "\n".join(extracted_sections)
+    return "\n\n".join(extracted_sections)
 
 def _extract_sections_by_title(pdf_paths: List[Path], section_titles: List[str], max_chars_per_section: int = 10000) -> str:
     """Extract sections by their titles from PDFs."""
@@ -1060,17 +1161,24 @@ Your task is to:
 4. Note that not all campaigns have substrate scope data - it's okay to return empty results if no substrate scope data exists for this campaign
 5. Determine which enzyme variants from this campaign were tested in substrate scope studies
 
+IMPORTANT FIGURE REFERENCE RULES:
+- For figures, ALWAYS return the main figure number only (e.g., "Figure 2", NOT "Figure 2a" or "Figure 2(a)")
+- Include the figure caption if available to help with identification
+- The extraction system will handle retrieving the entire figure including all sub-panels
+
 Return your analysis as JSON array (max {max_results} locations, or empty array if no substrate scope data for this campaign):
 [
   {{
-    "location": "Description of where the data is found",
+    "location": "Main figure/table reference (e.g., 'Figure 2', 'Table S1', NOT 'Figure 2a')",
     "type": "table|figure|text",
     "confidence": 0.0-1.0,
     "enzyme_variants": ["list of enzyme IDs found"],
     "substrates_tested": ["list of substrates if identifiable"],
     "campaign_match": true/false,
     "is_substrate_scope": true/false,
-    "model_reaction_excluded": "reason why this is not a model reaction"
+    "model_reaction_excluded": "reason why this is not a model reaction",
+    "caption": "Include the figure/table caption if available",
+    "document": "manuscript|supplementary - specify whether this location is in the main manuscript or supplementary information"
   }}
 ]
 
@@ -1790,22 +1898,28 @@ def extract_substrate_scope_entries_for_campaign(
     all_refs = []
     
     if locations:
-        # Include ALL locations, not just primary
-        location_strs = []
-        for loc in locations[:3]:  # Up to 3 locations
-            loc_str = loc.get('location', '')
-            location_strs.append(loc_str)
-            all_refs.append(loc_str)
+        # Sort locations by confidence and use only the PRIMARY (most confident) location
+        sorted_locations = sorted(locations, key=lambda x: x.get('confidence', 0), reverse=True)
+        primary_location = sorted_locations[0] if sorted_locations else None
         
-        extraction_hints = f"\nSubstrate scope locations for campaign {campaign_id}: {', '.join(location_strs)}"
+        if primary_location:
+            primary_ref = primary_location.get('location', '')
+            all_refs = [primary_ref]  # Only extract from primary location
+            
+            extraction_hints = f"\nPRIMARY substrate scope location for campaign {campaign_id}: {primary_ref}"
+            extraction_hints += f"\nLocation confidence: {primary_location.get('confidence', 0)}%"
+            extraction_hints += f"\nLocation type: {primary_location.get('type', 'unknown')}"
         
         # Focus on campaign-specific enzyme variants
         extraction_hints += f"\nTarget enzymes for this campaign: {', '.join(enzyme_ids)}"
     
-    # Extract text from ALL identified locations (like the original function did)
+    # Extract text from ONLY the primary location
     extraction_texts = []
     figure_images = {}
     
+    # Create a mapping of location strings to their full location data
+    location_map = {loc.get('location', ''): loc for loc in locations}
+    
     for ref in all_refs:
         if ref and pdf_paths:
             ref_text = _extract_text_around_reference(pdf_paths, ref, context_chars=5000)
@@ -1814,7 +1928,10 @@ def extract_substrate_scope_entries_for_campaign(
                 
                 # Extract figure images for this reference (crop page around figure)
                 try:
-                    fig_base64 = extract_figure_image(pdf_paths, ref)
+                    # Get caption and document hints if available
+                    caption_hint = location_map.get(ref, {}).get('caption', '')
+                    document_hint = location_map.get(ref, {}).get('document', '')
+                    fig_base64 = extract_figure_image(pdf_paths, ref, caption_hint=caption_hint, document_hint=document_hint)
                     if fig_base64:
                         figure_images[ref] = fig_base64
                         log.info("Campaign %s - extracted cropped figure image for %s", campaign_id, ref)
@@ -1867,6 +1984,14 @@ IMPORTANT INSTRUCTIONS:
 4. Not all campaigns have substrate scope data - if no substrate scope data exists for this campaign, return an empty array
 5. Include all relevant reaction performance data (yield, ee, ttn, etc.)
 
+CRITICAL DATA ACCURACY REQUIREMENTS:
+- BE EXTREMELY CAREFUL about which substrate ID maps to which yield, TTN, and selectivity values
+- Each substrate entry should have its OWN yield, ee, and TTN values - do not mix up values between substrates
+- If looking at a table or figure, carefully match each substrate with its corresponding row/bar/data point
+- Double-check that substrate 1a's data is not confused with substrate 1b's data, etc.
+- If values are unclear or ambiguous for a specific substrate, return null rather than guessing
+- Pay special attention when extracting from figures - ensure you're reading the correct bar/point for each substrate
+
 {extraction_hints}
 
 Return your analysis as JSON in this format:
@@ -2212,13 +2337,15 @@ def get_substrate_scope(
         if should_extract:
             figure_ref = location_str
             confidence = loc.get('confidence', 0)
+            caption_hint = loc.get('caption', '')
             log.info("Extracting image for %s (confidence: %d%%, type: %s)", figure_ref, confidence, location_type)
             
             # Use appropriate extraction function based on type
             if 'scheme' in location_str.lower() or location_type == 'scheme':
                 figure_image = extract_scheme_image(pdf_paths, figure_ref)
             else:
-                figure_image = extract_figure_image(pdf_paths, figure_ref)
+                document_hint = loc.get('document', '')
+                figure_image = extract_figure_image(pdf_paths, figure_ref, caption_hint=caption_hint, document_hint=document_hint)
                 
             if figure_image:
                 log.info("Successfully extracted %s image for %s (%d bytes)", 

debase/wrapper.py

@@ -7,10 +7,10 @@ Pipeline flow:
 2. cleanup_sequence.py - Clean and validate protein sequences
 3. reaction_info_extractor.py - Extract reaction performance metrics
 4. substrate_scope_extractor.py - Extract substrate scope data (runs independently)
-5. lineage_format_o3.py - Format and merge all data into final CSV
+5. lineage_format.py - Format and merge all data into final CSV
 
 The reaction_info and substrate_scope extractors run in parallel,
-then their outputs are combined in lineage_format_o3.
+then their outputs are combined in lineage_format.
 """
 import os
 import sys
@@ -579,7 +579,7 @@ Pipeline steps:
   2. cleanup_sequence - Validate and clean protein sequences  
   3. reaction_info_extractor - Extract reaction performance metrics
   4. substrate_scope_extractor - Extract substrate scope data
-  5. lineage_format_o3 - Format and merge into final CSV
+  5. lineage_format - Format and merge into final CSV
 
 The pipeline automatically handles all steps sequentially.
         """

{debase-0.6.0.dist-info → debase-0.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: debase
-Version: 0.6.0
+Version: 0.6.2
 Summary: Enzyme lineage analysis and sequence extraction package
 Home-page: https://github.com/YuemingLong/DEBase
 Author: DEBase Team

debase-0.6.2.dist-info/RECORD

@@ -0,0 +1,18 @@
+debase/__init__.py,sha256=YeKveGj_8fwuu5ozoK2mUU86so_FjiCwsvg1d_lYVZU,586
+debase/__main__.py,sha256=LbxYt2x9TG5Ced7LpzzX_8gkWyXeZSlVHzqHfqAiPwQ,160
+debase/_version.py,sha256=t771GcmZTaJJGrIex6Ea6Q5pcMqVPIihCdRFRA1dMAM,49
+debase/build_db.py,sha256=bW574GxsL1BJtDwM19urLbciPcejLzfraXZPpzm09FQ,7167
+debase/campaign_utils.py,sha256=6Mo6ps8gIOxBrfNNshvny-9GTKBt8UARc8t59o1obAk,4756
+debase/caption_pattern.py,sha256=F1cxQxyQDmzw3ogi3zXJp7iEvOdFdIN2kDzLrUg_amE,2043
+debase/cleanup_sequence.py,sha256=XbA0pZFFIJRJf4XCEN-j4s7dnkdXN9mYdbcuz-ZSjg4,75520
+debase/enzyme_lineage_extractor.py,sha256=OXO2jUqAqF0pXrw17oIQERnek1uZ5gsFIuKRz4NMS1o,188556
+debase/lineage_format.py,sha256=YWAP9OhFN3MQWbqk5gguX0C2cCwGvKJAtMq9pG5TJp8,59515
+debase/reaction_info_extractor.py,sha256=kQBxPpzurjHXsHFWE_WM84ArSnc3E8f6xPMJpyTIGnU,188246
+debase/substrate_scope_extractor.py,sha256=hRlt8iWOURmgW4SJHB1Svoh3TTa4fa9YIE8qVUZPnY0,122621
+debase/wrapper.py,sha256=Vcad6c_f3jZHpefZMP9XJPI3fo7w-pCgcSqEEQyDgS0,24559
+debase-0.6.2.dist-info/licenses/LICENSE,sha256=5sk9_tcNmr1r2iMIUAiioBo7wo38u8BrPlO7f0seqgE,1075
+debase-0.6.2.dist-info/METADATA,sha256=gnPvTWvazrsdGrIKX8tA4Wwt8yKYph87POVKF25rkkg,4047
+debase-0.6.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+debase-0.6.2.dist-info/entry_points.txt,sha256=hUcxA1b4xORu-HHBFTe9u2KTdbxPzt0dwz95_6JNe9M,48
+debase-0.6.2.dist-info/top_level.txt,sha256=2BUeq-4kmQr0Rhl06AnRzmmZNs8WzBRK9OcJehkcdk8,7
+debase-0.6.2.dist-info/RECORD,,

debase-0.6.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-debase/__init__.py,sha256=YeKveGj_8fwuu5ozoK2mUU86so_FjiCwsvg1d_lYVZU,586
-debase/__main__.py,sha256=LbxYt2x9TG5Ced7LpzzX_8gkWyXeZSlVHzqHfqAiPwQ,160
-debase/_version.py,sha256=C3pfAAiv8eypvKmkKXrxXIwx9sLe4TtShkzld5GJJ7k,49
-debase/build_db.py,sha256=bW574GxsL1BJtDwM19urLbciPcejLzfraXZPpzm09FQ,7167
-debase/cleanup_sequence.py,sha256=qKAou871Eri4SDQMz-XCfD3D2BuuINxSxzJZMACJ7p4,73313
-debase/enzyme_lineage_extractor.py,sha256=C2rVFyM84TvDy7hvk_xIeVSdh1F6WSe4QQB8B8QrPC4,168026
-debase/lineage_format.py,sha256=BE8uW1XUCmxlcYKiD7QveF4r99xObfGf1vP1rZzJTV8,56525
-debase/reaction_info_extractor.py,sha256=9QXbtp0RSP6QMqQ_azBWDceGIqiw2JPCg3eJ0Ba_lxA,167849
-debase/substrate_scope_extractor.py,sha256=ydU6iZVRw3fLyQ8kIQs6ZuruBMvM4mMXIeGuPgCUOn4,115956
-debase/wrapper.py,sha256=0z1BRvs3pzuPV_sgJxrBVmX_IXqwX3tB4u0GXdSgR3c,24568
-debase-0.6.0.dist-info/licenses/LICENSE,sha256=5sk9_tcNmr1r2iMIUAiioBo7wo38u8BrPlO7f0seqgE,1075
-debase-0.6.0.dist-info/METADATA,sha256=o_Iq-jjk_ekBLLheIQZuLEeC7tWbduq70b5jqfiCmro,4047
-debase-0.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-debase-0.6.0.dist-info/entry_points.txt,sha256=hUcxA1b4xORu-HHBFTe9u2KTdbxPzt0dwz95_6JNe9M,48
-debase-0.6.0.dist-info/top_level.txt,sha256=2BUeq-4kmQr0Rhl06AnRzmmZNs8WzBRK9OcJehkcdk8,7
-debase-0.6.0.dist-info/RECORD,,