msfiddle 0.1.0__py3-none-any.whl

msfiddle/utils/refine_utils.py

@@ -0,0 +1,246 @@
+import re
+import argparse
+import yaml
+from molmass import Formula
+import time
+
+from .mol_utils import ATOMS_WEIGHT, ATOMS_VALENCE
+
+
+
+def parse_formula(formula):
+	pattern = r'([A-Z][a-z]?)(\d*)'
+	matches = re.findall(pattern, formula)
+
+	atom_counts = {}
+	for atom, count in matches:
+		count = int(count) if count else 1
+		atom_counts[atom] = atom_counts.get(atom, 0) + count
+	return atom_counts
+
+def format_formula(atom_counts):
+	# Sort atoms alphabetically and format the formula
+	return ''.join([atom + (str(count) if count > 1 else '') for atom, count in sorted(atom_counts.items())])
+
+def passes_senior_rule(formula):
+	atom_counts = parse_formula(formula)
+	total_valence = 0
+	max_valence = 0
+
+	for atom, count in atom_counts.items():
+		valence = ATOMS_VALENCE.get(atom, 0)
+		total_valence += valence * count
+		max_valence = max(max_valence, valence)
+
+	num_atoms = sum(atom_counts.values())
+
+	sum_odd_valences = sum(valence * count for atom, count in atom_counts.items() if ATOMS_VALENCE.get(atom, 0) % 2 != 0)
+	if sum_odd_valences % 2 != 0:
+		return False
+
+	if total_valence < 2 * max_valence:
+		return False
+
+	if total_valence < 2 * (num_atoms - 1):
+		return False
+
+	return True
+
+def exceed_refine_atom_limit(refined_counts, formulas, refine_atom_type, refine_atom_num): 
+	"""Check if the refined formula exceeds the refinement limit for a given atom type."""
+	# refined_counts = parse_formula(refined_formula)
+	for formula in formulas: 
+		original_counts = parse_formula(formula)
+	
+		for t, n in zip(refine_atom_type, refine_atom_num): 
+			if n == -1: # No limitation
+				continue
+
+			refined_n = refined_counts.get(t, 0)
+			original_n = original_counts.get(t, 0)
+			# Check if the difference in atom counts exceeds the allowed number
+			if abs(refined_n - original_n) > n: 
+				return True  # Exceeds the limit for at least one formula
+
+	return False  # Does not exceed the limit for any formula
+
+def adjust_hydrogen(atom_counts, M): 
+	delta_h = round((M - Formula(format_formula(atom_counts)).isotope.mass) / 1.007941) 
+	if 'H' not in atom_counts.keys():
+		atom_counts['H'] = delta_h
+	else:
+		atom_counts['H'] += delta_h
+	if atom_counts['H'] <= 0: del atom_counts['H']
+	return atom_counts
+
+def remove_duplicates_preserve_order(seq):
+	seen = set()
+	return [x for x in seq if not (x in seen or seen.add(x))]
+
+def candidate_formulas_generation(f, M, f0_list, refine_atom_type, refine_atom_num): 
+	atom_counts = parse_formula(f)
+	formulas = []
+
+	for a in refine_atom_type: 
+		if a == 'H': continue # Skip 'H'
+
+		# Add one atom
+		new_atom_counts = dict(atom_counts)
+		new_atom_counts[a] = new_atom_counts.get(a, 0) + 1
+		if not exceed_refine_atom_limit(new_atom_counts, f0_list, refine_atom_type, refine_atom_num) and 'H' in atom_counts.keys(): 
+			new_atom_counts = adjust_hydrogen(new_atom_counts, M) # Ajust 'H'
+			formulas.append(format_formula(new_atom_counts))
+
+		# Remove one atom if it exists
+		if a in atom_counts and atom_counts[a] > 0:
+			new_atom_counts = dict(atom_counts)
+			new_atom_counts[a] -= 1
+			if new_atom_counts[a] == 0:
+				del new_atom_counts[a]
+			if not exceed_refine_atom_limit(new_atom_counts, f0_list, refine_atom_type, refine_atom_num) and 'H' in atom_counts.keys(): 
+				new_atom_counts = adjust_hydrogen(new_atom_counts, M) # Ajust 'H'
+				formulas.append(format_formula(new_atom_counts))
+
+	# Sort based on proximity to M
+	formulas.sort(key=lambda formula: abs(Formula(formula).isotope.mass - M)) 
+
+	return formulas
+
+def formula_refinement(f0_list, M, delta_M, ppm_mode, K, D, T, refine_atom_type, refine_atom_num): 
+	start_time = time.time()
+	refine_f = []  # List of refined formulas
+	trace_f = set()  # Keep track of all formulas that have been focused on
+	
+	if ppm_mode:
+		delta_M = delta_M * M / 10 ** 6
+	
+	# If no halogen in prediction, no halogen in refinement
+	# pred_atom_types = set()
+	# for f0 in f0_list:
+	# 	pred_atom_types.update([atom for atom, n in parse_formula(f0).items() if n > 0])
+	# for atom in ['P', 'S', 'F', 'Cl', 'B', 'Br', 'I', 'Na', 'K']: 
+	# 	if atom not in pred_atom_types and atom in refine_atom_type: 
+	# 		i = refine_atom_type.index(atom)
+	# 		refine_atom_type.pop(i)
+	# 		refine_atom_num.pop(i)
+
+	candidate_f = [format_formula(adjust_hydrogen(parse_formula(f0), M)) for f0 in f0_list] # Initialize candidate_f 
+	candidate_d = [0] * len(candidate_f)
+	search_deep = 0
+	# print('Init {} candidate formulas from predictions'.format(len(candidate_f)))
+	# print(candidate_f)
+	# print([(Formula(f).isotope.mass, abs(Formula(f).isotope.mass - M)) for f in candidate_f])
+	
+	# Search >>>
+	while len(refine_f) < K and (candidate_f or search_deep==0): # It is okay if at begining there is no formula in candidate_f
+		if search_deep == 0: 
+			# Check if the predicted formula falls into the target space
+			for f0 in candidate_f: 
+				m = Formula(f0).isotope.mass
+				if M - delta_M <= m <= M + delta_M and passes_senior_rule(f0) and f0 not in refine_f: # Passed SENIOR rule
+					refine_f.append(f0) # Append the refined formula for return
+					# print('Got one refined formula')
+			
+			# Generate more candidates from the init formula list
+			new_candidates = []
+			for f0 in f0_list:
+				new_candidates += candidate_formulas_generation(f0, M, f0_list, refine_atom_type, refine_atom_num)
+			new_candidates = remove_duplicates_preserve_order(new_candidates) # Remove duplicates
+			new_candidates.sort(key=lambda formula: abs(Formula(formula).isotope.mass - M)) # Need resort, because they are extend from multiple candidate list
+			new_depths = [search_deep+1] * len(new_candidates)
+
+			candidate_f = new_candidates + candidate_f
+			candidate_d = new_depths + candidate_d
+
+		elif search_deep <= D: 
+			# Generate more candidates from the current focus formula f
+			new_candidates = candidate_formulas_generation(f, M, f0_list, refine_atom_type, refine_atom_num)
+			new_candidates = remove_duplicates_preserve_order(new_candidates) # Remove duplicates
+			new_candidates = [i for i in new_candidates if i not in trace_f and i not in candidate_f]
+			new_depths = [search_deep+1] * len(new_candidates)
+
+			while len(new_candidates) == 0 and len(candidate_f) > 0: 
+				f = candidate_f.pop(0) # Reject to continue (no new candidate), trace back
+				search_deep = candidate_d.pop(0)
+				trace_f.add(f) 
+				# print('Trackback')
+
+				# Generate more candidates from the current focus formula f
+				new_candidates = candidate_formulas_generation(f, M, f0_list, refine_atom_type, refine_atom_num)
+				new_candidates = remove_duplicates_preserve_order(new_candidates) # Remove duplicates
+				new_candidates = [i for i in new_candidates if i not in trace_f and i not in candidate_f]
+				new_depths = [search_deep+1] * len(new_candidates)
+			if len(new_candidates) == 0: # No other candidates exit
+				break
+
+			candidate_f = new_candidates + candidate_f
+			candidate_d = new_depths + candidate_d
+
+		else: # While exceed search limitation, the candidate_f will be depleted
+			if len(candidate_f) == 0: break
+			f = candidate_f.pop(0) # Reject to continue (exceed search limitation), trace back
+			search_deep = candidate_d.pop(0)
+			trace_f.add(f)
+			# print('Trackback')
+
+		if len(candidate_f) == 0: break
+		f = candidate_f.pop(0) # Select the next formula to focus on
+		search_deep = candidate_d.pop(0)
+		m = Formula(f).isotope.mass
+		trace_f.add(f)
+		# print('\nNext step: {} ({}, {})'.format(f, m, abs(m - M)))
+		
+		if M - delta_M <= m <= M + delta_M: 
+			if passes_senior_rule(f) and f not in refine_f: # Passed SENIOR rule
+				refine_f.append(f)  # Append the refined formula for return
+				# print('Got one refined formula')
+		
+		# Check if timeout
+		running_time = time.time() - start_time
+		if T > 0 and running_time > T: # Timeout
+			break
+	# End >>>
+
+	refine_f.sort(key=lambda formula: abs(Formula(formula).isotope.mass - M))
+	refine_m = [Formula(formula).isotope.mass for formula in refine_f]
+
+	# Pad refine_f and refine_m with None if necessary
+	if len(refine_f) < K:
+		refine_f += [None] * (K - len(refine_f))
+		refine_m += [None] * (K - len(refine_m))
+
+	return {'formula': refine_f, 'mass': refine_m}
+
+
+
+if __name__ == "__main__": 
+	# Post-process settings
+	# to check `formula_refinement`: python refine_utils.py --config_path ./config/fiddle_tcn.yml
+	parser = argparse.ArgumentParser(description='Mass Spectra to formula (post-process)')
+	parser.add_argument('--config_path', type=str, required=True,
+						help='Path to configuration (.yml)')
+	args = parser.parse_args()
+
+	# Load configuration
+	with open(args.config_path, 'r') as f:
+		config = yaml.safe_load(f)
+	
+	refine_atom_type = config['post_processing']['refine_atom_type']
+	refine_atom_num = config['post_processing']['refine_atom_num']
+	mass_tolerance = config['post_processing']['mass_tolerance']
+	ppm_mode = config['post_processing']['ppm_mode']
+	top_k = config['post_processing']['top_k']
+	maxium_miss_atom_num = config['post_processing']['maxium_miss_atom_num']
+	time_out = config['post_processing']['time_out']
+
+	predicted_formula = ["C6H7O2N2"]
+	target_formula = "C5H9NO4"
+	compound_mass = Formula(target_formula).isotope.mass
+
+	print('predicted formulas:', predicted_formula)
+	print('target formula: {} ({})'.format(target_formula, compound_mass))
+
+	result = formula_refinement(predicted_formula, compound_mass, 
+								mass_tolerance, ppm_mode, top_k, maxium_miss_atom_num, time_out, 
+								refine_atom_type, refine_atom_num)
+	print('restults:', result)

msfiddle-0.1.0.dist-info/METADATA

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: msfiddle
+Version: 0.1.0
+Summary: A package for predicting chemical formulas from tandem mass spectra
+Home-page: https://github.com/JosieHong/msfiddle
+Author: Yuhui Hong
+Author-email: josieexception@outlook.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<2.0.0,>=1.20.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: tqdm>=4.60.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: scikit-learn>=1.0.0
+Requires-Dist: scipy>=1.8.0
+Requires-Dist: pyarrow>=10.0.0
+Requires-Dist: rdkit>=2022.03.5
+Requires-Dist: molmass
+Requires-Dist: pyteomics
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# msfiddle
+
+Source code for the FIDDLE PyPI package featuring:
+
+* Chemical formula prediction from MS/MS spectra
+* Formula refinement with confidence score estimation
+* Seamless integration with BUDDY and SIRIUS tools
+
+Preprint: https://doi.org/10.1101/2024.11.25.625316
+
+For the complete experimenal codes, please visit the GitHub repository: https://github.com/JosieHong/FIDDLE
+
+## Installation
+
+```bash
+# Install msfiddle (without PyTorch)
+pip install msfiddle
+```
+
+To use `msfiddle`, you need to install `torch>=1.13.0,<2.0.0` separately with the appropriate version for your system. Please refer to the official PyTorch installation guide:
+🔗 [PyTorch Installation Guide](https://pytorch.org/get-started/previous-versions/#v1130). 
+
+## Usage 
+
+**Step 1**: Download pre-trained models
+
+```bash
+# Download models to the default location (inside the package directory)
+msfiddle-download-models
+
+# Or specify a custom location and models
+msfiddle-download-models --destination /path/to/models \
+                          --models fiddle_tcn_qtof fiddle_fdr_qtof
+```
+
+**Step 2**: Run predictions
+
+Using demo data (simplest option)
+
+```bash
+# Run prediction with the built-in demo data
+msfiddle --demo --result_path ./output_demo.csv --device 0
+```
+
+Using your own data:
+
+```bash
+# Run prediction with your data - automatically selects appropriate model
+msfiddle --test_data /path/to/data.mgf \
+         --instrument_type orbitrap \
+         --result_path /path/to/results.csv \
+         --device 0
+```
+
+The `--instrument_type` parameter can be either `orbitrap` (default) or `qtof`. 
+
+Below is an example of input MS/MS data formatted in `.mgf`. The fields `TITLE`, `PRECURSOR_MZ`, `PRECURSOR_TYPE`, and `COLLISION_ENERGY` are required for msfiddle processing: 
+
+```mgf
+BEGIN IONS
+TITLE=EMBL_MCF_2_0_HRMS_Library000529
+PEPMASS=111.02016
+CHARGE=1-
+PRECURSOR_TYPE=[M-H]-
+PRECURSOR_MZ=111.02016
+COLLISION_ENERGY=50.0
+SMILES=[H]c1c([H])n([H])c(=O)n([H])c1=O
+FORMULA=C4H4N2O2
+THEORETICAL_PRECURSOR_MZ=111.019453
+PPM=6.368253318682487
+SIMULATED_PRECURSOR_MZ=111.01946768634916
+41.0148 0.329893 
+41.9986 89.226766 
+55.8055 0.200544 
+56.2625 0.194617 
+67.0304 0.330612 
+68.0258 0.402906 
+111.0203 100.0 
+112.0515 1.2809 
+END IONS
+```
+
+### Additional Options
+
+Show all model paths:
+
+```bash
+msfiddle-checkpoint-paths
+```
+
+Advanced usage with custom paths:
+
+```bash
+msfiddle --test_data /path/to/data.mgf \
+         --config_path /path/to/config.yml \
+         --resume_path /path/to/tcn_model.pt \
+         --fdr_resume_path /path/to/fdr_model.pt \
+         --result_path /path/to/results.csv \
+         --device 0
+```
+
+## Citation
+
+```
+@article{hong2024fiddle,
+  title={FIDDLE: a deep learning method for chemical formulas prediction from tandem mass spectra},
+  author={Hong, Yuhui and Li, Sujun and Ye, Yuzhen and Tang, Haixu},
+  journal={bioRxiv},
+  pages={2024--11},
+  year={2024},
+  publisher={Cold Spring Harbor Laboratory}
+}
+```

msfiddle-0.1.0.dist-info/RECORD

@@ -0,0 +1,27 @@
+msfiddle/__init__.py,sha256=9fp9FuPN7dZ5VjAie0hVqY8VtAXFitXUWMD4lb4yjb4,1327
+msfiddle/dataset.py,sha256=Tc8b0JqHk4-PI1LKSxbvL7IKca-aXCCsOkWkpAM9XbQ,5601
+msfiddle/download.py,sha256=sSAw5IWXhoM-0ASJC4ELBY6GPySvoWDPbmNfKKAzD6Q,7314
+msfiddle/main.py,sha256=bUHMJ26PZxMM-eKqyDjNaTfjohFbdEIJWI1epNx0xYg,16832
+msfiddle/model_tcn.py,sha256=zOkC8RY6YFj-BNv69Xq0oKNbXodNoR8hULno_0mRizI,8094
+msfiddle/config/fiddle_tcn_casmi.yml,sha256=UtLialE8V8KuoaO3vd4zEimDnaZfC83JRGcPIP1RylQ,2731
+msfiddle/config/fiddle_tcn_demo.yml,sha256=GieQU_9Mr0ETDTF2o-b1bbyftjfRAZur5_43bBasX7Y,3096
+msfiddle/config/fiddle_tcn_demo_wo_da.yml,sha256=puzdqehyX-EOFlwgSYH0atjPOiquYEG9eGs4FsPO13s,3095
+msfiddle/config/fiddle_tcn_embl.yml,sha256=wTyM8tmkj4R1QG3CRrivtC7tU5MoRZkecpFwq03lDe8,2620
+msfiddle/config/fiddle_tcn_orbitrap.yml,sha256=z6eqKIi6RN6adAtmrxft4KlEAi4bQYxO1g_PDCFjnnA,4645
+msfiddle/config/fiddle_tcn_qtof.yml,sha256=jyvXu1RQlJww7i9vfwm8mIKbB2p_1j_mNXHvT51w4CA,5759
+msfiddle/demo/input_msms.mgf,sha256=ZMSrWib4ruLm7_W5YfzYEQ3VMYCoMKxioznvMcDiQeE,9728
+msfiddle/demo/output_buddy.csv,sha256=U36nN98k9gANWE4PFCmpO6iefl4tD5aI7nByDTGtGzg,1800
+msfiddle/demo/output_fiddle.csv,sha256=LeUJnP7PYFOkBDClXNtL5LkP2JFBrmmVzwpfIoVgaH0,8586
+msfiddle/demo/output_fiddle_all.csv,sha256=zu7E5_W-eQHSZA7ctUIay3Hi0wvY5EhnTMkdYZ98kOc,8524
+msfiddle/demo/output_sirius.csv,sha256=2z0gx_TN7KZYxYz07lmu_qh8GiQuYPktaq2Le38G3dI,1867
+msfiddle/utils/__init__.py,sha256=uSVIp_bUvo8LYG5sxpGuVyrgW1xGOddOJAadCXNfwoU,1125
+msfiddle/utils/mol_utils.py,sha256=GhicKfSNqPxt6qiJGKSCPKW_qobRAwmWdUa_SRW0PFU,2776
+msfiddle/utils/msms_utils.py,sha256=ItiwVxgRNNMWVvN-vXRuJfUHQfqHO6E3jl8BuuGTsRQ,12166
+msfiddle/utils/pkl_utils.py,sha256=nBsUSXwrF1RRSgocT4-EGtqtgJLHsKQ2D8OiETQwKnY,14893
+msfiddle/utils/refine_utils.py,sha256=d5Nr0EHZBwScmnVHcCN0IfbRAFa7U7iTeP5XaCi2L8c,9629
+msfiddle-0.1.0.dist-info/licenses/LICENSE,sha256=T2JIdijrbGLQADQx_qdJIs6PC4By9Ew3NXNb-G5aR0o,34553
+msfiddle-0.1.0.dist-info/METADATA,sha256=KzV47TE3pUcZARESyFkgmlkOgPKia2SO5SBXvRf3JTk,4198
+msfiddle-0.1.0.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+msfiddle-0.1.0.dist-info/entry_points.txt,sha256=KyPVa2Z8HqvrVfrhfpanoIUyavlgCbe3U1Cnm4ZTCWM,186
+msfiddle-0.1.0.dist-info/top_level.txt,sha256=x3Q69x9woIbchXb1bx6oEug-TdnpT_3FLmvdoXhxaIc,9
+msfiddle-0.1.0.dist-info/RECORD,,

msfiddle-0.1.0.dist-info/WHEEL

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

msfiddle-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+msfiddle = msfiddle.main:main
+msfiddle-checkpoint-paths = msfiddle.download:print_checkpoint_paths_cli
+msfiddle-download-models = msfiddle.download:download_models_cli