debase 0.1.0__py3-none-any.whl

debase/wrapper.py

@@ -0,0 +1,303 @@
+#!/usr/bin/env python3
+"""
+Enzyme Analysis Pipeline Wrapper (Clean Version)
+
+Pipeline flow:
+1. enzyme_lineage_extractor.py - Extract enzyme data from PDFs
+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
+
+The reaction_info and substrate_scope extractors run in parallel,
+then their outputs are combined in lineage_format_o3.
+"""
+import os
+import sys
+import argparse
+import logging
+import time
+from datetime import datetime
+from pathlib import Path
+
+# Setup logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger("EnzymePipeline")
+
+
+def run_lineage_extraction(manuscript: Path, si: Path, output: Path, debug_dir: Path = None) -> Path:
+    """
+    Step 1: Extract enzyme lineage data from PDFs
+    Calls: enzyme_lineage_extractor.py
+    """
+    logger.info(f"Extracting enzyme lineage from {manuscript.name}")
+    
+    import sys
+    sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+    from src.debase.enzyme_lineage_extractor import run_pipeline
+    run_pipeline(manuscript=manuscript, si=si, output_csv=output, debug_dir=debug_dir)
+    
+    logger.info(f"Lineage extraction complete: {output}")
+    return output
+
+
+def run_sequence_cleanup(input_csv: Path, output_csv: Path) -> Path:
+    """
+    Step 2: Clean and validate protein sequences
+    Calls: cleanup_sequence.py
+    """
+    logger.info(f"Cleaning sequences from {input_csv.name}")
+    
+    from src.debase.cleanup_sequence import main as cleanup_sequences
+    cleanup_sequences([str(input_csv), str(output_csv)])
+    
+    logger.info(f"Sequence cleanup complete: {output_csv}")
+    return output_csv
+
+
+def run_reaction_extraction(manuscript: Path, si: Path, lineage_csv: Path, output: Path, debug_dir: Path = None) -> Path:
+    """
+    Step 3a: Extract reaction performance metrics
+    Calls: reaction_info_extractor.py
+    """
+    logger.info(f"Extracting reaction info for enzymes in {lineage_csv.name}")
+    
+    from src.debase.reaction_info_extractor import ReactionExtractor, Config
+    import pandas as pd
+    
+    # Load enzyme data
+    enzyme_df = pd.read_csv(lineage_csv)
+    
+    # Initialize extractor and run
+    cfg = Config()
+    extractor = ReactionExtractor(manuscript, si, cfg, debug_dir=debug_dir)
+    df_metrics = extractor.run(enzyme_df)
+    
+    # Save results
+    df_metrics.to_csv(output, index=False)
+    logger.info(f"Reaction extraction complete: {output}")
+    return output
+
+
+def run_substrate_scope_extraction(manuscript: Path, si: Path, lineage_csv: Path, output: Path, debug_dir: Path = None) -> Path:
+    """
+    Step 3b: Extract substrate scope data (runs in parallel with reaction extraction)
+    Calls: substrate_scope_extractor.py
+    """
+    logger.info(f"Extracting substrate scope for enzymes in {lineage_csv.name}")
+    
+    from src.debase.substrate_scope_extractor import run_pipeline
+    
+    # Run substrate scope extraction
+    run_pipeline(
+        manuscript=manuscript,
+        si=si,
+        lineage_csv=lineage_csv,
+        output_csv=output,
+        debug_dir=debug_dir
+    )
+    
+    logger.info(f"Substrate scope extraction complete: {output}")
+    return output
+
+
+def run_lineage_format(reaction_csv: Path, substrate_scope_csv: Path, cleaned_csv: Path, output_csv: Path) -> Path:
+    """
+    Step 4: Format and merge all data into final CSV
+    Calls: lineage_format.py
+    """
+    logger.info(f"Formatting and merging data into final output")
+    
+    from src.debase.lineage_format import run_pipeline
+    import pandas as pd
+    
+    # First, we need to merge the protein sequences into the reaction data
+    df_reaction = pd.read_csv(reaction_csv)
+    df_sequences = pd.read_csv(cleaned_csv)
+    
+    # Merge sequences into reaction data
+    # Include generation and parent info for proper mutation calculation
+    sequence_cols = ['protein_sequence', 'dna_seq', 'seq_confidence', 'truncated', 'flag', 
+                     'generation', 'parent_enzyme_id', 'mutations']
+    sequence_data = df_sequences[['enzyme_id'] + [col for col in sequence_cols if col in df_sequences.columns]]
+    
+    # Merge on enzyme_id or variant_id
+    if 'enzyme_id' in df_reaction.columns:
+        df_reaction = df_reaction.merge(sequence_data, on='enzyme_id', how='left', suffixes=('', '_seq'))
+    elif 'enzyme' in df_reaction.columns:
+        sequence_data = sequence_data.rename(columns={'enzyme_id': 'enzyme'})
+        df_reaction = df_reaction.merge(sequence_data, on='enzyme', how='left', suffixes=('', '_seq'))
+    
+    # Save the merged reaction data
+    df_reaction.to_csv(reaction_csv, index=False)
+    
+    # Run the formatting pipeline
+    df_final = run_pipeline(
+        reaction_csv=reaction_csv,
+        substrate_scope_csv=substrate_scope_csv,
+        output_csv=output_csv
+    )
+    
+    logger.info(f"Final formatting complete: {output_csv}")
+    return output_csv
+
+
+def run_pipeline(
+    manuscript_path: Path,
+    si_path: Path = None,
+    output_path: Path = None,
+    keep_intermediates: bool = False,
+    debug_dir: Path = None
+) -> Path:
+    """Run the complete enzyme analysis pipeline."""
+    # Setup paths
+    manuscript_path = Path(manuscript_path)
+    si_path = Path(si_path) if si_path else None
+    
+    # Create output filename based on manuscript
+    if not output_path:
+        output_name = manuscript_path.stem.replace(' ', '_')
+        output_path = Path(f"{output_name}_debase.csv")
+    else:
+        output_path = Path(output_path)
+    
+    # Use the output directory for all files
+    output_dir = output_path.parent
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Define intermediate file paths (all in the same directory as output)
+    lineage_csv = output_dir / "enzyme_lineage_data.csv"  # This is what enzyme_lineage_extractor actually outputs
+    cleaned_csv = output_dir / "2_enzyme_sequences.csv"
+    reaction_csv = output_dir / "3a_reaction_info.csv"
+    substrate_csv = output_dir / "3b_substrate_scope.csv"
+    
+    try:
+        logger.info("="*60)
+        logger.info("Starting DEBase Enzyme Analysis Pipeline")
+        logger.info(f"Manuscript: {manuscript_path}")
+        logger.info(f"SI: {si_path if si_path else 'None'}")
+        logger.info(f"Output: {output_path}")
+        logger.info("="*60)
+        
+        start_time = time.time()
+        
+        # Step 1: Extract enzyme lineage
+        logger.info("\n[Step 1/5] Extracting enzyme lineage...")
+        run_lineage_extraction(manuscript_path, si_path, lineage_csv, debug_dir=debug_dir)
+        
+        # Step 2: Clean sequences
+        logger.info("\n[Step 2/5] Cleaning sequences...")
+        run_sequence_cleanup(lineage_csv, cleaned_csv)
+        
+        # Step 3: Extract reaction and substrate scope in parallel
+        logger.info("\n[Step 3/5] Extracting reaction info and substrate scope...")
+        
+        # Run reaction extraction
+        logger.info("  - Extracting reaction metrics...")
+        run_reaction_extraction(manuscript_path, si_path, cleaned_csv, reaction_csv, debug_dir=debug_dir)
+        
+        # Add small delay to avoid API rate limits
+        time.sleep(2)
+        
+        # Run substrate scope extraction
+        logger.info("  - Extracting substrate scope...")
+        run_substrate_scope_extraction(manuscript_path, si_path, cleaned_csv, substrate_csv, debug_dir=debug_dir)
+        
+        # Step 4: Format and merge
+        logger.info("\n[Step 4/5] Formatting and merging data...")
+        run_lineage_format(reaction_csv, substrate_csv, cleaned_csv, output_path)
+        
+        # Step 5: Finalize
+        logger.info("\n[Step 5/5] Finalizing...")
+        elapsed = time.time() - start_time
+        
+        if keep_intermediates:
+            logger.info(f"All intermediate files saved in: {output_dir}")
+        else:
+            logger.info("Note: Use --keep-intermediates to save intermediate files")
+        
+        logger.info("\n" + "="*60)
+        logger.info("PIPELINE COMPLETED SUCCESSFULLY")
+        logger.info(f"Output: {output_path}")
+        logger.info(f"Runtime: {elapsed:.1f} seconds")
+        logger.info("="*60)
+        
+        return output_path
+        
+    except Exception as e:
+        logger.error(f"Pipeline failed: {str(e)}")
+        raise
+    
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='DEBase Enzyme Analysis Pipeline - Extract enzyme data from chemistry papers',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Pipeline steps:
+  1. enzyme_lineage_extractor - Extract enzyme variants from PDFs
+  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
+
+The pipeline automatically handles all steps sequentially.
+        """
+    )
+    
+    # Required arguments
+    parser.add_argument(
+        '--manuscript',
+        type=Path,
+        help='Path to manuscript PDF'
+    )
+    
+    # Optional arguments
+    parser.add_argument(
+        '--si',
+        type=Path,
+        help='Path to supplementary information PDF'
+    )
+    parser.add_argument(
+        '--output',
+        type=Path,
+        help='Output CSV path (default: manuscript_name_debase.csv)'
+    )
+    parser.add_argument(
+        '--keep-intermediates',
+        action='store_true',
+        help='Keep intermediate files for debugging'
+    )
+    parser.add_argument(
+        '--debug-dir',
+        type=Path,
+        help='Directory for debug output (prompts, API responses)'
+    )
+    
+    args = parser.parse_args()
+    
+    # Check inputs
+    if not args.manuscript.exists():
+        parser.error(f"Manuscript not found: {args.manuscript}")
+    if args.si and not args.si.exists():
+        parser.error(f"SI not found: {args.si}")
+    
+    # Run pipeline
+    try:
+        run_pipeline(
+            manuscript_path=args.manuscript,
+            si_path=args.si,
+            output_path=args.output,
+            keep_intermediates=args.keep_intermediates,
+            debug_dir=args.debug_dir
+        )
+    except Exception as e:
+        logger.error(f"Pipeline error: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

debase-0.1.0.dist-info/METADATA

@@ -0,0 +1,299 @@
+Metadata-Version: 2.4
+Name: debase
+Version: 0.1.0
+Summary: Enzyme lineage analysis and sequence extraction package
+Home-page: https://github.com/YuemingLong/DEBase
+Author: DEBase Team
+Author-email: DEBase Team <ylong@caltech.edu>
+License: MIT
+Project-URL: Homepage, https://github.com/YuemingLong/DEBase
+Project-URL: Documentation, https://github.com/YuemingLong/DEBase#readme
+Project-URL: Repository, https://github.com/YuemingLong/DEBase
+Project-URL: Issues, https://github.com/YuemingLong/DEBase/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.0.0
+Requires-Dist: PyMuPDF>=1.18.0
+Requires-Dist: numpy>=1.19.0
+Requires-Dist: google-generativeai>=0.3.0
+Requires-Dist: biopython>=1.78
+Requires-Dist: requests>=2.25.0
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: tqdm>=4.60.0
+Requires-Dist: openpyxl>=3.0.0
+Requires-Dist: PyPDF2>=2.0.0
+Requires-Dist: Pillow>=8.0.0
+Requires-Dist: networkx>=2.5
+Provides-Extra: rdkit
+Requires-Dist: rdkit>=2020.03.1; extra == "rdkit"
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=4.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme; extra == "docs"
+Requires-Dist: myst-parser; extra == "docs"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# DEBase
+
+Enzyme lineage analysis and sequence extraction package with advanced parallel processing capabilities.
+
+## Installation
+
+```bash
+pip install debase
+```
+
+For full functionality with chemical SMILES support:
+
+```bash
+pip install debase[rdkit]
+```
+
+## Requirements
+
+- Python 3.8 or higher
+- A Gemini API key (set as environment variable `GEMINI_API_KEY`)
+
+## Recent Updates
+
+- **Campaign-Aware Extraction**: Automatically detects and processes multiple directed evolution campaigns in a single paper
+- **Improved Model Support**: Updated to use stable Gemini models for better reliability
+- **Enhanced PDB Integration**: Intelligent AI-based matching of PDB structures to enzyme variants
+- **Better Filtering**: Automatic removal of non-enzyme entries (buffers, controls, media)
+- **Optimized Performance**: Removed unnecessary rate limiting for faster processing
+- **External Sequence Fetching**: Automatic retrieval from PDB and UniProt databases when sequences aren't in papers
+- **Improved SI Processing**: Structure-aware extraction of supplementary information
+- **Vision Support**: Extracts data from figures and tables using multimodal AI capabilities
+
+## Quick Start
+
+### Basic Usage
+```bash
+# Run the full pipeline (sequential processing)
+debase --manuscript manuscript.pdf --si supplementary.pdf --output output.csv
+```
+
+### High-Performance Parallel Processing
+```bash
+# Use parallel individual processing for maximum speed + accuracy
+debase --manuscript manuscript.pdf --si supplementary.pdf --output output.csv \
+  --use-parallel-individual --max-workers 5
+
+# Use batch processing for maximum speed (slight accuracy trade-off)
+debase --manuscript manuscript.pdf --si supplementary.pdf --output output.csv \
+  --use-optimized-reaction --reaction-batch-size 5
+```
+
+## Processing Methods
+
+DEBase offers three processing approaches optimized for different use cases:
+
+### 1. **Parallel Individual Processing** (Recommended)
+- **42 individual API calls** (21 for reactions + 21 for substrate scope)
+- **5 calls running simultaneously** for 4-5x speedup
+- **Maximum accuracy** - each enzyme gets dedicated attention
+- **Best for:** Production use, important analyses
+
+```bash
+debase --manuscript paper.pdf --si si.pdf --use-parallel-individual --max-workers 5
+```
+
+### 2. **Batch Processing** (Fastest)
+- **~8 total API calls** (multiple enzymes per call)
+- **Fastest processing** - up to 8x speedup
+- **Good accuracy** - slight trade-off for complex chemical names
+- **Best for:** Quick analyses, large-scale processing
+
+```bash
+debase --manuscript paper.pdf --si si.pdf --use-optimized-reaction --reaction-batch-size 5
+```
+
+### 3. **Sequential Processing** (Most Accurate)
+- **42 sequential API calls** (one at a time)
+- **Highest accuracy** but slowest
+- **Best for:** Critical analyses, small datasets
+
+```bash
+debase --manuscript paper.pdf --si si.pdf  # Default method
+```
+
+## Performance Comparison
+
+| Method | Total Time | API Calls | Accuracy | Best For |
+|--------|------------|-----------|----------|----------|
+| Sequential | ~45 min | 44 calls | Highest | Small datasets |
+| **Parallel Individual** | **~12 min** | **44 calls** | **High** | **Recommended** |
+| Batch Processing | ~8 min | ~8 calls | Good | Speed-critical |
+
+## Advanced Usage
+
+### Skip Steps with Existing Data
+```bash
+# Skip lineage extraction if you already have it
+debase --manuscript paper.pdf --si si.pdf --output output.csv \
+  --skip-lineage --existing-lineage existing_lineage.csv \
+  --use-parallel-individual
+```
+
+### Direct Module Usage
+```bash
+# Run only reaction extraction with parallel processing
+python -m debase.reaction_info_extractor_parallel \
+  --manuscript paper.pdf --si si.pdf --lineage-csv lineage.csv \
+  --max-workers 5 --output reactions.csv
+
+# Run only substrate scope extraction with parallel processing  
+python -m debase.substrate_scope_extractor_parallel \
+  --manuscript paper.pdf --si si.pdf --lineage-csv lineage.csv \
+  --max-workers 5 --output substrate_scope.csv
+```
+
+## Python API
+
+```python
+from debase.wrapper import run_pipeline
+
+# Run full pipeline with parallel processing
+run_pipeline(
+    manuscript_path="paper.pdf",
+    si_path="si.pdf", 
+    output="output.csv",
+    use_parallel_individual=True,
+    max_workers=5
+)
+
+# For individual steps
+from debase.reaction_info_extractor_parallel import extract_reaction_info_parallel
+from debase.enzyme_lineage_extractor import setup_gemini_api
+
+model = setup_gemini_api()
+reaction_data = extract_reaction_info_parallel(
+    model, manuscript_path, si_path, enzyme_csv_path, max_workers=5
+)
+```
+
+## Pipeline Architecture
+
+The DEBase pipeline consists of 5 main steps:
+
+1. **Lineage Extraction** (Sequential) - Identifies all enzymes and their relationships
+   - Extracts mutation information and evolutionary paths
+   - Detects multiple directed evolution campaigns automatically
+   - Fetches sequences from external databases (PDB, UniProt)
+   - Filters out non-enzyme entries automatically
+2. **Sequence Cleanup** (Local) - Generates protein sequences from mutations  
+   - Applies mutations to parent sequences
+   - Handles complex mutations and domain modifications
+   - Validates sequence integrity
+3. **Reaction Extraction** (Parallel/Batch/Sequential) - Extracts reaction conditions and performance data
+   - Campaign-aware extraction for multi-lineage papers
+   - Vision-based extraction from figures and tables
+   - Automatic IUPAC name resolution
+4. **Substrate Scope Extraction** (Parallel/Sequential) - Finds additional substrates tested
+5. **Data Formatting** (Local) - Combines all data into final output
+
+## Features
+
+- **Multi-processing modes:** Sequential, parallel individual, and batch processing
+- **Campaign detection:** Automatically identifies and separates multiple directed evolution campaigns
+- **Intelligent error handling:** Automatic retries with exponential backoff
+- **External database integration:** Automatic sequence fetching from PDB and UniProt
+- **AI-powered matching:** Uses Gemini to intelligently match database entries to enzyme variants
+- **Smart filtering:** Automatically excludes non-enzyme entries (buffers, controls, etc.)
+- **Progress tracking:** Real-time status updates
+- **Flexible output:** CSV format with comprehensive chemical and performance data
+- **Caching:** PDF encoding cache for improved performance
+- **Vision capabilities:** Extracts data from both text and images in PDFs
+
+## Complete Command Reference
+
+### Core Arguments
+```bash
+--manuscript PATH           # Required: Path to manuscript PDF
+--si PATH                  # Optional: Path to supplementary information PDF
+--output PATH              # Output file path (default: manuscript_name_debase.csv)
+--queries N                # Number of consensus queries (default: 2)
+```
+
+### Performance Options
+```bash
+--use-parallel-individual  # Use parallel processing (recommended)
+--max-workers N            # Number of parallel workers (default: 5)
+--use-optimized-reaction   # Use batch processing for speed
+--reaction-batch-size N    # Enzymes per batch (default: 5)
+--no-parallel-queries      # Disable parallel processing
+```
+
+### Pipeline Control
+```bash
+--skip-lineage             # Skip lineage extraction step
+--skip-sequence            # Skip sequence cleanup step  
+--skip-reaction            # Skip reaction extraction step
+--skip-substrate-scope     # Skip substrate scope extraction step
+--skip-lineage-format      # Skip final formatting step
+--skip-validation          # Skip data validation step
+```
+
+### Data Management
+```bash
+--existing-lineage PATH    # Use existing lineage data
+--existing-sequence PATH   # Use existing sequence data
+--existing-reaction PATH   # Use existing reaction data
+--keep-intermediates       # Preserve intermediate files
+```
+
+### Advanced Options
+```bash
+--model-name NAME          # Gemini model to use
+--max-retries N            # Maximum retry attempts (default: 2)
+--max-chars N              # Max characters from PDFs (default: 75000)
+--debug-dir PATH           # Directory for debug output (prompts, API responses)
+```
+
+## Tips for Best Performance
+
+1. **Use parallel individual processing** for the best balance of speed and accuracy
+2. **Set max-workers to 5** to avoid API rate limits while maximizing throughput
+3. **Use batch processing** only when speed is critical and some accuracy loss is acceptable
+4. **Skip validation** (`--skip-validation`) for faster processing in production
+5. **Keep intermediates** (`--keep-intermediates`) for debugging and incremental runs
+6. **Check external databases** - Many sequences can be automatically fetched from PDB/UniProt
+7. **Verify enzyme entries** - The system automatically filters out buffers and controls
+
+## Troubleshooting
+
+### No sequences found
+- The extractor will automatically search PDB and UniProt databases
+- Check the logs for which database IDs were found and attempted
+- Sequences with PDB structures will be fetched with high confidence
+
+### Incorrect enzyme extraction
+- Non-enzyme entries (buffers, controls, media) are automatically filtered
+- Check the log for entries marked as "Filtering out non-enzyme entry"
+
+### PDB matching issues
+- The system uses AI to match PDB IDs to specific enzyme variants
+- Increased context extraction ensures better matching accuracy
+- Check logs for "Gemini PDB matching" entries to see the matching process

debase-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+debase/PIPELINE_FLOW.md,sha256=S4nQyZlX39-Bchw1gQWPK60sHiFpB1eWHqo5GR9oTY8,4741
+debase/__init__.py,sha256=YeKveGj_8fwuu5ozoK2mUU86so_FjiCwsvg1d_lYVZU,586
+debase/__main__.py,sha256=LbxYt2x9TG5Ced7LpzzX_8gkWyXeZSlVHzqHfqAiPwQ,160
+debase/_version.py,sha256=HnfC_TWAA2mfjIbkXT0ipZEqElS5wLaMzSj1DkE1F88,49
+debase/build_db.py,sha256=bW574GxsL1BJtDwM19urLbciPcejLzfraXZPpzm09FQ,7167
+debase/cleanup_sequence.py,sha256=QyhUqvTBVFTGM7ebAHmP3tif3Jq-8hvoLApYwAJtpH4,32702
+debase/enzyme_lineage_extractor.py,sha256=1GcgHA-lQPRf9-bNDlvQIP8p-KsP3D2WhIuOtCVJ_ME,87276
+debase/lineage_format.py,sha256=mACni9M1RXA_1tIyDZJpStQoutd_HLG2qQMAORTusZs,30045
+debase/reaction_info_extractor.py,sha256=euw-4NHFuOPxpF99PJxTMLYYG0WryBDUCpoANB-SPPM,109655
+debase/substrate_scope_extractor.py,sha256=dbve8q3K7ggA3A6EwB-KK9L19BnMNgPZMZ05G937dSY,82262
+debase/wrapper.py,sha256=UlUBxxIXBnVtSIT9lZXkQeImlCABiUuof1CVZNKv9N4,10482
+debase-0.1.0.dist-info/licenses/LICENSE,sha256=5sk9_tcNmr1r2iMIUAiioBo7wo38u8BrPlO7f0seqgE,1075
+debase-0.1.0.dist-info/METADATA,sha256=3s1NGPGYOb2bbP5PD5OoWBcJ7UeZ2OTQiOQ-SE5uqoM,11509
+debase-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+debase-0.1.0.dist-info/entry_points.txt,sha256=hUcxA1b4xORu-HHBFTe9u2KTdbxPzt0dwz95_6JNe9M,48
+debase-0.1.0.dist-info/top_level.txt,sha256=2BUeq-4kmQr0Rhl06AnRzmmZNs8WzBRK9OcJehkcdk8,7
+debase-0.1.0.dist-info/RECORD,,

debase-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

debase-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+debase = debase.__main__:main

debase-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 DEBase Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

debase-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+debase