matchms package

class matchms.Fragments(mz=None, intensities=None)

Bases: object

Stores arrays of intensities and M/z values, with some checks on their internal consistency.

For example

import numpy as np
from matchms import Fragments

mz = np.array([10, 20, 30], dtype="float")
intensities = np.array([100, 20, 300], dtype="float")

peaks = Fragments(mz=mz, intensities=intensities)
print(peaks[2])

Should output

[ 30. 300.]

mz

Numpy array of m/z values.

intensities

Numpy array of peak intensity values.

__init__(mz=None, intensities=None)

property intensities

getter method for intensities private variable

property mz

getter method for mz private variable

property to_numpy

getter method to return stacked numpy array of both peak mz and intensities

class matchms.Metadata(metadata: dict | None = None, matchms_key_style: bool = True)

Bases: object

Class to handle spectrum metadata in matchms.

Metadata entries will be stored as PickyDict dictionary in metadata.data. Unlike normal Python dictionaries, not all key names will be accepted. Key names will be forced to be lower-case to avoid confusions between key such as “Precursor_MZ” and “precursor_mz”.

To avoid the default harmonization of the metadata dictionary use the option matchms_key_style=False.

Code example:

metadata = Metadata({"Precursor_MZ": 201.5, "Compound Name": "SuperStuff"})
print(metadata["precursor_mz"])  # => 201.5
print(metadata["compound_name"])  # => SuperStuff

Or if the matchms default metadata harmonization should not take place:

metadata = Metadata({"Precursor_MZ": 201.5, "Compound Name": "SuperStuff"},
                    matchms_key_style=False)
print(metadata["precursor_mz"])  # => 201.5
print(metadata["compound_name"])  # => None (now you need to use "compound name")

__init__(metadata: dict | None = None, matchms_key_style: bool = True)

Parameters:

• metadata – Spectrum metadata as a dictionary.

• matchms_key_style – Set to False if metadata harmonization to default keys is not desired. The default is True.

get(key: str, default=None)

Retrieve value from metadata dict.

harmonize_keys()

Runs default harmonization of metadata.

Method harmonized metadata field names which includes setting them to lower-case and runing a series of regex replacements followed by default field name replacements (such as precursor_mass –> precursor_mz).

harmonize_values()

Runs default harmonization of metadata.

This includes harmonizing entries for ionmode, retention time and index, charge, as well as the removal of invalid entried (“”, “NA”, “N/A”, “NaN”).

items()

Retrieve all items (key, value pairs) of metadata dict.

keys()

Retrieve all keys of metadata dict.

set(key: str, value)

Set value in metadata dict.

static set_key_replacements(keys: dict)

Set key replacements for metadata harmonization.

Parameters:

keys – Dictionary with key replacements.

to_dict(export_style: str = 'matchms')

Returns a regular Python dictionary containing the metadata entries.

Parameters:

export_style – Specifies the naming style of the metadata fields. Default is “matchms”.

values()

Retrieve all values of metadata dict.

class matchms.Pipeline(workflow: OrderedDict, progress_bar=True, logging_level: str = 'WARNING', logging_file: str | None = None)

Bases: object

Central pipeline class.

The matchms Pipeline class is meant to make running extensive analysis pipelines fast and easy. It can be used in two different ways. First, a pipeline can be defined using a config file (a yaml file, best to start from the template provided to define your own pipline).

Once a config file is defined, the pipeline can be executed with the following code:

The second way to define a pipeline is via a Python script. The following code is an example of how this works:

To combine this with custom made scores or available matchms-compatible scores such as Spec2Vec or MS2DeepScore, it is also possible to pass objects instead of names to create_workflow

from spec2vec import Spec2Vec
workflow = create_workflow(score_computations = [["precursormzmatch",  {"tolerance": 120.0}],
                                       [Spec2Vec, {"model": "my_spec2vec_model.model"}],
                               ["filter_by_range", {"name": "Spec2Vec", "low": 0.3}]])

__init__(workflow: OrderedDict, progress_bar=True, logging_level: str = 'WARNING', logging_file: str | None = None)

Parameters:

• workflow – Contains an orderedDict containing the workflow settings. Can be created using create_workflow.

• progress_bar – Default is True. Set to False if no progress bar should be displayed.

check_workflow()

Define Pipeline workflow based on a yaml file (config_file).

import_spectrums(query_files: List[str] | str, reference_files: List[str] | str | None = None)

Import spectra from file(s).

Parameters:

• query_files – List of files, or single filename, containing the query spectra.

• reference_files – List of files, or single filename, containing the reference spectra. If set to None (default) then all query spectra will be compared to each other.

run(query_files, reference_files=None, cleaned_query_file=None, cleaned_reference_file=None)

Execute the defined Pipeline workflow.

This method will execute all steps of the workflow. 1) Initializing the log file and importing the spectrums 2) Spectrum processing (using matchms filters) 3) Score Computations

set_logging()

Set the matchms logger to write messages to file (if defined).

write_to_logfile(line)

Write message to log file.

class matchms.Scores(references: List[object] | Tuple[object] | ndarray, queries: List[object] | Tuple[object] | ndarray, is_symmetric: bool = False)

Bases: object

Contains reference and query spectrums and the scores between them.

The scores can be retrieved as a matrix with the Scores.scores attribute. The reference spectrum, query spectrum, score pairs can also be iterated over in query then reference order.

Example to calculate scores between 2 spectrums and iterate over the scores

import numpy as np
from matchms import calculate_scores
from matchms import Spectrum
from matchms.similarity import CosineGreedy

spectrum_1 = Spectrum(mz=np.array([100, 150, 200.]),
                      intensities=np.array([0.7, 0.2, 0.1]),
                      metadata={'id': 'spectrum1'})
spectrum_2 = Spectrum(mz=np.array([100, 140, 190.]),
                      intensities=np.array([0.4, 0.2, 0.1]),
                      metadata={'id': 'spectrum2'})
spectrum_3 = Spectrum(mz=np.array([110, 140, 195.]),
                      intensities=np.array([0.6, 0.2, 0.1]),
                      metadata={'id': 'spectrum3'})
spectrum_4 = Spectrum(mz=np.array([100, 150, 200.]),
                      intensities=np.array([0.6, 0.1, 0.6]),
                      metadata={'id': 'spectrum4'})
references = [spectrum_1, spectrum_2]
queries = [spectrum_3, spectrum_4]

similarity_measure = CosineGreedy()
scores = calculate_scores(references, queries, similarity_measure)

for (reference, query, score) in scores:
    print(f"Cosine score between {reference.get('id')} and {query.get('id')}" +
          f" is {score[0]:.2f} with {score[1]} matched peaks")

Should output

Cosine score between spectrum1 and spectrum4 is 0.80 with 3 matched peaks
Cosine score between spectrum2 and spectrum3 is 0.14 with 1 matched peaks
Cosine score between spectrum2 and spectrum4 is 0.61 with 1 matched peaks

__init__(references: List[object] | Tuple[object] | ndarray, queries: List[object] | Tuple[object] | ndarray, is_symmetric: bool = False)

Parameters:

• references – List of reference objects

• queries – List of query objects

• is_symmetric – Set to True when references and queries are identical (as for instance for an all-vs-all comparison). By using the fact that score[i,j] = score[j,i] the calculation will be about 2x faster. Default is False.

calculate(similarity_function: BaseSimilarity, name: str | None = None, array_type: str = 'numpy', join_type='left') → Scores

Calculate the similarity between all reference objects vs all query objects using the most suitable available implementation of the given similarity_function. If Scores object already contains similarity scores, the newly computed measures will be added to a new layer (name –> layer name). Additional scores will be added as specified with join_type, the default being ‘left’.

Parameters:

• similarity_function – Function which accepts a reference + query object and returns a score or tuple of scores

• name – Label of the new scores layer. If None, the name of the similarity_function class will be used.

• array_type – Specify the type of array to store and compute the scores. Choose from “numpy” or “sparse”.

• join_type – Choose from left, right, outer, inner to specify the merge type.

filter_by_range(**kwargs)

Remove all scores for which the score name is outside the given range.

Parameters:

kwargs – See “Keyword arguments” section below.

Keyword Arguments:

• name – Name of the score which is used for filtering. Run .score_names to see all scores stored in the sparse array.

• low – Lower threshold below which all scores will be removed.

• high – Upper threshold above of which all scores will be removed.

• above_operator – Define operator to be used to compare against low. Default is ‘>’. Possible choices are ‘>’, ‘<’, ‘>=’, ‘<=’.

• below_operator – Define operator to be used to compare against high. Default is ‘<’. Possible choices are ‘>’, ‘<’, ‘>=’, ‘<=’.

scores_by_query(query: List[object] | Tuple[object] | ndarray, name: str | None = None, sort: bool = False) → ndarray

Return all scores for the given query spectrum.

For example

import numpy as np
from matchms import calculate_scores, Scores, Spectrum
from matchms.similarity import CosineGreedy

spectrum_1 = Spectrum(mz=np.array([100, 150, 200.]),
                      intensities=np.array([0.7, 0.2, 0.1]),
                      metadata={'id': 'spectrum1'})
spectrum_2 = Spectrum(mz=np.array([100, 140, 190.]),
                      intensities=np.array([0.4, 0.2, 0.1]),
                      metadata={'id': 'spectrum2'})
spectrum_3 = Spectrum(mz=np.array([110, 140, 195.]),
                      intensities=np.array([0.6, 0.2, 0.1]),
                      metadata={'id': 'spectrum3'})
spectrum_4 = Spectrum(mz=np.array([100, 150, 200.]),
                      intensities=np.array([0.6, 0.1, 0.6]),
                      metadata={'id': 'spectrum4'})
references = [spectrum_1, spectrum_2, spectrum_3]
queries = [spectrum_2, spectrum_3, spectrum_4]

scores = calculate_scores(references, queries, CosineGreedy())
selected_scores = scores.scores_by_query(spectrum_4, 'CosineGreedy_score', sort=True)
print([x[1][0].round(3) for x in selected_scores])

Should output

[0.796, 0.613]

Parameters:

• query – Single query Spectrum.

• name – Name of the score that should be returned (if multiple scores are stored).

• sort – Set to True to obtain the scores in a sorted way (relying on the sort() function from the given similarity_function).

scores_by_reference(reference: List[object] | Tuple[object] | ndarray, name: str | None = None, sort: bool = False) → ndarray

Return all scores of given name for the given reference spectrum.

Parameters:

• reference – Single reference Spectrum.

• name – Name of the score that should be returned (if multiple scores are stored).

• sort – Set to True to obtain the scores in a sorted way (relying on the sort() function from the given similarity_function).

to_array(name=None) → ndarray

Scores as numpy array

For example

import numpy as np
from matchms import calculate_scores, Scores, Spectrum
from matchms.similarity import IntersectMz

spectrum_1 = Spectrum(mz=np.array([100, 150, 200.]),
                      intensities=np.array([0.7, 0.2, 0.1]))
spectrum_2 = Spectrum(mz=np.array([100, 140, 190.]),
                      intensities=np.array([0.4, 0.2, 0.1]))
spectrums = [spectrum_1, spectrum_2]

scores = calculate_scores(spectrums, spectrums, IntersectMz()).to_array()

print(scores.shape)
print(scores)

Should output

(2, 2)
[[1.  0.2]
 [0.2 1. ]]

Parameters:

name – Name of the score that should be returned (if multiple scores are stored).

to_coo(name=None) → coo_matrix

Scores as scipy sparse COO matrix

Parameters:

name – Name of the score that should be returned (if multiple scores are stored).

to_dict() → dict

Return a dictionary representation of scores.

to_json(filename: str)

Export Scores to a JSON file.

Parameters:

filename – Path to file to write to

to_pickle(filename: str)

Export Scores to a Pickle file.

Parameters:

filename – Path to file to write to

class matchms.Spectrum(mz: array, intensities: array, metadata: dict | None = None, metadata_harmonization: bool = True)

Bases: object

Container for a collection of peaks, losses and metadata.

Spectrum peaks are stored as Fragments object which can be addressed calling spectrum.peaks and contains m/z values and the respective peak intensities.

Spectrum metadata is stored as Metadata object which can be addressed by spectrum.metadata.

Code example

import numpy as np
from matchms import Scores, Spectrum
from matchms.similarity import CosineGreedy

spectrum = Spectrum(mz=np.array([100, 150, 200.]),
                    intensities=np.array([0.7, 0.2, 0.1]),
                    metadata={"id": 'spectrum1',
                              "precursor_mz": 222.333,
                              "peak_comments": {200.: "the peak at 200 m/z"}})

print(spectrum)
print(spectrum.peaks.mz[0])
print(spectrum.peaks.intensities[0])
print(spectrum.get('id'))
print(spectrum.peak_comments.get(200))

Should output

Spectrum(precursor m/z=222.33, 3 fragments between 100.0 and 200.0)
100.0
0.7
spectrum1
the peak at 200 m/z

peaks

Peaks of spectrum

Type:

Fragments

losses

Losses of spectrum, the difference between the precursor and all peaks.

Can be filled with

from matchms import Fragments
spectrum.losess = Fragments(mz=np.array([50.]), intensities=np.array([0.1]))

Type:

Fragments or None

metadata

Dict of metadata with for example the scan number of precursor m/z.

Type:

dict

__init__(mz: array, intensities: array, metadata: dict | None = None, metadata_harmonization: bool = True)

Parameters:

• mz – Array of m/z for the peaks

• intensities – Array of intensities for the peaks

• metadata – Dictionary with for example the scan number of precursor m/z.

• metadata_harmonization (bool, optional) – Set to False if default metadata filters should not be applied. The default is True.

clone()

Return a deepcopy of the spectrum instance.

get(key: str, default=None)

Retrieve value from metadata dict. Shorthand for

val = self.metadata[key]

metadata_dict(export_style: str = 'matchms') → dict

Convert spectrum metadata to Python dictionary.

Parameters:

export_style – Converts the keys to the required export style. One of [“matchms”, “massbank”, “nist”, “riken”, “gnps”]. Default is “matchms”

metadata_hash()

Return a (truncated) sha256-based hash which is generated based on the spectrum metadata. Spectra with same metadata results in same metadata_hash.

plot(figsize=(8, 6), dpi=200, **kwargs)

Plot to visually inspect a spectrum run spectrum.plot()

Example of a spectrum plotted using spectrum.plot() ..

plot_against(other_spectrum, figsize=(8, 6), dpi=200, **spectrum_kws)

Compare two spectra visually in a mirror plot.

To visually compare the peaks of two spectra run spectrum.plot_against(other_spectrum)

Example of a mirror plot comparing two spectra spectrum.plot_against() ..

set(key: str, value)

Set value in metadata dict. Shorthand for

self.metadata[key] = val

spectrum_hash()

Return a (truncated) sha256-based hash which is generated based on the spectrum peaks (mz:intensity pairs). Spectra with same peaks will results in same spectrum_hash.

to_dict(export_style: str = 'matchms') → dict

Return a dictionary representation of a spectrum.

Parameters:

export_style – Converts the keys to the required export style. One of [“matchms”, “massbank”, “nist”, “riken”, “gnps”]. Default is “matchms”

classmethod update_peak_comments_mz_tolerance(mz_tolerance: float)

Change current peak comment m/z tolerance to mz_tolerance.

class matchms.SpectrumProcessor(filters: Iterable[str | Callable | Tuple[Callable | str, Dict[str, any]]])

Bases: object

A class to process spectra using a series of filters.

The class enables a user to define a custom spectrum processing workflow by setting multiple flags and parameters.

Parameters:

filters – A list of filter functions, see add_filter for all the allowed formats.

__init__(filters: Iterable[str | Callable | Tuple[Callable | str, Dict[str, any]]])

parse_and_add_filter(filter_description: str | Callable | Tuple[Callable | str, Dict[str, any]], filter_position: int | None = None)

Adds a filter, by parsing the different allowed inputs.

filter:

Allowed formats: str (has to be a matchms function name) (str, {str, any} (has to be a matchms function name, followed by parameters) Callable (can be matchms filter or custom made filter) Callable, {str, any} (the dict should be parameters.

filter_position:

If None: Matchms filters are automatically ordered. Custom filters will be added at the end of the filter list. If not None, the filter will be added to the given position in the filter order list.

process_spectrum(spectrum, processing_report: ProcessingReport | None = None)

Process the given spectrum with all filters in the processing pipeline.

Parameters:

• spectrum (Spectrum) – The spectrum to process.

• processing_report – A ProcessingReport object When passed the progress will be added to the object.

Returns:

The processed spectrum.

Return type:

Spectrum

process_spectrums(spectrums: list, progress_bar: bool = True, cleaned_spectra_file=None)

Process a list of spectrums with all filters in the processing pipeline.

Parameters:

• spectrums (list[Spectrum]) – The spectrums to process.

• create_report (bool, optional) – Creates and outputs a report of the main changes during processing. The report will be returned as pandas DataFrame. Default is set to False.

• progress_bar (bool, optional) – Displays progress bar if set to True. Default is True.

• cleaned_spectra_file – Path to where the cleaned spectra should be saved.

Returns:

• Spectrums – List containing the processed spectrums.

• processing_report – A ProcessingReport containing the effect of the filters.

matchms.calculate_scores(references: List[object] | Tuple[object] | ndarray, queries: List[object] | Tuple[object] | ndarray, similarity_function: BaseSimilarity, array_type: str = 'numpy', is_symmetric: bool = False) → Scores

Calculate the similarity between all reference objects versus all query objects.

Example to calculate scores between 2 spectrums and iterate over the scores

import numpy as np
from matchms import calculate_scores, Spectrum
from matchms.similarity import CosineGreedy

spectrum_1 = Spectrum(mz=np.array([100, 150, 200.]),
                      intensities=np.array([0.7, 0.2, 0.1]),
                      metadata={'id': 'spectrum1'})
spectrum_2 = Spectrum(mz=np.array([100, 140, 190.]),
                      intensities=np.array([0.4, 0.2, 0.1]),
                      metadata={'id': 'spectrum2'})
spectrums = [spectrum_1, spectrum_2]

scores = calculate_scores(spectrums, spectrums, CosineGreedy())

for (reference, query, score) in scores:
    print(f"Cosine score between {reference.get('id')} and {query.get('id')}" +
          f" is {score[0]:.2f} with {score[1]} matched peaks")

Should output

Cosine score between spectrum1 and spectrum1 is 1.00 with 3 matched peaks
Cosine score between spectrum1 and spectrum2 is 0.83 with 1 matched peaks
Cosine score between spectrum2 and spectrum1 is 0.83 with 1 matched peaks
Cosine score between spectrum2 and spectrum2 is 1.00 with 3 matched peaks

Parameters:

• references – List of reference objects

• queries – List of query objects

• similarity_function – Function which accepts a reference + query object and returns a score or tuple of scores

• array_type – Specify the type of array to store and compute the scores. Choose from “numpy” or “sparse”.

• is_symmetric – Set to True when references and queries are identical (as for instance for an all-vs-all comparison). By using the fact that score[i,j] = score[j,i] the calculation will be about 2x faster. Default is False.

Return type:

Scores

matchms.set_matchms_logger_level(loglevel: str, logger_name='matchms')

Update logging level to given loglevel.

Parameters:

• loglevels – Can be ‘DEBUG’, ‘INFO’, ‘WARNING’, ‘ERROR’, ‘CRITICAL’.

• logger_name – Default is “matchms”. Change if logger name should be different.

Subpackages

• matchms.exporting package
  • Functions for exporting mass spectral data
  • save_as_json()
  • save_as_mgf()
  • save_as_msp()
  • save_spectra()
  • Submodules
    • matchms.exporting.metadata_export module
      • export_metadata_as_csv()
      • export_metadata_as_json()
      • get_metadata_as_array()
    • matchms.exporting.save_as_json module
      • save_as_json()
    • matchms.exporting.save_as_mgf module
      • save_as_mgf()
    • matchms.exporting.save_as_msp module
      • save_as_msp()
    • matchms.exporting.save_spectra module
      • save_as_pickled_file()
      • save_spectra()
• matchms.filtering package
  • Processing (or: filtering) mass spectra
  • SpeciesString
    • SpeciesString.dirty
    • SpeciesString.target
    • SpeciesString.cleaned
    • SpeciesString.__init__()
    • SpeciesString.clean()
    • SpeciesString.clean_as_inchi()
    • SpeciesString.clean_as_inchikey()
    • SpeciesString.clean_as_smiles()
    • SpeciesString.guess_target()
    • SpeciesString.looks_like_a_smiles()
    • SpeciesString.looks_like_an_inchi()
    • SpeciesString.looks_like_an_inchikey()
  • add_compound_name()
  • add_fingerprint()
  • add_losses()
  • add_parent_mass()
  • add_precursor_mz()
  • add_retention_index()
  • add_retention_time()
  • clean_adduct()
  • clean_compound_name()
  • correct_charge()
  • default_filters()
  • derive_adduct_from_name()
  • derive_annotation_from_compound_name()
  • derive_formula_from_name()
  • derive_inchi_from_smiles()
  • derive_inchikey_from_inchi()
  • derive_ionmode()
  • derive_smiles_from_inchi()
  • harmonize_undefined_inchi()
  • harmonize_undefined_inchikey()
  • harmonize_undefined_smiles()
  • interpret_pepmass()
  • make_charge_int()
  • normalize_intensities()
  • reduce_to_number_of_peaks()
  • remove_peaks_around_precursor_mz()
  • remove_peaks_outside_top_k()
  • repair_adduct_based_on_smiles()
  • repair_inchi_inchikey_smiles()
  • repair_not_matching_annotation()
  • repair_parent_mass_is_mol_wt()
  • repair_parent_mass_match_smiles_wrapper()
  • repair_precursor_is_parent_mass()
  • repair_smiles_of_salts()
  • require_correct_ionmode()
  • require_minimum_number_of_high_peaks()
  • require_minimum_number_of_peaks()
  • require_parent_mass_match_smiles()
  • require_precursor_below_mz()
  • require_precursor_mz()
  • require_valid_annotation()
  • select_by_intensity()
  • select_by_mz()
  • select_by_relative_intensity()
  • Subpackages
    • matchms.filtering.filter_utils package
      • Submodules
    • matchms.filtering.metadata_processing package
      • Submodules
    • matchms.filtering.peak_processing package
      • Submodules
  • Submodules
    • matchms.filtering.SpeciesString module
      • SpeciesString
    • matchms.filtering.SpectrumProcessor module
      • ProcessingReport
      • SpectrumProcessor
      • check_all_parameters_given()
      • create_partial_function()
      • get_parameter_settings()
      • objects_differ()
    • matchms.filtering.default_filters module
      • default_filters()
    • matchms.filtering.default_pipelines module
    • matchms.filtering.filter_order module
• matchms.importing package
  • Functions for importing mass spectral data
  • load_from_json()
  • load_from_mgf()
  • load_from_msp()
  • load_from_mzml()
  • load_from_mzxml()
  • load_from_pickle()
  • load_from_usi()
  • load_spectra()
  • scores_from_json()
  • scores_from_pickle()
  • Submodules
    • matchms.importing.load_from_json module
      • as_spectrum()
      • dict2spectrum()
      • load_from_json()
      • scores_json_decoder()
    • matchms.importing.load_from_mgf module
      • load_from_mgf()
    • matchms.importing.load_from_msp module
      • contains_metadata()
      • get_peak_comment()
      • get_peak_values()
      • load_from_msp()
      • parse_metadata()
      • parse_msp_file()
    • matchms.importing.load_from_mzml module
      • load_from_mzml()
    • matchms.importing.load_from_mzxml module
      • load_from_mzxml()
    • matchms.importing.load_from_pickle module
      • load_from_pickle()
    • matchms.importing.load_from_usi module
      • load_from_usi()
    • matchms.importing.load_scores module
      • scores_from_json()
      • scores_from_pickle()
    • matchms.importing.load_spectra module
      • load_list_of_spectrum_files()
      • load_spectra()
    • matchms.importing.parsing_utils module
      • find_by_key()
      • parse_mzml_mzxml_metadata()
      • parse_spectrum_dict()
      • sort_by_mz()
• matchms.networking package
  • Functions for creating and analysing spectral networks
  • SimilarityNetwork
    • SimilarityNetwork.__init__()
    • SimilarityNetwork.create_network()
    • SimilarityNetwork.export_to_file()
    • SimilarityNetwork.export_to_graphml()
    • SimilarityNetwork.graph
  • Submodules
    • matchms.networking.SimilarityNetwork module
      • SimilarityNetwork
    • matchms.networking.networking_functions module
      • get_top_hits()
• matchms.plotting package
  • Functions for plotting one or multiple spectra
  • plot_spectra_array()
  • plot_spectra_mirror()
  • plot_spectrum()
  • Submodules
    • matchms.plotting.spectrum_plots module
      • plot_spectra_array()
      • plot_spectra_mirror()
      • plot_spectrum()
• matchms.similarity package
  • Functions for computing spectra similarities
  • CosineGreedy
    • CosineGreedy.__init__()
    • CosineGreedy.keep_score()
    • CosineGreedy.matrix()
    • CosineGreedy.pair()
    • CosineGreedy.sparse_array()
    • CosineGreedy.to_dict()
  • CosineHungarian
    • CosineHungarian.__init__()
    • CosineHungarian.keep_score()
    • CosineHungarian.matrix()
    • CosineHungarian.pair()
    • CosineHungarian.sparse_array()
    • CosineHungarian.to_dict()
  • FingerprintSimilarity
    • FingerprintSimilarity.__init__()
    • FingerprintSimilarity.keep_score()
    • FingerprintSimilarity.matrix()
    • FingerprintSimilarity.pair()
    • FingerprintSimilarity.score_datatype
    • FingerprintSimilarity.sparse_array()
    • FingerprintSimilarity.to_dict()
  • IntersectMz
    • IntersectMz.__init__()
    • IntersectMz.keep_score()
    • IntersectMz.matrix()
    • IntersectMz.pair()
    • IntersectMz.score_datatype
    • IntersectMz.sparse_array()
    • IntersectMz.to_dict()
  • MetadataMatch
    • MetadataMatch.__init__()
    • MetadataMatch.keep_score()
    • MetadataMatch.matrix()
    • MetadataMatch.pair()
    • MetadataMatch.score_datatype
    • MetadataMatch.sparse_array()
    • MetadataMatch.to_dict()
  • ModifiedCosine
    • ModifiedCosine.__init__()
    • ModifiedCosine.keep_score()
    • ModifiedCosine.matrix()
    • ModifiedCosine.pair()
    • ModifiedCosine.sparse_array()
    • ModifiedCosine.to_dict()
  • NeutralLossesCosine
    • NeutralLossesCosine.__init__()
    • NeutralLossesCosine.keep_score()
    • NeutralLossesCosine.matrix()
    • NeutralLossesCosine.pair()
    • NeutralLossesCosine.sparse_array()
    • NeutralLossesCosine.to_dict()
  • ParentMassMatch
    • ParentMassMatch.__init__()
    • ParentMassMatch.keep_score()
    • ParentMassMatch.matrix()
    • ParentMassMatch.pair()
    • ParentMassMatch.score_datatype
    • ParentMassMatch.sparse_array()
    • ParentMassMatch.to_dict()
  • PrecursorMzMatch
    • PrecursorMzMatch.__init__()
    • PrecursorMzMatch.keep_score()
    • PrecursorMzMatch.matrix()
    • PrecursorMzMatch.pair()
    • PrecursorMzMatch.score_datatype
    • PrecursorMzMatch.sparse_array()
    • PrecursorMzMatch.to_dict()
  • Submodules
    • matchms.similarity.BaseSimilarity module
      • BaseSimilarity
    • matchms.similarity.CosineGreedy module
      • CosineGreedy
    • matchms.similarity.CosineHungarian module
      • CosineHungarian
    • matchms.similarity.FingerprintSimilarity module
      • FingerprintSimilarity
    • matchms.similarity.IntersectMz module
      • IntersectMz
    • matchms.similarity.MetadataMatch module
      • MetadataMatch
    • matchms.similarity.ModifiedCosine module
      • ModifiedCosine
    • matchms.similarity.NeutralLossesCosine module
      • NeutralLossesCosine
    • matchms.similarity.ParentMassMatch module
      • ParentMassMatch
    • matchms.similarity.PrecursorMzMatch module
      • PrecursorMzMatch
    • matchms.similarity.spectrum_similarity_functions module
      • collect_peak_pairs()
      • find_matches()
      • number_matching()
      • number_matching_ppm()
      • number_matching_symmetric()
      • number_matching_symmetric_ppm()
      • score_best_matches()
    • matchms.similarity.vector_similarity_functions module
      • cosine_similarity()
      • cosine_similarity_matrix()
      • dice_similarity()
      • dice_similarity_matrix()
      • jaccard_index()
      • jaccard_similarity_matrix()

Submodules

• matchms.Fragments module
  • Fragments
    • Fragments.mz
    • Fragments.intensities
    • Fragments.__init__()
    • Fragments.intensities
    • Fragments.mz
    • Fragments.to_numpy
• matchms.Metadata module
  • Metadata
    • Metadata.__init__()
    • Metadata.get()
    • Metadata.harmonize_keys()
    • Metadata.harmonize_values()
    • Metadata.items()
    • Metadata.keys()
    • Metadata.set()
    • Metadata.set_key_replacements()
    • Metadata.to_dict()
    • Metadata.values()
• matchms.Pipeline module
  • Pipeline
    • Pipeline.__init__()
    • Pipeline.check_workflow()
    • Pipeline.import_spectrums()
    • Pipeline.run()
    • Pipeline.set_logging()
    • Pipeline.write_to_logfile()
  • check_score_computation()
  • create_workflow()
  • get_unused_filters()
• matchms.Scores module
  • Scores
    • Scores.__init__()
    • Scores.calculate()
    • Scores.filter_by_range()
    • Scores.scores_by_query()
    • Scores.scores_by_reference()
    • Scores.to_array()
    • Scores.to_coo()
    • Scores.to_dict()
    • Scores.to_json()
    • Scores.to_pickle()
  • ScoresBuilder
    • ScoresBuilder.__init__()
    • ScoresBuilder.build()
    • ScoresBuilder.from_json()
  • ScoresJSONEncoder
    • ScoresJSONEncoder.__init__()
    • ScoresJSONEncoder.default()
    • ScoresJSONEncoder.encode()
    • ScoresJSONEncoder.iterencode()
• matchms.Spectrum module
  • Spectrum
    • Spectrum.peaks
    • Spectrum.losses
    • Spectrum.metadata
    • Spectrum.__init__()
    • Spectrum.clone()
    • Spectrum.get()
    • Spectrum.metadata_dict()
    • Spectrum.metadata_hash()
    • Spectrum.plot()
    • Spectrum.plot_against()
    • Spectrum.set()
    • Spectrum.spectrum_hash()
    • Spectrum.to_dict()
    • Spectrum.update_peak_comments_mz_tolerance()
• matchms.Spikes module
  • Spikes
    • Spikes.__init__()
    • Spikes.intensities
    • Spikes.mz
    • Spikes.to_numpy
• matchms.calculate_scores module
  • calculate_scores()
• matchms.constants module
• matchms.hashing module
  • metadata_hash()
  • spectrum_hash()
• matchms.logging_functions module
  • add_logging_to_file()
  • reset_matchms_logger()
  • set_matchms_logger_level()
• matchms.typing module
  • ReferencesType
• matchms.utils module
  • filter_none()
  • get_common_keys()
  • get_first_common_element()
  • load_export_key_conversions()
  • load_known_key_conversions()
• matchms.yaml_file_functions module
  • ordered_load()