drugbud-suite / dockm8 Goto Github PK

Collect the known actives (positive controls) for retrospective analysis. For a given target, these can be found in the scientific literature, patent literature or public databases such as IUPHAR/BPS114, ChEMBL115 or ZINC9,99,116, or available in-house.

While it may be possible to find dozens of actives, it is likely that many come from the same chemical series. For a rigorous control analysis, redundant (i.e., highly similar) compounds should be clustered and the most potent compound selected.While it may be possible to find dozens of actives, it is likely that many come from the same chemical series. For a rigorous control analysis, redundant (i.e., highly similar) compounds should be clustered and the most potent compound selected.While it may be possible to find dozens of actives, it is likely that many come from the same chemical series. For a rigorous control analysis, redundant (i.e., highly similar) compounds should be clustered and the most potent compound selected.

Implement one or several of the available active-learning libraries for docking score prediction

• HASTEN (https://github.com/TuomoKalliokoski/HASTEN)
• DeepDocking (https://github.com/jamesgleave/DD_protocol)
• MolPal (https://github.com/coleygroup/molpal)

Implement as a wrapper around dockM8, first iteration with random compound selection, then run dockM8 workflow.

Scores should be standardized according to the 1st and 99th percentile (or choosable threshold) to ensure consistency across the chemical space of the dataset.

Implement --mode in dockm8.py to handle the active learning mode.

PDBminer github

Allow for input of a PDB ID or a UNIprot ID and DockM8 to search for the ideal structure to use

• Provide test files (.sdf library and .pdb file)
• Setup pytest to automatically run DockM8 and check produced files
• Be mindful of computation time on GitHub Actions (may be costly)

• GenScore: A scoring framework for predicting protein-ligand binding affinity.
• ITScoreAff: iterative knowledge-based scoring function for protein-ligand interactions by considering binding affinity information

• Pharmacophore generation and filtering of library
  • Automatic PH4 generation from crystal structure
    • GRAIL
    • apo2ph4
  • PH4 generation from library of compounds
• Fingerprint similarity to given library of actives
• Shape Based screening (https://cdpkit.org/master/applications/shapescreen.html)

Python already has a logging function

• replace all printlog calls with python logging handling
• Make sure log file is cleared at the start of every dockm8 run

IF-SitePred : github
P2Rank : github

Add the ability to filter the library before running docking predictions.
MW, n_heavy_atoms, n_rotatable_bonds, etc.

https://github.com/RepoDynamics/PyPackIT

https://github.com/dptech-corp/Uni-Dock
https://github.com/schrojunzhang/KarmaDock
https://github.com/molecularmodelinglab/plantain

Generate a single SDF with best hits

• Docked pose
• DockM8 score
• Single scoring functions scores
• Descriptors

Output a pymol session file for visualisation?

• Score / MW
• Strain energy
• Lipophilicity
• Burial ?

I've analyzed the Python scripts within the scripts folder of your repository. Here are some suggestions on how you can refactor these scripts into classes suitable for object-oriented programming (OOP):

Clustering Functions (clustering_functions.py):

Create a class Clusterer with methods for different clustering algorithms like kmedoids_clustering and affinity_propagation_clustering. This class can hold common attributes needed for clustering, such as the input DataFrame and any hyperparameters for the algorithms.
Clustering Metrics (clustering_metrics.py):

Consider a class ClusteringMetrics with static methods for each metric calculation like simpleRMSD_calc, spyRMSD_calc, espsim_calc, etc. This approach groups all related metric functions and makes it clear that these functions are closely related and perform similar roles.
Consensus Methods (consensus_methods.py):

A class ConsensusCalculator can encapsulate methods like ECR_best, ECR_avg, avg_ECR, etc. This class can also manage common resources or shared data needed across these methods, improving data encapsulation and reusability.
Docking Functions:

Since the content wasn't provided, I recommend structuring docking-related functions into a class that might be named DockingProcessor. This class could manage docking operations, including preparing ligands and proteins, performing the docking process, and analyzing the results.
DoGSiteScorer Integration (dogsitescorer.py):

A class DoGSiteScorerAPI could encapsulate all functionalities required to interact with the DoGSiteScorer API, including submitting jobs, uploading PDB files, and fetching results. This class would act as an API client dedicated to DoGSiteScorer.
Pocket Detection (get_pocket.py):

A PocketDetector class can encapsulate functionalities for detecting and processing pockets in protein structures, leveraging the methods already defined in the script.
Library Preparation (library_preparation.py):

Consider a class LibraryPreparer that includes methods for molecule standardization, conformer generation, and any preprocessing steps required before docking simulations. This class centralizes the preprocessing steps into a single, reusable component.
Performance Calculation (performance_calculation.py):

A class PerformanceEvaluator could contain methods for calculating various performance metrics for docking or virtual screening results. This class would provide a structured way to assess the effectiveness of the docking process.
Utilities (utilities.py):

While utilities often remain as a collection of standalone functions, consider grouping related utilities into classes if they share common data or are used together frequently.

CDPKit single conformer
CDPKit conformer ensembles
Other methods : [https://drugbud-suite.github.io/CADD_Vault/Cheminformatics/Conformer%20Generation/]

Use a database to store molecules and results. Each docking and scoring operation can be done on single molecules instead of split SDF files.

Need to be careful of I/O time becoming the bottleneck instead of CPU.
Each molecule can be written as a temp file for input into docking and restoring.

Alternatively, write every molecule/pose to a single SDF file.