' + + '' + + _("Hide Search Matches") + + "
" + ) + ); + }, + + /** + * helper function to hide the search marks again + */ + hideSearchWords: () => { + document + .querySelectorAll("#searchbox .highlight-link") + .forEach((el) => el.remove()); + document + .querySelectorAll("span.highlighted") + .forEach((el) => el.classList.remove("highlighted")); + localStorage.removeItem("sphinx_highlight_terms") + }, + + initEscapeListener: () => { + // only install a listener if it is really needed + if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) return; + + document.addEventListener("keydown", (event) => { + // bail for input elements + if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return; + // bail with special keys + if (event.shiftKey || event.altKey || event.ctrlKey || event.metaKey) return; + if (DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS && (event.key === "Escape")) { + SphinxHighlight.hideSearchWords(); + event.preventDefault(); + } + }); + }, +}; + +_ready(() => { + /* Do not call highlightSearchWords() when we are on the search page. + * It will highlight words from the *previous* search query. + */ + if (typeof Search === "undefined") SphinxHighlight.highlightSearchWords(); + SphinxHighlight.initEscapeListener(); +}); diff --git a/v0.3.6-alpha/imspy/genindex.html b/v0.3.6-alpha/imspy/genindex.html new file mode 100644 index 00000000..f77ae184 --- /dev/null +++ b/v0.3.6-alpha/imspy/genindex.html @@ -0,0 +1,2069 @@ + + + + + + +| + | + |
|
+
|
+
| + | + |
| + |
| + | + |
| + | + |
| + |
| + |
| + | + |
Bases: PeptideIonMobilityApex
ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
DataFrame
Bases: Model
Builds the model based on input shapes received.
+This is to be used for subclassed models, which do not know at +instantiation time what their inputs look like.
+This method only exists for users who want to call model.build() in a +standalone way (as a substitute for calling the model on real data to +build it). It will never be called by the framework (and thus it will +never throw unexpected errors in an unrelated workflow).
+input_shape – Single tuple, TensorShape instance, or list/dict of +shapes, where shapes are tuples, integers, or TensorShape +instances.
+ValueError –
In case of invalid user-provided data (not of type tuple, + list, TensorShape, or dict). + 2. If the model requires call arguments that are agnostic + to the input shapes (positional or keyword arg in call + signature). + 3. If not all layers were properly built. + 4. If float type inputs are not supported within the layers.
In each of these cases, the user should build their model by calling –
it on real tensor data. –
Calls the model on new inputs and returns the outputs as tensors.
+In this case call() just reapplies +all ops in the graph to the new inputs +(e.g. build a new computational graph from the provided inputs).
+Note: This method should not be called directly. It is only meant to be +overridden when subclassing tf.keras.Model. +To call a model on an input, always use the __call__() method, +i.e. model(inputs), which relies on the underlying call() method.
+inputs – Input tensor, or dict/list/tuple of input tensors.
training – Boolean or boolean scalar tensor, indicating whether to +run the Network in training mode or inference mode.
mask – A mask or list of masks. A mask can be either a boolean tensor +or None (no mask). For more details, check the guide +[here](https://www.tensorflow.org/guide/keras/masking_and_padding).
A tensor if there is a single output, or +a list of tensors if there are more than one outputs.
+Creates a layer from its config.
+This method is the reverse of get_config, +capable of instantiating the same layer from the config +dictionary. It does not handle layer connectivity +(handled by Network), nor weights (handled by set_weights).
+config – A Python dictionary, typically the +output of get_config.
+A layer instance.
+Returns the config of the Model.
+Config is a Python dictionary (serializable) containing the +configuration of an object, which in this case is a Model. This allows +the Model to be be reinstantiated later (without its trained weights) +from this configuration.
+Note that get_config() does not guarantee to return a fresh copy of +dict every time it is called. The callers should make a copy of the +returned dict if they want to modify it.
+Developers of subclassed Model are advised to override this method, +and continue to update the dict from super(MyModel, self).get_config() +to provide the proper configuration of this Model. The default config +will return config dict for init parameters if they are basic types. +Raises NotImplementedError when in cases where a custom +get_config() implementation is required for the subclassed model.
+Python dictionary containing the configuration of this Model.
+Bases: ABC
ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
DataFrame
Bases: Layer
Creates the variables of the layer (for subclass implementers).
+This is a method that implementers of subclasses of Layer or Model +can override if they need a state-creation step in-between +layer instantiation and layer call. It is invoked automatically before +the first execution of call().
+This is typically used to create the weights of Layer subclasses +(at the discretion of the subclass implementer).
+input_shape – Instance of TensorShape, or list of instances of +TensorShape if the layer expects a list of inputs +(one instance per input).
+This is where the layer’s logic lives.
+The call() method may not create state (except in its first +invocation, wrapping the creation of variables or other resources in +tf.init_scope()). It is recommended to create state, including +tf.Variable instances and nested Layer instances,
+++in __init__(), or in the build() method that is
+
called automatically before call() executes for the first time.
+inputs –
Input tensor, or dict/list/tuple of input tensors. +The first positional inputs argument is subject to special rules: +- inputs must be explicitly passed. A layer cannot have zero
+++arguments, and inputs cannot be provided via the default value +of a keyword argument.
+
NumPy array or Python scalar values in inputs get cast as +tensors.
Keras mask metadata is only collected from inputs.
Layers are built (build(input_shape) method) +using shape info from inputs only.
input_spec compatibility is only checked against inputs.
Mixed precision input casting is only applied to inputs. +If a layer has tensor arguments in *args or **kwargs, their +casting behavior in mixed precision should be handled manually.
The SavedModel input specification is generated using inputs +only.
Integration with various ecosystem packages like TFMOT, TFLite, +TF.js, etc is only supported for inputs and not for tensors in +positional and keyword arguments.
*args – Additional positional arguments. May contain tensors, although +this is not recommended, for the reasons above.
**kwargs –
Additional keyword arguments. May contain tensors, although +this is not recommended, for the reasons above. +The following optional keyword arguments are reserved: +- training: Boolean scalar tensor of Python boolean indicating
+++whether the call is meant for training or inference.
+
mask: Boolean input mask. If the layer’s call() method takes a +mask argument, its default value will be set to the mask +generated for inputs by the previous layer (if input did come +from a layer that generated a corresponding mask, i.e. if it came +from a Keras layer with masking support).
A tensor or list/tuple of tensors.
+Creates a layer from its config.
+This method is the reverse of get_config, +capable of instantiating the same layer from the config +dictionary. It does not handle layer connectivity +(handled by Network), nor weights (handled by set_weights).
+config – A Python dictionary, typically the +output of get_config.
+A layer instance.
+Returns the config of the layer.
+A layer config is a Python dictionary (serializable) +containing the configuration of a layer. +The same layer can be reinstantiated later +(without its trained weights) from this configuration.
+The config of a layer does not include connectivity +information, nor the layer class name. These are handled +by Network (one layer of abstraction above).
+Note that get_config() does not guarantee to return a fresh copy of +dict every time it is called. The callers should make a copy of the +returned dict if they want to modify it.
+Python dictionary.
+Fit the square root model to the provided data.
+:type mz: ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
+:param mz: The m/z values.
+:type charge: ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
+:param charge: The charge states.
+:type ccs: ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
+:param ccs: The collision cross sections.
+:type fit_charge_state_one: bool
+:param fit_charge_state_one: Whether to fit the charge state one.
Tuple[ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]], ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]]
The slopes and intercepts of the square root model fit.
+Model
Predicts the inverse ion mobility for a collection of peptide spectrum matches.
+:type psm_collection: List[Psm]
+:param psm_collection: A list of peptide spectrum matches.
+:type refine_model: bool
+:param refine_model: Whether to refine the model by fine-tuning it on the provided data.
+:type verbose: bool
+:param verbose: Whether to print additional information during the prediction.
None
None, the inverse ion mobility is set in the peptide spectrum matches in place.
+Bases: object
Tensor
Bases: CosimHasher
Class to create hash keys from a given set of weights.
+trials (int) – number of trials to use for random projection.
len_trial (int) – length of each trial.
seed (int) – seed for random projection.
resolution (int) – resolution of the random projection.
num_dalton (int) – number of dalton to use for random projection.
Bases: Callback
Called at the end of an epoch.
+Subclasses should override for any actions to run. This function should +only be called during TRAIN mode.
+epoch – Integer, index of epoch.
logs – Dict, metric results for this training epoch, and for the +validation epoch if validation is performed. Validation result +keys are prefixed with val_. For training epoch, the values of +the Model’s metrics are returned. Example: +{‘loss’: 0.2, ‘accuracy’: 0.7}.
Called at the beginning of training.
+Subclasses should override for any actions to run.
+logs – Dict. Currently no data is passed to this argument for this +method but that may change in the future.
+Called at the end of training.
+Subclasses should override for any actions to run.
+logs – Dict. Currently the output of the last call to +on_epoch_end() is passed to this argument for this method but +that may change in the future.
+Get the path to a pretrained model
+model_name (str) – The name of the model to load
Traversable
The path to the pretrained model
+Load a tokenizer from resources
+Tokenizer
The pretrained tokenizer
+Bases: ABC
ABSTRACT INTERFACE for simulation of ion-mobility apex value
+ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
DataFrame
Bases: IonIntensityPredictor
Wrapper for the Prosit 2023 TIMS-TOF predictor
+List[ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]]
DataFrame
DataFrame
Get the collision energy calibration factor for a given sample.
+:type sample: List[Psm]
+:param sample: a list of PeptideSpectrumMatch objects
+:type model: Prosit2023TimsTofWrapper
+:param model: a Prosit2023TimsTofWrapper object
+:type lower: int
+:param lower: lower bound for the search
+:type upper: int
+:param upper: upper bound for the search
+:type verbose: bool
+:param verbose: whether to print progress
the collision energy calibration factor and the angle similarities
+Tuple[float, List[float]]
+Get a pretrained deep predictor model +This model was downloaded from ZENODO: https://zenodo.org/records/8211811 +PAPER : https://doi.org/10.1101/2023.07.17.549401 +:returns: The pretrained deep predictor model
+Predict the fragment ion intensities using Prosit.
+:type psm_collection: List[Psm]
+:param psm_collection: a list of peptide-spectrum matches
+:type calibrate_collision_energy: bool
+:param calibrate_collision_energy: whether to calibrate the collision energy
+:type verbose: bool
+:param verbose: whether to print progress
+:type num_threads: int
+:param num_threads: number of threads to use
None
None, the fragment ion intensities are stored in the PeptideSpectrumMatch objects
+Remove the unimod annotation from a peptide sequence.
+:type sequence: str
+:param sequence: a peptide sequence
the peptide sequence without unimod annotation
+str
+The beta score is a variant of the OpenMS proposed score calculation, using predicted intensities instead of a constant value for the expected intensity. +:type fragments_observed: +:param fragments_observed: The Sage Fragment object containing the observed intensities +:type fragments_predicted: +:param fragments_predicted: The Sage Fragment object containing the predicted intensities, e.g. from Prosit
+The beta score, hyper score variant using predicted intensities instead of a constant value for the expected intensity
+float
+Generate a dataset for predicting fragment intensities using Prosit.
+:type sequences: List[str]
+:param sequences: A list of peptide sequences.
+:type charges: ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
+:param charges: A numpy array of precursor charges.
+:type collision_energies: ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]] | None
+:param collision_energies: A numpy array of collision energies.
A tf.data.Dataset object that yields batches of data in the format expected by the model.
+Get the list of fragment ion labels for Prosit.
+:rtype: List[str]
+:returns: List of fragment ion labels, giving the returned order of fragment intensities.
post process the predicted fragment intensities
+:type data_pred: DataFrame
+:param data_pred: dataframe containing the predicted fragment intensities
ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
numpy array of fragment intensities
+Convert a sequence to a list of indices into the alphabet.
+seq (str) – A string representing a sequence of amino acids.
max_length (int) – The maximum length of the sequence to allow.
ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
A list of integers, each representing an index into the alphabet.
+translate a list of fixed length numpy arrays into a tensorflow tensor
+:type sequences: List
+:param sequences: list of numpy arrays, representing peptide sequences
Tensor
tensorflow tensor
+Unpack the dictionary of features into the expected inputs for the model.
+features – A dictionary of features, with keys ‘peptides_in’, ‘precursor_charge_in’, and ‘collision_energy_in’
+(peptides, precursor_charge, collision_energy)
+A tuple of the expected inputs for the model
+Bases: PeptideChargeStateDistribution, ABC
DataFrame
array
Bases: PeptideChargeStateDistribution, ABC
Simulate charge state distribution for a pandas DataFrame containing peptide sequences
+data (DataFrame) – pandas DataFrame containing peptide sequences
charge_state_one_probability (float) – probability of charge state 1
batch_size (int) – batch size for prediction
min_charge_contrib (float) – minimum relative abundance of a charge state to be included in the output
DataFrame
pandas DataFrame containing simulated charge state distributions
+ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
Bases: Model
Builds the model based on input shapes received.
+This is to be used for subclassed models, which do not know at +instantiation time what their inputs look like.
+This method only exists for users who want to call model.build() in a +standalone way (as a substitute for calling the model on real data to +build it). It will never be called by the framework (and thus it will +never throw unexpected errors in an unrelated workflow).
+input_shape – Single tuple, TensorShape instance, or list/dict of +shapes, where shapes are tuples, integers, or TensorShape +instances.
+ValueError –
In case of invalid user-provided data (not of type tuple, + list, TensorShape, or dict). + 2. If the model requires call arguments that are agnostic + to the input shapes (positional or keyword arg in call + signature). + 3. If not all layers were properly built. + 4. If float type inputs are not supported within the layers.
In each of these cases, the user should build their model by calling –
it on real tensor data. –
Calls the model on new inputs and returns the outputs as tensors.
+In this case call() just reapplies +all ops in the graph to the new inputs +(e.g. build a new computational graph from the provided inputs).
+Note: This method should not be called directly. It is only meant to be +overridden when subclassing tf.keras.Model. +To call a model on an input, always use the __call__() method, +i.e. model(inputs), which relies on the underlying call() method.
+inputs – Input tensor, or dict/list/tuple of input tensors.
training – Boolean or boolean scalar tensor, indicating whether to +run the Network in training mode or inference mode.
mask – A mask or list of masks. A mask can be either a boolean tensor +or None (no mask). For more details, check the guide +[here](https://www.tensorflow.org/guide/keras/masking_and_padding).
A tensor if there is a single output, or +a list of tensors if there are more than one outputs.
+Creates a layer from its config.
+This method is the reverse of get_config, +capable of instantiating the same layer from the config +dictionary. It does not handle layer connectivity +(handled by Network), nor weights (handled by set_weights).
+config – A Python dictionary, typically the +output of get_config.
+A layer instance.
+Returns the config of the Model.
+Config is a Python dictionary (serializable) containing the +configuration of an object, which in this case is a Model. This allows +the Model to be be reinstantiated later (without its trained weights) +from this configuration.
+Note that get_config() does not guarantee to return a fresh copy of +dict every time it is called. The callers should make a copy of the +returned dict if they want to modify it.
+Developers of subclassed Model are advised to override this method, +and continue to update the dict from super(MyModel, self).get_config() +to provide the proper configuration of this Model. The default config +will return config dict for init parameters if they are basic types. +Raises NotImplementedError when in cases where a custom +get_config() implementation is required for the subclassed model.
+Python dictionary containing the configuration of this Model.
+Bases: ABC
ABSTRACT INTERFACE for ionization simulation of peptides
+DataFrame
array
ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
Get a pretrained deep predictor model
+Model
The pretrained deep predictor model
+Bases: PeptideChromatographyApex
DatasetV2
DatasetV2
ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
DataFrame
Bases: Model
Builds the model based on input shapes received.
+This is to be used for subclassed models, which do not know at +instantiation time what their inputs look like.
+This method only exists for users who want to call model.build() in a +standalone way (as a substitute for calling the model on real data to +build it). It will never be called by the framework (and thus it will +never throw unexpected errors in an unrelated workflow).
+input_shape – Single tuple, TensorShape instance, or list/dict of +shapes, where shapes are tuples, integers, or TensorShape +instances.
+ValueError –
In case of invalid user-provided data (not of type tuple, + list, TensorShape, or dict). + 2. If the model requires call arguments that are agnostic + to the input shapes (positional or keyword arg in call + signature). + 3. If not all layers were properly built. + 4. If float type inputs are not supported within the layers.
In each of these cases, the user should build their model by calling –
it on real tensor data. –
Calls the model on new inputs and returns the outputs as tensors.
+In this case call() just reapplies +all ops in the graph to the new inputs +(e.g. build a new computational graph from the provided inputs).
+Note: This method should not be called directly. It is only meant to be +overridden when subclassing tf.keras.Model. +To call a model on an input, always use the __call__() method, +i.e. model(inputs), which relies on the underlying call() method.
+inputs – Input tensor, or dict/list/tuple of input tensors.
training – Boolean or boolean scalar tensor, indicating whether to +run the Network in training mode or inference mode.
mask – A mask or list of masks. A mask can be either a boolean tensor +or None (no mask). For more details, check the guide +[here](https://www.tensorflow.org/guide/keras/masking_and_padding).
A tensor if there is a single output, or +a list of tensors if there are more than one outputs.
+Creates a layer from its config.
+This method is the reverse of get_config, +capable of instantiating the same layer from the config +dictionary. It does not handle layer connectivity +(handled by Network), nor weights (handled by set_weights).
+config – A Python dictionary, typically the +output of get_config.
+A layer instance.
+Returns the config of the Model.
+Config is a Python dictionary (serializable) containing the +configuration of an object, which in this case is a Model. This allows +the Model to be be reinstantiated later (without its trained weights) +from this configuration.
+Note that get_config() does not guarantee to return a fresh copy of +dict every time it is called. The callers should make a copy of the +returned dict if they want to modify it.
+Developers of subclassed Model are advised to override this method, +and continue to update the dict from super(MyModel, self).get_config() +to provide the proper configuration of this Model. The default config +will return config dict for init parameters if they are basic types. +Raises NotImplementedError when in cases where a custom +get_config() implementation is required for the subclassed model.
+Python dictionary containing the configuration of this Model.
+Bases: ABC
ABSTRACT INTERFACE for a chromatographic separation for peptides
+ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
DataFrame
DatasetV2
DatasetV2
Model
Predict the retention times for a collection of peptide-spectrum matches
+:type psm_collection: List[Psm]
+:param psm_collection: a list of peptide-spectrum matches
+:type refine_model: bool
+:param refine_model: whether to refine the model
+:type verbose: bool
+:param verbose: whether to print verbose output
None
None, retention times are set in the peptide-spectrum matches
+Convert CCS to reduced ion mobility (1/k0).
+ccs – collision cross-section
mz – mass-over-charge of the ion
charge – charge state of the ion
mass_gas – mass of drift gas
temp – temperature of the drift gas in C°
t_diff – factor to translate from C° to K
reduced ion mobility
+float
+Convert reduced ion mobility (1/k0) to CCS.
+one_over_k0 – reduced ion mobility
mz – mass-over-charge of the ion
charge – charge state of the ion
mass_gas – mass of drift gas
temp – temperature of the drift gas in C°
t_diff – factor to translate from C° to K
collision cross-section
+float
+Calculate m/z value.
+mass (float) – Mass.
charge (int) – Charge.
m/z value.
+float
+Calculate transmission dependent fragment ion isotope distribution.
+target_spec (MzSpectrum) – Target spectrum.
complement_spec (MzSpectrum) – Complement spectrum.
transmitted_isotopes (MzSpectrum) – Transmitted isotopes.
max_isotope (int) – Maximum isotope.
Transmission dependent fragment ion isotope distribution.
+Bases: RustWrapperObject
Calculate the isotopic spectrum of the peptide ion.
+mass_tolerance (float) – The mass tolerance for the isotopic spectrum calculation.
abundance_threshold (float) – The abundance threshold for the isotopic spectrum calculation.
max_result (int) – The maximum number of results to return.
intensity_min (float) – The minimum intensity of the isotopic spectrum.
The isotopic spectrum of the peptide ion.
+Calculate the isotopic spectrum of the peptide ion.
+mass_tolerance (float) – The mass tolerance for the isotopic spectrum calculation.
abundance_threshold (float) – The abundance threshold for the isotopic spectrum calculation.
max_result (int) – The maximum number of results to return.
intensity_min (float) – The minimum intensity of the isotopic spectrum.
The isotopic spectrum of the peptide ion.
+str
Bases: RustWrapperObject
Calculate the isotope distribution of the product ion.
+mass_tolerance (float) – The mass tolerance for the isotope distribution calculation.
abundance_threshold (float) – The abundance threshold for the isotope distribution calculation.
max_result (int) – The maximum number of results to return.
intensity_min (float) – The minimum intensity of the isotope distribution.
List[Tuple[float, float]]
The isotope distribution of the product ion.
+str
Bases: RustWrapperObject
str
Bases: RustWrapperObject
Find the product ion series with the given charge.
+charge (int) – The charge of the product ion series.
Optional[PeptideProductIonSeries]
The product ion series with the given charge, or None if not found.
+Calculate the isotope distribution of the product ion series collection.
+mass_tolerance (float) – The mass tolerance for the isotope distribution calculation.
abundance_threshold (float) – The abundance threshold for the isotope distribution calculation.
max_result (int) – The maximum number of results to return.
intensity_min (float) – The minimum intensity of the isotope distribution.
The isotope distribution of the product ion series collection.
+Calculate the isotope distribution of the product ion series collection.
+mass_tolerance (float) – The mass tolerance for the isotope distribution calculation.
abundance_threshold (float) – The abundance threshold for the isotope distribution calculation.
max_result (int) – The maximum number of results to return.
intensity_min (float) – The minimum intensity of the isotope distribution.
The isotope distribution of the product ion series collection.
+str
Bases: RustWrapperObject
Associate the peptide sequence with predicted intensities from Prosit intensity prediction.
+flat_intensities (List[float]) – The flat intensities.
TODO (#) – check how charge should be handled
charge (int) – The charge of the product ions.
fragment_type (str) – The type of the product ions, must be one of ‘a’, ‘b’, ‘c’, ‘x’, ‘y’, ‘z’.
normalize (bool) – Whether to normalize the intensities.
half_charge_one (bool) – Whether to use half charge one.
The b and y product ion series of the peptide sequence.
+Calculate the isotopic product ion spectrum of the peptide sequence.
+intensity_min (float)
max_result (int)
abundance_threshold (float)
mass_tolerance (float)
charge (int) – The charge of the product ions.
fragment_type (str) – The type of the product ions, must be one of ‘a’, ‘b’, ‘c’, ‘x’, ‘y’, ‘z’.
The isotopic product ion spectrum of the peptide sequence.
+Calculate the mono-isotopic product ion spectrum of the peptide sequence.
+charge (int) – The charge of the product ions.
fragment_type (str) – The type of the product ions, must be one of ‘a’, ‘b’, ‘c’, ‘x’, ‘y’, ‘z’.
The mono-isotopic product ion spectrum of the peptide sequence.
+Calculate the mono-isotopic product ion spectrum of the peptide sequence.
+charge (int) – The charge of the product ions.
fragment_type (str) – The type of the product ions, must be one of ‘a’, ‘b’, ‘c’, ‘x’, ‘y’, ‘z’.
The mono-isotopic product ion spectrum of the peptide sequence.
+Calculate the b and y product ion series of the peptide sequence.
+charge (int) – The charge of the product ions.
fragment_type (str) – The type of the product ions, must be one of ‘a’, ‘b’, ‘c’, ‘x’, ‘y’, ‘z’.
Tuple[List[PeptideProductIon], List[PeptideProductIon]]
The b and y product ion series of the peptide sequence.
+str
Tuple[str, List[float]]
List[str]
Bases: RustWrapperObject
Data.
+Data.
+pd.DataFrame
+Filter the spectrum for a given m/z range and intensity range.
+mz_min (float) – Minimum m/z value.
mz_max (float) – Maximum m/z value.
intensity_min (float, optional) – Minimum intensity value. Defaults to 0.0.
intensity_max (float, optional) – Maximum intensity value. Defaults to 1e9.
Filtered spectrum.
+Create a IndexedMzSpectrum from a PyIndexedMzSpectrum.
+spec (pims.PyIndexedMzSpectrum) – PyIndexedMzSpectrum to create the IndexedMzSpectrum from.
+IndexedMzSpectrum created from the PyIndexedMzSpectrum.
+Get the spec_ptr.
+spec_ptr.
+pims.PyIndexedMzSpectrum
+Index.
+Index.
+NDArray[np.int32]
+Intensity.
+Intensity.
+NDArray[np.float64]
+m/z.
+m/z.
+NDArray[np.float64]
+Bases: RustWrapperObject
Add normal noise to the intensity values of the spectrum.
+noise_ppm (float) – Noise ppm, noise will be sampled from a normal distribution with mean 0 and std noise_ppm / 3.0.
+Spectrum with added noise.
+Add uniform noise to the m/z values of the spectrum.
+noise_ppm (float) – Noise ppm, noise will be sampled from a uniform distribution with mean 0 and std noise_ppm.
right_drag (bool, optional) – If true, the noise will be shifted to the right. Defaults to False.
Spectrum with added noise.
+Data.
+Data.
+pd.DataFrame
+Filter the spectrum for a given m/z range and intensity range.
+mz_min (float) – Minimum m/z value.
mz_max (float) – Maximum m/z value.
intensity_min (float, optional) – Minimum intensity value. Defaults to 0.0.
intensity_max (float, optional) – Maximum intensity value. Defaults to 1e9.
Filtered spectrum.
+Generates a convoluted mass spectrum by adding all spectra in the given list.
+spectra_list (List[MzSpectrum]) – List of mass spectra.
resolution (int) – Desired resolution of returned spectrum.
Convoluted spectrum.
+Create a MzSpectrum from a PyMzSpectrum.
+spec (pims.PyMzSpectrum) – PyMzSpectrum to create the MzSpectrum from.
+MzSpectrum created from the PyMzSpectrum.
+Get the spec_ptr.
+spec_ptr.
+pims.PyMzSpectrum
+Intensity.
+Intensity.
+NDArray[np.float64]
+m/z.
+m/z.
+NDArray[np.float64]
+Convert the spectrum to a centroided spectrum.
+Centroided spectrum.
+generates json string representation of MzSpectrum
+str
Bins the spectrum’s m/z values to a +given resolution and sums the intensities.
+resolution (int) – Negative decadic logarithm of bin size.
+A new MzSpectrum where m/z values are binned according to the given resolution.
+Convert the spectrum to a list of windows.
+window_length (float, optional) – Window length. Defaults to 10.
overlapping (bool, optional) – Whether the windows should overlap. Defaults to True.
min_num_peaks (int, optional) – Minimum number of peaks in a window. Defaults to 5.
min_intensity (float, optional) – Minimum intensity of a peak in a window. Defaults to 1.
List of windows.
+Tuple[NDArray, List[MzSpectrum]]
+Convert the spectrum to a vectorized spectrum.
+resolution (int, optional) – Resolution. Defaults to 2.
+Vectorized spectrum.
+Bases: RustWrapperObject
Create a MzSpectrum from a PyMzSpectrum.
+spec (pims.PyMzSpectrum) – PyMzSpectrum to create the MzSpectrum from.
+MzSpectrum created from the PyMzSpectrum.
+Get the spec_ptr.
+spec_ptr.
+pims.PyMzSpectrumVectorized
+m/z.
+m/z.
+NDArray[np.float64]
+Resolution.
+Resolution.
+float
+Convert the spectrum to a centroided spectrum.
+Centroided spectrum.
+Intensity.
+Intensity.
+NDArray[np.float64]
+Bases: RustWrapperObject
Data.
+Data.
+pd.DataFrame
+Filter the spectrum for a given m/z range and intensity range.
+mz_min (float) – Minimum m/z value.
mz_max (float) – Maximum m/z value.
intensity_min (float, optional) – Minimum intensity value. Defaults to 0.0.
intensity_max (float, optional) – Maximum intensity value. Defaults to 1e9.
Filtered spectrum.
+Frame ID.
+Frame ID.
+int
+Create a TimsSpectrum from a PyTimsSpectrum.
+spec (pims.PyTimsSpectrum) – PyTimsSpectrum to create the TimsSpectrum from.
+TimsSpectrum created from the PyTimsSpectrum.
+Get the spec_ptr.
+spec_ptr.
+pims.PyTimsSpectrum
+Index.
+Index.
+NDArray[np.int32]
+Intensity.
+Intensity.
+NDArray[np.float64]
+Inverse mobility.
+Inverse mobility.
+float
+MS type.
+MS type.
+str
+m/z.
+m/z.
+NDArray[np.float64]
+Get the MzSpectrum.
+Spectrum.
+Retention time.
+Retention time.
+float
+Scan.
+Scan.
+int
+Calculates the integral of the peaks in a spectrum.
+peaks (NDArray[np.int32]) – Peak indices.
peak_info (dict) – Peak info.
Peak integrals.
+NDArray[np.float64]
+Bases: object
ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
Create an instance from existing data without calling __init__.
+DataFrame
DataFrame
Bases: TimsTofAcquisitionBuilder, ABC
ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
Bases: TimsTofAcquisitionBuilder, ABC
ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
Create an instance from existing data for DIA without calling __init__.
+DataFrame
Bases: RustWrapperObject
PyContributionSource
Bases: RustWrapperObject
PyMzSpectrumAnnotated
Bases: RustWrapperObject
PyPeakAnnotation
Bases: ABC
Bases: RustWrapperObject
PySignalAttributes
Bases: RustWrapperObject
PySourceType
Bases: RustWrapperObject
PyTimsFrameAnnotated
Bases: object
DataFrame
Bases: SyntheticExperimentDataHandle, ABC
Bases: RustWrapperObject
Build a frame.
+frame_id (int) – Frame ID.
fragment (bool) – if true, frame will undergo synthetic fragmentation if it is a fragment frame,
fragmentation. (otherwise quadrupole isolation will still be applied but no)
mz_noise_precursor (bool) – if true, noise will be added to the precursor m/z values.
mz_noise_uniform (bool) – if true, noise will be added to the precursor m/z values uniformly.
precursor_noise_ppm (float) – PPM of the precursor noise.
mz_noise_fragment (bool) – if true, noise will be added to the fragment m/z values.
fragment_noise_ppm (float) – PPM of the fragment noise.
right_drag (bool) – if true, the noise will be shifted to the right.
Frame.
+Build a frame. The frame will be annotated.
+frame_id (int) – Frame ID.
fragment (bool) – if true, frame will undergo synthetic fragmentation if it is a fragment frame,
fragmentation. (otherwise quadrupole isolation will still be applied but no)
mz_noise_precursor (bool) – if true, noise will be added to the precursor m/z values.
mz_noise_uniform (bool) – if true, noise will be added to the precursor m/z values uniformly.
precursor_noise_ppm (float) – PPM of the precursor noise.
mz_noise_fragment (bool) – if true, noise will be added to the fragment m/z values.
fragment_noise_ppm (float) – PPM of the fragment noise.
right_drag (bool) – if true, the noise will be shifted to the right.
Frame.
+Build frames.
+frame_ids (List[int]) – Frame IDs.
fragment (bool) – if true, frame will undergo synthetic fragmentation if it is a fragment frame,
fragmentation. (otherwise quadrupole isolation will still be applied but no)
mz_noise_precursor (bool) – if true, noise will be added to the precursor m/z values.
mz_noise_uniform (bool) – if true, noise will be added to the precursor m/z values uniformly.
precursor_noise_ppm (float) – PPM of the precursor noise.
mz_noise_fragment (bool) – if true, noise will be added to the fragment m/z values.
fragment_noise_ppm (float) – PPM of the fragment noise.
right_drag (bool) – if true, the noise will be shifted to the right.
num_threads (int) – Number of threads.
Frames.
+List[TimsFrame]
+Build frames. The frames will be annotated.
+frame_ids (List[int]) – Frame IDs.
fragment (bool) – if true, frame will undergo synthetic fragmentation if it is a fragment frame,
fragmentation. (otherwise quadrupole isolation will still be applied but no)
mz_noise_precursor (bool) – if true, noise will be added to the precursor m/z values.
mz_noise_uniform (bool) – if true, noise will be added to the precursor m/z values uniformly.
precursor_noise_ppm (float) – PPM of the precursor noise.
mz_noise_fragment (bool) – if true, noise will be added to the fragment m/z values.
fragment_noise_ppm (float) – PPM of the fragment noise.
right_drag (bool) – if true, the noise will be shifted to the right.
num_threads (int) – Number of threads.
Frames.
+List[TimsFrameAnnotated]
+(int, int)
List[Tuple[int, int]]
Create a TimsTofSyntheticFrameBuilderDIA from a PyTimsTofSyntheticsFrameBuilderDIA.
+py_ptr (ims.PyTimsTofSyntheticsFrameBuilderDIA) – PyTimsTofSyntheticsFrameBuilderDIA.
+TimsTofSyntheticFrameBuilderDIA.
+List[float]
float
ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
PyTimsTofSyntheticsFrameBuilderDIA
Bases: RustWrapperObject
List[TimsFrameAnnotated]
PyTimsTofSyntheticsPrecursorFrameBuilder
This module contains several noise models, +such as detection noise, shot noise and baseline noise.
+signal (Union[_SupportsArray[dtype[Any]], _NestedSequence[_SupportsArray[dtype[Any]]], bool, int, float, complex, str, bytes, _NestedSequence[Union[bool, int, float, complex, str, bytes]]])
method (str)
custom_mu_function (Optional[Callable])
custom_sigma_function (Optional[Callable])
Union[_SupportsArray[dtype[Any]], _NestedSequence[_SupportsArray[dtype[Any]]], bool, int, float, complex, str, bytes, _NestedSequence[Union[bool, int, float, complex, str, bytes]]]
Union[_SupportsArray[dtype[Any]], _NestedSequence[_SupportsArray[dtype[Any]]], bool, int, float, complex, str, bytes, _NestedSequence[Union[bool, int, float, complex, str, bytes]]]
Union[_SupportsArray[dtype[Any]], _NestedSequence[_SupportsArray[dtype[Any]]], bool, int, float, complex, str, bytes, _NestedSequence[Union[bool, int, float, complex, str, bytes]]]
Union[_SupportsArray[dtype[Any]], _NestedSequence[_SupportsArray[dtype[Any]]], bool, int, float, complex, str, bytes, _NestedSequence[Union[bool, int, float, complex, str, bytes]]]
Bases: object
Bases: object
Build a row for the frame meta data table from a TimsFrame object.
+:type frame: TimsFrame
+:param frame: TimsFrame object
+:type scan_mode: int
+:param scan_mode: int
+:type frame_start_pos: int
+:param frame_start_pos: int
+:type only_frame_one: bool
+:param only_frame_one: bool
Compress a single frame using zstd.
+:type frame: TimsFrame
+:param frame: TimsFrame object
+:type only_frame_one: bool
+:param only_frame_one: bool
compressed data
+bytes
+DataFrame
Convert inverse mobility values to scan values for a given frame using the helper handle. +# CAUTION: This will use the calibration data from the reference handle.
+Convert m/z values to TOF values for a given frame using the helper handle. +# CAUTION: This will use the calibration data from the reference handle.
+Convert scan values to inverse mobility values for a given frame using the helper handle. +# CAUTION: This will use the calibration data from the reference handle.
+Convert TOF values to m/z values for a given frame using the helper handle. +# CAUTION: This will use the calibration data from the reference handle.
+None
None
Write a single frame to the binary file.
+:type frame: TimsFrame
+:param frame: TimsFrame object
+:type scan_mode: int
+:param scan_mode: int
+:type only_frame_one: bool
+:param only_frame_one: bool
None
None
Calculate the accumulated intensity between two points using the custom CDF.
+Calculate the m/z value of a b or y fragment.
+:type sequence: str
+:param sequence: the peptide sequence
+:type modifications: ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
+:param modifications: potential modifications
+:type is_y: bool
+:param is_y: is the fragment a y ion
+:type charge: int
+:param charge: the charge state of the peptide precursor
float
m/z value of the fragment
+Calculate the b and y ion series for a given peptide sequence.
+:type sequence: str
+:param sequence: the peptide sequence
+:type modifications: ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
+:param modifications: potential modifications
+:type charge: int
+:param charge: the charge state of the peptide precursor
Tuple[List, List]
b ion series, y ion series
+Calculate the bounds of a normal distribution for a given z-score.
+mean (float) – Mean of the normal distribution
std (float) – Standard deviation of the normal distribution
z_score (float) – Z-score of the normal distribution
Lower bound of the normal distribution
+float
+Calculate the amount of mobility that will be occupied by a single scan
+mobility_min (float) – Minimum mobility value
mobility_max (float) – Maximum mobility value
num_scans (int) – Number of scans that will be taken during the acquisition
Mobility spacing
+float
+Calculate the number of frames that will be taken during the acquisition
+gradient_length (float) – Length of the gradient in seconds
rt_cycle_length (float) – Length of the RT cycle in seconds
Number of frames that will be taken during the acquisition
+int
+Custom implementation of the CDF for a normal distribution.
+Get the path to a pretrained model
+acquisition_mode (str) – The name of the model to load
Traversable
The path to the pretrained model
+Dict[str, float]
Check if the provided fasta path is a folder or file, if its a folder, check if it exists and return all fasta +:type fasta_path: +:param fasta_path: Path to the fasta file or folder containing fasta files
+Dict[str, str]
List of fasta file paths
+Get the frames that will be acquired for a given retention time value. +:type rt_value: +:param rt_value: Retention time value +:type rt_value: float +:type times_array: +:param times_array: Array of retention times +:type times_array: NDArray +:type std_rt: +:param std_rt: Standard deviation of the retention time +:type std_rt: float +:type z_score: +:param z_score: Z-score of the normal distribution +:type z_score: float
+Array of frame indices
+NDArray
+Get the path to a pretrained model
+Traversable
The path to the pretrained model
+Get the path to a pretrained model
+ds_name (str) – The name of the dataset to load
str
The path to the pretrained model
+Get the scans that will be acquired for a given ion mobility value.
+Scale an array of values from the original range (min_val, max_val) to a new range (new_min, new_max).
+irt (NDArray) – Array of values to be scaled.
new_min (float) – Minimum value of the new range.
new_max (float) – Maximum value of the new range.
Array of scaled values.
+NDArray
+str
Dict[str, Any]
Simulate ion intensities for a peptide sequence, charge, and collision energy.
+:type sequence: str
+:param sequence: Peptide sequence
+:type charge: int
+:param charge: Peptide charge
+:type intensities_flat: List[float]
+:param intensities_flat: List of intensities
+:type normalized: bool
+:param normalized: Whether to normalize the intensities
+:type half_charge_one: bool
+:param half_charge_one: Whether to divide the intensity by 2 if the charge is 1
Array of ion intensities
+NDArray
+translate a peptide sequence given as python string into a numpy array of characters with a fixed length
+:type sequence: str
+:param sequence: the peptide sequence
+:type max_length: int
+:param max_length: the maximum length a sequence can have
ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
numpy array of characters
+Simulate ion intensities for a list of peptide sequences, charges, and collision energies.
+:type sequences: List[str]
+:param sequences: List of peptide sequences
+:type charges: List[int]
+:param charges: List of peptide charges
+:type intensities_flat: List[List[float]]
+:param intensities_flat: List of intensities
+:type normalized: bool
+:param normalized: Whether to normalize the intensities
+:type half_charge_one: bool
+:param half_charge_one: Whether to divide the intensity by 2 if the charge is 1
+:type num_threads: int
+:param num_threads: Number of threads to use for the calculation
Array of ion intensities
+NDArray
+Sets a given percentage of the non-zero elements of a numpy vector to zero, +where the probability of being set to 0 is inversely proportional to the element’s value +relative to other values in the vector.
+row (np.ndarray) – Input vector of arbitrary length
percentage (float) – Percentage of non-zero elements to set to zero (between 0 and 1)
Modified vector with the specified percentage of non-zero elements set to zero
+np.ndarray
+check_path()Add noise to frame.
+acquisition_builder (TimsTofAcquisitionBuilderDIA) – Acquisition builder.
frames (List[TimsFrame]) – Frames.
intensity_max_precursor (float) – Maximum intensity for precursor.
intensity_max_fragment (float) – Maximum intensity for fragment.
precursor_sample_fraction (float) – Sample fraction for precursor.
fragment_sample_fraction (float) – Sample fraction for fragment.
num_precursor_frames (int) – Number of precursor frames.
num_fragment_frames (int) – Number of fragment frames.
Frames.
+List[TimsFrame]
+Assemble frames from frame ids and write them to the database.
+acquisition_builder (TimsTofAcquisitionBuilderDIA) – Acquisition builder object.
frames (DataFrame) – DataFrame containing frame ids.
batch_size (int) – Batch size for frame assembly, i.e. how many frames are assembled at once.
verbose (bool) – Verbosity.
mz_noise_precursor (bool) – Add noise to precursor m/z values.
mz_noise_uniform (bool) – Add uniform noise to m/z values.
precursor_noise_ppm (float) – PPM value for precursor noise.
mz_noise_fragment (bool) – Add noise to fragment m/z values.
fragment_noise_ppm (float) – PPM value for fragment noise.
num_threads (int) – Number of threads for frame assembly.
add_real_data_noise (bool) – Add real data noise to the frames.
intensity_max_precursor (float) – Maximum intensity for precursor noise.
intensity_max_fragment (float) – Maximum intensity for fragment noise.
precursor_sample_fraction (float) – Sample fraction for precursor noise.
fragment_sample_fraction (float) – Sample fraction for fragment noise.
num_precursor_frames (int) – Number of precursor frames.
num_fragment_frames (int) – Number of fragment frames.
fragment (bool) – if False, Quadrupole isolation will still be used, but no fragmentation will be performed.
None
None, writes frames to disk and metadata to database.
+Build acquisition object from reference path.
+path (str) – Path where the acquisition will be saved.
reference_path (str) – Path to the reference dataset.
exp_name (str) – Experiment name.
acquisition_type (str) – Acquisition type, must be ‘dia’, ‘midia’, ‘slice’ or ‘synchro’.
verbose (bool) – Verbosity.
gradient_length (float) – Gradient length.
use_reference_ds_layout (bool) – Use reference dataset layout for synthetic dataset.
reference_in_memory (bool) – Load reference dataset into memory.
round_collision_energy (bool) – Round collision energy.
collision_energy_decimals (int) – Number of decimals for collision energy (controls coarseness).
use_bruker_sdk (bool) – Use Bruker SDK for reading reference dataset.
Acquisition object.
+Digest a fasta file.
+fasta_file_path (str) – Path to the fasta file.
missed_cleavages (int) – Number of missed cleavages.
min_len (int) – Minimum peptide length.
max_len (int) – Maximum peptide length.
cleave_at (str) – Cleavage sites.
restrict (str) – Restrict to specific proteins.
decoys (bool) – Generate decoys.
verbose (bool) – Verbosity.
job_name (str) – Job name.
static_mods (dict[str, str]) – Static modifications.
variable_mods (dict[str, list[str]]) – Variable modifications.
exclude_accumulated_gradient_start (bool) – Exclude low retention times.
min_rt_percent (float) – Minimum retention time in percent.
gradient_length (float) – Gradient length in seconds (in seconds).
Peptide digest object.
+Simulate charge states for peptides.
+peptides (DataFrame) – Peptides DataFrame.
mz_lower (float) – Lower m/z value.
mz_upper (float) – Upper m/z value.
p_charge (float) – Probability of charge.
charge_state_one_probability (float) – Probability of charge state one.
min_charge_contrib (float) – Minimum charge contribution.
Ions DataFrame.
+pd.DataFrame
+Simulate fragment ion intensity distributions.
+path (str) – Path to the synthetic data.
name (str) – Name of the synthetic data.
acquisition_builder (TimsTofAcquisitionBuilderDIA) – Acquisition builder object.
batch_size (int) – Batch size for frame assembly, i.e. how many frames are assembled at once.
verbose (bool) – Verbosity.
num_threads (int) – Number of threads for frame assembly.
down_sample_factor (int) – Down sample factor for fragment ion intensity distributions.
None
None, writes frames to disk and metadata to database.
+Simulate frame distributions for peptides.
+peptides (DataFrame) – Peptide DataFrame.
frames (DataFrame) – Frame DataFrame.
z_score (float) – Z-score.
std_rt (float) – Standard deviation of retention time.
rt_cycle_length (float) – Retention time cycle length in seconds.
verbose (bool) – Verbosity.
add_noise (bool) – Add noise.
normalize (bool) – Normalize frame abundance.
Peptide DataFrame with frame distributions.
+pd.DataFrame
+Simulate frame distributions for peptides.
+peptides (DataFrame) – Peptide DataFrame.
frames (DataFrame) – Frame DataFrame.
mean_std_rt (float) – mean retention time.
variance_std_rt (float) – variance retention time.
mean_scewness (float) – mean scewness.
variance_scewness (float) – variance scewness.
target_p (float) – target p.
step_size (float) – step size.
rt_cycle_length (float) – Retention time cycle length in seconds.
verbose (bool) – Verbosity.
add_noise (bool) – Add noise.
normalize (bool) – Normalize frame abundance.
n_steps (int) – number of steps.
num_threads (int) – number of threads.
from_existing (bool) – Use existing parameters.
sigmas (ndarray) – sigmas.
lambdas (ndarray) – lambdas.
Peptide DataFrame with frame distributions.
+pd.DataFrame
+Simulate ion mobilities.
+ions (DataFrame) – Ions DataFrame.
im_lower (float) – Lower ion mobility.
im_upper (float) – Upper ion mobility.
verbose (bool) – Verbosity.
Ions DataFrame.
+pd.DataFrame
+Simulate peptide occurrences.
+peptides (DataFrame) – Peptides DataFrame.
intensity_mean (float) – Intensity mean.
intensity_min (float) – Intensity minimum.
intensity_max (float) – Intensity maximum.
verbose (bool) – Verbosity.
sample_occurrences (bool) – Sample occurrences.
intensity_value (float) – Intensity value.
mixture_contribution (float) – Mixture contribution.
Peptides DataFrame.
+pd.DataFrame
+Simulate retention times.
+peptides (DataFrame) – Peptides DataFrame.
verbose (bool) – Verbosity.
gradient_length (float) – Gradient length in seconds.
Peptides DataFrame.
+pd.DataFrame
+Simulate scan distributions for ions.
+ions (DataFrame) – Ions DataFrame.
scans (DataFrame) – Scan DataFrame.
z_score (float) – Z-score.
mean_std_im (float) – Standard deviation of ion mobility.
variance_std_im (float) – Variance of standard deviation of ion mobility.
verbose (bool) – Verbosity.
add_noise (bool) – Add noise.
normalize (bool) – Normalize scan abundance.
from_existing (bool) – Use existing parameters.
std_means (ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]) – Standard deviations.
Ions DataFrame with scan distributions.
+pd.DataFrame
+str
Bases: object
str
Breaks a set of objects into k sets of equal size at random.
+sequence_set – Set of sequences to be divided
k (int) – Number of sets to divide the objects into
A list containing k sets, each with equal number of randomly chosen sequences
+Generate training data.
+:type psms: DataFrame
+:param psms: List of PeptideSpectrumMatch objects
+:type method: str
+:param method: Method to use for training data generation
+:type q_max: float
+:param q_max: Maximum q-value allowed for positive examples
+:type balance: bool
+:param balance: Whether to balance the dataset
X_train and Y_train
+Tuple[NDArray, NDArray]
+Re-score PSMs using LDA.
+:type psms: DataFrame
+:param psms: List of PeptideSpectrumMatch objects
+:type num_splits: int
+:param num_splits: Number of splits
+:type verbose: bool
+:param verbose: Whether to print progress
+:type balance: bool
+:param balance: Whether to balance the dataset
+:type score: str
+:param score: Score to use for re-scoring
+:type positive_example_q_max: float
+:param positive_example_q_max: Maximum q-value allowed for positive examples
List of PeptideSpectrumMatch objects
+List[PeptideSpectrumMatch]
+str
list
Extract TIMSTOF DDA data from bruker timsTOF TDF file.
+:type path: str
+:param path: Path to TIMSTOF DDA data
+:type in_memory: bool
+:param in_memory: Whether to load data in memory
+:type use_bruker_sdk: bool
+:param use_bruker_sdk: Whether to use bruker SDK for data extraction
+:type isolation_window_lower: float
+:param isolation_window_lower: Lower bound for isolation window (Da)
+:type isolation_window_upper: float
+:param isolation_window_upper: Upper bound for isolation window (Da)
+:type take_top_n: int
+:param take_top_n: Number of top peaks to take
+:type num_threads: int
+:param num_threads: Number of threads to use
DataFrame containing timsTOF DDA data
+pd.DataFrame
+List[Psm]
List[Psm]
Generate training data.
+:type psms: List[Psm]
+:param psms: List of PeptideSpectrumMatch objects
+:type method: str
+:param method: Method to use for training data generation
+:type q_max: float
+:param q_max: Maximum q-value allowed for positive examples
+:type balance: bool
+:param balance: Whether to balance the dataset
X_train and Y_train
+Tuple[NDArray, NDArray]
+Get SAGE searchable spectrum from raw data.
+:type precursor: Precursor
+:param precursor: Precursor object
+:type raw_fragment_data: TimsFrame
+:param raw_fragment_data: TimsFrame object
+:type time: float
+:param time: float
+:type spec_processor: SpectrumProcessor
+:param spec_processor: SpectrumProcessor object
+:type spec_id: str
+:param spec_id: str
+:type file_id: int
+:param file_id: int
+:type ms_level: int
+:param ms_level: int
ProcessedSpectrum object
+ProcessedSpectrum
+Maps the input data linearly into the domain [0, l].
+Parameters: +- data: list or numpy array of numerical values +- l: float, the upper limit of the target domain [0, l]
+Returns: +- mapped_data: list of values mapped into the domain [0, l]
+Sanitize charge value.
+:type charge: Optional[float]
+:param charge: Charge value as float.
Charge value as int.
+int
+Sanitize mz value.
+:type mz: Optional[float]
+:param mz: Mz value as float.
+:type mz_highest: float
+:param mz_highest: Highest mz value.
Mz value as float.
+float
+Split a fasta file into multiple fasta files.
+:type fasta: str
+:param fasta: Fasta file as string.
+:type num_splits: int
+:param num_splits: Number of splits fasta file should be split into.
+:type randomize: bool
+:param randomize: Whether to randomize the order of sequences before splitting.
List[str]
List of fasta files as strings, will contain num_splits fasta files with equal number of sequences.
+Split PSMs into multiple splits.
+psms (List[Psm]) – List of PeptideSpectrumMatch objects
num_splits (int) – Number of splits
List of splits
+List[List[PeptideSpectrumMatch]]
+Write PSMs to binary file.
+:type byte_array:
+:param byte_array: Byte array
+:type folder_path: str
+:param folder_path: Folder path
+:type file_name: str
+:param file_name: File name
+:type total: bool
+:param total: Whether to write to total folder
main()extract_timstof_dda_data()generate_balanced_im_dataset()generate_balanced_rt_dataset()generate_training_data()get_searchable_spec()linear_map()map_to_domain()merge_dicts_with_merge_dict()sanitize_charge()sanitize_mz()split_fasta()split_psms()transform_psm_to_pin()write_psms_binary()Bases: object
list[float]
float
Bases: TimsTofCollisionEnergy
list[float]
float
Bases: RustWrapperObject
Get an AcquisitionMode from a pointer.
+ptr (pims.AcquisitionMode) – Pointer to an acquisition mode.
+Acquisition mode.
+Get the acquisition mode.
+Acquisition mode.
+str
+Bases: ABC
Get the acquisition mode.
+Acquisition mode.
+str
+Get the acquisition mode as a numerical value.
+Acquisition mode as a numerical value.
+int
+Convert bytes to scan, tof, and intensity values.
+values (NDArray[np.uint8]) – Bytes.
+Scan values. +NDArray[np.int32]: TOF values. +NDArray[np.float64]: Intensity values.
+NDArray[np.int32]
+Compress a collection of frames.
+frames (List[TimsFrame]) – List of frames.
num_threads (int) – Number of threads to use.
List of compressed bytes.
+List[NDArray[np.uint8]]
+Compress values using ZSTD.
+values (NDArray[np.float64]) – Values to compress.
+Compressed values.
+NDArray[np.uint8]
+Decompress values using ZSTD.
+values (NDArray[np.float64]) – Values to decompress.
ignore_first_n (int) – Number of bytes to ignore.
Decompressed values.
+NDArray[np.uint8]
+Get the number of frames.
+Number of frames.
+int
+Get a table.
+table_name (str) – Table name.
+Table.
+pd.DataFrame
+Get a TimsFrame.
+frame_id (int) – Frame ID.
+TimsFrame.
+Get a TimsFrame.
+frame_ids (int) – Frame ID.
num_threads (int) – Number of threads.
TimsFrame.
+Convert scan and intensity values to bytes.
+scan_values (NDArray[np.int32]) – Scan values.
tof_values (NDArray[np.int32]) – TOF values.
intensity_values (NDArray[np.float64]) – Intensity values.
total_scans (int) – Total number of scans.
Bytes.
+NDArray[np.uint8]
+Convert inverse mobility values to scan values.
+frame_id (int) – Frame ID.
im_values (NDArray[np.float64]) – Inverse mobility values.
Scan values.
+NDArray[np.int32]
+Convert m/z values to TOF values.
+frame_id (int) – Frame ID.
mz_values (NDArray[np.float64]) – m/z values.
TOF values.
+NDArray[np.int32]
+Get the number of scans.
+Number of scans.
+int
+Convert scan values to inverse mobility values.
+frame_id (int) – Frame ID.
scan_values (NDArray[np.int32]) – Scan values.
Inverse mobility values.
+NDArray[np.float64]
+Convert TOF values to m/z values.
+frame_id (int) – Frame ID.
tof_values (NDArray[np.int32]) – TOF values.
m/z values.
+NDArray[np.float64]
+Bases: RustWrapperObject
Bases: TimsDataset, RustWrapperObject
Get PASEF fragments.
+Args: num_threads (int, optional): Number of threads. Defaults to 1. CAUTION: As long as connection to +datasets is established via bruker so / dll, using multiple threads is unstable.
+List of PASEF fragments.
+List[FragmentDDA]
+Bases: TimsDataset, RustWrapperObject
Get DIA MS/MS info.
+DIA MS/MS info.
+pd.DataFrame
+Get PASEF meta data for DIA.
+PASEF meta data.
+pd.DataFrame
+Read compressed data.
+Compressed data.
+List[bytes]
+Sample fragment signal.
+num_frames (int) – Number of frames.
window_group (int) – Window group to take frames from.
max_intensity (float) – Maximum intensity.
take_probability (float) – Probability to take signals from sampled frames.
Frame.
+Sample precursor signal.
+num_frames (int) – Number of frames.
max_intensity (float) – Maximum intensity.
take_probability (float) – Probability to take signals from sampled frames.
Frame.
+Bases: RustWrapperObject
Data as a pandas DataFrame.
+Data.
+pd.DataFrame
+Filter the frame for a given m/z range, scan range and intensity range.
+mz_min (float) – Minimum m/z value.
mz_max (float) – Maximum m/z value.
scan_min (int, optional) – Minimum scan value. Defaults to 0.
scan_max (int, optional) – Maximum scan value. Defaults to 1000.
mobility_min (float, optional) – Minimum inverse mobility value. Defaults to 0.0.
mobility_max (float, optional) – Maximum inverse mobility value. Defaults to 2.0.
intensity_min (float, optional) – Minimum intensity value. Defaults to 0.0.
intensity_max (float, optional) – Maximum intensity value. Defaults to 1e9.
Filtered frame.
+Frame ID.
+Frame ID.
+int
+Create a TimsFrame from a PyTimsFrame.
+frame (pims.PyTimsFrame) – PyTimsFrame to create the TimsFrame from.
+TimsFrame created from the PyTimsFrame.
+Create a TimsFrame from a list of TimsSpectrum.
+spectra (List[TimsSpectrum]) – List of TimsSpectrum.
+TimsFrame created from the TimsSpectrum.
+Create a TimsFrame from a list of windows.
+windows (List[TimsSpectrum]) – List of windows.
+TimsFrame created from the windows.
+Get the inverse mobility along the scan marginal.
+Inverse mobility.
+float
+Get the mean and variance of the inverse mobility.
+Mean and variance of the inverse mobility.
+Tuple[float, float]
+Intensity.
+Intensity.
+NDArray[np.float64]
+Inverse mobility.
+Inverse mobility.
+NDArray[np.float64]
+MS type.
+MS type.
+int
+MS type.
+MS type.
+int
+m/z.
+m/z.
+NDArray[np.float64]
+Randomly subsample the frame.
+Args: +take_probability (float): Take probability.
+Returns: +TimsFrame: Subsampled frame.
+Retention time.
+Retention time.
+float
+Scan.
+Scan.
+NDArray[np.int32]
+ndarray[Any, dtype[float64]]
Convert the frame to an IndexedMzSpectrum.
+IndexedMzSpectrum.
+Convert the frame to a noise annotated frame.
+Noise annotated frame.
+Convert the frame to a given resolution.
+resolution (int) – Resolution.
+Frame with the given resolution.
+Convert the frame to a list of TimsSpectrum.
+List of TimsSpectrum.
+List[TimsSpectrum]
+Convert the frame to a list of windows.
+window_length (float, optional) – Window length. Defaults to 10.
overlapping (bool, optional) – Whether the windows should overlap. Defaults to True.
min_num_peaks (int, optional) – Minimum number of peaks in a window. Defaults to 5.
min_intensity (float, optional) – Minimum intensity of a peak in a window. Defaults to 1.
List of windows.
+List[MzSpectrum]
+Time of flight.
+Time of flight.
+NDArray[np.int32]
+Convert the frame to a vectorized frame.
+resolution (int, optional) – Resolution. Defaults to 2.
+Vectorized frame.
+Bases: RustWrapperObject
Data as a pandas DataFrame.
+Data.
+pd.DataFrame
+Filter the frame for a given m/z range, scan range and intensity range.
+mz_min (float) – Minimum m/z value.
mz_max (float) – Maximum m/z value.
scan_min (int, optional) – Minimum scan value. Defaults to 0.
scan_max (int, optional) – Maximum scan value. Defaults to 1000.
mobility_min (float, optional) – Minimum inverse mobility value. Defaults to 0.0.
mobility_max (float, optional) – Maximum inverse mobility value. Defaults to 2.0.
intensity_min (float, optional) – Minimum intensity value. Defaults to 0.0.
intensity_max (float, optional) – Maximum intensity value. Defaults to 1e9.
Filtered frame.
+Frame ID.
+Frame ID.
+int
+Create a TimsFrameVectorized from a PyTimsFrameVectorized.
+frame (pims.PyTimsFrameVectorized) – PyTimsFrameVectorized to create the TimsFrameVectorized from.
+TimsFrameVectorized created from the PyTimsFrameVectorized.
+Get the arrays at a given index.
+index (int) – Index.
+Arrays at the index.
+NDArray[np.float64]
+Indices.
+Indices.
+NDArray[np.int32]
+Intensity.
+Intensity.
+NDArray[np.float64]
+Inverse mobility.
+Inverse mobility.
+NDArray[np.float64]
+MS type.
+MS type.
+int
+Retention time.
+Retention time.
+float
+Scan.
+Scan.
+NDArray[np.int32]
+Time of flight.
+Time of flight.
+NDArray[np.int32]
+Bases: object
bool
bool
ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
int
set[int]
bool
bool
Get the transmission probability for a list of isotopes
+:type frame_id: int
+:param frame_id:
+:type scan_id: int
+:param scan_id:
+:type mz_mono: float
+:param mz_mono:
+:type mz: ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]
+:param mz:
+:type min_proba: float | None
+:param min_proba:
Returns:
+tuple[float, list[tuple[float, float]]]
List[List[MzSpectrum]]
Bases: object
Create a TimsPlane from a PyTimsPlane.
+plane (pims.PyTimsPlane) – PyTimsPlane to create the TimsPlane from.
+TimsPlane created from the PyTimsPlane.
+Bases: object
Get the data as a pandas DataFrame.
+Data.
+pd.DataFrame
+Filter the slice by m/z, scan and intensity.
+mz_min (float) – Minimum m/z value.
mz_max (float) – Maximum m/z value.
scan_min (int, optional) – Minimum scan value. Defaults to 0.
scan_max (int, optional) – Maximum scan value. Defaults to 1000.
mobility_min (float, optional) – Minimum inverse mobility value. Defaults to 0.0.
mobility_max (float, optional) – Maximum inverse mobility value. Defaults to 2.0.
intensity_min (float, optional) – Minimum intensity value. Defaults to 0.0.
intensity_max (float, optional) – Maximum intensity value. Defaults to 1e9.
num_threads (int, optional) – Number of threads to use. Defaults to 4.
Filtered slice.
+Filter the slice by m/z, scan and intensity, for MS1 and MS2 with different ranges.
+mz_min_ms1 (float, optional) – Minimum m/z value for MS1. Defaults to 0.
mz_max_ms1 (float, optional) – Maximum m/z value for MS1. Defaults to 2000.
scan_min_ms1 (int, optional) – Minimum scan value for MS1. Defaults to 0.
scan_max_ms1 (int, optional) – Maximum scan value for MS1. Defaults to 1000.
inv_mob_min_ms1 (float, optional) – Minimum inverse mobility value for MS1. Defaults to 0.
inv_mob_max_ms1 (float, optional) – Maximum inverse mobility value for MS1. Defaults to 2.
intensity_min_ms1 (float, optional) – Minimum intensity value for MS1. Defaults to 0.
intensity_max_ms1 (float, optional) – Maximum intensity value for MS1. Defaults to 1e9.
mz_min_ms2 (float, optional) – Minimum m/z value for MS2. Defaults to 0.
mz_max_ms2 (float, optional) – Maximum m/z value for MS2. Defaults to 2000.
scan_min_ms2 (int, optional) – Minimum scan value for MS2. Defaults to 0.
scan_max_ms2 (int, optional) – Maximum scan value for MS2. Defaults to 1000.
inv_mob_min_ms2 (float, optional) – Minimum inverse mobility value for MS2. Defaults to 0.
inv_mob_max_ms2 (float, optional) – Maximum inverse mobility value for MS2. Defaults to 2.
intensity_min_ms2 (float, optional) – Minimum intensity value for MS2. Defaults to 0.
intensity_max_ms2 (float, optional) – Maximum intensity value for MS2. Defaults to 1e9.
num_threads (int, optional) – Number of threads to use. Defaults to 4.
Filtered slice.
+First frame ID.
+First frame ID.
+int
+Get the frames.
+Frames.
+List[TimsFrame]
+Create a TimsSlice from a list of TimsFrames.
+ +Create a TimsSlice from a PyTimsSlice.
+tims_slice (pims.PyTimsSlice) – PyTimsSlice to create the TimsSlice from.
+TimsSlice created from the PyTimsSlice.
+List[TimsPlane]
Last frame ID.
+Last frame ID.
+int
+tuple[list[ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]], list[ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]], list[ndarray[Any, dtype[TypeVar(_ScalarType_co, bound= generic, covariant=True)]]]]
Convert the slice to a given resolution.
+resolution (int) – Resolution.
num_threads (int, optional) – Number of threads to use. Defaults to 4.
Slice with given resolution.
+Convert the slice to a list of windows.
+window_length (float, optional) – Window length. Defaults to 10.
overlapping (bool, optional) – Whether the windows should overlap. Defaults to True.
min_num_peaks (int, optional) – Minimum number of peaks in a window. Defaults to 5.
min_intensity (float, optional) – Minimum intensity of a peak in a window. Defaults to 1.
num_threads (int, optional) – Number of threads to use. Defaults to 1.
List of windows.
+List[MzSpectrum]
+Get a vectorized version of the slice.
+resolution (int, optional) – Resolution. Defaults to 2.
num_threads (int, optional) – Number of threads to use. Defaults to 4.
Vectorized version of the slice.
+Bases: object
Get the data as a pandas DataFrame.
+Data.
+pd.DataFrame
+Filter the slice by m/z, scan and intensity.
+mz_min (float) – Minimum m/z value.
mz_max (float) – Maximum m/z value.
scan_min (int, optional) – Minimum scan value. Defaults to 0.
scan_max (int, optional) – Maximum scan value. Defaults to 1000.
mobility_min (float, optional) – Minimum inverse mobility value. Defaults to 0.0.
mobility_max (float, optional) – Maximum inverse mobility value. Defaults to 2.0.
intensity_min (float, optional) – Minimum intensity value. Defaults to 0.0.
intensity_max (float, optional) – Maximum intensity value. Defaults to 1e9.
num_threads (int, optional) – Number of threads to use. Defaults to 4.
Filtered slice.
+First frame ID.
+First frame ID.
+int
+Get the frames.
+Frames.
+List[TimsFrame]
+Create a TimsSlice from a PyTimsSlice.
+tims_slice (pims.PyTimsSlice) – PyTimsSlice to create the TimsSlice from.
+TimsSlice created from the PyTimsSlice.
+Last frame ID.
+Last frame ID.
+int
+Tokenizes a sequence of modified amino acids.
+:type unimod_sequence: str
+:param unimod_sequence: A string representing the sequence of amino acids with modifications.
List[str]
A list of tokenized amino acids.
+Bases: object
Bases: object
Bases: object
Exponential function
+:type x:
+:param x:
+:type λ: float
+:param λ:
+:return:
laplacian distribution with exponential decay
+:type x:
+:param x:
+:type μ: float
+:param μ:
+:type σ: float
+:param σ:
+:type λ: float
+:param λ:
+:return:
Gaussian function
+:type x:
+:param x:
+:type μ: float
+:param μ:
+:type σ: float
+:param σ:
+:return:
get number of amino acids in sequence
+sequence (str) – proforma formatted aa sequence
+Number of amino acids
+int
+Tests if char is end of unimod +bracket
+char (str) – Character of a proForma formatted aa sequence
+Whether char is end of unimod bracket
+bool
+Tests if char is start of unimod +bracket
+char (str) – Character of a proForma formatted aa sequence
+Whether char is start of unimod bracket
+bool
+x (Union[_SupportsArray[dtype[Any]], _NestedSequence[_SupportsArray[dtype[Any]]], bool, int, float, complex, str, bytes, _NestedSequence[Union[bool, int, float, complex, str, bytes]]])
mass (float)
s (float)
inv_sqrt_2pi (float)
normalize (bool)
Re-index indices, i.e. replace gaps in indices with consecutive numbers. +Can be used, e.g., to re-index frame IDs from precursors for visualization. +:type ids: +:param ids: Indices.
+Indices.
+Tokenize a ProForma formatted sequence string.
+sequence (str) – Sequence string (ProForma formatted)
+List of tokens
+List
+load a pre-fit tokenizer from a json file
+:type path: str
+:param path: path to tokenizer as json file
+:return: a keras tokenizer loaded from json
save a fit keras tokenizer to json for later use
+:type tokenizer: Tokenizer
+:param tokenizer: fit keras tokenizer to save
+:type path: str
+:param path: path to save json to
The imspy package contains the following submodules:
++ Searching for multiple words only shows matches that contain + all words. +
+ + + + + + + + +