spec2function 0.1.1__py3-none-any.whl

Spec2Function/pubmed.py

@@ -0,0 +1,251 @@
+# -*- coding: utf-8 -*-
+"""
+PubMed literature search for Spec2Function
+"""
+from Bio import Entrez
+from typing import List, Dict
+import time
+
+
+class PubMedSearcher:
+    """PubMed literature search helper."""
+
+    def __init__(self, email: str = "your_email@example.com"):
+        """
+        Args:
+            email: Your email address (required by PubMed API).
+        """
+        Entrez.email = email
+
+    def search_by_metabolites(self, metabolite_names: List[str], 
+                            max_results: int = 5) -> List[Dict]:
+        """
+        Search by multiple metabolite names (combined query).
+        Use OR to join keywords rather than full phrases.
+        """
+        # Clean metabolite names
+        clean_names = [self._clean_metabolite_name(name) for name in metabolite_names[:3]]
+
+        # Extract keywords by splitting on whitespace
+        keywords = []
+        for name in clean_names:
+            words = name.split()
+            keywords.extend(words)
+
+        # Deduplicate and limit count (avoid overly long queries)
+        keywords = list(dict.fromkeys(keywords))[:6]
+
+        if not keywords:
+            print("Warning: No valid keywords extracted")
+            return []
+
+        # Build query with OR
+        query = ' OR '.join([f'"{kw}"[Title/Abstract]' for kw in keywords])
+
+        print(f"  Keywords: {keywords}")
+        print(f"PubMed query: {query}")
+
+        try:
+            handle = Entrez.esearch(
+                db="pubmed", 
+                term=query, 
+                retmax=max_results, 
+                sort="relevance"
+            )
+            record = Entrez.read(handle)
+            handle.close()
+
+            id_list = record.get("IdList", [])
+            print(f"Found {len(id_list)} papers")
+
+            if not id_list:
+                return []
+
+            # Fetch details
+            time.sleep(0.5)
+            handle = Entrez.efetch(db="pubmed", id=id_list, retmode="xml")
+            records = Entrez.read(handle)
+            handle.close()
+
+            papers = []
+            for i, article in enumerate(records.get('PubmedArticle', [])):
+                try:
+                    medline = article['MedlineCitation']
+                    article_data = medline['Article']
+
+                    title = article_data.get('ArticleTitle', 'No title')
+
+                    pub_date = article_data['Journal']['JournalIssue']['PubDate']
+                    year = pub_date.get('Year', pub_date.get('MedlineDate', 'Unknown'))
+                    try:
+                        year = int(str(year)[:4])
+                    except:
+                        year = 2023
+
+                    authors = []
+                    if 'AuthorList' in article_data:
+                        for author in article_data['AuthorList'][:3]:
+                            if 'LastName' in author:
+                                authors.append(author['LastName'])
+                    authors_str = ', '.join(authors)
+                    if len(article_data.get('AuthorList', [])) > 3:
+                        authors_str += ' et al.'
+
+                    journal = article_data['Journal'].get('Title', 'Unknown journal')
+
+                    abstract = ''
+                    if 'Abstract' in article_data:
+                        abstract_texts = article_data['Abstract'].get('AbstractText', [])
+                        if abstract_texts:
+                            if isinstance(abstract_texts, list):
+                                abstract = ' '.join(str(text) for text in abstract_texts)
+                            else:
+                                abstract = str(abstract_texts)
+
+                    pmid = str(medline['PMID'])
+                    relevance = 90 - i * 3
+
+                    papers.append({
+                        'pmid': pmid,
+                        'title': title,
+                        'year': year,
+                        'authors': authors_str,
+                        'journal': journal,
+                        'abstract': abstract,
+                        'relevance': relevance
+                    })
+
+                except Exception as e:
+                    print(f"Warning: Error parsing article: {e}")
+                    continue
+
+            return papers
+
+        except Exception as e:
+            print(f"PubMed search error: {e}")
+            return []
+
+    def _clean_metabolite_name(self, name: str) -> str:
+        """Clean metabolite names and remove noisy tokens."""
+        import re
+
+        # Remove stereochemical markers like (R)-, (S)-, (E)-, (Z)-, (+)-, (-)-
+        name = re.sub(r'\([RSZE+\-]\)-', '', name)
+
+        # Remove numeric prefixes like 1,1,2-
+        name = re.sub(r'^\d+,[\d,]+-', '', name)
+
+        # Collapse extra whitespace
+        name = ' '.join(name.split())
+
+        return name.strip()
+
+    def search_by_metabolite(self, metabolite_name: str, 
+                            max_results: int = 5) -> List[Dict]:
+        """Search PubMed by a single metabolite name."""
+
+        # 1. Clean the metabolite name
+        clean_name = self._clean_metabolite_name(metabolite_name)
+
+        # 2. Try multiple query strategies
+        queries = [
+            f'"{clean_name}"[Title/Abstract]',  # exact match
+            f'{clean_name}[Title/Abstract]',     # loose match
+            f'{clean_name}',                      # broadest
+        ]
+
+        for i, query in enumerate(queries):
+            print(f"Try #{i+1}: {query}")
+
+            try:
+                handle = Entrez.esearch(
+                    db="pubmed", 
+                    term=query, 
+                    retmax=max_results, 
+                    sort="relevance"
+                )
+                record = Entrez.read(handle)
+                handle.close()
+
+                id_list = record.get("IdList", [])
+                print(f"  Found {len(id_list)} results")
+
+                if id_list:  # Return on first hit
+                    return self._fetch_paper_details(id_list)
+
+            except Exception as e:
+                print(f"  Query failed: {e}")
+                continue
+
+        print(f"Warning: No papers found for: {metabolite_name}")
+        return []
+
+    def _fetch_paper_details(self, id_list: List[str]) -> List[Dict]:
+        """Fetch detailed article info for a list of PubMed IDs."""
+        time.sleep(0.3)
+
+        try:
+            handle = Entrez.efetch(db="pubmed", id=id_list, retmode="xml")
+            records = Entrez.read(handle)
+            handle.close()
+        except Exception as e:
+            print(f"Fetch error: {e}")
+            return []
+
+        papers = []
+        for i, article in enumerate(records.get('PubmedArticle', [])):
+            try:
+                medline = article['MedlineCitation']
+                article_data = medline['Article']
+
+                title = article_data.get('ArticleTitle', 'No title')
+
+                # Year
+                pub_date = article_data['Journal']['JournalIssue']['PubDate']
+                year = pub_date.get('Year', pub_date.get('MedlineDate', 'Unknown'))
+                try:
+                    year = int(str(year)[:4])
+                except:
+                    year = 2023
+
+                # Authors
+                authors = []
+                if 'AuthorList' in article_data:
+                    for author in article_data['AuthorList'][:3]:
+                        if 'LastName' in author:
+                            authors.append(author['LastName'])
+                authors_str = ', '.join(authors)
+                if len(article_data.get('AuthorList', [])) > 3:
+                    authors_str += ' et al.'
+
+                # Journal
+                journal = article_data['Journal'].get('Title', 'Unknown')
+
+                # Abstract
+                abstract = ''
+                if 'Abstract' in article_data:
+                    abstract_texts = article_data['Abstract'].get('AbstractText', [])
+                    if abstract_texts:
+                        if isinstance(abstract_texts, list):
+                            abstract = ' '.join(str(t) for t in abstract_texts)
+                        else:
+                            abstract = str(abstract_texts)
+
+                pmid = str(medline['PMID'])
+                relevance = 95 - i * 5
+
+                papers.append({
+                    'pmid': pmid,
+                    'title': title,
+                    'year': year,
+                    'authors': authors_str,
+                    'journal': journal,
+                    'abstract': abstract,
+                    'relevance': relevance
+                })
+
+            except Exception as e:
+                print(f"Warning: Parse error: {e}")
+                continue
+
+        return papers

Spec2Function/read_raw_data.py

@@ -0,0 +1,154 @@
+import os
+import pandas as pd
+import xml.etree.ElementTree as ET
+from pathlib import Path
+import numpy as np
+import pickle
+
+def parse_ms_xml_folder(folder_path):
+    """
+    解析包含MS-MS数据的XML文件夹
+    
+    参数:
+    folder_path (str): 包含XML文件的文件夹路径
+    
+    返回:
+    tuple: (ms_data, meta_data)
+        - ms_data: 字典，键为不带扩展名的文件名，值为包含mz、intensity和molecule_id的字典
+        - meta_data: DataFrame，包含每个文件的元数据
+    """
+    # 初始化数据结构
+    ms_data = {}
+    meta_data_list = []
+    
+    # 获取所有XML文件
+    xml_files = [f for f in os.listdir(folder_path) if f.endswith('.xml')]
+    
+    for file_name in xml_files:
+        file_path = os.path.join(folder_path, file_name)
+        
+        try:
+            # 解析XML文件
+            tree = ET.parse(file_path)
+            root = tree.getroot()
+            
+            # 移除文件扩展名
+            file_name_without_ext = os.path.splitext(file_name)[0]
+            
+            # 提取MS-MS峰值数据
+            mz_list = []
+            intensity_list = []
+            molecule_id_list = []
+            
+            for peak in root.findall('.//ms-ms-peak'):
+                mz = peak.find('mass-charge')
+                intensity = peak.find('intensity')
+                molecule_id = peak.find('molecule-id')
+                
+                if mz is not None and intensity is not None:
+                    mz_list.append(float(mz.text))
+                    intensity_list.append(float(intensity.text))
+                    
+                    # 提取molecule_id，如果为nil则为None
+                    if molecule_id is not None and 'nil' not in molecule_id.attrib:
+                        molecule_id_list.append(molecule_id.text)
+                    else:
+                        molecule_id_list.append(None)
+            
+            # 获取database-id
+            database_id_elem = root.find('database-id')
+            database_id = database_id_elem.text if database_id_elem is not None and database_id_elem.text else np.nan
+            
+            # 获取ionization-mode (Polarity)
+            polarity_elem = root.find('ionization-mode')
+            polarity = polarity_elem.text if polarity_elem is not None and polarity_elem.text else np.nan
+            
+            # 获取precursor_mass (adduct-mass)
+            adduct_mass_elem = root.find('adduct-mass')
+            precursor_mass = adduct_mass_elem.text if adduct_mass_elem is not None and adduct_mass_elem.text else np.nan
+            
+            # 获取splash-key
+            splash_id_elem = root.find('splash-key')
+            splash_id = splash_id_elem.text if splash_id_elem is not None and splash_id_elem.text else np.nan
+            
+            # 存储MS数据 - 使用不带扩展名的文件名
+            ms_data[file_name_without_ext] = {
+                'mz': mz_list,
+                'intensity': intensity_list,
+                'molecule_id': database_id  # 使用database-id作为molecule_id
+            }
+            
+            # 存储元数据 - 使用不带扩展名的文件名
+            meta_data_list.append({
+                'file_name': file_name_without_ext,
+                'HMDB.ID': database_id,
+                'Polarity': polarity,
+                'precursor_mass': precursor_mass,
+                'splash_id': splash_id
+            })
+            
+        except Exception as e:
+            print(f"处理文件 {file_name} 时出错: {e}")
+    
+    # 创建元数据DataFrame
+    meta_data = pd.DataFrame(meta_data_list)
+    
+    return ms_data, meta_data
+
+def save_ms_data(ms_data, output_file):
+    """
+    保存MS数据到pickle文件
+    
+    参数:
+    ms_data (dict): MS数据字典
+    output_file (str): 输出文件路径
+    """
+    import pickle
+    with open(output_file, 'wb') as f:
+        pickle.dump(ms_data, f)
+    print(f"MS数据已保存到 {output_file}")
+
+def save_meta_data(meta_data, output_file):
+    """
+    保存元数据到CSV文件
+    
+    参数:
+    meta_data (DataFrame): 元数据DataFrame
+    output_file (str): 输出文件路径
+    """
+    meta_data.to_csv(output_file, index=False)
+    print(f"元数据已保存到 {output_file}")
+
+def main():
+    # 示例用法
+    folder_path = "/Users/cgxjdzz/Desktop/NTU phd/ms2_database_feifan/HMDB raw/hmdb_experimental_msms_spectra"  # 替换为实际XML文件夹路径
+    output_dir = "/Users/cgxjdzz/Desktop/NTU phd/ms2_database_feifan/MS2BioText"  # 替换为实际输出目录路径
+    
+    # 确保输出目录存在
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # 解析XML文件
+    ms_data, meta_data = parse_ms_xml_folder(folder_path)
+    
+    # 打印结果示例
+    print("MS数据样例:")
+    for file_name, data in list(ms_data.items())[:1]:  # 只打印第一个文件的数据
+        print(f"文件: {file_name}")
+        print(f"质荷比数量: {len(data['mz'])}")
+        print(f"前5个质荷比: {data['mz'][:5]}")
+        print(f"前5个强度值: {data['intensity'][:5]}")
+        print(f"molecule_id: {data['molecule_id']}")
+        print()
+    
+    print("元数据:")
+    print(meta_data.head())
+    
+    # 保存数据
+    ms_data_file = os.path.join(output_dir, "new_ms_data.pkl")
+    meta_data_file = os.path.join(output_dir, "new_meta_data.csv")
+    
+    save_ms_data(ms_data, ms_data_file)
+    save_meta_data(meta_data, meta_data_file)
+
+if __name__ == "__main__":
+    main()

Spec2Function/utils.py

@@ -0,0 +1,216 @@
+# -*- coding: utf-8 -*-
+"""
+Utility functions for Spec2Function
+"""
+import numpy as np
+import base64
+from typing import List, Dict, Tuple
+
+
+def parse_mgf(file_content: str) -> List[Dict]:
+    """
+    Parse an MGF file.
+
+    Args:
+        file_content: MGF file content as text.
+    Returns:
+        List of spectra, each containing:
+        {
+            'title': str,
+            'precursor_mz': float,
+            'charge': int,
+            'mz': List[float],
+            'intensity': List[float]
+        }
+    """
+    spectra = []
+    current_spectrum = None
+
+    lines = file_content.strip().split('\n')
+
+    for line in lines:
+        line = line.strip()
+
+        if line.startswith('BEGIN IONS'):
+            current_spectrum = {
+                'title': '',
+                'precursor_mz': 0.0,
+                'charge': 0,
+                'mz': [],
+                'intensity': []
+            }
+
+        elif line.startswith('END IONS'):
+            if current_spectrum and len(current_spectrum['mz']) > 0:
+                spectra.append(current_spectrum)
+            current_spectrum = None
+
+        elif current_spectrum is not None:
+            if line.startswith('TITLE='):
+                current_spectrum['title'] = line.split('=', 1)[1]
+
+            elif line.startswith('PEPMASS='):
+                current_spectrum['precursor_mz'] = float(line.split('=')[1].split()[0])
+
+            elif line.startswith('CHARGE='):
+                charge_str = line.split('=')[1].replace('+', '').replace('-', '')
+                try:
+                    current_spectrum['charge'] = int(charge_str)
+                except:
+                    current_spectrum['charge'] = 0
+
+            elif line and not line.startswith(('TITLE', 'PEPMASS', 'CHARGE', 'RTINSECONDS', 'SCANS')):
+                # Peak line: m/z intensity
+                try:
+                    parts = line.split()
+                    if len(parts) >= 2:
+                        mz = float(parts[0])
+                        intensity = float(parts[1])
+                        current_spectrum['mz'].append(mz)
+                        current_spectrum['intensity'].append(intensity)
+                except:
+                    pass
+
+    return spectra
+
+
+def parse_msp(file_content: str) -> List[Dict]:
+    """
+    Parse an MSP file.
+
+    Args:
+        file_content: MSP file content as text.
+    Returns:
+        List of spectra (same format as parse_mgf)
+    """
+    spectra = []
+    current_spectrum = None
+    num_peaks = 0
+    peaks_read = 0
+
+    lines = file_content.strip().split('\n')
+
+    for line in lines:
+        line = line.strip()
+
+        if not line:
+            if current_spectrum and len(current_spectrum['mz']) > 0:
+                spectra.append(current_spectrum)
+            current_spectrum = None
+            peaks_read = 0
+            continue
+
+        if line.startswith('Name:'):
+            current_spectrum = {
+                'title': line.split(':', 1)[1].strip(),
+                'precursor_mz': 0.0,
+                'charge': 0,
+                'mz': [],
+                'intensity': []
+            }
+
+        elif current_spectrum is not None:
+            if line.startswith('PrecursorMZ:') or line.startswith('PRECURSORMZ:'):
+                current_spectrum['precursor_mz'] = float(line.split(':')[1].strip())
+
+            elif line.startswith('Num peaks:') or line.startswith('Num Peaks:'):
+                num_peaks = int(line.split(':')[1].strip())
+
+            elif peaks_read < num_peaks:
+                # Peak line
+                try:
+                    parts = line.split()
+                    if len(parts) >= 2:
+                        mz = float(parts[0])
+                        intensity = float(parts[1])
+                        current_spectrum['mz'].append(mz)
+                        current_spectrum['intensity'].append(intensity)
+                        peaks_read += 1
+                except:
+                    pass
+
+    # Handle the last spectrum
+    if current_spectrum and len(current_spectrum['mz']) > 0:
+        spectra.append(current_spectrum)
+
+    return spectra
+
+
+def parse_json_spectrum(json_data: Dict) -> Dict:
+    peaks = json_data.get('peaks', [])
+    precursor_mz = json_data.get('precursor_mz', 0.0)
+    return {
+        'title': 'Single Spectrum',
+        'precursor_mz': precursor_mz,
+        'charge': 0,
+        'mz': [peak[0] for peak in peaks],
+        'intensity': [peak[1] for peak in peaks]
+    }
+
+
+def decode_uploaded_file(contents: str, filename: str) -> Tuple[str, str]:
+    """
+    Decode a file uploaded via Dash Upload.
+    Args:
+        contents: Base64-encoded content string.
+        filename: Original filename.
+    Returns:
+        (file_content, file_type)
+    """
+    content_type, content_string = contents.split(',')
+    decoded = base64.b64decode(content_string)
+
+    try:
+        file_content = decoded.decode('utf-8')
+    except:
+        file_content = decoded.decode('latin-1')
+
+    file_type = filename.split('.')[-1].lower()
+
+    return file_content, file_type
+
+
+def preprocess_spectrum(mz: List[float], intensity: List[float], 
+                        max_peaks: int = 100) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Preprocess an MS2 spectrum.
+
+    Args:
+        mz: m/z values
+        intensity: Intensity values
+        max_peaks: Maximum number of peaks to keep
+
+    Returns:
+        (mz_array, intensity_array) - preprocessed and normalized
+    """
+    mz = np.array(mz, dtype=np.float32)
+    intensity = np.array(intensity, dtype=np.float32)
+
+    # Sort by intensity and keep top peaks
+    if len(intensity) > max_peaks:
+        top_indices = np.argsort(intensity)[-max_peaks:]
+        mz = mz[top_indices]
+        intensity = intensity[top_indices]
+
+    # Sort by m/z
+    sorted_indices = np.argsort(mz)
+    mz = mz[sorted_indices]
+    intensity = intensity[sorted_indices]
+
+    # Normalize intensity
+    if intensity.max() > 0:
+        intensity = intensity / intensity.max()
+
+    return mz, intensity
+
+
+def format_similarity_score(score: float) -> str:
+    """Format a similarity score."""
+    return f"{score:.3f}"
+
+
+def truncate_text(text: str, max_length: int = 200) -> str:
+    """Truncate long text."""
+    if len(text) <= max_length:
+        return text
+    return text[:max_length] + "..."