drop alignment

Author: antonkulaga

README.md

@@ -41,8 +41,6 @@ The server includes local file saving capabilities through the `DownloadTools` i
 ### Download Tools
 - **`download_entrez_data`**: Download data from NCBI Entrez databases (returns content as string)
 - **`download_entrez_data_local`**: Download data from NCBI Entrez databases and save to local file
-- **`perform_pairwise_alignment`**: Perform pairwise sequence alignment (returns alignment results)
-- **`perform_pairwise_alignment_local`**: Perform pairwise sequence alignment and save results to local file
 
 ### Output Directory Management
 - **Default Location**: Files are saved to `biothings_output/` directory in the current working directory

src/biothings_mcp/download_api.py

@@ -5,7 +5,6 @@
 import json
 import uuid
 from Bio import Entrez, SeqIO
-from Bio.Align import PairwiseAligner
 from Bio.Seq import Seq
 from pydantic import BaseModel, Field, ConfigDict
 from pathlib import Path
@@ -37,36 +36,6 @@ class EntrezDownloadRequest(BaseModel):
         }
     }
 
-class PairwiseAlignmentRequest(BaseModel):
-    sequence1: str = Field(..., description="First sequence for alignment.")
-    sequence2: str = Field(..., description="Second sequence for alignment.")
-    match_score: float = Field(1.0, description="Score for a match.")
-    mismatch_penalty: float = Field(-1.0, description="Penalty for a mismatch. Should be negative or zero.")
-    open_gap_penalty: float = Field(-0.5, description="Penalty for opening a gap. Should be negative or zero.")
-    extend_gap_penalty: float = Field(-0.1, description="Penalty for extending a gap. Should be negative or zero.")
-    mode: Literal["global", "local"] = Field("global", description="Alignment mode: 'global' or 'local'.")
-
-    model_config = ConfigDict(
-        json_schema_extra = {
-            "example": {
-                "sequence1": "GATTACA",
-                "sequence2": "GCATGCU",
-                "match_score": 2.0,
-                "mismatch_penalty": -1.0,
-                "open_gap_penalty": -1.0,
-                "extend_gap_penalty": -0.5,
-                "mode": "global"
-            }
-        }
-    )
-
-class PairwiseAlignmentResponse(BaseModel):
-    score: float
-    aligned_sequence1: str
-    aligned_sequence2: str
-    full_alignment_str: str
-    parameters_used: Dict
-
 # Type hint for local file results
 LocalFileResult = Dict[Literal["path", "format", "success", "error"], Any]
 
@@ -286,215 +255,7 @@ def download_entrez_data_local(
                         "success": False,
                         "error": f"An unexpected error occurred during Entrez download: {str(e)}"
                     }
-        
-        @self.mcp_server.tool(
-            name=f"{self.prefix}perform_pairwise_alignment",
-            description="""Perform pairwise sequence alignment using Biopython's PairwiseAligner.
-            
-            Performs a pairwise sequence alignment (global or local) using Biopython's PairwiseAligner.
-            You can specify sequences and alignment scoring parameters.
-            
-            **Parameters:**
-            - `sequence1` (str): First sequence for alignment
-            - `sequence2` (str): Second sequence for alignment
-            - `match_score` (float): Score for a match (default: 1.0)
-            - `mismatch_penalty` (float): Penalty for a mismatch (default: -1.0, should be negative or zero)
-            - `open_gap_penalty` (float): Penalty for opening a gap (default: -0.5, should be negative or zero)
-            - `extend_gap_penalty` (float): Penalty for extending a gap (default: -0.1, should be negative or zero)
-            - `mode` (str): Alignment mode - 'global' or 'local' (default: 'global')
-            
-            **Returns:**
-            PairwiseAlignmentResponse containing:
-            - `score`: Alignment score
-            - `aligned_sequence1`: First sequence with gaps
-            - `aligned_sequence2`: Second sequence with gaps
-            - `full_alignment_str`: Complete alignment visualization
-            - `parameters_used`: Parameters used for the alignment
-            
-            **Example Usage:**
-            ```
-            perform_pairwise_alignment(
-                sequence1="GATTACA",
-                sequence2="GCATGCU",
-                match_score=2.0,
-                mismatch_penalty=-1.0,
-                mode="global"
-            )
-            ```
-            """)
-        def perform_pairwise_alignment(
-            sequence1: str,
-            sequence2: str,
-            match_score: float = 1.0,
-            mismatch_penalty: float = -1.0,
-            open_gap_penalty: float = -0.5,
-            extend_gap_penalty: float = -0.1,
-            mode: Literal["global", "local"] = "global"
-        ) -> PairwiseAlignmentResponse:
-            with start_action(action_type="perform_pairwise_alignment", 
-                            sequence1_length=len(sequence1), 
-                            sequence2_length=len(sequence2), 
-                            mode=mode) as action:
-                try:
-                    request = PairwiseAlignmentRequest(
-                        sequence1=sequence1,
-                        sequence2=sequence2,
-                        match_score=match_score,
-                        mismatch_penalty=mismatch_penalty,
-                        open_gap_penalty=open_gap_penalty,
-                        extend_gap_penalty=extend_gap_penalty,
-                        mode=mode
-                    )
-                    response = run_pairwise_alignment(request)
-                    action.add_success_fields(alignment_score=response.score)
-                    return response
-                except ValueError as ve:
-                    action.add_error_fields(error=str(ve))
-                    raise ValueError(str(ve)) from ve
-                except Exception as e:
-                    action.add_error_fields(error=f"Unexpected error during alignment: {str(e)}")
-                    raise ValueError(f"An unexpected error occurred during alignment: {str(e)}") from e
-        
-        @self.mcp_server.tool(
-            name=f"{self.prefix}perform_pairwise_alignment_local",
-            description="""Perform pairwise sequence alignment and save results to local file.
-            
-            Same as perform_pairwise_alignment but saves the alignment result to a local file instead of returning it.
-            This is useful for preserving alignment results for further analysis.
-            
-            **Parameters:**
-            - `sequence1` (str): First sequence for alignment
-            - `sequence2` (str): Second sequence for alignment
-            - `match_score` (float): Score for a match (default: 1.0)
-            - `mismatch_penalty` (float): Penalty for a mismatch (default: -1.0, should be negative or zero)
-            - `open_gap_penalty` (float): Penalty for opening a gap (default: -0.5, should be negative or zero)
-            - `extend_gap_penalty` (float): Penalty for extending a gap (default: -0.1, should be negative or zero)
-            - `mode` (str): Alignment mode - 'global' or 'local' (default: 'global')
-            - `output_path` (Optional[str]): Custom output path. If None, generates unique filename
-            
-            **Returns:**
-            LocalFileResult containing:
-            - `path`: Path to the saved alignment file
-            - `format`: File format used ('alignment')
-            - `success`: Whether the operation succeeded
-            - `error`: Error message if failed
-            
-            **Example Usage:**
-            ```
-            perform_pairwise_alignment_local(
-                sequence1="GATTACA",
-                sequence2="GCATGCU",
-                match_score=2.0,
-                mismatch_penalty=-1.0,
-                mode="global",
-                output_path="alignment_result.aln"
-            )
-            ```
-            """)
-        def perform_pairwise_alignment_local(
-            sequence1: str,
-            sequence2: str,
-            match_score: float = 1.0,
-            mismatch_penalty: float = -1.0,
-            open_gap_penalty: float = -0.5,
-            extend_gap_penalty: float = -0.1,
-            mode: Literal["global", "local"] = "global",
-            output_path: Optional[str] = None
-        ) -> LocalFileResult:
-            with start_action(action_type="perform_pairwise_alignment_local", 
-                            sequence1_length=len(sequence1), 
-                            sequence2_length=len(sequence2), 
-                            mode=mode) as action:
-                try:
-                    request = PairwiseAlignmentRequest(
-                        sequence1=sequence1,
-                        sequence2=sequence2,
-                        match_score=match_score,
-                        mismatch_penalty=mismatch_penalty,
-                        open_gap_penalty=open_gap_penalty,
-                        extend_gap_penalty=extend_gap_penalty,
-                        mode=mode
-                    )
-                    response = run_pairwise_alignment(request)
-                    
-                    # Create detailed alignment output
-                    alignment_content = f"""Pairwise Alignment Results
-=============================
-
-Parameters:
-- Match Score: {response.parameters_used['match_score']}
-- Mismatch Penalty: {response.parameters_used['mismatch_penalty']}
-- Open Gap Penalty: {response.parameters_used['open_gap_penalty']}
-- Extend Gap Penalty: {response.parameters_used['extend_gap_penalty']}
-- Mode: {response.parameters_used['mode']}
-
-Alignment Score: {response.score}
-
-Aligned Sequences:
-{response.full_alignment_str}
-
-Sequence 1 (aligned): {response.aligned_sequence1}
-Sequence 2 (aligned): {response.aligned_sequence2}
-"""
-                    
-                    result = self._save_to_local_file(
-                        data=alignment_content,
-                        format_type="alignment",
-                        output_path=output_path,
-                        default_prefix="pairwise_alignment"
-                    )
-                    action.add_success_fields(
-                        alignment_score=response.score,
-                        saved_to=result.get("path"),
-                        success=result.get("success")
-                    )
-                    return result
-                except ValueError as ve:
-                    action.add_error_fields(error=str(ve))
-                    return {
-                        "path": None,
-                        "format": "alignment",
-                        "success": False,
-                        "error": str(ve)
-                    }
-                except Exception as e:
-                    action.add_error_fields(error=f"Unexpected error during alignment: {str(e)}")
-                    return {
-                        "path": None,
-                        "format": "alignment",
-                        "success": False,
-                        "error": f"An unexpected error occurred during alignment: {str(e)}"
-                    }
-
-def run_pairwise_alignment(request: PairwiseAlignmentRequest) -> PairwiseAlignmentResponse:
-    """Run pairwise alignment using Biopython."""
-    aligner = PairwiseAligner()
-    aligner.match_score = request.match_score
-    aligner.mismatch_score = request.mismatch_penalty
-    aligner.open_gap_score = request.open_gap_penalty
-    aligner.extend_gap_score = request.extend_gap_penalty
-    aligner.mode = request.mode
-
-    seq1 = Seq(request.sequence1)
-    seq2 = Seq(request.sequence2)
-
-    alignments = list(aligner.align(seq1, seq2))
-
-    if not alignments:
-        raise ValueError("No alignment could be produced with the given sequences and parameters.")
-
-    best_alignment = alignments[0]
-    
-    aligned_seq1_str = str(best_alignment[0])
-    aligned_seq2_str = str(best_alignment[1])
-
-    return PairwiseAlignmentResponse(
-        score=best_alignment.score,
-        aligned_sequence1=aligned_seq1_str,
-        aligned_sequence2=aligned_seq2_str,
-        full_alignment_str=str(best_alignment),
-        parameters_used=request.model_dump()
-    )
+      
 
 def get_entrez(ids: List[str], db: DB_LITERAL, reftype: Literal["fasta", "gb"]) -> str:
     """