def get_search(): '''Returns the search query for string matching''' if not defaults.DEFAULTS['search_case_sensitive']: return re.compile(defaults.DEFAULTS['search_form'], re.I) else: return re.compile(defaults.DEFAULTS['search_form'])
def get_search(): '''Returns the search query for string matching''' if not defaults.DEFAULTS['search_case_sensitive']: return re.compile(defaults.DEFAULTS['search_form'], re.I) else: return re.compile(defaults.DEFAULTS['search_form'])
def __init__(self): super(UniProtServerIterator, self).__init__() self.downloader = uniprot.GeneDownloader() if self.escape_filter: self.regex = re.compile(re.escape(self.filter)) else: self.regex = re.compile(self.filter)
def __init__(self): super(UniProtServerIterator, self).__init__() self.downloader = uniprot.GeneDownloader() if self.escape_filter: self.regex = re.compile(re.escape(self.filter)) else: self.regex = re.compile(self.filter)
def fromengine(cls, engine, start=False, end=False): '''Compiles the start and end subs and initializes the class''' startsub = engine.defaults.start if start: startsub = re.compile(startsub) endsub = engine.defaults.end if end: endsub = re.compile(endsub) return cls(startsub, endsub)
def fromengine(cls, engine, start=False, end=False): '''Compiles the start and end subs and initializes the class''' startsub = engine.defaults.start if start: startsub = re.compile(startsub) endsub = engine.defaults.end if end: endsub = re.compile(endsub) return cls(startsub, endsub)
def __init__(self, source): super(ParsePDCsv, self).__init__(source) logger.Logging.info("Initializing ParsePDSqlite3....") self.engine = get_engine(self.data) residues = ''.join(chemical_defs.AMINOACIDS) nterm, cterm = map(self.engine.get, ['nterm', 'cterm']) self.mod_parser = re.compile(self._mod.format(residues, nterm, cterm))
class ParseCsv(base.MatchedPeptideBase): '''Processes data from matched scans to dictionary from a file object''' # REGEXP # ------ header = re.compile(HEADER) def __init__(self, row): super(ParseCsv, self).__init__(row) self.csv = csv_.CSVUtils(row) self.csv.process['modifications'] = self.getmodification self.modparser = modifications.ModificationParser(row) @logger.call('matched', 'debug') def __call__(self): ''' Finds search name from Protein Prospector output, finds dataframe and dumps to dictionary of lists, where the keys are columns and lists values. ''' self.setfileheader() header = self.row.engines['matched'].defaults.header - 1 while header: self.fileobj.readline() header -= 1 self.csv.set_reader(self.fileobj) self.csv() self.setids() # SETTERS def setfileheader(self): '''Grabs the search and project names from the header line.''' match = self.header.match(self.fileobj.readline()) self.row.data['attrs']['project'] = match.group(1).strip() self.row.data['attrs']['search'] = match.group(2).strip() # GETTERS def getmodification(self, unparsed): '''Returns the parsed modification from the unparsed string''' peptide = self.row.data['matched']['peptide'][-1] start = self.row.data['matched']['start'][-1] # parse the modification if isinstance(unparsed, list): unparsed = unparsed[0] modification = Modification(unparsed, peptide, start) self.modparser(modification) return modification.todict()
def __init__(self, fileobj, group, engine): super(ParseText, self).__init__() self.fileobj = fileobj self.group = group self.source = self.app.discovererthread self.scan_finder = scan_parser.ScanFinder.fromengine(engine) self._parser = getattr(self, PARSERS[engine.tostr()]) self.re_scan = re.compile(engine.defaults.regexp)
class ColumnsDict(dict): '''Custom __getitem__ that removes suffixes''' # REGEXES # ------- suffix = re.compile(r'^.* (?:[A-Z0-9])$') whitespace = re.compile(r'\s+') # MAGIC def __getitem__(self, key, dict_getitem=dict.__getitem__): '''CD[k] -> v''' key = self._keychecker(key) return dict_getitem(self, key) # HELPERS def _keychecker(self, item): '''Returns the suffix-less key''' if isinstance(item, six.string_types): return self._stringchecker(item) elif isinstance(item, (list, tuple)): return self._sequencechecker(item) def _stringchecker(self, item): '''Returns the suffix-less key from a string column''' if self.suffix.match(item): return item[:-2] return item def _sequencechecker(self, item): '''Returns the suffix-less key from a column sequence''' # comparative has null string columns in row 1, while quantitative # has null or isotope columns in row 0 string = [i for i in item if self.whitespace.sub("", i)][-1] if self.suffix.match(string): return string[:-2] return string
def __init__(self, row, group, fileobj): super(ParseFullms, self).__init__() self.row = row self.group = group self.fileobj = fileobj engine = row.engines['ms1'] self.extractor = scans.ChromatogramExtractor(row) self.scan_finder = scan_parser.ScanFinder.fromengine(engine, end=True) self._parser = getattr(self, PARSERS[engine.tostr()]) self.re_scan = re.compile(engine.defaults.regexp)
def __init__(self, row, group, fileobj): super(ParseFullms, self).__init__() self.row = row self.group = group self.fileobj = fileobj engine = row.engines['ms1'] self.extractor = scans.ChromatogramExtractor(row) self.scan_finder = scan_parser.ScanFinder.fromengine(engine, end=True) self._parser = getattr(self, PARSERS[engine.tostr()]) self.re_scan = re.compile(engine.defaults.regexp)
# LICENSE=Licensed to: --- # MP= # NM= # COM=10ftmol BSA # IATOL= # IA2TOL= # IASTOL= # IBTOL= # IB2TOL= # IBSTOL= # IYTOL= # IY2TOL= # REGEXP # ------ CONSTANT_RESIDUES = re.compile(r'C_term|N_term|[A-Z]') FIXEDMOD = re.compile(r'^FixedMod\d*$') FIXMOD_RESIDUES = re.compile(r'^FixedModResidues\d*$') # CONSTANTS # --------- TERMINI = {'C_term': 'cterm', 'N_term': 'nterm'} # HELPERS # ------- @logger.init('matched', 'DEBUG') class Hits(base.BaseObject): '''Convenience class to facilitate adding Mascot search hits to a scan''' def __init__(self, modifications, queries):
class MSFParser(SQLiteUtils): ''' Provides convenient methods to parse the MSF file format, which is a simple, readable SQLITE3 format. ''' _fraction = None _path_sep = re.compile(r'\\|/') def __init__(self, parent): super(MSFParser, self).__init__() self.data = parent.data self.engine = get_engine(self.data) self.source = parent.source self.fragments = parent.fragments self.database = sqlite3.connect(parent.fileobj.name) self.cursor = self.database.cursor() self.peptide_to_spectrum = {} self.peptides = mapping.OrderedRecursiveDict() self.proteins = {} # all mods are defined internally within the file mods = ProteomeDiscovererMods(self.cursor, self.engine) # need to convert to the namedtuple format params.tupleize(mods) self.mod_ids = mods.ids self.engine['mods'].update(mods) def run(self): '''On start''' self.init_spectrum() self.fetch_enzyme() self.set_file() self.add_spectrum() self.add_scores() self.add_mods() self.add_ppms() self.set_proteins() self.add_proteins() # ------------------ # MAIN # ------------------ def init_spectrum(self): '''Sets the peptides with a SpectrumID as a key reference''' columns = "PeptideID, SpectrumID, Sequence, SearchEngineRank" self.cursor.execute("SELECT {} FROM Peptides;".format(columns)) # Spectrum ID is the unique spectral identifier # Peptide ID is the unique peptide identifier # Sequence is the peptide sequence, ex: "KATNE" for peptide_id, spectrum_id, sequence, rank in self.cursor: self.peptide_to_spectrum[peptide_id] = spectrum_id entry = self.peptides[spectrum_id][peptide_id] entry['peptide'] = sequence entry['rank'] = rank def fetch_enzyme(self): '''Extracts the proteolytic enzyme for the peptide search''' columns = "ParameterName, ParameterValue" table = "ProcessingNodeParameters" items = {k: v for k, v in self.fetch("fetchall", columns, table)} try: self.data['enzyme'] = items['Enzyme'] except KeyError: # no enzyme defined pass def set_file(self): '''Sets the current file name uses from the RAW file''' files = self.fetch("fetchall", "FileName", "FileInfos") # joins consecutive file names together, FileInfos should be 1 # use regex path splitter, since Windows path mappings don't work # on Linux or OS X. files = (self._path_sep.split(i[0])[-1] for i in files) self._fraction = ' - '.join(files) for entry in self.peptides.values(): entry['fraction'] = self._fraction def add_spectrum(self): '''Adds the spectral data, which includes the m/zs and charge states''' columns = "SpectrumID, ScanNumbers, Charge, Mass" self.cursor.execute("SELECT {} FROM SpectrumHeaders;".format(columns)) # Spectrum ID is the unique spectral identifier # num is the scan number associated with the spectral ID # charge is the charge state of the peptide # mass is the singly-charged mass of the peptide for spectrum_id, num, charge, mass in self.cursor: # peptide_ids = self.spectrum[spectrum_id] self.peptides[spectrum_id]['num'] = num self.peptides[spectrum_id]['z'] = charge # mz = masstools.mz(mass - params.PROTON_MASS, charge, 0) self.peptides[spectrum_id]['m/z'] = mz def add_scores(self): ''' Adds the score and calculates the EV from the score : score == -10*log(ev, 10) ''' columns = "PeptideID, ScoreValue" self.cursor.execute("SELECT {} FROM PeptideScores;".format(columns)) # Peptide ID is the unique peptide identifier, which # is for each peptide hit from the spectral ID # Score is the - 10 * log(p-value, 10) for peptide_id, score in self.cursor: expect = 10**(-score / 10) spectrum_id = self.peptide_to_spectrum[peptide_id] entry = self.peptides[spectrum_id][peptide_id] entry['score'] = score # need to calculate the p-value, or expectation value entry['ev'] = expect def add_mods(self): '''Finds all the target mods from the IDs and adds them to a holder''' self._mod_templates() self._internal_mods() self._terminal_mods() def add_ppms(self): '''Calculates the PPMs from the mods and peptides for each entry''' keys = ['peptide', 'm/z', 'z'] for peptide_id, spectrum_id in self.peptide_to_spectrum.items(): entry = self.peptides[spectrum_id] hit = entry[peptide_id] mod = hit['mods'] peptide, exper, charge = map(entry.get, keys) hit['formula'] = formula = self.calculate_formula(peptide, mod) hit['ppm'] = self.calculate_ppm(formula, mod, exper, charge) def set_proteins(self): '''Creates a {ProteinID: (UniProt ID: Protein Name)} holder''' columns = 'ProteinID, Description' table = "ProteinAnnotations" self.cursor.execute("SELECT {0} FROM {1};".format(columns, table)) for protein_id, description in self.cursor: # description == '>sp|P62894|CYC_BOVIN Cytochrome ...' id_, name = description.split('|')[1:] self.proteins[protein_id] = (id_, name) def add_proteins(self): '''Adds the protein names and IDs to each entry''' columns = "PeptideID, ProteinID" self.cursor.execute("SELECT {} FROM PeptidesProteins;".format(columns)) for peptide_id, protein_id in self.cursor: spectrum_id = self.peptide_to_spectrum[peptide_id] entry = self.peptides[spectrum_id][peptide_id] id_, name = self.proteins[protein_id] entry['id'] = id_ entry['name'] = name # ------------------ # UTILS # ------------------ # MODS def _internal_mods(self): '''Adds all the internal modifications to the mod holders''' columns = "PeptideID, AminoAcidModificationID, Position" table = "PeptidesAminoAcidModifications" self.cursor.execute("SELECT {} FROM {};".format(columns, table)) for peptide_id, mod_id, position in self.cursor: spectrum_id = self.peptide_to_spectrum.get(peptide_id) modname = self.mod_ids[mod_id] # for some weird reason, the mods can have peptide IDs which don't # exist otherwise, causing errors. Not decoys, nothing. if spectrum_id is not None: mods = self.peptides[spectrum_id][peptide_id]['mods'] mods['certain'].setdefault(modname, []) mods['certain'][modname].append(position) def _terminal_mods(self): '''Adds all the N-/C-terminal modifications to the mod holders''' columns = "PeptideID, TerminalModificationID" table = "PeptidesTerminalModifications" self.cursor.execute("SELECT {} FROM {};".format(columns, table)) for peptide_id, mod_id in self.cursor: spectrum_id = self.peptide_to_spectrum.get(peptide_id) # for some weird reason, the mods can have peptide IDs which don't # exist otherwise, causing errors. Not decoys, nothing. if spectrum_id is not None: mods = self.peptides[spectrum_id][peptide_id]['mods'] modname = self.mod_ids[mod_id] mods['certain'].setdefault(modname, []) if self.engine['nterm'] in self.engine['mods'][modname][1]: mods['certain'][modname].append(self.engine['nterm']) else: mods['certain'][modname].append(self.engine['cterm']) def _mod_templates(self): '''Sets the mod template holders for each peptide ID''' template = params.TEMPLATES['mods'] for peptide_id, spectrum_id in self.peptide_to_spectrum.items(): hit = self.peptides[spectrum_id][peptide_id] hit.setdefault('mods', copy.deepcopy(template))
# CONSTANTS # --------- REPLACE = '[REPLACE]' SKYLINE = r'\[CROSSLINKER(\+-?[0-9]+\.[0-9])?\]' CROSSLINKER_POSITIVE = '[CROSSLINKER+{0}]' CROSSLINKER_NEGATIVE = '[CROSSLINKER{0}]' CROSSLINKER = '[CROSSLINKER]' SKYLINE_POSITIVE = '[+{0}]' SKYLINE_NEGATIVE = '[-{0}]' # REGEXES # ------- PARENTHESES = re.compile(r'\(|\)') LETTERS = re.compile('([A-Z]{2})') MASS_MODIFICATION = re.compile(r'(\[(?:\+|-)([0-9]*\.?[0-9]?)\])') # HELPERS # ------- def mappedresidues(deadends): '''Maps the CSV residue keys as values to each individual residue''' mapped = defaultdict(list) for key in deadends: for residue in key.split(','): mapped[residue].append(key)
class PeptideDatabase(PeptideDBSettings, CutSites, AddMods, HDF5Utils): ''' Creates a custom peptide database with various settings from 1- max crosslinker modifications for each permutation, and the number of mods up to the max (with XL mods) defined by the search. ''' db_modes = {True: {'standard', 'decoy'}, False: {'standard'}} peptides = None searchables = None mods_length = None modifications_dtype = None mod_ids = None _mode = None id_regex = re.compile(uniprot.SERVER['id']['regex'], re.IGNORECASE) entry_regex = re.compile(uniprot.SERVER['entry']['regex'], re.IGNORECASE) def __init__(self, grp, xler, source): super(PeptideDatabase, self).__init__() self.grp = grp self.xler = xler self.source = source self.mods = params.CUSTOM_MODS self.react = set(self.xler['react_sites']) # default to true, newly set value self.uncleaved = self.xler.get("uncleaved", True) self.fragment_masses = self.get_fragment_masses() self.basemods = self.organize_basemods() self._set_mod_ids() self.sequences = self._get_sequences() self.decoy = params.MASS_FINGERPRINT['search_decoys'] self._peptide_holders() self.run() def run(self): '''On start''' self._mode = 'standard' self.add_ids() self.make_searchables() if self.decoy: self._mode = 'decoy' self.make_searchables() for key in {'base_peptides', 'peptides'}: del self.grp[key] self.linearize() # ------------------ # PUBLIC # ------------------ def add_ids(self): '''Adds a way to map the sequence ids to the current holder''' ids = [i.encode('utf-8') for i in self.sequences] self.grp.attrs.create('protein_ids', data=ids) names = [i.name.encode('utf-8') for i in self.sequences.values()] self.grp.attrs.create('protein_names', data=names) def make_searchables(self): '''On start''' self.cut_sequences() self.add_mods() # ------------------ # PRIVATE -- INIT # ------------------ def _get_sequences(self): '''Updates sequence dictionary with entries from the limited db''' sequences = {} limited_db = self.source.limited_database for id_ in limited_db: if id_ in self.source.custom_proteins: sequences[id_] = self.source.custom_proteins[id_] elif id_ in self.source.gene_name: sequences[id_] = self.source.gene_name[id_] return sequences def _peptide_holders(self): '''Adds peptide holders for later stimulated cutting''' for key in {'base_peptides', 'decoy', 'standard'}: self.grp.create_group(key) peptides = self.grp.create_group('peptides') db_keys = self.db_modes[self.decoy] for key in db_keys: for missed_cleavages in range(self.max_missed + 1): peptides.create_group('{}/{}'.format(key, missed_cleavages)) # temporary, fast data holder for in memory searchables self.searchables = {} for key in db_keys: self.searchables[key] = defaultdict(list) def _set_mod_ids(self): ''' Assigns unique mod ids for each modification and stores a copy in the dataset. ''' names = [i[0] for item in self.basemods.values() for i in item] names += self.xler['fragments']['name'] # grabs the number of places required to store data self.mods_length = (len(names) // 10) + 1 # +2 for n and c-term max_mods = self.mods_length * self.max_length + 2 self.modifications_dtype = 'S{}'.format(max_mods) self.mod_ids = {} for index, name in enumerate(names): self.mod_ids[name] = index # store as attrs to unpack later self.grp.attrs.create('modification_ids', data=range(len(names))) bin_names = [i.encode('utf-8') for i in names] self.grp.attrs.create('modification', data=bin_names)
# MP= # NM= # COM=10ftmol BSA # IATOL= # IA2TOL= # IASTOL= # IBTOL= # IB2TOL= # IBSTOL= # IYTOL= # IY2TOL= # REGEXP # ------ CONSTANT_RESIDUES = re.compile(r'C_term|N_term|[A-Z]') FIXEDMOD = re.compile(r'^FixedMod\d*$') FIXMOD_RESIDUES = re.compile(r'^FixedModResidues\d*$') # CONSTANTS # --------- TERMINI = { 'C_term': 'cterm', 'N_term': 'nterm' } # HELPERS # -------
''' # load modules from xldlib import exception from xldlib.definitions import re, ZIP from xldlib.objects import matched from xldlib.qt.objects import base from xldlib.utils import logger from . import hierarchical # REGEXES # ------- NUMBER = re.compile(r'-?[0-9]*\.?[0-9]+') # HELPERS # ------- @logger.init('matched', 'DEBUG') class CheckTermini(base.BaseObject): '''Helper class which identifies false modification termini''' def __init__(self, engine): super(CheckTermini, self).__init__() self.nterm = engine.defaults.nterm self.engine_modifications = engine.defaults.modifications
from xldlib.definitions import re # load objects/functions from collections import defaultdict # CONSTANTS # --------- HEADER_CHARACTERS = 3 # REGEXP # ------ FIRST_CAP = re.compile('(.)([A-Z][a-z]+)') ALL_CAP = re.compile('([a-z0-9])([A-Z])') # REGISTER # -------- # Item register to avoid malicious, external script execution REGISTER = defaultdict(set) NAME_REGISTER = {} # DATA #---- BUILTINS = {
(comparable to BioPython). :copyright: (c) 2015 The Regents of the University of California. :license: GNU GPL, see licenses/GNU GPLv3.txt for more details. ''' # load modules from xldlib import exception from xldlib.definitions import re from xldlib.utils import logger from xldlib.utils.io_ import high_level, ziptools # REGEXP # ------ ISOFORM = re.compile(r'^(.*)\.\d$') HYPHEN = re.compile(r'-') ASTERIX = re.compile(r'\*') # OBJECTS # ------- class FastaParserMixin(object): ''' Mixin to provide methods to parse FASTA records using specific identifiers. ''' # NON-PUBLIC
Processing Mascot modnames depending on the UniMod specification. :copyright: (c) 2015 The Regents of the University of California. :license: GNU GPL, see licenses/GNU GPLv3.txt for more details. ''' # load modules/submodules from xldlib import resources from xldlib.definitions import re from xldlib.qt.objects import base # REGEXES # ------- PARSERS = [re.compile(i.regexp) for i in resources.SCAN_TITLES] # MATCHER # ------- class TitleFormatter(base.BaseObject): ''' Identify the scan title format based on regex matches, otherwise raise an `AssertionError`. After identifying the title format, use the title formatter to extract the scan number from scan filters. ''' def __init__(self): super(TitleFormatter, self).__init__()
class ChemicalParserMixin(object): '''Mixin for parsing chemical formulas and updating a mapping object''' # REGEX # ----- chemical = re.compile(r'^{}$'.format(CHEMICAL)) monomer = re.compile(r'^{}$'.format(MONOMER)) atom = re.compile(r'[A-Z][a-z]?') # PUBLIC def update_chemical(self, formula, count): ''' Update atomic counts from a string or mapping `formula`, and multiple by `count`. Args: formula (string, mapping): chemical or glycan formula count (int): scalar for elemental counts ''' if isinstance(formula, Mapping): self._update_mapping(formula, count) elif isinstance(formula, six.string_types): self._update_str(formula, count) # NON-PUBLIC def _update_mapping(self, formula, count): ''' Update the elemental counts from a mapping `formula` multiplied by a scalar `count`. See `update_chemical` for full arg specs. ''' for symbol, isotopes in formula.items(): for isotope, number in isotopes.items(): self[symbol][isotope] += number * count def _update_str(self, formula, count): ''' Update the elemental counts from a str `formula` multiplied by a scalar `count`. See `update_chemical` for full arg specs. ''' for item in formula.split(): for symbol, isotope, number in self._parse(item): self[symbol][isotope] += number * count def _parse(self, item): ''' Extract atomic symbol, isotope, and atomic counts from the `item` string. Args: item (str): str in format of "13C6", "13C(6)", "Hex", "C6" ''' match = self.chemical.match(item) if match: return [self._parse_element(match)] else: return self._parse_monomer(self.monomer.match(item)) def _parse_element(self, match): '''Extract elemental data from re `match` group''' isotope, symbol, free, parentheses = match.groups() assert self._symbolchecker(symbol) isotope = int(isotope or -1) count = _element_count(free, parentheses) return symbol, isotope, count def _parse_monomer(self, match): '''Extract glycan monomer data from re `match` group''' monomer, free, parentheses = match.groups() count = _element_count(free, parentheses) formula = MONOMERS[monomer] for item in formula.split(): match = self.chemical.match(item) symbol, isotope, number = self._parse_element(match) yield symbol, isotope, number * count # HELPERS def _symbolchecker(self, symbol): '''Check validity of atomic `symbol`''' return self.atom.match(symbol)
def getproteinmods(self, modification, start): '''Gets the protein mods from the manually specified data''' if defaults.DEFAULTS['concatenate_hybrid_modifications']: modification = modification.concatenate() positions = list(self.getcertain(modification, start)) if modification['uncertain']: positions.append(self.getuncertain(modification, start)) return positions # REGEXP # ------ LETTERS = re.compile('([A-Z]{2})') PARENTHESES = re.compile(r'(\))') # STRINGS # ------- TERMINUS = '{0}-{1}' INTERNAL = '{0}({1}){2}' # PEPTIDE-EMBEDDED MODIFICATIONS # ------------------------------ @logger.init('spreadsheet', 'DEBUG') class ModificationsInPeptide(base.BaseObject): '''Adds the given user mods to the target peptide sequence'''
from xldlib.utils import decorators, logger, xictools __all__ = [ 'Amplitudes', 'Dataframe', 'HierarchicalDataframe', 'QuantitativeDataframe' ] # CONSTANTS # --------- LOWER_SIGMA = u'\u03C3' UPPER_SIGMA = u'\u03A3' # REGEXES # ------- NONQUANTIFIED = re.compile(u'<|>|-|{}'.format(xictools.INFINITY), re.UNICODE) # DATA # ---- CONCATENATED = { 'report', 'best_peptide', 'best_peptide_file', } POLYPEPTIDE = { reports.LINKTYPES['interlink'], reports.LINKTYPES['multilink'], }
Processing Mascot modnames depending on the UniMod specification. :copyright: (c) 2015 The Regents of the University of California. :license: GNU GPL, see licenses/GNU GPLv3.txt for more details. ''' # load modules/submodules from xldlib import resources from xldlib.definitions import re from xldlib.qt.objects import base # REGEXES # ------- PARSERS = [re.compile(i.regexp) for i in resources.SCAN_TITLES] # MATCHER # ------- class TitleFormatter(base.BaseObject): ''' Identify the scan title format based on regex matches, otherwise raise an `AssertionError`. After identifying the title format, use the title formatter to extract the scan number from scan filters. ''' def __init__(self):
from xldlib.definitions import re, ZIP from xldlib.qt.objects import base from xldlib.resources.parameters import defaults from xldlib.utils import decorators, logger from xldlib.xlpy.tools import peak_picking # load objects/functions from collections import namedtuple # OBJECTS # ------- BinaryData = namedtuple("BinaryData", "data precision compression") # REGEXP # ------ MZML_SCAN = re.compile(r'scan=([0-9]+)') # HELPERS # ------- @logger.init('scans', level='DEBUG') class Start(base.BaseObject): '''Utilities for processing data from XML start elements''' def __init__(self, group): super(Start, self).__init__() self.group = group self.source = self.app.discovererthread def spectrum(self, attrs):
class ScientificSpinBox(DoubleSpinBox): ''' Recipe for a QDoubleSpinBox with support for floating point numbers in scientific notation. ''' # VALIDATION # ---------- float_regex = re.compile(SCIENTIFIC) precision = 1 def __init__(self, parent=None, **kwds): super(ScientificSpinBox, self).__init__(parent, **kwds) self.validator = QtGui.QDoubleValidator() self.validator.setNotation(QtGui.QDoubleValidator.ScientificNotation) self._string = '{{:0.{num}e}}'.format(num=self.precision) self.formatter = self._string.format # PUBLIC FUNCTIONS def validate(self, text, position): return self.validator.validate(text, position) def fixup(self, text): return self.tostr(self.tofloat(text)) def valueFromText(self, text): return self.tofloat(text) def textFromValue(self, value): return self.tostr(value) def stepBy(self, steps): value = self.value() + steps * self.singleStep() self.lineEdit().setText(self.formatter(value)) # HELPERS def tofloat(self, text, default=0.): '''Returns a floating-point representation from text''' match = self.float_regex.match(text) if match is not None: return self.frommatch(match) return default def tostr(self, value): return self.formatter(value) @staticmethod def frommatch(match): '''Converts a match group to a floating point representation''' sig, sign, exp = match.groups() if sign is None: sign = '+' if exp is None: exp = '0' return float(sig) * (10**int(sign + exp))
'ID_REGEX', 'MNEMONIC_REGEX' ] # CONSTANTS # --------- ID = (r'[OPQ][0-9][A-Z0-9]{3}[0-9]|[A-NR-Z][0-9]' r'([A-Z][A-Z0-9]{2}[0-9]){1,2}') MNEMONIC = r'[a-zA-Z0-9]{1,5}_[a-zA-Z0-9]{1,5}' # REGEXP # ------ ID_REGEX = re.compile(ID, re.IGNORECASE) MNEMONIC_REGEX = re.compile(MNEMONIC, re.IGNORECASE) GIT_SERVER = { 'domain': { 'repos': 'repos', 'tags': ['tags'], 'releases': ['releases'], 'assets': ['releases', 'assets'], 'owner': 'Alexhuszagh', 'repo': 'xlDiscoverer' }, 'protocol': 'https', 'scheme': '://', 'host': 'api.github.com',
from xldlib.resources.parameters import defaults from xldlib.utils import decorators, logger from xldlib.xlpy.tools import peak_picking # load objects/functions from collections import namedtuple # OBJECTS # ------- BinaryData = namedtuple("BinaryData", "data precision compression") # REGEXP # ------ MZML_SCAN = re.compile(r'scan=([0-9]+)') # HELPERS # ------- @logger.init('scans', level='DEBUG') class Start(base.BaseObject): '''Utilities for processing data from XML start elements''' def __init__(self, group): super(Start, self).__init__() self.group = group self.source = self.app.discovererthread
class ProteomeDiscovererMods(mapping.MethodlessCopyDict, SQLiteUtils): ''' Processes the SQLITE3 mod objects to produce a mod dictionary : 3 SQLITE3 tables -> {modname: formula: res_csv} ''' _attrs = { 'identifiers': ("AminoAcidModificationID, AminoAcidID", "AminoAcidModificationsAminoAcids"), 'mods': ("AminoAcidModificationID, ModificationName, " "Abbreviation, Substitution, LeavingGroup", "AminoAcidModifications"), 'aminoacids': ("AminoAcidID, AminoAcidName, OneLetterCode", "AminoAcids"), } formula = re.compile(r'\(|\)') def __init__(self, cursor, engine): super(ProteomeDiscovererMods, self).__init__() self.cursor = cursor self.engine = engine self._terms = {self.engine['nterm'], self.engine['cterm']} for attr, (column, table) in self._attrs.items(): setattr(self, attr, self.fetch("fetchall", column, table)) self.aminoacids = {i[0]: i[1:] for i in self.aminoacids} self.mods = {i[0]: i[1:] for i in self.mods} self.ids = {} self.add_standard() self.add_terminal() self.process_residues() # ------------------ # MAIN # ------------------ def add_standard(self): '''Adds the standard mods which do not have a "terminal" ID''' for mod_id, aminoacid_id in self.identifiers: modname, abbrev, string_formula, leaving_group = self.mods[mod_id] if 'Mascot' in modname: continue self.ids[mod_id] = modname formula = self._get_formula(string_formula, modname, leaving_group) if formula is None: continue holder = [formula, set()] self.setdefault(modname, holder) self.setdefault(abbrev, holder) residue = self._get_residue(aminoacid_id) self[modname][1].add(residue) def add_terminal(self): '''Adds the mods which are terminal only''' standard_ids = set(i[0] for i in self.identifiers) terminal_ids = set(self.mods).difference(standard_ids) for mod_id in terminal_ids: modname, abbrev = self.mods[mod_id][0:2] self.ids[mod_id] = modname self.setdefault(modname, TERMINAL_MODS[modname]) self.setdefault(abbrev, TERMINAL_MODS[modname]) def process_residues(self): '''Processes the residues from a set to the CSV format''' # memoize to avoid double processing the same holder from the # modname and the abbrev memo = set() for values in self.values(): id_ = id(values) if id_ not in memo: residues = ','.join(sorted(values[1])) values[1] = residues memo.add(id_) # ------------------ # UTILS # ------------------ def _get_formula(self, string_formula, modname, leaving_group): ''' Produces the net mod formula, with the addition or overall formula defined by string_formula and the loss by the leaving_group. If no formula is defined or is a monomer formula (not chemical), an AssertionError or AttributeError is defined and the formula is attempted to be solved via .mods.MONOMERS. ''' try: assert string_formula string_formula = self.formula.sub('', string_formula) formula = chemical.Molecule(string_formula) formula.update_formula(leaving_group, count=-1) formula = formula.tostr() except (AssertionError, AttributeError): formula = MONOMERS.get(modname) if formula is None: print(exception.CODES['024'].format(modname), file=sys.stderr) return formula def _get_residue(self, aminoacid_id): '''Returns the residue name based on whether N-/C-term or internal''' aminoacid_name, one_letter = self.aminoacids[aminoacid_id] if aminoacid_name in self._terms: residue = aminoacid_name else: residue = one_letter return residue
'HierarchicalDataframe', 'QuantitativeDataframe' ] # CONSTANTS # --------- LOWER_SIGMA = u'\u03C3' UPPER_SIGMA = u'\u03A3' # REGEXES # ------- NONQUANTIFIED = re.compile(u'<|>|-|{}'.format(xictools.INFINITY), re.UNICODE) # DATA # ---- CONCATENATED = { 'report', 'best_peptide', 'best_peptide_file', } POLYPEPTIDE = { reports.LINKTYPES['interlink'], reports.LINKTYPES['multilink'], }
def __init__(self, enzyme=None): super(ProteolyticEnzyme, self).__init__() self.enzyme = self._enzymechecker(enzyme) self.cut_regex = re.compile(self.enzyme.cut_regex)
Solution: Same as above, only with 'D,E' rather than 'K' ''' # load modules from xldlib import exception from xldlib.definitions import re, ZIP from xldlib.objects import matched from xldlib.qt.objects import base from xldlib.utils import logger from . import hierarchical # REGEXES # ------- NUMBER = re.compile(r'-?[0-9]*\.?[0-9]+') # HELPERS # ------- @logger.init('matched', 'DEBUG') class CheckTermini(base.BaseObject): '''Helper class which identifies false modification termini''' def __init__(self, engine): super(CheckTermini, self).__init__() self.nterm = engine.defaults.nterm self.engine_modifications = engine.defaults.modifications source = self.app.discovererthread
'bzip2', 'gz', 'hdf5', 'mime', 'pkzip', 'raw', 'seek_start', 'sqlite', 'tar', 'xml', ] # REGEX # ----- XML_DECLARATION = re.compile(r'<\?xml version="\d\.\d" encoding=".+"\?>\r?\n') XML_FORMAT = re.compile(r'^\s*<\w+ xmlns=') MIME_DELARATION = re.compile('MIME-Version: .+') # HELPERS # ------- @contextlib.contextmanager def seek_start(fileobj): ''' Context manager which seeks the fileobj start, yields the fileobj, and then re-seeks the object start to allow sequential reads for file-format determination to leave the fileobj start position unchanged.
from xldlib.definitions import re, ZIP from xldlib.qt.objects import base from xldlib.resources.parameters import defaults from xldlib.utils import decorators, logger from xldlib.xlpy.tools import peak_picking # OBJECTS # ------- BinaryData = namedtuple("BinaryData", "data precision compression byteorder") # REGEXP # ------ MZXML_RT = re.compile(r'^PT((\d*\.?\d*)M)?((\d*\.?\d*)S)?$') # HELPERS # ------- @logger.init('scans', level='DEBUG') class Start(base.BaseObject): '''Utilities for processing data from XML start elements''' def __init__(self, group): super(Start, self).__init__() self.source = self.app.discovererthread
# load modules/submodules from xldlib.definitions import re __all__ = ['GIT_SERVER', 'ID_REGEX', 'MNEMONIC_REGEX'] # CONSTANTS # --------- ID = (r'[OPQ][0-9][A-Z0-9]{3}[0-9]|[A-NR-Z][0-9]' r'([A-Z][A-Z0-9]{2}[0-9]){1,2}') MNEMONIC = r'[a-zA-Z0-9]{1,5}_[a-zA-Z0-9]{1,5}' # REGEXP # ------ ID_REGEX = re.compile(ID, re.IGNORECASE) MNEMONIC_REGEX = re.compile(MNEMONIC, re.IGNORECASE) GIT_SERVER = { 'domain': { 'repos': 'repos', 'tags': ['tags'], 'releases': ['releases'], 'assets': ['releases', 'assets'], 'owner': 'Alexhuszagh', 'repo': 'xlDiscoverer' }, 'protocol': 'https', 'scheme': '://', 'host': 'api.github.com', 'path': '/',