def test_roundtrip2(self):
"""Ensure DB is the same after saving and loading."""
from e3fp.fingerprint.fprint import Fingerprint
from e3fp.fingerprint.db import FingerprintDatabase
fprints = []
for i in range(10):
fprints.append(
Fingerprint.from_indices(
np.random.uniform(0, 2 ** 32, size=30),
bits=2 ** 32,
level=5,
)
)
fprints[-1].name = "fp" + str(i)
fprints[-1].set_prop("index", float(i))
db = FingerprintDatabase(fp_type=Fingerprint, level=5)
db.add_fingerprints(fprints)
desc, db_file = tempfile.mkstemp(suffix=".fps.bz2")
os.close(desc)
db.save(db_file)
db2 = db.load(db_file)
os.unlink(db_file)
self.assertEqual(db, db2)
self.assertListEqual(db2.get_prop("index").tolist(), list(range(10)))
def run(sdf_files,
bits=BITS,
first=FIRST_DEF,
level=LEVEL_DEF,
radius_multiplier=RADIUS_MULTIPLIER_DEF,
counts=COUNTS_DEF,
stereo=STEREO_DEF,
include_disconnected=INCLUDE_DISCONNECTED_DEF,
rdkit_invariants=RDKIT_INVARIANTS_DEF,
exclude_floating=EXCLUDE_FLOATING_DEF,
params=None,
out_dir_base=None,
out_ext=OUT_EXT_DEF,
db_file=None,
overwrite=False,
all_iters=False,
log=None,
num_proc=None,
parallel_mode=None,
verbose=False):
"""Generate E3FP fingerprints from SDF files."""
setup_logging(log, verbose=verbose)
if params is not None:
params = read_params(params, fill_defaults=True)
bits = get_value(params, "fingerprinting", "bits", int)
first = get_value(params, "fingerprinting", "first", int)
level = get_value(params, "fingerprinting", "level", int)
radius_multiplier = get_value(params, "fingerprinting",
"radius_multiplier", float)
counts = get_value(params, "fingerprinting", "counts", bool)
stereo = get_value(params, "fingerprinting", "stereo", bool)
include_disconnected = get_value(params, "fingerprinting",
"include_disconnected", bool)
rdkit_invariants = get_value(params, "fingerprinting",
"rdkit_invariants", bool)
exclude_floating = get_value(params, "fingerprinting",
"exclude_floating", bool)
para = Parallelizer(num_proc=num_proc, parallel_mode=parallel_mode)
if para.rank == 0:
logging.info("Initializing E3FP generation.")
logging.info("Getting SDF files")
if len(sdf_files) == 1 and os.path.isdir(sdf_files[0]):
from glob import glob
sdf_files = glob("{:s}/*sdf*".format(sdf_files[0]))
data_iterator = make_data_iterator(sdf_files)
logging.info("SDF File Number: {:d}".format(len(sdf_files)))
if out_dir_base is not None:
logging.info("Out Directory Basename: {:s}".format(out_dir_base))
logging.info("Out Extension: {:s}".format(out_ext))
if db_file is not None:
logging.info("Database File: {:s}".format(db_file))
if db_file is None and out_dir_base is None:
sys.exit('Either `db_file` or `out_dir_base` must be specified.')
logging.info("Max First Conformers: {:d}".format(first))
logging.info("Bits: {:d}".format(bits))
logging.info("Level/Max Iterations: {:d}".format(level))
logging.info(
"Shell Radius Multiplier: {:.4g}".format(radius_multiplier))
logging.info("Stereo Mode: {!s}".format(stereo))
if include_disconnected:
logging.info("Connected-only mode: on")
if rdkit_invariants:
logging.info("Invariant type: RDKit")
else:
logging.info("Invariant type: Daylight")
logging.info("Parallel Mode: {!s}".format(para.parallel_mode))
logging.info("Starting")
else:
data_iterator = iter([])
fp_kwargs = {
"first": first,
"bits": bits,
"level": level,
"radius_multiplier": radius_multiplier,
"stereo": stereo,
"counts": counts,
"include_disconnected": include_disconnected,
"rdkit_invariants": rdkit_invariants,
"exclude_floating": exclude_floating,
"out_dir_base": out_dir_base,
"out_ext": out_ext,
"all_iters": all_iters,
"overwrite": overwrite,
"save": False
}
if out_dir_base is not None:
fp_kwargs['save'] = True
run_kwargs = {"kwargs": fp_kwargs}
results_iter = para.run_gen(fprints_dict_from_sdf, data_iterator,
**run_kwargs)
if db_file is not None:
fprints = []
for result, data in results_iter:
try:
fprints.extend(result.get(level, result[max(result.keys())]))
except (AttributeError, ValueError):
# fprinting failed, assume logged in method
continue
if len(fprints) > 0:
db = FingerprintDatabase(fp_type=type(fprints[0]), level=level)
db.add_fingerprints(fprints)
db.save(db_file)
logging.info("Saved fingerprints to {:s}".format(db_file))
else:
list(results_iter)