Spaces:
No application file
No application file
| # Copyright 2003 Iddo Friedberg. All rights reserved. | |
| # | |
| # This file is part of the Biopython distribution and governed by your | |
| # choice of the "Biopython License Agreement" or the "BSD 3-Clause License". | |
| # Please see the LICENSE file that should have been included as part of this | |
| # package. | |
| """A parser for the NCBI blastpgp version 2.2.5 output format. | |
| Currently only supports the '-m 9' option, (table w/ annotations). | |
| Returns a BlastTableRec instance | |
| """ | |
| import warnings | |
| from Bio import BiopythonDeprecationWarning | |
| warnings.warn( | |
| "Bio.Blast.ParseBlastTable.py has been deprecated, and will be removed " | |
| "in a future version of Biopython. To parse tabular output from BLAST " | |
| "programs, please use the Bio.Align module:\n" | |
| "\n" | |
| "from Bio import Align\n" | |
| "alignments = Align.parse('myblastoutputfile.txt', 'tabular')\n" | |
| "\n" | |
| "and iterate over the alignments.", | |
| BiopythonDeprecationWarning, | |
| ) | |
| class BlastTableEntry: | |
| """Container for Blast Table Entry, the field values from the table.""" | |
| def __init__(self, in_rec): | |
| """Initialize the class.""" | |
| bt_fields = in_rec.split() | |
| self.qid = bt_fields[0].split("|") | |
| self.sid = bt_fields[1].split("|") | |
| self.pid = float(bt_fields[2]) | |
| self.ali_len = int(bt_fields[3]) | |
| self.mis = int(bt_fields[4]) | |
| self.gaps = int(bt_fields[5]) | |
| self.q_bounds = (int(bt_fields[6]), int(bt_fields[7])) | |
| self.s_bounds = (int(bt_fields[8]), int(bt_fields[9])) | |
| self.e_value = float(bt_fields[10]) | |
| self.bit_score = float(bt_fields[11]) | |
| class BlastTableRec: | |
| """Container for Blast Table record, list of Blast Table Entries.""" | |
| def __init__(self): | |
| """Initialize the class.""" | |
| self.program = None | |
| self.version = None | |
| self.date = None | |
| self.iteration = None | |
| self.query = None | |
| self.database = None | |
| self.entries = [] | |
| def add_entry(self, entry): | |
| """Add entry to Blast Table.""" | |
| self.entries.append(entry) | |
| class BlastTableReader: | |
| """Reader for the output of blastpgp.""" | |
| reader_keywords = { | |
| "BLASTP": "version", | |
| "Iteration": "iteration", | |
| "Query": "query", | |
| "Database": "database", | |
| "Fields": "fields", | |
| } | |
| def __init__(self, handle): | |
| """Initialize the class.""" | |
| self.handle = handle | |
| inline = self.handle.readline() | |
| # zip forward to start of record | |
| while inline and "BLASTP" not in inline: | |
| inline = self.handle.readline() | |
| self._lookahead = inline | |
| self._n = 0 | |
| self._in_header = 1 | |
| def __next__(self): | |
| """Return the next record when iterating over the file.""" | |
| self.table_record = BlastTableRec() | |
| self._n += 1 | |
| inline = self._lookahead | |
| if not inline: | |
| return None | |
| while inline: | |
| if inline[0] == "#": | |
| if self._in_header: | |
| self._in_header = self._consume_header(inline) | |
| else: | |
| break | |
| else: | |
| self._consume_entry(inline) | |
| self._in_header = 0 | |
| inline = self.handle.readline() | |
| self._lookahead = inline | |
| self._in_header = 1 | |
| return self.table_record | |
| def _consume_entry(self, inline): | |
| current_entry = BlastTableEntry(inline) | |
| self.table_record.add_entry(current_entry) | |
| def _consume_header(self, inline): | |
| for keyword in self.reader_keywords: | |
| if keyword in inline: | |
| return self._Parse(f"_parse_{self.reader_keywords[keyword]}", inline) | |
| def _parse_version(self, inline): | |
| program, version, date = inline.split()[1:] | |
| self.table_record.program = program | |
| self.table_record.version = version | |
| self.table_record.date = date | |
| return 1 | |
| def _parse_iteration(self, inline): | |
| self.table_record.iteration = int(inline.split()[2]) | |
| return 1 | |
| def _parse_query(self, inline): | |
| self.table_record.query = inline.split()[2:] | |
| return 1 | |
| def _parse_database(self, inline): | |
| self.table_record.database = inline.split()[2] | |
| return 1 | |
| def _parse_fields(self, inline): | |
| return 0 | |
| def _Parse(self, method_name, inline): | |
| return getattr(self, method_name)(inline) | |