qsprpred.data.descriptors package

Submodules

qsprpred.data.descriptors.fingerprints module

Fingerprint classes.

class qsprpred.data.descriptors.fingerprints.AtomPairFP(nBits=2048, **kwargs)

Bases: Fingerprint

Initialize the processor with the name of the property that contains the molecule’s unique identifier.

Parameters:

id_prop (str) – Name of the property that contains the molecule’s unique identifier. Defaults to “QSPRID”.

property descriptors: list[str]

Return a list of current descriptor names.

property dtype

Convert the descriptor values to this type.

classmethod fromFile(filename: str) → Any

Initialize a new instance from a JSON file.

Parameters:

filename (str) – path to the JSON file

Returns:

new instance of the class

Return type:

instance (object)

classmethod fromJSON(json: str) → Any

Reconstruct object from a JSON string.

Parameters:

json (str) – JSON string of the object

Returns:

reconstructed object

Return type:

obj (object)

getDescriptors(mols: list[rdkit.Chem.rdchem.Mol], props: dict[str, list[Any]], *args, **kwargs) → ndarray

Method to calculate descriptors for a list of molecules.

This method should use molecules as they are without any preparation. Any preparation steps should be defined in the DescriptorSet.prepMols method., which is picked up by the main DescriptorSet.__call__.

Parameters:

• mols (list) – list of SMILES or RDKit molecules

• props (dict) – dictionary of properties

• *args – positional arguments

• **kwargs – keyword arguments

Returns:

numpy array of descriptor values of shape (n_mols, n_descriptors)

property isFP

Return True if descriptor set is a binary fingerprint.

static iterMols(mols: list[str | rdkit.Chem.rdchem.Mol], to_list=False) → list[rdkit.Chem.rdchem.Mol] | Generator[Mol, None, None]

Create a molecule generator or list from RDKit molecules or SMILES.

Parameters:

• mols – list of molecules (SMILES str or RDKit Mol)

• to_list – if True, return a list instead of a generator

Returns:

a list or generator of RDKit molecules

prepMols(mols: list[str | rdkit.Chem.rdchem.Mol]) → list[rdkit.Chem.rdchem.Mol]

Prepare the molecules for descriptor calculation.

property requiredProps: list[str]

The properties required by the processor. This is to inform the caller that the processor requires certain properties to be passed to the __call__ method. By default, no properties are required.

property supportsParallel: bool

Return True if the descriptor set supports parallel calculation.

toFile(filename: str) → str

Serialize object to a JSON file. This JSON file should contain all data necessary to reconstruct the object.

Parameters:

filename (str) – filename to save object to

Returns:

absolute path to the saved JSON file of the object

Return type:

filename (str)

toJSON() → str

Serialize object to a JSON string. This JSON string should

contain all data necessary to reconstruct the object.

Returns:

JSON string of the object

Return type:

json (str)

transformToFeatureNames()

static treatInfs(df: DataFrame) → DataFrame

Replace infinite values by NaNs.

Parameters:

df – dataframe to treat

Returns:

dataframe with infinite values replaced by NaNs

property usedBits: list[int] | None

class qsprpred.data.descriptors.fingerprints.AvalonFP(nBits=1024, **kwargs)

Bases: Fingerprint

Initialize the processor with the name of the property that contains the molecule’s unique identifier.

Parameters:

id_prop (str) – Name of the property that contains the molecule’s unique identifier. Defaults to “QSPRID”.

property descriptors: list[str]

Return a list of current descriptor names.

property dtype

Convert the descriptor values to this type.

classmethod fromFile(filename: str) → Any

Initialize a new instance from a JSON file.

Parameters:

filename (str) – path to the JSON file

Returns:

new instance of the class

Return type:

instance (object)

classmethod fromJSON(json: str) → Any

Reconstruct object from a JSON string.

Parameters:

json (str) – JSON string of the object

Returns:

reconstructed object

Return type:

obj (object)

getDescriptors(mols: list[rdkit.Chem.rdchem.Mol], props: dict[str, list[Any]], *args, **kwargs) → ndarray

Method to calculate descriptors for a list of molecules.

This method should use molecules as they are without any preparation. Any preparation steps should be defined in the DescriptorSet.prepMols method., which is picked up by the main DescriptorSet.__call__.

Parameters:

• mols (list) – list of SMILES or RDKit molecules

• props (dict) – dictionary of properties

• *args – positional arguments

• **kwargs – keyword arguments

Returns:

numpy array of descriptor values of shape (n_mols, n_descriptors)

property isFP

Return True if descriptor set is a binary fingerprint.

static iterMols(mols: list[str | rdkit.Chem.rdchem.Mol], to_list=False) → list[rdkit.Chem.rdchem.Mol] | Generator[Mol, None, None]

Create a molecule generator or list from RDKit molecules or SMILES.

Parameters:

• mols – list of molecules (SMILES str or RDKit Mol)

• to_list – if True, return a list instead of a generator

Returns:

a list or generator of RDKit molecules

prepMols(mols: list[str | rdkit.Chem.rdchem.Mol]) → list[rdkit.Chem.rdchem.Mol]

Prepare the molecules for descriptor calculation.

property requiredProps: list[str]

The properties required by the processor. This is to inform the caller that the processor requires certain properties to be passed to the __call__ method. By default, no properties are required.

property supportsParallel: bool

Return True if the descriptor set supports parallel calculation.

toFile(filename: str) → str

Serialize object to a JSON file. This JSON file should contain all data necessary to reconstruct the object.

Parameters:

filename (str) – filename to save object to

Returns:

absolute path to the saved JSON file of the object

Return type:

filename (str)

toJSON() → str

Serialize object to a JSON string. This JSON string should

contain all data necessary to reconstruct the object.

Returns:

JSON string of the object

Return type:

json (str)

transformToFeatureNames()

static treatInfs(df: DataFrame) → DataFrame

Replace infinite values by NaNs.

Parameters:

df – dataframe to treat

Returns:

dataframe with infinite values replaced by NaNs

property usedBits: list[int] | None

class qsprpred.data.descriptors.fingerprints.Fingerprint(used_bits: list[int] | None = None)

Bases: DescriptorSet, ABC

Base class for calculation of binary fingerprints.

Variables:

usedBits (list) – list of bits of the fingerprint currently being used

Initialize the processor with the name of the property that contains the molecule’s unique identifier.

Parameters:

id_prop (str) – Name of the property that contains the molecule’s unique identifier. Defaults to “QSPRID”.

property descriptors: list[str]

Return a list of current descriptor names.

property dtype

Convert the descriptor values to this type.

classmethod fromFile(filename: str) → Any

Initialize a new instance from a JSON file.

Parameters:

filename (str) – path to the JSON file

Returns:

new instance of the class

Return type:

instance (object)

classmethod fromJSON(json: str) → Any

Reconstruct object from a JSON string.

Parameters:

json (str) – JSON string of the object

Returns:

reconstructed object

Return type:

obj (object)

abstract getDescriptors(mols: list[rdkit.Chem.rdchem.Mol], props: dict[str, list[Any]], *args, **kwargs) → ndarray

Method to calculate descriptors for a list of molecules.

This method should use molecules as they are without any preparation. Any preparation steps should be defined in the DescriptorSet.prepMols method., which is picked up by the main DescriptorSet.__call__.

Parameters:

• mols (list) – list of SMILES or RDKit molecules

• props (dict) – dictionary of properties

• *args – positional arguments

• **kwargs – keyword arguments

Returns:

numpy array of descriptor values of shape (n_mols, n_descriptors)

property isFP

Return True if descriptor set is a binary fingerprint.

static iterMols(mols: list[str | rdkit.Chem.rdchem.Mol], to_list=False) → list[rdkit.Chem.rdchem.Mol] | Generator[Mol, None, None]

Create a molecule generator or list from RDKit molecules or SMILES.

Parameters:

• mols – list of molecules (SMILES str or RDKit Mol)

• to_list – if True, return a list instead of a generator

Returns:

a list or generator of RDKit molecules

prepMols(mols: list[str | rdkit.Chem.rdchem.Mol]) → list[rdkit.Chem.rdchem.Mol]

Prepare the molecules for descriptor calculation.

property requiredProps: list[str]

The properties required by the processor. This is to inform the caller that the processor requires certain properties to be passed to the __call__ method. By default, no properties are required.

property supportsParallel: bool

Return True if the descriptor set supports parallel calculation.

toFile(filename: str) → str

Serialize object to a JSON file. This JSON file should contain all data necessary to reconstruct the object.

Parameters:

filename (str) – filename to save object to

Returns:

absolute path to the saved JSON file of the object

Return type:

filename (str)

toJSON() → str

Serialize object to a JSON string. This JSON string should

contain all data necessary to reconstruct the object.

Returns:

JSON string of the object

Return type:

json (str)

transformToFeatureNames()

static treatInfs(df: DataFrame) → DataFrame

Replace infinite values by NaNs.

Parameters:

df – dataframe to treat

Returns:

dataframe with infinite values replaced by NaNs

property usedBits: list[int] | None

class qsprpred.data.descriptors.fingerprints.LayeredFP(minPath=1, maxPath=7, nBits=2048, **kwargs)

Bases: Fingerprint

Initialize the processor with the name of the property that contains the molecule’s unique identifier.

Parameters:

id_prop (str) – Name of the property that contains the molecule’s unique identifier. Defaults to “QSPRID”.

property descriptors: list[str]

Return a list of current descriptor names.

property dtype

Convert the descriptor values to this type.

classmethod fromFile(filename: str) → Any

Initialize a new instance from a JSON file.

Parameters:

filename (str) – path to the JSON file

Returns:

new instance of the class

Return type:

instance (object)

classmethod fromJSON(json: str) → Any

Reconstruct object from a JSON string.

Parameters:

json (str) – JSON string of the object

Returns:

reconstructed object

Return type:

obj (object)

getDescriptors(mols: list[rdkit.Chem.rdchem.Mol], props: dict[str, list[Any]], *args, **kwargs) → ndarray

Method to calculate descriptors for a list of molecules.

This method should use molecules as they are without any preparation. Any preparation steps should be defined in the DescriptorSet.prepMols method., which is picked up by the main DescriptorSet.__call__.

Parameters:

• mols (list) – list of SMILES or RDKit molecules

• props (dict) – dictionary of properties

• *args – positional arguments

• **kwargs – keyword arguments

Returns:

numpy array of descriptor values of shape (n_mols, n_descriptors)

property isFP

Return True if descriptor set is a binary fingerprint.

static iterMols(mols: list[str | rdkit.Chem.rdchem.Mol], to_list=False) → list[rdkit.Chem.rdchem.Mol] | Generator[Mol, None, None]

Create a molecule generator or list from RDKit molecules or SMILES.

Parameters:

• mols – list of molecules (SMILES str or RDKit Mol)

• to_list – if True, return a list instead of a generator

Returns:

a list or generator of RDKit molecules

prepMols(mols: list[str | rdkit.Chem.rdchem.Mol]) → list[rdkit.Chem.rdchem.Mol]

Prepare the molecules for descriptor calculation.

property requiredProps: list[str]

The properties required by the processor. This is to inform the caller that the processor requires certain properties to be passed to the __call__ method. By default, no properties are required.

property supportsParallel: bool

Return True if the descriptor set supports parallel calculation.

toFile(filename: str) → str

Serialize object to a JSON file. This JSON file should contain all data necessary to reconstruct the object.

Parameters:

filename (str) – filename to save object to

Returns:

absolute path to the saved JSON file of the object

Return type:

filename (str)

toJSON() → str

Serialize object to a JSON string. This JSON string should

contain all data necessary to reconstruct the object.

Returns:

JSON string of the object

Return type:

json (str)

transformToFeatureNames()

static treatInfs(df: DataFrame) → DataFrame

Replace infinite values by NaNs.

Parameters:

df – dataframe to treat

Returns:

dataframe with infinite values replaced by NaNs

property usedBits: list[int] | None

class qsprpred.data.descriptors.fingerprints.MaccsFP(nBits=167, **kwargs)

Bases: Fingerprint

Initialize the processor with the name of the property that contains the molecule’s unique identifier.

Parameters:

id_prop (str) – Name of the property that contains the molecule’s unique identifier. Defaults to “QSPRID”.

property descriptors: list[str]

Return a list of current descriptor names.

property dtype

Convert the descriptor values to this type.

classmethod fromFile(filename: str) → Any

Initialize a new instance from a JSON file.

Parameters:

filename (str) – path to the JSON file

Returns:

new instance of the class

Return type:

instance (object)

classmethod fromJSON(json: str) → Any

Reconstruct object from a JSON string.

Parameters:

json (str) – JSON string of the object

Returns:

reconstructed object

Return type:

obj (object)

getDescriptors(mols: list[rdkit.Chem.rdchem.Mol], props: dict[str, list[Any]], *args, **kwargs) → ndarray

Method to calculate descriptors for a list of molecules.

This method should use molecules as they are without any preparation. Any preparation steps should be defined in the DescriptorSet.prepMols method., which is picked up by the main DescriptorSet.__call__.

Parameters:

• mols (list) – list of SMILES or RDKit molecules

• props (dict) – dictionary of properties

• *args – positional arguments

• **kwargs – keyword arguments

Returns:

numpy array of descriptor values of shape (n_mols, n_descriptors)

property isFP

Return True if descriptor set is a binary fingerprint.

static iterMols(mols: list[str | rdkit.Chem.rdchem.Mol], to_list=False) → list[rdkit.Chem.rdchem.Mol] | Generator[Mol, None, None]

Create a molecule generator or list from RDKit molecules or SMILES.

Parameters:

• mols – list of molecules (SMILES str or RDKit Mol)

• to_list – if True, return a list instead of a generator

Returns:

a list or generator of RDKit molecules

prepMols(mols: list[str | rdkit.Chem.rdchem.Mol]) → list[rdkit.Chem.rdchem.Mol]

Prepare the molecules for descriptor calculation.

property requiredProps: list[str]

The properties required by the processor. This is to inform the caller that the processor requires certain properties to be passed to the __call__ method. By default, no properties are required.

property supportsParallel: bool

Return True if the descriptor set supports parallel calculation.

toFile(filename: str) → str

Serialize object to a JSON file. This JSON file should contain all data necessary to reconstruct the object.

Parameters:

filename (str) – filename to save object to

Returns:

absolute path to the saved JSON file of the object

Return type:

filename (str)

toJSON() → str

Serialize object to a JSON string. This JSON string should

contain all data necessary to reconstruct the object.

Returns:

JSON string of the object

Return type:

json (str)

transformToFeatureNames()

static treatInfs(df: DataFrame) → DataFrame

Replace infinite values by NaNs.

Parameters:

df – dataframe to treat

Returns:

dataframe with infinite values replaced by NaNs

property usedBits: list[int] | None

class qsprpred.data.descriptors.fingerprints.MorganFP(radius=2, nBits=2048, **kwargs)

Bases: Fingerprint

Morgan fingerprint.

Initialize the processor with the name of the property that contains the molecule’s unique identifier.

Parameters:

id_prop (str) – Name of the property that contains the molecule’s unique identifier. Defaults to “QSPRID”.

property descriptors: list[str]

Return a list of current descriptor names.

property dtype

Convert the descriptor values to this type.

classmethod fromFile(filename: str) → Any

Initialize a new instance from a JSON file.

Parameters:

filename (str) – path to the JSON file

Returns:

new instance of the class

Return type:

instance (object)

classmethod fromJSON(json: str) → Any

Reconstruct object from a JSON string.

Parameters:

json (str) – JSON string of the object

Returns:

reconstructed object

Return type:

obj (object)

getDescriptors(mols: list[rdkit.Chem.rdchem.Mol], props: dict[str, list[Any]], *args, **kwargs) → ndarray

Method to calculate descriptors for a list of molecules.

This method should use molecules as they are without any preparation. Any preparation steps should be defined in the DescriptorSet.prepMols method., which is picked up by the main DescriptorSet.__call__.

Parameters:

• mols (list) – list of SMILES or RDKit molecules

• props (dict) – dictionary of properties

• *args – positional arguments

• **kwargs – keyword arguments

Returns:

numpy array of descriptor values of shape (n_mols, n_descriptors)

property isFP

Return True if descriptor set is a binary fingerprint.

static iterMols(mols: list[str | rdkit.Chem.rdchem.Mol], to_list=False) → list[rdkit.Chem.rdchem.Mol] | Generator[Mol, None, None]

Create a molecule generator or list from RDKit molecules or SMILES.

Parameters:

• mols – list of molecules (SMILES str or RDKit Mol)

• to_list – if True, return a list instead of a generator

Returns:

a list or generator of RDKit molecules

prepMols(mols: list[str | rdkit.Chem.rdchem.Mol]) → list[rdkit.Chem.rdchem.Mol]

Prepare the molecules for descriptor calculation.

property requiredProps: list[str]

The properties required by the processor. This is to inform the caller that the processor requires certain properties to be passed to the __call__ method. By default, no properties are required.

property supportsParallel: bool

Return True if the descriptor set supports parallel calculation.

toFile(filename: str) → str

Serialize object to a JSON file. This JSON file should contain all data necessary to reconstruct the object.

Parameters:

filename (str) – filename to save object to

Returns:

absolute path to the saved JSON file of the object

Return type:

filename (str)

toJSON() → str

Serialize object to a JSON string. This JSON string should

contain all data necessary to reconstruct the object.

Returns:

JSON string of the object

Return type:

json (str)

transformToFeatureNames()

static treatInfs(df: DataFrame) → DataFrame

Replace infinite values by NaNs.

Parameters:

df – dataframe to treat

Returns:

dataframe with infinite values replaced by NaNs

property usedBits: list[int] | None

class qsprpred.data.descriptors.fingerprints.PatternFP(nBits=2048, **kwargs)

Bases: Fingerprint

Initialize the processor with the name of the property that contains the molecule’s unique identifier.

Parameters:

id_prop (str) – Name of the property that contains the molecule’s unique identifier. Defaults to “QSPRID”.

property descriptors: list[str]

Return a list of current descriptor names.

property dtype

Convert the descriptor values to this type.

classmethod fromFile(filename: str) → Any

Initialize a new instance from a JSON file.

Parameters:

filename (str) – path to the JSON file

Returns:

new instance of the class

Return type:

instance (object)

classmethod fromJSON(json: str) → Any

Reconstruct object from a JSON string.

Parameters:

json (str) – JSON string of the object

Returns:

reconstructed object

Return type:

obj (object)

getDescriptors(mols: list[rdkit.Chem.rdchem.Mol], props: dict[str, list[Any]], *args, **kwargs) → ndarray

Method to calculate descriptors for a list of molecules.

This method should use molecules as they are without any preparation. Any preparation steps should be defined in the DescriptorSet.prepMols method., which is picked up by the main DescriptorSet.__call__.

Parameters:

• mols (list) – list of SMILES or RDKit molecules

• props (dict) – dictionary of properties

• *args – positional arguments

• **kwargs – keyword arguments

Returns:

numpy array of descriptor values of shape (n_mols, n_descriptors)

property isFP

Return True if descriptor set is a binary fingerprint.

static iterMols(mols: list[str | rdkit.Chem.rdchem.Mol], to_list=False) → list[rdkit.Chem.rdchem.Mol] | Generator[Mol, None, None]

Create a molecule generator or list from RDKit molecules or SMILES.

Parameters:

• mols – list of molecules (SMILES str or RDKit Mol)

• to_list – if True, return a list instead of a generator

Returns:

a list or generator of RDKit molecules

prepMols(mols: list[str | rdkit.Chem.rdchem.Mol]) → list[rdkit.Chem.rdchem.Mol]

Prepare the molecules for descriptor calculation.

property requiredProps: list[str]

The properties required by the processor. This is to inform the caller that the processor requires certain properties to be passed to the __call__ method. By default, no properties are required.

property supportsParallel: bool

Return True if the descriptor set supports parallel calculation.

toFile(filename: str) → str

Serialize object to a JSON file. This JSON file should contain all data necessary to reconstruct the object.

Parameters:

filename (str) – filename to save object to

Returns:

absolute path to the saved JSON file of the object

Return type:

filename (str)

toJSON() → str

Serialize object to a JSON string. This JSON string should

contain all data necessary to reconstruct the object.

Returns:

JSON string of the object

Return type:

json (str)

transformToFeatureNames()

static treatInfs(df: DataFrame) → DataFrame

Replace infinite values by NaNs.

Parameters:

df – dataframe to treat

Returns:

dataframe with infinite values replaced by NaNs

property usedBits: list[int] | None

class qsprpred.data.descriptors.fingerprints.RDKitFP(minPath=1, maxPath=7, nBits=2048, **kwargs)

Bases: Fingerprint

Initialize the processor with the name of the property that contains the molecule’s unique identifier.

Parameters:

id_prop (str) – Name of the property that contains the molecule’s unique identifier. Defaults to “QSPRID”.

property descriptors: list[str]

Return a list of current descriptor names.

property dtype

Convert the descriptor values to this type.

classmethod fromFile(filename: str) → Any

Initialize a new instance from a JSON file.

Parameters:

filename (str) – path to the JSON file

Returns:

new instance of the class

Return type:

instance (object)

classmethod fromJSON(json: str) → Any

Reconstruct object from a JSON string.

Parameters:

json (str) – JSON string of the object

Returns:

reconstructed object

Return type:

obj (object)

getDescriptors(mols: list[rdkit.Chem.rdchem.Mol], props: dict[str, list[Any]], *args, **kwargs) → ndarray

Method to calculate descriptors for a list of molecules.

This method should use molecules as they are without any preparation. Any preparation steps should be defined in the DescriptorSet.prepMols method., which is picked up by the main DescriptorSet.__call__.

Parameters:

• mols (list) – list of SMILES or RDKit molecules

• props (dict) – dictionary of properties

• *args – positional arguments

• **kwargs – keyword arguments

Returns:

numpy array of descriptor values of shape (n_mols, n_descriptors)

property isFP

Return True if descriptor set is a binary fingerprint.

static iterMols(mols: list[str | rdkit.Chem.rdchem.Mol], to_list=False) → list[rdkit.Chem.rdchem.Mol] | Generator[Mol, None, None]

Create a molecule generator or list from RDKit molecules or SMILES.

Parameters:

• mols – list of molecules (SMILES str or RDKit Mol)

• to_list – if True, return a list instead of a generator

Returns:

a list or generator of RDKit molecules

prepMols(mols: list[str | rdkit.Chem.rdchem.Mol]) → list[rdkit.Chem.rdchem.Mol]

Prepare the molecules for descriptor calculation.

property requiredProps: list[str]

The properties required by the processor. This is to inform the caller that the processor requires certain properties to be passed to the __call__ method. By default, no properties are required.

property supportsParallel: bool

Return True if the descriptor set supports parallel calculation.

toFile(filename: str) → str

Serialize object to a JSON file. This JSON file should contain all data necessary to reconstruct the object.

Parameters:

filename (str) – filename to save object to

Returns:

absolute path to the saved JSON file of the object

Return type:

filename (str)

toJSON() → str

Serialize object to a JSON string. This JSON string should

contain all data necessary to reconstruct the object.

Returns:

JSON string of the object

Return type:

json (str)

transformToFeatureNames()

static treatInfs(df: DataFrame) → DataFrame

Replace infinite values by NaNs.

Parameters:

df – dataframe to treat

Returns:

dataframe with infinite values replaced by NaNs

property usedBits: list[int] | None

class qsprpred.data.descriptors.fingerprints.RDKitMACCSFP(used_bits: list[int] | None = None)

Bases: Fingerprint

RDKits implementation of MACCS keys fingerprint.

Initialize the processor with the name of the property that contains the molecule’s unique identifier.

Parameters:

id_prop (str) – Name of the property that contains the molecule’s unique identifier. Defaults to “QSPRID”.

property descriptors: list[str]

Return a list of current descriptor names.

property dtype

Convert the descriptor values to this type.

classmethod fromFile(filename: str) → Any

Initialize a new instance from a JSON file.

Parameters:

filename (str) – path to the JSON file

Returns:

new instance of the class

Return type:

instance (object)

classmethod fromJSON(json: str) → Any

Reconstruct object from a JSON string.

Parameters:

json (str) – JSON string of the object

Returns:

reconstructed object

Return type:

obj (object)

getDescriptors(mols: list[rdkit.Chem.rdchem.Mol], props: dict[str, list[Any]], *args, **kwargs) → ndarray

Method to calculate descriptors for a list of molecules.

This method should use molecules as they are without any preparation. Any preparation steps should be defined in the DescriptorSet.prepMols method., which is picked up by the main DescriptorSet.__call__.

Parameters:

• mols (list) – list of SMILES or RDKit molecules

• props (dict) – dictionary of properties

• *args – positional arguments

• **kwargs – keyword arguments

Returns:

numpy array of descriptor values of shape (n_mols, n_descriptors)

property isFP

Return True if descriptor set is a binary fingerprint.

static iterMols(mols: list[str | rdkit.Chem.rdchem.Mol], to_list=False) → list[rdkit.Chem.rdchem.Mol] | Generator[Mol, None, None]

Create a molecule generator or list from RDKit molecules or SMILES.

Parameters:

• mols – list of molecules (SMILES str or RDKit Mol)

• to_list – if True, return a list instead of a generator

Returns:

a list or generator of RDKit molecules

prepMols(mols: list[str | rdkit.Chem.rdchem.Mol]) → list[rdkit.Chem.rdchem.Mol]

Prepare the molecules for descriptor calculation.

property requiredProps: list[str]

The properties required by the processor. This is to inform the caller that the processor requires certain properties to be passed to the __call__ method. By default, no properties are required.

property supportsParallel: bool

Return True if the descriptor set supports parallel calculation.

toFile(filename: str) → str

Serialize object to a JSON file. This JSON file should contain all data necessary to reconstruct the object.

Parameters:

filename (str) – filename to save object to

Returns:

absolute path to the saved JSON file of the object

Return type:

filename (str)

toJSON() → str

Serialize object to a JSON string. This JSON string should

contain all data necessary to reconstruct the object.

Returns:

JSON string of the object

Return type:

json (str)

transformToFeatureNames()

static treatInfs(df: DataFrame) → DataFrame

Replace infinite values by NaNs.

Parameters:

df – dataframe to treat

Returns:

dataframe with infinite values replaced by NaNs

property usedBits: list[int] | None

class qsprpred.data.descriptors.fingerprints.TopologicalFP(nBits=2048, **kwargs)

Bases: Fingerprint

Initialize the processor with the name of the property that contains the molecule’s unique identifier.

Parameters:

id_prop (str) – Name of the property that contains the molecule’s unique identifier. Defaults to “QSPRID”.

property descriptors: list[str]

Return a list of current descriptor names.

property dtype

Convert the descriptor values to this type.

classmethod fromFile(filename: str) → Any

Initialize a new instance from a JSON file.

Parameters:

filename (str) – path to the JSON file

Returns:

new instance of the class

Return type:

instance (object)

classmethod fromJSON(json: str) → Any

Reconstruct object from a JSON string.

Parameters:

json (str) – JSON string of the object

Returns:

reconstructed object

Return type:

obj (object)

getDescriptors(mols: list[rdkit.Chem.rdchem.Mol], props: dict[str, list[Any]], *args, **kwargs) → ndarray

Method to calculate descriptors for a list of molecules.

This method should use molecules as they are without any preparation. Any preparation steps should be defined in the DescriptorSet.prepMols method., which is picked up by the main DescriptorSet.__call__.

Parameters:

• mols (list) – list of SMILES or RDKit molecules

• props (dict) – dictionary of properties

• *args – positional arguments

• **kwargs – keyword arguments

Returns:

numpy array of descriptor values of shape (n_mols, n_descriptors)

property isFP

Return True if descriptor set is a binary fingerprint.

static iterMols(mols: list[str | rdkit.Chem.rdchem.Mol], to_list=False) → list[rdkit.Chem.rdchem.Mol] | Generator[Mol, None, None]

Create a molecule generator or list from RDKit molecules or SMILES.

Parameters:

• mols – list of molecules (SMILES str or RDKit Mol)

• to_list – if True, return a list instead of a generator

Returns:

a list or generator of RDKit molecules

prepMols(mols: list[str | rdkit.Chem.rdchem.Mol]) → list[rdkit.Chem.rdchem.Mol]

Prepare the molecules for descriptor calculation.

property requiredProps: list[str]

The properties required by the processor. This is to inform the caller that the processor requires certain properties to be passed to the __call__ method. By default, no properties are required.

property supportsParallel: bool

Return True if the descriptor set supports parallel calculation.

toFile(filename: str) → str

Serialize object to a JSON file. This JSON file should contain all data necessary to reconstruct the object.

Parameters:

filename (str) – filename to save object to

Returns:

absolute path to the saved JSON file of the object

Return type:

filename (str)

toJSON() → str

Serialize object to a JSON string. This JSON string should

contain all data necessary to reconstruct the object.

Returns:

JSON string of the object

Return type:

json (str)

transformToFeatureNames()

static treatInfs(df: DataFrame) → DataFrame

Replace infinite values by NaNs.

Parameters:

df – dataframe to treat

Returns:

dataframe with infinite values replaced by NaNs

property usedBits: list[int] | None

qsprpred.data.descriptors.sets module

Descriptorset: a collection of descriptors that can be calculated for a molecule. To add a new descriptor or fingerprint calculator: * Add a descriptor subclass for your descriptor calculator * Add a function to retrieve your descriptor by name to the descriptor retriever class

class qsprpred.data.descriptors.sets.DataFrameDescriptorSet(df: DataFrame, joining_cols: list[str] | None = None, suffix='', source_is_multi_index=False)

Bases: DescriptorSet

DescriptorSet that uses a pandas.DataFrame of precalculated descriptors.

Initialize the descriptor set with a dataframe of descriptors.

Parameters:

• df – dataframe of descriptors

• joining_cols – list of columns to use as joining index, properties of the same name must exist in the data set this descriptor is added to

• suffix – suffix to add to the descriptor name

• source_is_multi_index – assume that a multi-index is already present in the supplied dataframe. If True, the joining_cols argument must also be specified to indicate which properties should be used to create the multi-index in the destination.

property descriptors

Return a list of current descriptor names.

property dtype

Convert the descriptor values to this type.

classmethod fromFile(filename: str) → Any

Initialize a new instance from a JSON file.

Parameters:

filename (str) – path to the JSON file

Returns:

new instance of the class

Return type:

instance (object)

classmethod fromJSON(json: str) → Any

Reconstruct object from a JSON string.

Parameters:

json (str) – JSON string of the object

Returns:

reconstructed object

Return type:

obj (object)

getDF()

Return the dataframe of descriptors.

getDescriptors(mols: list[rdkit.Chem.rdchem.Mol], props: dict[str, list[Any]], *args, **kwargs) → ndarray

Return the descriptors for the input molecules. It simply searches for descriptor values in the data frame using the idProp as index.

Parameters:

• mols – list of SMILES or RDKit molecules

• props – dictionary of properties

• *args – positional arguments

• **kwargs – keyword arguments

Returns:

numpy array of descriptor values of shape (n_mols, n_descriptors)

getIndex()

Return the index of the dataframe.

getIndexCols()

Return the index columns of the dataframe.

property isFP

Return True if descriptor set is a binary fingerprint.

static iterMols(mols: list[str | rdkit.Chem.rdchem.Mol], to_list=False) → list[rdkit.Chem.rdchem.Mol] | Generator[Mol, None, None]

Create a molecule generator or list from RDKit molecules or SMILES.

Parameters:

• mols – list of molecules (SMILES str or RDKit Mol)

• to_list – if True, return a list instead of a generator

Returns:

a list or generator of RDKit molecules

prepMols(mols: list[str | rdkit.Chem.rdchem.Mol]) → list[rdkit.Chem.rdchem.Mol]

Prepare the molecules for descriptor calculation.

property requiredProps: list[str]

Return the required properties for the dataframe.

static setIndex(df: DataFrame, cols: list[str])

Create a multi-index from several columns of the data set.

Parameters:

• df (pd.DataFrame) – DataFrame to set index for.

• cols (list[str]) – List of columns to use as the new multi-index.

property supportsParallel: bool

Return True if the descriptor set supports parallel calculation.

toFile(filename: str) → str

Serialize object to a JSON file. This JSON file should contain all data necessary to reconstruct the object.

Parameters:

filename (str) – filename to save object to

Returns:

absolute path to the saved JSON file of the object

Return type:

filename (str)

toJSON() → str

Serialize object to a JSON string. This JSON string should

contain all data necessary to reconstruct the object.

Returns:

JSON string of the object

Return type:

json (str)

transformToFeatureNames()

static treatInfs(df: DataFrame) → DataFrame

Replace infinite values by NaNs.

Parameters:

df – dataframe to treat

Returns:

dataframe with infinite values replaced by NaNs

class qsprpred.data.descriptors.sets.DescriptorSet(id_prop: str | None = None)

Bases: JSONSerializable, MolProcessorWithID, ABC

MolProcessorWithID that calculates descriptors for a molecule.

Initialize the processor with the name of the property that contains the molecule’s unique identifier.

Parameters:

id_prop (str) – Name of the property that contains the molecule’s unique identifier. Defaults to “QSPRID”.

abstract property descriptors: list[str]

Return a list of current descriptor names.

property dtype

Convert the descriptor values to this type.

classmethod fromFile(filename: str) → Any

Initialize a new instance from a JSON file.

Parameters:

filename (str) – path to the JSON file

Returns:

new instance of the class

Return type:

instance (object)

classmethod fromJSON(json: str) → Any

Reconstruct object from a JSON string.

Parameters:

json (str) – JSON string of the object

Returns:

reconstructed object

Return type:

obj (object)

abstract getDescriptors(mols: list[rdkit.Chem.rdchem.Mol], props: dict[str, list[Any]], *args, **kwargs) → ndarray

Method to calculate descriptors for a list of molecules.

This method should use molecules as they are without any preparation. Any preparation steps should be defined in the DescriptorSet.prepMols method., which is picked up by the main DescriptorSet.__call__.

Parameters:

• mols (list) – list of SMILES or RDKit molecules

• props (dict) – dictionary of properties

• *args – positional arguments

• **kwargs – keyword arguments

Returns:

numpy array of descriptor values of shape (n_mols, n_descriptors)

property isFP

Return True if descriptor set is a binary fingerprint.

static iterMols(mols: list[str | rdkit.Chem.rdchem.Mol], to_list=False) → list[rdkit.Chem.rdchem.Mol] | Generator[Mol, None, None]

Create a molecule generator or list from RDKit molecules or SMILES.

Parameters:

• mols – list of molecules (SMILES str or RDKit Mol)

• to_list – if True, return a list instead of a generator

Returns:

a list or generator of RDKit molecules

prepMols(mols: list[str | rdkit.Chem.rdchem.Mol]) → list[rdkit.Chem.rdchem.Mol]

Prepare the molecules for descriptor calculation.

property requiredProps: list[str]

The properties required by the processor. This is to inform the caller that the processor requires certain properties to be passed to the __call__ method. By default, no properties are required.

property supportsParallel: bool

Return True if the descriptor set supports parallel calculation.

toFile(filename: str) → str

Serialize object to a JSON file. This JSON file should contain all data necessary to reconstruct the object.

Parameters:

filename (str) – filename to save object to

Returns:

absolute path to the saved JSON file of the object

Return type:

filename (str)

toJSON() → str

Serialize object to a JSON string. This JSON string should

contain all data necessary to reconstruct the object.

Returns:

JSON string of the object

Return type:

json (str)

transformToFeatureNames()

static treatInfs(df: DataFrame) → DataFrame

Replace infinite values by NaNs.

Parameters:

df – dataframe to treat

Returns:

dataframe with infinite values replaced by NaNs

class qsprpred.data.descriptors.sets.DrugExPhyschem(physchem_props: list[str] | None = None)

Bases: DescriptorSet

Various properties used for scoring in DrugEx.

Initialize the descriptorset with Property arguments (a list of properties to calculate) to select a subset.

Parameters:

physchem_props – list of properties to calculate

property descriptors

Return a list of current descriptor names.

property dtype

Convert the descriptor values to this type.

classmethod fromFile(filename: str) → Any

Initialize a new instance from a JSON file.

Parameters:

filename (str) – path to the JSON file

Returns:

new instance of the class

Return type:

instance (object)

classmethod fromJSON(json: str) → Any

Reconstruct object from a JSON string.

Parameters:

json (str) – JSON string of the object

Returns:

reconstructed object

Return type:

obj (object)

getDescriptors(mols, props, *args, **kwargs)

Calculate the DrugEx properties for a molecule.

static getPropDict()

property isFP

Return True if descriptor set is a binary fingerprint.

static iterMols(mols: list[str | rdkit.Chem.rdchem.Mol], to_list=False) → list[rdkit.Chem.rdchem.Mol] | Generator[Mol, None, None]

Create a molecule generator or list from RDKit molecules or SMILES.

Parameters:

• mols – list of molecules (SMILES str or RDKit Mol)

• to_list – if True, return a list instead of a generator

Returns:

a list or generator of RDKit molecules

prepMols(mols: list[str | rdkit.Chem.rdchem.Mol]) → list[rdkit.Chem.rdchem.Mol]

Prepare the molecules for descriptor calculation.

property requiredProps: list[str]

The properties required by the processor. This is to inform the caller that the processor requires certain properties to be passed to the __call__ method. By default, no properties are required.

property supportsParallel: bool

Return True if the descriptor set supports parallel calculation.

toFile(filename: str) → str

Serialize object to a JSON file. This JSON file should contain all data necessary to reconstruct the object.

Parameters:

filename (str) – filename to save object to

Returns:

absolute path to the saved JSON file of the object

Return type:

filename (str)

toJSON() → str

Serialize object to a JSON string. This JSON string should

contain all data necessary to reconstruct the object.

Returns:

JSON string of the object

Return type:

json (str)

transformToFeatureNames()

static treatInfs(df: DataFrame) → DataFrame

Replace infinite values by NaNs.

Parameters:

df – dataframe to treat

Returns:

dataframe with infinite values replaced by NaNs

class qsprpred.data.descriptors.sets.PredictorDesc(model: Type[QSPRModel] | str)

Bases: DescriptorSet

MoleculeDescriptorSet that uses a Predictor object to calculate descriptors from a molecule.

Initialize the descriptorset with a QSPRModel object.

Parameters:

model (QSPRModel) – a fitted model instance or a path to the model’s meta file

property descriptors

Return a list of current descriptor names.

property dtype

Convert the descriptor values to this type.

classmethod fromFile(filename: str) → Any

Initialize a new instance from a JSON file.

Parameters:

filename (str) – path to the JSON file

Returns:

new instance of the class

Return type:

instance (object)

classmethod fromJSON(json: str) → Any

Reconstruct object from a JSON string.

Parameters:

json (str) – JSON string of the object

Returns:

reconstructed object

Return type:

obj (object)

getDescriptors(mols, props, *args, **kwargs)

Calculate the descriptor for a list of molecules.

Parameters:

mols (list) – list of smiles or rdkit molecules

Returns:

an array of descriptor values

property isFP

Return True if descriptor set is a binary fingerprint.

static iterMols(mols: list[str | rdkit.Chem.rdchem.Mol], to_list=False) → list[rdkit.Chem.rdchem.Mol] | Generator[Mol, None, None]

Create a molecule generator or list from RDKit molecules or SMILES.

Parameters:

• mols – list of molecules (SMILES str or RDKit Mol)

• to_list – if True, return a list instead of a generator

Returns:

a list or generator of RDKit molecules

prepMols(mols: list[str | rdkit.Chem.rdchem.Mol]) → list[rdkit.Chem.rdchem.Mol]

Prepare the molecules for descriptor calculation.

property requiredProps: list[str]

The properties required by the processor. This is to inform the caller that the processor requires certain properties to be passed to the __call__ method. By default, no properties are required.

property supportsParallel: bool

Return True if the descriptor set supports parallel calculation.

toFile(filename: str) → str

Serialize object to a JSON file. This JSON file should contain all data necessary to reconstruct the object.

Parameters:

filename (str) – filename to save object to

Returns:

absolute path to the saved JSON file of the object

Return type:

filename (str)

toJSON() → str

Serialize object to a JSON string. This JSON string should

contain all data necessary to reconstruct the object.

Returns:

JSON string of the object

Return type:

json (str)

transformToFeatureNames()

static treatInfs(df: DataFrame) → DataFrame

Replace infinite values by NaNs.

Parameters:

df – dataframe to treat

Returns:

dataframe with infinite values replaced by NaNs

class qsprpred.data.descriptors.sets.RDKitDescs(rdkit_descriptors: list[str] | None = None, include_3d: bool = False)

Bases: DescriptorSet

Calculate RDkit descriptors.

Parameters:

• rdkit_descriptors – list of descriptors to calculate, if none, all 2D rdkit descriptors will be calculated

• include_3d – if True, 3D descriptors will be calculated

Initialize the processor with the name of the property that contains the molecule’s unique identifier.

Parameters:

id_prop (str) – Name of the property that contains the molecule’s unique identifier. Defaults to “QSPRID”.

property descriptors

Return a list of current descriptor names.

property dtype

Convert the descriptor values to this type.

classmethod fromFile(filename: str) → Any

Initialize a new instance from a JSON file.

Parameters:

filename (str) – path to the JSON file

Returns:

new instance of the class

Return type:

instance (object)

classmethod fromJSON(json: str) → Any

Reconstruct object from a JSON string.

Parameters:

json (str) – JSON string of the object

Returns:

reconstructed object

Return type:

obj (object)

getDescriptors(mols: list[rdkit.Chem.rdchem.Mol], props: dict[str, list[Any]], *args, **kwargs) → ndarray

Method to calculate descriptors for a list of molecules.

This method should use molecules as they are without any preparation. Any preparation steps should be defined in the DescriptorSet.prepMols method., which is picked up by the main DescriptorSet.__call__.

Parameters:

• mols (list) – list of SMILES or RDKit molecules

• props (dict) – dictionary of properties

• *args – positional arguments

• **kwargs – keyword arguments

Returns:

numpy array of descriptor values of shape (n_mols, n_descriptors)

property isFP

Return True if descriptor set is a binary fingerprint.

static iterMols(mols: list[str | rdkit.Chem.rdchem.Mol], to_list=False) → list[rdkit.Chem.rdchem.Mol] | Generator[Mol, None, None]

Create a molecule generator or list from RDKit molecules or SMILES.

Parameters:

• mols – list of molecules (SMILES str or RDKit Mol)

• to_list – if True, return a list instead of a generator

Returns:

a list or generator of RDKit molecules

prepMols(mols: list[str | rdkit.Chem.rdchem.Mol]) → list[rdkit.Chem.rdchem.Mol]

Prepare the molecules for descriptor calculation.

property requiredProps: list[str]

The properties required by the processor. This is to inform the caller that the processor requires certain properties to be passed to the __call__ method. By default, no properties are required.

property supportsParallel: bool

Return True if the descriptor set supports parallel calculation.

toFile(filename: str) → str

Serialize object to a JSON file. This JSON file should contain all data necessary to reconstruct the object.

Parameters:

filename (str) – filename to save object to

Returns:

absolute path to the saved JSON file of the object

Return type:

filename (str)

toJSON() → str

Serialize object to a JSON string. This JSON string should

contain all data necessary to reconstruct the object.

Returns:

JSON string of the object

Return type:

json (str)

transformToFeatureNames()

static treatInfs(df: DataFrame) → DataFrame

Replace infinite values by NaNs.

Parameters:

df – dataframe to treat

Returns:

dataframe with infinite values replaced by NaNs

class qsprpred.data.descriptors.sets.SmilesDesc(id_prop: str | None = None)

Bases: DescriptorSet

Descriptorset that calculates descriptors from a SMILES sequence.

Initialize the processor with the name of the property that contains the molecule’s unique identifier.

Parameters:

id_prop (str) – Name of the property that contains the molecule’s unique identifier. Defaults to “QSPRID”.

property descriptors

Return a list of current descriptor names.

property dtype

Convert the descriptor values to this type.

classmethod fromFile(filename: str) → Any

Initialize a new instance from a JSON file.

Parameters:

filename (str) – path to the JSON file

Returns:

new instance of the class

Return type:

instance (object)

classmethod fromJSON(json: str) → Any

Reconstruct object from a JSON string.

Parameters:

json (str) – JSON string of the object

Returns:

reconstructed object

Return type:

obj (object)

getDescriptors(mols: list[rdkit.Chem.rdchem.Mol], props: dict[str, list[Any]], *args, **kwargs) → ndarray

Return smiles as descriptors.

Parameters:

mols (list) – list of smiles or rdkit molecules

Returns:

an array or data frame of descriptor values of shape (n_mols, n_descriptors)

property isFP

Return True if descriptor set is a binary fingerprint.

static iterMols(mols: list[str | rdkit.Chem.rdchem.Mol], to_list=False) → list[rdkit.Chem.rdchem.Mol] | Generator[Mol, None, None]

Create a molecule generator or list from RDKit molecules or SMILES.

Parameters:

• mols – list of molecules (SMILES str or RDKit Mol)

• to_list – if True, return a list instead of a generator

Returns:

a list or generator of RDKit molecules

prepMols(mols: list[str | rdkit.Chem.rdchem.Mol]) → list[rdkit.Chem.rdchem.Mol]

Prepare the molecules for descriptor calculation.

property requiredProps: list[str]

The properties required by the processor. This is to inform the caller that the processor requires certain properties to be passed to the __call__ method. By default, no properties are required.

property supportsParallel: bool

Return True if the descriptor set supports parallel calculation.

toFile(filename: str) → str

Serialize object to a JSON file. This JSON file should contain all data necessary to reconstruct the object.

Parameters:

filename (str) – filename to save object to

Returns:

absolute path to the saved JSON file of the object

Return type:

filename (str)

toJSON() → str

Serialize object to a JSON string. This JSON string should

contain all data necessary to reconstruct the object.

Returns:

JSON string of the object

Return type:

json (str)

transformToFeatureNames()

static treatInfs(df: DataFrame) → DataFrame

Replace infinite values by NaNs.

Parameters:

df – dataframe to treat

Returns:

dataframe with infinite values replaced by NaNs

class qsprpred.data.descriptors.sets.TanimotoDistances(list_of_smiles, fingerprint_type, *args, **kwargs)

Bases: DescriptorSet

Calculate Tanimoto distances to a list of SMILES sequences.

Parameters:

• list_of_smiles (list of strings) – list of SMILES to calculate the distances.

• fingerprint_type (str) – fingerprint type to use.

• *args – fingerprint arguments

• **kwargs – fingerprint keyword arguments, should contain fingerprint_type

Initialize the descriptorset with a list of SMILES sequences and a fingerprint type.

Parameters:

• list_of_smiles (list of strings) – list of SMILES sequences to calculate distance to

• fingerprint_type (Fingerprint) – fingerprint type to use

calculate_fingerprints(list_of_smiles)

Calculate the fingerprints for the list of SMILES sequences.

property descriptors

Return a list of current descriptor names.

property dtype

Convert the descriptor values to this type.

classmethod fromFile(filename: str) → Any

Initialize a new instance from a JSON file.

Parameters:

filename (str) – path to the JSON file

Returns:

new instance of the class

Return type:

instance (object)

classmethod fromJSON(json: str) → Any

Reconstruct object from a JSON string.

Parameters:

json (str) – JSON string of the object

Returns:

reconstructed object

Return type:

obj (object)

getDescriptors(mols: list[rdkit.Chem.rdchem.Mol], props: dict[str, list[Any]], *args, **kwargs) → ndarray

Calculate the Tanimoto distances to the list of SMILES sequences.

Parameters:

mols (List[str] or List[rdkit.Chem.rdchem.Mol]) – SMILES sequences or RDKit molecules to calculate the distances.

property isFP

Return True if descriptor set is a binary fingerprint.

static iterMols(mols: list[str | rdkit.Chem.rdchem.Mol], to_list=False) → list[rdkit.Chem.rdchem.Mol] | Generator[Mol, None, None]

Create a molecule generator or list from RDKit molecules or SMILES.

Parameters:

• mols – list of molecules (SMILES str or RDKit Mol)

• to_list – if True, return a list instead of a generator

Returns:

a list or generator of RDKit molecules

prepMols(mols: list[str | rdkit.Chem.rdchem.Mol]) → list[rdkit.Chem.rdchem.Mol]

Prepare the molecules for descriptor calculation.

property requiredProps: list[str]

The properties required by the processor. This is to inform the caller that the processor requires certain properties to be passed to the __call__ method. By default, no properties are required.

property supportsParallel: bool

Return True if the descriptor set supports parallel calculation.

toFile(filename: str) → str

Serialize object to a JSON file. This JSON file should contain all data necessary to reconstruct the object.

Parameters:

filename (str) – filename to save object to

Returns:

absolute path to the saved JSON file of the object

Return type:

filename (str)

toJSON() → str

Serialize object to a JSON string. This JSON string should

contain all data necessary to reconstruct the object.

Returns:

JSON string of the object

Return type:

json (str)

transformToFeatureNames()

static treatInfs(df: DataFrame) → DataFrame

Replace infinite values by NaNs.

Parameters:

df – dataframe to treat

Returns:

dataframe with infinite values replaced by NaNs

qsprpred.data.descriptors.tests module

class qsprpred.data.descriptors.tests.TestDescriptorCalculation(methodName='runTest')

Bases: DataSetsPathMixIn, QSPRTestCase

Test the calculation of descriptors.

Create an instance of the class that will use the named test method when executed. Raises a ValueError if the instance does not have a method with the specified name.

classmethod addClassCleanup(function, /, *args, **kwargs)

Same as addCleanup, except the cleanup items are called even if setUpClass fails (unlike tearDownClass).

addCleanup(function, /, *args, **kwargs)

Add a function, with arguments, to be called when the test is completed. Functions added are called on a LIFO basis and are called after tearDown on test failure or success.

Cleanup items are called even if setUp fails (unlike tearDown).

addTypeEqualityFunc(typeobj, function)

Add a type specific assertEqual style function to compare a type.

This method is for use by TestCase subclasses that need to register their own type equality functions to provide nicer error messages.

Parameters:

• typeobj – The data type to call this function on when both values are of the same type in assertEqual().

• function – The callable taking two arguments and an optional msg= argument that raises self.failureException with a useful error message when the two arguments are not equal.

assertAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are unequal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the difference between the two objects is more than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

If the two objects compare equal then they will automatically compare almost equal.

assertCountEqual(first, second, msg=None)

Asserts that two iterables have the same elements, the same number of times, without regard to order.

self.assertEqual(Counter(list(first)),

Counter(list(second)))

Example:

• [0, 1, 1] and [1, 0, 1] compare equal.

• [0, 0, 1] and [0, 1] compare unequal.

assertDictEqual(d1, d2, msg=None)

assertEqual(first, second, msg=None)

Fail if the two objects are unequal as determined by the ‘==’ operator.

assertFalse(expr, msg=None)

Check that the expression is false.

assertGreater(a, b, msg=None)

Just like self.assertTrue(a > b), but with a nicer default message.

assertGreaterEqual(a, b, msg=None)

Just like self.assertTrue(a >= b), but with a nicer default message.

assertIn(member, container, msg=None)

Just like self.assertTrue(a in b), but with a nicer default message.

assertIs(expr1, expr2, msg=None)

Just like self.assertTrue(a is b), but with a nicer default message.

assertIsInstance(obj, cls, msg=None)

Same as self.assertTrue(isinstance(obj, cls)), with a nicer default message.

assertIsNone(obj, msg=None)

Same as self.assertTrue(obj is None), with a nicer default message.

assertIsNot(expr1, expr2, msg=None)

Just like self.assertTrue(a is not b), but with a nicer default message.

assertIsNotNone(obj, msg=None)

Included for symmetry with assertIsNone.

assertLess(a, b, msg=None)

Just like self.assertTrue(a < b), but with a nicer default message.

assertLessEqual(a, b, msg=None)

Just like self.assertTrue(a <= b), but with a nicer default message.

assertListEqual(list1, list2, msg=None)

A list-specific equality assertion.

Parameters:

• list1 – The first list to compare.

• list2 – The second list to compare.

• msg – Optional message to use on failure instead of a list of differences.

assertLogs(logger=None, level=None)

Fail unless a log message of level level or higher is emitted on logger_name or its children. If omitted, level defaults to INFO and logger defaults to the root logger.

This method must be used as a context manager, and will yield a recording object with two attributes: output and records. At the end of the context manager, the output attribute will be a list of the matching formatted log messages and the records attribute will be a list of the corresponding LogRecord objects.

Example:

with self.assertLogs('foo', level='INFO') as cm:
    logging.getLogger('foo').info('first message')
    logging.getLogger('foo.bar').error('second message')
self.assertEqual(cm.output, ['INFO:foo:first message',
                             'ERROR:foo.bar:second message'])

assertMultiLineEqual(first, second, msg=None)

Assert that two multi-line strings are equal.

assertNoLogs(logger=None, level=None)

Fail unless no log messages of level level or higher are emitted on logger_name or its children.

This method must be used as a context manager.

assertNotAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are equal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the difference between the two objects is less than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

Objects that are equal automatically fail.

assertNotEqual(first, second, msg=None)

Fail if the two objects are equal as determined by the ‘!=’ operator.

assertNotIn(member, container, msg=None)

Just like self.assertTrue(a not in b), but with a nicer default message.

assertNotIsInstance(obj, cls, msg=None)

Included for symmetry with assertIsInstance.

assertNotRegex(text, unexpected_regex, msg=None)

Fail the test if the text matches the regular expression.

assertRaises(expected_exception, *args, **kwargs)

Fail unless an exception of class expected_exception is raised by the callable when invoked with specified positional and keyword arguments. If a different type of exception is raised, it will not be caught, and the test case will be deemed to have suffered an error, exactly as for an unexpected exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertRaises(SomeException):
    do_something()

An optional keyword argument ‘msg’ can be provided when assertRaises is used as a context object.

The context manager keeps a reference to the exception as the ‘exception’ attribute. This allows you to inspect the exception after the assertion:

with self.assertRaises(SomeException) as cm:
    do_something()
the_exception = cm.exception
self.assertEqual(the_exception.error_code, 3)

assertRaisesRegex(expected_exception, expected_regex, *args, **kwargs)

Asserts that the message in a raised exception matches a regex.

Parameters:

• expected_exception – Exception class expected to be raised.

• expected_regex – Regex (re.Pattern object or string) expected to be found in error message.

• args – Function to be called and extra positional args.

• kwargs – Extra kwargs.

• msg – Optional message used in case of failure. Can only be used when assertRaisesRegex is used as a context manager.

assertRegex(text, expected_regex, msg=None)

Fail the test unless the text matches the regular expression.

assertSequenceEqual(seq1, seq2, msg=None, seq_type=None)

An equality assertion for ordered sequences (like lists and tuples).

For the purposes of this function, a valid ordered sequence type is one which can be indexed, has a length, and has an equality operator.

Parameters:

• seq1 – The first sequence to compare.

• seq2 – The second sequence to compare.

• seq_type – The expected datatype of the sequences, or None if no datatype should be enforced.

• msg – Optional message to use on failure instead of a list of differences.

assertSetEqual(set1, set2, msg=None)

A set-specific equality assertion.

Parameters:

• set1 – The first set to compare.

• set2 – The second set to compare.

• msg – Optional message to use on failure instead of a list of differences.

assertSetEqual uses ducktyping to support different types of sets, and is optimized for sets specifically (parameters must support a difference method).

assertTrue(expr, msg=None)

Check that the expression is true.

assertTupleEqual(tuple1, tuple2, msg=None)

A tuple-specific equality assertion.

Parameters:

• tuple1 – The first tuple to compare.

• tuple2 – The second tuple to compare.

• msg – Optional message to use on failure instead of a list of differences.

assertWarns(expected_warning, *args, **kwargs)

Fail unless a warning of class warnClass is triggered by the callable when invoked with specified positional and keyword arguments. If a different type of warning is triggered, it will not be handled: depending on the other warning filtering rules in effect, it might be silenced, printed out, or raised as an exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertWarns(SomeWarning):
    do_something()

An optional keyword argument ‘msg’ can be provided when assertWarns is used as a context object.

The context manager keeps a reference to the first matching warning as the ‘warning’ attribute; similarly, the ‘filename’ and ‘lineno’ attributes give you information about the line of Python code from which the warning was triggered. This allows you to inspect the warning after the assertion:

with self.assertWarns(SomeWarning) as cm:
    do_something()
the_warning = cm.warning
self.assertEqual(the_warning.some_attribute, 147)

assertWarnsRegex(expected_warning, expected_regex, *args, **kwargs)

Asserts that the message in a triggered warning matches a regexp. Basic functioning is similar to assertWarns() with the addition that only warnings whose messages also match the regular expression are considered successful matches.

Parameters:

• expected_warning – Warning class expected to be triggered.

• expected_regex – Regex (re.Pattern object or string) expected to be found in error message.

• args – Function to be called and extra positional args.

• kwargs – Extra kwargs.

• msg – Optional message used in case of failure. Can only be used when assertWarnsRegex is used as a context manager.

clearGenerated()

Remove the directories that are used for testing.

countTestCases()

createLargeMultitaskDataSet(name='QSPRDataset_multi_test', target_props=[{'name': 'HBD', 'task': <TargetTasks.MULTICLASS: 'MULTICLASS'>, 'th': [-1, 1, 2, 100]}, {'name': 'CL', 'task': <TargetTasks.REGRESSION: 'REGRESSION'>}], preparation_settings=None, random_state=42)

Create a large dataset for testing purposes.

Parameters:

• name (str) – name of the dataset

• target_props (List of dicts or TargetProperty) – list of target properties

• preparation_settings (dict) – dictionary containing preparation settings

• random_state (int) – random state to use for splitting and shuffling

Returns:

a QSPRDataset object

Return type:

QSPRDataset

createLargeTestDataSet(name='QSPRDataset_test_large', target_props=[{'name': 'CL', 'task': <TargetTasks.REGRESSION: 'REGRESSION'>}], preparation_settings=None, random_state=42, n_jobs=1, chunk_size=None)

Create a large dataset for testing purposes.

Parameters:

• name (str) – name of the dataset

• target_props (List of dicts or TargetProperty) – list of target properties

• random_state (int) – random state to use for splitting and shuffling

• preparation_settings (dict) – dictionary containing preparation settings

Returns:

a QSPRDataset object

Return type:

QSPRDataset

createSmallTestDataSet(name='QSPRDataset_test_small', target_props=[{'name': 'CL', 'task': <TargetTasks.REGRESSION: 'REGRESSION'>}], preparation_settings=None, random_state=42)

Create a small dataset for testing purposes.

Parameters:

• name (str) – name of the dataset

• target_props (List of dicts or TargetProperty) – list of target properties

• random_state (int) – random state to use for splitting and shuffling

• preparation_settings (dict) – dictionary containing preparation settings

Returns:

a QSPRDataset object

Return type:

QSPRDataset

createTestDataSetFromFrame(df, name='QSPRDataset_test', target_props=[{'name': 'CL', 'task': <TargetTasks.REGRESSION: 'REGRESSION'>}], random_state=None, prep=None, n_jobs=1, chunk_size=None)

Create a dataset for testing purposes from the given data frame.

Parameters:

• df (pd.DataFrame) – data frame containing the dataset

• name (str) – name of the dataset

• target_props (List of dicts or TargetProperty) – list of target properties

• random_state (int) – random state to use for splitting and shuffling

• prep (dict) – dictionary containing preparation settings

Returns:

a QSPRDataset object

Return type:

QSPRDataset

debug()

Run the test without collecting errors in a TestResult

defaultTestResult()

classmethod doClassCleanups()

Execute all class cleanup functions. Normally called for you after tearDownClass.

doCleanups()

Execute all cleanup functions. Normally called for you after tearDown.

classmethod enterClassContext(cm)

Same as enterContext, but class-wide.

enterContext(cm)

Enters the supplied context manager.

If successful, also adds its __exit__ method as a cleanup function and returns the result of the __enter__ method.

fail(msg=None)

Fail immediately, with the given message.

failureException

alias of AssertionError

classmethod getAllDescriptors()

Return a list of (ideally) all available descriptor sets. For now they need to be added manually to the list below.

TODO: would be nice to create the list automatically by implementing a descriptor set registry that would hold all installed descriptor sets.

Returns:

list of DescriptorCalculator objects

Return type:

list

getBigDF()

Get a large data frame for testing purposes.

Returns:

a pandas.DataFrame containing the dataset

Return type:

pd.DataFrame

classmethod getDataPrepGrid()

Return a list of many possible combinations of descriptor calculators, splits, feature standardizers, feature filters and data filters. Again, this is not exhaustive, but should cover a lot of cases.

Returns:

a generator that yields tuples of all possible combinations as stated above, each tuple is defined as: (descriptor_calculator, split, feature_standardizer, feature_filters, data_filters)

Return type:

grid

classmethod getDefaultCalculatorCombo()

Makes a list of default descriptor calculators that can be used in tests. It creates a calculator with only morgan fingerprints and rdkit descriptors, but also one with them both to test behaviour with multiple descriptor sets. Override this method if you want to test with other descriptor sets and calculator combinations.

Returns:

list of created DescriptorCalculator objects

Return type:

list

static getDefaultPrep()

Return a dictionary with default preparation settings.

static getDescList()

classmethod getPrepCombos()

Return a list of all possible preparation combinations as generated by getDataPrepGrid as well as their names. The generated list can be used to parameterize tests with the given named combinations.

Returns:

list of `list`s of all possible combinations of preparation

Return type:

list

getSmallDF()

Get a small data frame for testing purposes.

Returns:

a pandas.DataFrame containing the dataset

Return type:

pd.DataFrame

id()

longMessage = True

maxDiff = 640

run(result=None)

setUp()

Set up the test Dataframe.

classmethod setUpClass()

Hook method for setting up class fixture before running tests in the class.

setUpPaths()

Create the directories that are used for testing.

shortDescription()

Returns a one-line description of the test, or None if no description has been provided.

The default implementation of this method returns the first line of the specified test method’s docstring.

skipTest(reason)

Skip this test.

subTest(msg=<object object>, **params)

Return a context manager that will return the enclosed block of code in a subtest identified by the optional message and keyword parameters. A failure in the subtest marks the test case as failed but resumes execution at the end of the enclosed block, allowing further test code to be executed.

tearDown()

Remove all files and directories that are used for testing.

classmethod tearDownClass()

Hook method for deconstructing the class fixture after running all tests in the class.

testDropping()

Test dropping of descriptors from data sets.

testSwitching = None

testSwitching_0(**kw)

Test if the feature calculator can be switched to a new dataset [with n_cpu=None, chunk_size=None].

testSwitching_1(**kw)

Test if the feature calculator can be switched to a new dataset [with n_cpu=1, chunk_size=None].

testSwitching_2(**kw)

Test if the feature calculator can be switched to a new dataset [with n_cpu=2, chunk_size=None].

testSwitching_3(**kw)

Test if the feature calculator can be switched to a new dataset [with n_cpu=4, chunk_size=50].

validate_split(dataset)

Check if the split has the data it should have after splitting.

class qsprpred.data.descriptors.tests.TestDescriptorSets(methodName='runTest')

Bases: DataSetsPathMixIn, QSPRTestCase

Test the descriptor sets.

Create an instance of the class that will use the named test method when executed. Raises a ValueError if the instance does not have a method with the specified name.

classmethod addClassCleanup(function, /, *args, **kwargs)

Same as addCleanup, except the cleanup items are called even if setUpClass fails (unlike tearDownClass).

addCleanup(function, /, *args, **kwargs)

Add a function, with arguments, to be called when the test is completed. Functions added are called on a LIFO basis and are called after tearDown on test failure or success.

Cleanup items are called even if setUp fails (unlike tearDown).

addTypeEqualityFunc(typeobj, function)

Add a type specific assertEqual style function to compare a type.

This method is for use by TestCase subclasses that need to register their own type equality functions to provide nicer error messages.

Parameters:

• typeobj – The data type to call this function on when both values are of the same type in assertEqual().

• function – The callable taking two arguments and an optional msg= argument that raises self.failureException with a useful error message when the two arguments are not equal.

assertAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are unequal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the difference between the two objects is more than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

If the two objects compare equal then they will automatically compare almost equal.

assertCountEqual(first, second, msg=None)

Asserts that two iterables have the same elements, the same number of times, without regard to order.

self.assertEqual(Counter(list(first)),

Counter(list(second)))

Example:

• [0, 1, 1] and [1, 0, 1] compare equal.

• [0, 0, 1] and [0, 1] compare unequal.

assertDictEqual(d1, d2, msg=None)

assertEqual(first, second, msg=None)

Fail if the two objects are unequal as determined by the ‘==’ operator.

assertFalse(expr, msg=None)

Check that the expression is false.

assertGreater(a, b, msg=None)

Just like self.assertTrue(a > b), but with a nicer default message.

assertGreaterEqual(a, b, msg=None)

Just like self.assertTrue(a >= b), but with a nicer default message.

assertIn(member, container, msg=None)

Just like self.assertTrue(a in b), but with a nicer default message.

assertIs(expr1, expr2, msg=None)

Just like self.assertTrue(a is b), but with a nicer default message.

assertIsInstance(obj, cls, msg=None)

Same as self.assertTrue(isinstance(obj, cls)), with a nicer default message.

assertIsNone(obj, msg=None)

Same as self.assertTrue(obj is None), with a nicer default message.

assertIsNot(expr1, expr2, msg=None)

Just like self.assertTrue(a is not b), but with a nicer default message.

assertIsNotNone(obj, msg=None)

Included for symmetry with assertIsNone.

assertLess(a, b, msg=None)

Just like self.assertTrue(a < b), but with a nicer default message.

assertLessEqual(a, b, msg=None)

Just like self.assertTrue(a <= b), but with a nicer default message.

assertListEqual(list1, list2, msg=None)

A list-specific equality assertion.

Parameters:

• list1 – The first list to compare.

• list2 – The second list to compare.

• msg – Optional message to use on failure instead of a list of differences.

assertLogs(logger=None, level=None)

Fail unless a log message of level level or higher is emitted on logger_name or its children. If omitted, level defaults to INFO and logger defaults to the root logger.

This method must be used as a context manager, and will yield a recording object with two attributes: output and records. At the end of the context manager, the output attribute will be a list of the matching formatted log messages and the records attribute will be a list of the corresponding LogRecord objects.

Example:

with self.assertLogs('foo', level='INFO') as cm:
    logging.getLogger('foo').info('first message')
    logging.getLogger('foo.bar').error('second message')
self.assertEqual(cm.output, ['INFO:foo:first message',
                             'ERROR:foo.bar:second message'])

assertMultiLineEqual(first, second, msg=None)

Assert that two multi-line strings are equal.

assertNoLogs(logger=None, level=None)

Fail unless no log messages of level level or higher are emitted on logger_name or its children.

This method must be used as a context manager.

assertNotAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are equal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the difference between the two objects is less than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

Objects that are equal automatically fail.

assertNotEqual(first, second, msg=None)

Fail if the two objects are equal as determined by the ‘!=’ operator.

assertNotIn(member, container, msg=None)

Just like self.assertTrue(a not in b), but with a nicer default message.

assertNotIsInstance(obj, cls, msg=None)

Included for symmetry with assertIsInstance.

assertNotRegex(text, unexpected_regex, msg=None)

Fail the test if the text matches the regular expression.

assertRaises(expected_exception, *args, **kwargs)

Fail unless an exception of class expected_exception is raised by the callable when invoked with specified positional and keyword arguments. If a different type of exception is raised, it will not be caught, and the test case will be deemed to have suffered an error, exactly as for an unexpected exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertRaises(SomeException):
    do_something()

An optional keyword argument ‘msg’ can be provided when assertRaises is used as a context object.

The context manager keeps a reference to the exception as the ‘exception’ attribute. This allows you to inspect the exception after the assertion:

with self.assertRaises(SomeException) as cm:
    do_something()
the_exception = cm.exception
self.assertEqual(the_exception.error_code, 3)

assertRaisesRegex(expected_exception, expected_regex, *args, **kwargs)

Asserts that the message in a raised exception matches a regex.

Parameters:

• expected_exception – Exception class expected to be raised.

• expected_regex – Regex (re.Pattern object or string) expected to be found in error message.

• args – Function to be called and extra positional args.

• kwargs – Extra kwargs.

• msg – Optional message used in case of failure. Can only be used when assertRaisesRegex is used as a context manager.

assertRegex(text, expected_regex, msg=None)

Fail the test unless the text matches the regular expression.

assertSequenceEqual(seq1, seq2, msg=None, seq_type=None)

An equality assertion for ordered sequences (like lists and tuples).

For the purposes of this function, a valid ordered sequence type is one which can be indexed, has a length, and has an equality operator.

Parameters:

• seq1 – The first sequence to compare.

• seq2 – The second sequence to compare.

• seq_type – The expected datatype of the sequences, or None if no datatype should be enforced.

• msg – Optional message to use on failure instead of a list of differences.

assertSetEqual(set1, set2, msg=None)

A set-specific equality assertion.

Parameters:

• set1 – The first set to compare.

• set2 – The second set to compare.

• msg – Optional message to use on failure instead of a list of differences.

assertSetEqual uses ducktyping to support different types of sets, and is optimized for sets specifically (parameters must support a difference method).

assertTrue(expr, msg=None)

Check that the expression is true.

assertTupleEqual(tuple1, tuple2, msg=None)

A tuple-specific equality assertion.

Parameters:

• tuple1 – The first tuple to compare.

• tuple2 – The second tuple to compare.

• msg – Optional message to use on failure instead of a list of differences.

assertWarns(expected_warning, *args, **kwargs)

Fail unless a warning of class warnClass is triggered by the callable when invoked with specified positional and keyword arguments. If a different type of warning is triggered, it will not be handled: depending on the other warning filtering rules in effect, it might be silenced, printed out, or raised as an exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertWarns(SomeWarning):
    do_something()

An optional keyword argument ‘msg’ can be provided when assertWarns is used as a context object.

The context manager keeps a reference to the first matching warning as the ‘warning’ attribute; similarly, the ‘filename’ and ‘lineno’ attributes give you information about the line of Python code from which the warning was triggered. This allows you to inspect the warning after the assertion:

with self.assertWarns(SomeWarning) as cm:
    do_something()
the_warning = cm.warning
self.assertEqual(the_warning.some_attribute, 147)

assertWarnsRegex(expected_warning, expected_regex, *args, **kwargs)

Asserts that the message in a triggered warning matches a regexp. Basic functioning is similar to assertWarns() with the addition that only warnings whose messages also match the regular expression are considered successful matches.

Parameters:

• expected_warning – Warning class expected to be triggered.

• expected_regex – Regex (re.Pattern object or string) expected to be found in error message.

• args – Function to be called and extra positional args.

• kwargs – Extra kwargs.

• msg – Optional message used in case of failure. Can only be used when assertWarnsRegex is used as a context manager.

clearGenerated()

Remove the directories that are used for testing.

countTestCases()

createLargeMultitaskDataSet(name='QSPRDataset_multi_test', target_props=[{'name': 'HBD', 'task': <TargetTasks.MULTICLASS: 'MULTICLASS'>, 'th': [-1, 1, 2, 100]}, {'name': 'CL', 'task': <TargetTasks.REGRESSION: 'REGRESSION'>}], preparation_settings=None, random_state=42)

Create a large dataset for testing purposes.

Parameters:

• name (str) – name of the dataset

• target_props (List of dicts or TargetProperty) – list of target properties

• preparation_settings (dict) – dictionary containing preparation settings

• random_state (int) – random state to use for splitting and shuffling

Returns:

a QSPRDataset object

Return type:

QSPRDataset

createLargeTestDataSet(name='QSPRDataset_test_large', target_props=[{'name': 'CL', 'task': <TargetTasks.REGRESSION: 'REGRESSION'>}], preparation_settings=None, random_state=42, n_jobs=1, chunk_size=None)

Create a large dataset for testing purposes.

Parameters:

• name (str) – name of the dataset

• target_props (List of dicts or TargetProperty) – list of target properties

• random_state (int) – random state to use for splitting and shuffling

• preparation_settings (dict) – dictionary containing preparation settings

Returns:

a QSPRDataset object

Return type:

QSPRDataset

createSmallTestDataSet(name='QSPRDataset_test_small', target_props=[{'name': 'CL', 'task': <TargetTasks.REGRESSION: 'REGRESSION'>}], preparation_settings=None, random_state=42)

Create a small dataset for testing purposes.

Parameters:

• name (str) – name of the dataset

• target_props (List of dicts or TargetProperty) – list of target properties

• random_state (int) – random state to use for splitting and shuffling

• preparation_settings (dict) – dictionary containing preparation settings

Returns:

a QSPRDataset object

Return type:

QSPRDataset

createTestDataSetFromFrame(df, name='QSPRDataset_test', target_props=[{'name': 'CL', 'task': <TargetTasks.REGRESSION: 'REGRESSION'>}], random_state=None, prep=None, n_jobs=1, chunk_size=None)

Create a dataset for testing purposes from the given data frame.

Parameters:

• df (pd.DataFrame) – data frame containing the dataset

• name (str) – name of the dataset

• target_props (List of dicts or TargetProperty) – list of target properties

• random_state (int) – random state to use for splitting and shuffling

• prep (dict) – dictionary containing preparation settings

Returns:

a QSPRDataset object

Return type:

QSPRDataset

debug()

Run the test without collecting errors in a TestResult

defaultTestResult()

classmethod doClassCleanups()

Execute all class cleanup functions. Normally called for you after tearDownClass.

doCleanups()

Execute all cleanup functions. Normally called for you after tearDown.

classmethod enterClassContext(cm)

Same as enterContext, but class-wide.

enterContext(cm)

Enters the supplied context manager.

If successful, also adds its __exit__ method as a cleanup function and returns the result of the __enter__ method.

fail(msg=None)

Fail immediately, with the given message.

failureException

alias of AssertionError

classmethod getAllDescriptors()

Return a list of (ideally) all available descriptor sets. For now they need to be added manually to the list below.

TODO: would be nice to create the list automatically by implementing a descriptor set registry that would hold all installed descriptor sets.

Returns:

list of DescriptorCalculator objects

Return type:

list

getBigDF()

Get a large data frame for testing purposes.

Returns:

a pandas.DataFrame containing the dataset

Return type:

pd.DataFrame

classmethod getDataPrepGrid()

Return a list of many possible combinations of descriptor calculators, splits, feature standardizers, feature filters and data filters. Again, this is not exhaustive, but should cover a lot of cases.

Returns:

a generator that yields tuples of all possible combinations as stated above, each tuple is defined as: (descriptor_calculator, split, feature_standardizer, feature_filters, data_filters)

Return type:

grid

classmethod getDefaultCalculatorCombo()

Makes a list of default descriptor calculators that can be used in tests. It creates a calculator with only morgan fingerprints and rdkit descriptors, but also one with them both to test behaviour with multiple descriptor sets. Override this method if you want to test with other descriptor sets and calculator combinations.

Returns:

list of created DescriptorCalculator objects

Return type:

list

static getDefaultPrep()

Return a dictionary with default preparation settings.

classmethod getPrepCombos()

Return a list of all possible preparation combinations as generated by getDataPrepGrid as well as their names. The generated list can be used to parameterize tests with the given named combinations.

Returns:

list of `list`s of all possible combinations of preparation

Return type:

list

getSmallDF()

Get a small data frame for testing purposes.

Returns:

a pandas.DataFrame containing the dataset

Return type:

pd.DataFrame

id()

longMessage = True

maxDiff = 640

run(result=None)

setUp()

Create the test Dataframe.

classmethod setUpClass()

Hook method for setting up class fixture before running tests in the class.

setUpPaths()

Create the directories that are used for testing.

shortDescription()

Returns a one-line description of the test, or None if no description has been provided.

The default implementation of this method returns the first line of the specified test method’s docstring.

skipTest(reason)

Skip this test.

subTest(msg=<object object>, **params)

Return a context manager that will return the enclosed block of code in a subtest identified by the optional message and keyword parameters. A failure in the subtest marks the test case as failed but resumes execution at the end of the enclosed block, allowing further test code to be executed.

tearDown()

Remove all files and directories that are used for testing.

classmethod tearDownClass()

Hook method for deconstructing the class fixture after running all tests in the class.

testConsistency()

Test if the descriptor calculator is consistent with the dataset.

testDrugExPhyschem()

Test the DrugExPhyschem descriptor calculator.

testFingerprintSet()

Test the fingerprint set descriptor calculator.

testPredictorDescriptor()

Test the PredictorDesc descriptor set.

testRDKitDescs()

Test the rdkit descriptors calculator.

testSmilesDesc()

Test the smiles descriptors calculator.

testTanimotoDistances()

Test the Tanimoto distances descriptor calculator, which calculates the Tanimoto distances between a list of SMILES.

validate_split(dataset)

Check if the split has the data it should have after splitting.

class qsprpred.data.descriptors.tests.TestDescriptorsAll(methodName='runTest')

Bases: DataSetsPathMixIn, DescriptorInDataCheckMixIn, QSPRTestCase

Test all descriptor sets in all data sets.

Create an instance of the class that will use the named test method when executed. Raises a ValueError if the instance does not have a method with the specified name.

classmethod addClassCleanup(function, /, *args, **kwargs)

Same as addCleanup, except the cleanup items are called even if setUpClass fails (unlike tearDownClass).

addCleanup(function, /, *args, **kwargs)

Add a function, with arguments, to be called when the test is completed. Functions added are called on a LIFO basis and are called after tearDown on test failure or success.

Cleanup items are called even if setUp fails (unlike tearDown).

addTypeEqualityFunc(typeobj, function)

Add a type specific assertEqual style function to compare a type.

This method is for use by TestCase subclasses that need to register their own type equality functions to provide nicer error messages.

Parameters:

• typeobj – The data type to call this function on when both values are of the same type in assertEqual().

• function – The callable taking two arguments and an optional msg= argument that raises self.failureException with a useful error message when the two arguments are not equal.

assertAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are unequal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the difference between the two objects is more than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

If the two objects compare equal then they will automatically compare almost equal.

assertCountEqual(first, second, msg=None)

Asserts that two iterables have the same elements, the same number of times, without regard to order.

self.assertEqual(Counter(list(first)),

Counter(list(second)))

Example:

• [0, 1, 1] and [1, 0, 1] compare equal.

• [0, 0, 1] and [0, 1] compare unequal.

assertDictEqual(d1, d2, msg=None)

assertEqual(first, second, msg=None)

Fail if the two objects are unequal as determined by the ‘==’ operator.

assertFalse(expr, msg=None)

Check that the expression is false.

assertGreater(a, b, msg=None)

Just like self.assertTrue(a > b), but with a nicer default message.

assertGreaterEqual(a, b, msg=None)

Just like self.assertTrue(a >= b), but with a nicer default message.

assertIn(member, container, msg=None)

Just like self.assertTrue(a in b), but with a nicer default message.

assertIs(expr1, expr2, msg=None)

Just like self.assertTrue(a is b), but with a nicer default message.

assertIsInstance(obj, cls, msg=None)

Same as self.assertTrue(isinstance(obj, cls)), with a nicer default message.

assertIsNone(obj, msg=None)

Same as self.assertTrue(obj is None), with a nicer default message.

assertIsNot(expr1, expr2, msg=None)

Just like self.assertTrue(a is not b), but with a nicer default message.

assertIsNotNone(obj, msg=None)

Included for symmetry with assertIsNone.

assertLess(a, b, msg=None)

Just like self.assertTrue(a < b), but with a nicer default message.

assertLessEqual(a, b, msg=None)

Just like self.assertTrue(a <= b), but with a nicer default message.

assertListEqual(list1, list2, msg=None)

A list-specific equality assertion.

Parameters:

• list1 – The first list to compare.

• list2 – The second list to compare.

• msg – Optional message to use on failure instead of a list of differences.

assertLogs(logger=None, level=None)

Fail unless a log message of level level or higher is emitted on logger_name or its children. If omitted, level defaults to INFO and logger defaults to the root logger.

This method must be used as a context manager, and will yield a recording object with two attributes: output and records. At the end of the context manager, the output attribute will be a list of the matching formatted log messages and the records attribute will be a list of the corresponding LogRecord objects.

Example:

with self.assertLogs('foo', level='INFO') as cm:
    logging.getLogger('foo').info('first message')
    logging.getLogger('foo.bar').error('second message')
self.assertEqual(cm.output, ['INFO:foo:first message',
                             'ERROR:foo.bar:second message'])

assertMultiLineEqual(first, second, msg=None)

Assert that two multi-line strings are equal.

assertNoLogs(logger=None, level=None)

Fail unless no log messages of level level or higher are emitted on logger_name or its children.

This method must be used as a context manager.

assertNotAlmostEqual(first, second, places=None, msg=None, delta=None)

Fail if the two objects are equal as determined by their difference rounded to the given number of decimal places (default 7) and comparing to zero, or by comparing that the difference between the two objects is less than the given delta.

Note that decimal places (from zero) are usually not the same as significant digits (measured from the most significant digit).

Objects that are equal automatically fail.

assertNotEqual(first, second, msg=None)

Fail if the two objects are equal as determined by the ‘!=’ operator.

assertNotIn(member, container, msg=None)

Just like self.assertTrue(a not in b), but with a nicer default message.

assertNotIsInstance(obj, cls, msg=None)

Included for symmetry with assertIsInstance.

assertNotRegex(text, unexpected_regex, msg=None)

Fail the test if the text matches the regular expression.

assertRaises(expected_exception, *args, **kwargs)

Fail unless an exception of class expected_exception is raised by the callable when invoked with specified positional and keyword arguments. If a different type of exception is raised, it will not be caught, and the test case will be deemed to have suffered an error, exactly as for an unexpected exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertRaises(SomeException):
    do_something()

An optional keyword argument ‘msg’ can be provided when assertRaises is used as a context object.

The context manager keeps a reference to the exception as the ‘exception’ attribute. This allows you to inspect the exception after the assertion:

with self.assertRaises(SomeException) as cm:
    do_something()
the_exception = cm.exception
self.assertEqual(the_exception.error_code, 3)

assertRaisesRegex(expected_exception, expected_regex, *args, **kwargs)

Asserts that the message in a raised exception matches a regex.

Parameters:

• expected_exception – Exception class expected to be raised.

• expected_regex – Regex (re.Pattern object or string) expected to be found in error message.

• args – Function to be called and extra positional args.

• kwargs – Extra kwargs.

• msg – Optional message used in case of failure. Can only be used when assertRaisesRegex is used as a context manager.

assertRegex(text, expected_regex, msg=None)

Fail the test unless the text matches the regular expression.

assertSequenceEqual(seq1, seq2, msg=None, seq_type=None)

An equality assertion for ordered sequences (like lists and tuples).

For the purposes of this function, a valid ordered sequence type is one which can be indexed, has a length, and has an equality operator.

Parameters:

• seq1 – The first sequence to compare.

• seq2 – The second sequence to compare.

• seq_type – The expected datatype of the sequences, or None if no datatype should be enforced.

• msg – Optional message to use on failure instead of a list of differences.

assertSetEqual(set1, set2, msg=None)

A set-specific equality assertion.

Parameters:

• set1 – The first set to compare.

• set2 – The second set to compare.

• msg – Optional message to use on failure instead of a list of differences.

assertSetEqual uses ducktyping to support different types of sets, and is optimized for sets specifically (parameters must support a difference method).

assertTrue(expr, msg=None)

Check that the expression is true.

assertTupleEqual(tuple1, tuple2, msg=None)

A tuple-specific equality assertion.

Parameters:

• tuple1 – The first tuple to compare.

• tuple2 – The second tuple to compare.

• msg – Optional message to use on failure instead of a list of differences.

assertWarns(expected_warning, *args, **kwargs)

Fail unless a warning of class warnClass is triggered by the callable when invoked with specified positional and keyword arguments. If a different type of warning is triggered, it will not be handled: depending on the other warning filtering rules in effect, it might be silenced, printed out, or raised as an exception.

If called with the callable and arguments omitted, will return a context object used like this:

with self.assertWarns(SomeWarning):
    do_something()

An optional keyword argument ‘msg’ can be provided when assertWarns is used as a context object.

The context manager keeps a reference to the first matching warning as the ‘warning’ attribute; similarly, the ‘filename’ and ‘lineno’ attributes give you information about the line of Python code from which the warning was triggered. This allows you to inspect the warning after the assertion:

with self.assertWarns(SomeWarning) as cm:
    do_something()
the_warning = cm.warning
self.assertEqual(the_warning.some_attribute, 147)

assertWarnsRegex(expected_warning, expected_regex, *args, **kwargs)

Asserts that the message in a triggered warning matches a regexp. Basic functioning is similar to assertWarns() with the addition that only warnings whose messages also match the regular expression are considered successful matches.

Parameters:

• expected_warning – Warning class expected to be triggered.

• expected_regex – Regex (re.Pattern object or string) expected to be found in error message.

• args – Function to be called and extra positional args.

• kwargs – Extra kwargs.

• msg – Optional message used in case of failure. Can only be used when assertWarnsRegex is used as a context manager.

checkDataSetContainsDescriptorSet(dataset, desc_set, prep_combo, target_props)

Check if a descriptor set is in a data set.

checkDescriptors(dataset: QSPRDataset, target_props: list[dict | qsprpred.tasks.TargetProperty])

Check if information about descriptors is consistent in the data set. Checks if calculators are consistent with the descriptors contained in the data set. This is tested also before and after serialization.

Parameters:

• dataset (QSPRDataset) – The data set to check.

• target_props (List of dicts or TargetProperty) – list of target properties

Raises:

AssertionError – If the consistency check fails.

checkFeatures(ds: QSPRDataset, expected_length: int)

Check if the feature names and the feature matrix of a data set is consistent with expected number of variables.

Parameters:

• ds (QSPRDataset) – The data set to check.

• expected_length (int) – The expected number of features.

Raises:

AssertionError – If the feature names or the feature matrix is not consistent

clearGenerated()

Remove the directories that are used for testing.

countTestCases()

createLargeMultitaskDataSet(name='QSPRDataset_multi_test', target_props=[{'name': 'HBD', 'task': <TargetTasks.MULTICLASS: 'MULTICLASS'>, 'th': [-1, 1, 2, 100]}, {'name': 'CL', 'task': <TargetTasks.REGRESSION: 'REGRESSION'>}], preparation_settings=None, random_state=42)

Create a large dataset for testing purposes.

Parameters:

• name (str) – name of the dataset

• target_props (List of dicts or TargetProperty) – list of target properties

• preparation_settings (dict) – dictionary containing preparation settings

• random_state (int) – random state to use for splitting and shuffling

Returns:

a QSPRDataset object

Return type:

QSPRDataset

createLargeTestDataSet(name='QSPRDataset_test_large', target_props=[{'name': 'CL', 'task': <TargetTasks.REGRESSION: 'REGRESSION'>}], preparation_settings=None, random_state=42, n_jobs=1, chunk_size=None)

Create a large dataset for testing purposes.

Parameters:

• name (str) – name of the dataset

• target_props (List of dicts or TargetProperty) – list of target properties

• random_state (int) – random state to use for splitting and shuffling

• preparation_settings (dict) – dictionary containing preparation settings

Returns:

a QSPRDataset object

Return type:

QSPRDataset

createSmallTestDataSet(name='QSPRDataset_test_small', target_props=[{'name': 'CL', 'task': <TargetTasks.REGRESSION: 'REGRESSION'>}], preparation_settings=None, random_state=42)

Create a small dataset for testing purposes.

Parameters:

• name (str) – name of the dataset

• target_props (List of dicts or TargetProperty) – list of target properties

• random_state (int) – random state to use for splitting and shuffling

• preparation_settings (dict) – dictionary containing preparation settings

Returns:

a QSPRDataset object

Return type:

QSPRDataset

createTestDataSetFromFrame(df, name='QSPRDataset_test', target_props=[{'name': 'CL', 'task': <TargetTasks.REGRESSION: 'REGRESSION'>}], random_state=None, prep=None, n_jobs=1, chunk_size=None)

Create a dataset for testing purposes from the given data frame.

Parameters:

• df (pd.DataFrame) – data frame containing the dataset

• name (str) – name of the dataset

• target_props (List of dicts or TargetProperty) – list of target properties

• random_state (int) – random state to use for splitting and shuffling

• prep (dict) – dictionary containing preparation settings

Returns:

a QSPRDataset object

Return type:

QSPRDataset

debug()

Run the test without collecting errors in a TestResult

defaultTestResult()

classmethod doClassCleanups()

Execute all class cleanup functions. Normally called for you after tearDownClass.

doCleanups()

Execute all cleanup functions. Normally called for you after tearDown.

classmethod enterClassContext(cm)

Same as enterContext, but class-wide.

enterContext(cm)

Enters the supplied context manager.

If successful, also adds its __exit__ method as a cleanup function and returns the result of the __enter__ method.

fail(msg=None)

Fail immediately, with the given message.

failureException

alias of AssertionError

classmethod getAllDescriptors()

Return a list of (ideally) all available descriptor sets. For now they need to be added manually to the list below.

TODO: would be nice to create the list automatically by implementing a descriptor set registry that would hold all installed descriptor sets.

Returns:

list of DescriptorCalculator objects

Return type:

list

getBigDF()

Get a large data frame for testing purposes.

Returns:

a pandas.DataFrame containing the dataset

Return type:

pd.DataFrame

static getDatSetName(desc_set, target_props)

Get a unique name for a data set.

classmethod getDataPrepGrid()

Return a list of many possible combinations of descriptor calculators, splits, feature standardizers, feature filters and data filters. Again, this is not exhaustive, but should cover a lot of cases.

Returns:

a generator that yields tuples of all possible combinations as stated above, each tuple is defined as: (descriptor_calculator, split, feature_standardizer, feature_filters, data_filters)

Return type:

grid

classmethod getDefaultCalculatorCombo()

Makes a list of default descriptor calculators that can be used in tests. It creates a calculator with only morgan fingerprints and rdkit descriptors, but also one with them both to test behaviour with multiple descriptor sets. Override this method if you want to test with other descriptor sets and calculator combinations.

Returns:

list of created DescriptorCalculator objects

Return type:

list

static getDefaultPrep()

Return a dictionary with default preparation settings.

classmethod getPrepCombos()

Return a list of all possible preparation combinations as generated by getDataPrepGrid as well as their names. The generated list can be used to parameterize tests with the given named combinations.

Returns:

list of `list`s of all possible combinations of preparation

Return type:

list

getSmallDF()

Get a small data frame for testing purposes.

Returns:

a pandas.DataFrame containing the dataset

Return type:

pd.DataFrame

id()

longMessage = True

maxDiff = 640

run(result=None)

setUp()

Hook method for setting up the test fixture before exercising it.

classmethod setUpClass()

Hook method for setting up class fixture before running tests in the class.

setUpPaths()

Create the directories that are used for testing.

shortDescription()

Returns a one-line description of the test, or None if no description has been provided.

The default implementation of this method returns the first line of the specified test method’s docstring.

skipTest(reason)

Skip this test.

subTest(msg=<object object>, **params)

Return a context manager that will return the enclosed block of code in a subtest identified by the optional message and keyword parameters. A failure in the subtest marks the test case as failed but resumes execution at the end of the enclosed block, allowing further test code to be executed.

tearDown()

Remove all files and directories that are used for testing.

classmethod tearDownClass()

Hook method for deconstructing the class fixture after running all tests in the class.

testDescriptorsAll = None

testDescriptorsAll_00_RDkit_REGRESSION(**kw)

Tests all available descriptor sets [with _=’RDkit_REGRESSION’, desc_set=<qsprpred.data.descriptors.sets….tDescs object at 0x7efffe1cba10>, target_props=[{‘name’: ‘CL’, ‘task’: <TargetTasks.REGRESSION: ‘REGRESSION’>}]].

Note that they are not checked with all possible settings and all possible preparations, but only with the default settings provided by DataSetsPathMixIn.getDefaultPrep(). The list itself is defined and configured by DataSetsPathMixIn.getAllDescriptors(), so if you need a specific descriptor tested, add it there.

testDescriptorsAll_01_DrugExPhyschem_REGRESSION(**kw)

Tests all available descriptor sets [with _=’DrugExPhyschem_REGRESSION’, desc_set=<qsprpred.data.descriptors.sets….yschem object at 0x7efffe1cbad0>, target_props=[{‘name’: ‘CL’, ‘task’: <TargetTasks.REGRESSION: ‘REGRESSION’>}]].

Note that they are not checked with all possible settings and all possible preparations, but only with the default settings provided by DataSetsPathMixIn.getDefaultPrep(). The list itself is defined and configured by DataSetsPathMixIn.getAllDescriptors(), so if you need a specific descriptor tested, add it there.

testDescriptorsAll_02_PredictorDesc_REGRESSION(**kw)

Tests all available descriptor sets [with _=’PredictorDesc_REGRESSION’, desc_set=<qsprpred.data.descriptors.sets….orDesc object at 0x7efffe205f70>, target_props=[{‘name’: ‘CL’, ‘task’: <TargetTasks.REGRESSION: ‘REGRESSION’>}]].

Note that they are not checked with all possible settings and all possible preparations, but only with the default settings provided by DataSetsPathMixIn.getDefaultPrep(). The list itself is defined and configured by DataSetsPathMixIn.getAllDescriptors(), so if you need a specific descriptor tested, add it there.

testDescriptorsAll_03_TanimotoDistances_REGRESSION(**kw)

Tests all available descriptor sets [with _=’TanimotoDistances_REGRESSION’, desc_set=<qsprpred.data.descriptors.sets….tances object at 0x7efffe23df10>, target_props=[{‘name’: ‘CL’, ‘task’: <TargetTasks.REGRESSION: ‘REGRESSION’>}]].

Note that they are not checked with all possible settings and all possible preparations, but only with the default settings provided by DataSetsPathMixIn.getDefaultPrep(). The list itself is defined and configured by DataSetsPathMixIn.getAllDescriptors(), so if you need a specific descriptor tested, add it there.

testDescriptorsAll_04_AtomPairFP_REGRESSION(**kw)

Tests all available descriptor sets [with _=’AtomPairFP_REGRESSION’, desc_set=<qsprpred.data.descriptors.finge…PairFP object at 0x7efffe23fb00>, target_props=[{‘name’: ‘CL’, ‘task’: <TargetTasks.REGRESSION: ‘REGRESSION’>}]].

Note that they are not checked with all possible settings and all possible preparations, but only with the default settings provided by DataSetsPathMixIn.getDefaultPrep(). The list itself is defined and configured by DataSetsPathMixIn.getAllDescriptors(), so if you need a specific descriptor tested, add it there.

testDescriptorsAll_05_AvalonFP_REGRESSION(**kw)

Tests all available descriptor sets [with _=’AvalonFP_REGRESSION’, desc_set=<qsprpred.data.descriptors.finge…alonFP object at 0x7efffe23fec0>, target_props=[{‘name’: ‘CL’, ‘task’: <TargetTasks.REGRESSION: ‘REGRESSION’>}]].

Note that they are not checked with all possible settings and all possible preparations, but only with the default settings provided by DataSetsPathMixIn.getDefaultPrep(). The list itself is defined and configured by DataSetsPathMixIn.getAllDescriptors(), so if you need a specific descriptor tested, add it there.

testDescriptorsAll_06_LayeredFP_REGRESSION(**kw)

Tests all available descriptor sets [with _=’LayeredFP_REGRESSION’, desc_set=<qsprpred.data.descriptors.finge…eredFP object at 0x7efffe23faa0>, target_props=[{‘name’: ‘CL’, ‘task’: <TargetTasks.REGRESSION: ‘REGRESSION’>}]].

Note that they are not checked with all possible settings and all possible preparations, but only with the default settings provided by DataSetsPathMixIn.getDefaultPrep(). The list itself is defined and configured by DataSetsPathMixIn.getAllDescriptors(), so if you need a specific descriptor tested, add it there.

testDescriptorsAll_07_MACCSFP_REGRESSION(**kw)

Tests all available descriptor sets [with _=’MACCSFP_REGRESSION’, desc_set=<qsprpred.data.descriptors.finge…accsFP object at 0x7efffe23f440>, target_props=[{‘name’: ‘CL’, ‘task’: <TargetTasks.REGRESSION: ‘REGRESSION’>}]].

Note that they are not checked with all possible settings and all possible preparations, but only with the default settings provided by DataSetsPathMixIn.getDefaultPrep(). The list itself is defined and configured by DataSetsPathMixIn.getAllDescriptors(), so if you need a specific descriptor tested, add it there.

testDescriptorsAll_08_MorganFP_REGRESSION(**kw)

Tests all available descriptor sets [with _=’MorganFP_REGRESSION’, desc_set=<qsprpred.data.descriptors.finge…rganFP object at 0x7f0044bc9370>, target_props=[{‘name’: ‘CL’, ‘task’: <TargetTasks.REGRESSION: ‘REGRESSION’>}]].

Note that they are not checked with all possible settings and all possible preparations, but only with the default settings provided by DataSetsPathMixIn.getDefaultPrep(). The list itself is defined and configured by DataSetsPathMixIn.getAllDescriptors(), so if you need a specific descriptor tested, add it there.

testDescriptorsAll_09_PatternFP_REGRESSION(**kw)

Tests all available descriptor sets [with _=’PatternFP_REGRESSION’, desc_set=<qsprpred.data.descriptors.finge…ternFP object at 0x7efffe289d90>, target_props=[{‘name’: ‘CL’, ‘task’: <TargetTasks.REGRESSION: ‘REGRESSION’>}]].

Note that they are not checked with all possible settings and all possible preparations, but only with the default settings provided by DataSetsPathMixIn.getDefaultPrep(). The list itself is defined and configured by DataSetsPathMixIn.getAllDescriptors(), so if you need a specific descriptor tested, add it there.

testDescriptorsAll_10_RDKitFP_REGRESSION(**kw)

Tests all available descriptor sets [with _=’RDKitFP_REGRESSION’, desc_set=<qsprpred.data.descriptors.finge…DKitFP object at 0x7efffe288dd0>, target_props=[{‘name’: ‘CL’, ‘task’: <TargetTasks.REGRESSION: ‘REGRESSION’>}]].

Note that they are not checked with all possible settings and all possible preparations, but only with the default settings provided by DataSetsPathMixIn.getDefaultPrep(). The list itself is defined and configured by DataSetsPathMixIn.getAllDescriptors(), so if you need a specific descriptor tested, add it there.

testDescriptorsAll_11_RDKitMACCSFP_REGRESSION(**kw)

Tests all available descriptor sets [with _=’RDKitMACCSFP_REGRESSION’, desc_set=<qsprpred.data.descriptors.finge…ACCSFP object at 0x7efffe28b770>, target_props=[{‘name’: ‘CL’, ‘task’: <TargetTasks.REGRESSION: ‘REGRESSION’>}]].

Note that they are not checked with all possible settings and all possible preparations, but only with the default settings provided by DataSetsPathMixIn.getDefaultPrep(). The list itself is defined and configured by DataSetsPathMixIn.getAllDescriptors(), so if you need a specific descriptor tested, add it there.

testDescriptorsAll_12_TopologicalFP_REGRESSION(**kw)

Tests all available descriptor sets [with _=’TopologicalFP_REGRESSION’, desc_set=<qsprpred.data.descriptors.finge…icalFP object at 0x7efffe28a2a0>, target_props=[{‘name’: ‘CL’, ‘task’: <TargetTasks.REGRESSION: ‘REGRESSION’>}]].

Note that they are not checked with all possible settings and all possible preparations, but only with the default settings provided by DataSetsPathMixIn.getDefaultPrep(). The list itself is defined and configured by DataSetsPathMixIn.getAllDescriptors(), so if you need a specific descriptor tested, add it there.

validate_split(dataset)

Check if the split has the data it should have after splitting.

Module contents