varidock 0.1.0__tar.gz

varidock-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Abdolla Hegazy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

varidock-0.1.0/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: varidock
+Version: 0.1.0
+Summary: Docker Automation
+Author-email: Abdolla Hegazy <hegazyab@msu.edu>
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Dynamic: license-file
+
+# pypi-template 
+
+[![Custom shields.io](https://img.shields.io/badge/docs-brightgreen?logo=github&logoColor=green&label=gh-pages)](https://lonelyneutrin0.github.io/pypi-template/)
+[![PyPI version shields.io](https://img.shields.io/pypi/v/neurop.svg)](https://pypi.python.org/pypi/pypi-template/)
+[![PyPI pyversions shields.io](https://img.shields.io/pypi/pyversions/neurop.svg)](https://pypi.python.org/pypi/pypi-template/)
+
+## About pypi-template
+
+## Usage
+`pypi-template` is published on [PyPi](https://pypi.python.org/pypi/pypi-template/) and can be installed using `pip` - 
+```
+pip install pypi-template
+```
+
+## License
+`pypi-template` is available under the MIT License.
+
+## Attribution
+
+## Contributing

varidock-0.1.0/README.md

@@ -0,0 +1,20 @@
+# pypi-template 
+
+[![Custom shields.io](https://img.shields.io/badge/docs-brightgreen?logo=github&logoColor=green&label=gh-pages)](https://lonelyneutrin0.github.io/pypi-template/)
+[![PyPI version shields.io](https://img.shields.io/pypi/v/neurop.svg)](https://pypi.python.org/pypi/pypi-template/)
+[![PyPI pyversions shields.io](https://img.shields.io/pypi/pyversions/neurop.svg)](https://pypi.python.org/pypi/pypi-template/)
+
+## About pypi-template
+
+## Usage
+`pypi-template` is published on [PyPi](https://pypi.python.org/pypi/pypi-template/) and can be installed using `pip` - 
+```
+pip install pypi-template
+```
+
+## License
+`pypi-template` is available under the MIT License.
+
+## Attribution
+
+## Contributing

varidock-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "varidock"
+version = "0.1.0"
+description = "Docker Automation"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+
+authors = [{ name = "Abdolla Hegazy", email = "hegazyab@msu.edu" }]
+
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+  "pytest>=8",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["varidock"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[project.scripts]
+varidock = "varidock.cli:cli"

varidock-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

varidock-0.1.0/setup.py

@@ -0,0 +1,5 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="varidock"
+)

varidock-0.1.0/varidock/broker/adfr/__init__.py

@@ -0,0 +1,3 @@
+from .prepare_receptor import prepare_receptor
+
+__all__ = ["prepare_receptor"]

varidock-0.1.0/varidock/broker/adfr/prepare_receptor.py

@@ -0,0 +1,118 @@
+import os
+
+from MolKit import Read
+from AutoDockTools.MoleculePreparation import AD4ReceptorPreparation
+
+
+def prepare_receptor(
+    receptor_filename: str,
+    verbose: bool = False,
+    outputfilename: str | None = None,
+    repairs: str = "",
+    charges_to_add: str | None = "gasteiger",
+    preserve_charge_types: str | None = None,
+    cleanup: str = "nphs_lps_waters_nonstdres",
+    mode: str = "automatic",
+    delete_single_nonstd_residues: bool = False,
+    dictionary: str | None = None,
+    unique_atom_names: bool = False,
+):
+    """Prepare a receptor PDB/MOL2 file for AutoDock4 docking (produces PDBQT)."""
+    if not receptor_filename:
+        raise ValueError("receptor filename must be specified.")
+
+    mols = Read(receptor_filename)
+    if verbose:
+        print("read ", receptor_filename)
+    mol = mols[0]
+
+    if unique_atom_names:
+        for at in mol.allAtoms:
+            if mol.allAtoms.get(at.name) > 1:
+                at.name = at.name + str(at._uniqIndex + 1)
+        if verbose:
+            print(
+                "renamed %d atoms: each newname is the original name of the atom plus its (1-based) uniqIndex"
+                % len(mol.allAtoms)
+            )
+
+    preserved = {}
+    has_autodock_element = False
+    if charges_to_add and preserve_charge_types:
+        if hasattr(mol, "allAtoms") and not hasattr(
+            mol.allAtoms[0], "autodock_element"
+        ):
+            file_name, file_ext = os.path.splitext(receptor_filename)
+            if file_ext == ".pdbqt":
+                has_autodock_element = True
+        if preserve_charge_types and not has_autodock_element:
+            raise RuntimeError(
+                "input format does not have autodock_element SO unable to preserve charges on "
+                + preserve_charge_types
+            )
+        preserved_types = preserve_charge_types.split(",")
+        if verbose:
+            print("preserved_types=", preserved_types)
+        for t in preserved_types:
+            if verbose:
+                print("preserving charges on type->", t)
+            if not len(t):
+                continue
+            ats = mol.allAtoms.get(lambda x: x.autodock_element == t)
+            if verbose:
+                print("preserving charges on ", ats.name)
+            for a in ats:
+                if a.chargeSet is not None:
+                    preserved[a] = [a.chargeSet, a.charge]
+
+    if len(mols) > 1:
+        if verbose:
+            print("more than one molecule in file")
+        ctr = 1
+        for m in mols[1:]:
+            ctr += 1
+            if len(m.allAtoms) > len(mol.allAtoms):
+                mol = m
+                if verbose:
+                    print(
+                        "mol set to ",
+                        ctr,
+                        "th molecule with",
+                        len(mol.allAtoms),
+                        "atoms",
+                    )
+
+    mol.buildBondsByDistance()
+    alt_loc_ats = mol.allAtoms.get(lambda x: "@" in x.name)
+    len_alt_loc_ats = len(alt_loc_ats)
+    if len_alt_loc_ats:
+        print(
+            "WARNING!",
+            mol.name,
+            "has",
+            len_alt_loc_ats,
+            " alternate location atoms!\nUse prepare_pdb_split_alt_confs.py to create pdb files containing a single conformation.\n",
+        )
+
+    if verbose:
+        print("setting up RPO with mode=", mode, end=" ")
+        print("and outputfilename= ", outputfilename)
+        print("charges_to_add=", charges_to_add)
+        print("delete_single_nonstd_residues=", delete_single_nonstd_residues)
+
+    RPO = AD4ReceptorPreparation(  # noqa: F841
+        mol,
+        mode,
+        repairs,
+        charges_to_add,
+        cleanup,
+        outputfilename=outputfilename,
+        preserved=preserved,
+        delete_single_nonstd_residues=delete_single_nonstd_residues,
+        dict=dictionary,
+    )
+
+    if charges_to_add:
+        for atom, chargeList in list(preserved.items()):
+            atom._charges[chargeList[0]] = chargeList[1]
+            atom.chargeSet = chargeList[0]

varidock-0.1.0/varidock/broker/deepsurf/__init__.py

@@ -0,0 +1,3 @@
+from .predict import predict
+
+__all__ = ["predict"]

varidock-0.1.0/varidock/broker/deepsurf/bsite_extraction.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python2
+# -*- coding: utf-8 -*-
+"""
+Created on Thu Jan 30 16:00:46 2020
+
+@author: smylonas
+"""
+
+import numpy as np
+from sklearn.cluster import MeanShift
+
+
+class Bsite_extractor():
+    def __init__(self,lig_thres,bw=15):
+        self.T = lig_thres
+        self.ms = MeanShift(bandwidth=bw,bin_seeding=True,cluster_all=False,n_jobs=4)
+    
+    def _cluster_points(self,prot,lig_scores):
+        T_new = self.T
+        while sum(lig_scores>=T_new) < 10 and T_new>0.3001:    # at least 10 points with prob>P  and P>=0.3
+            T_new -= 0.1 
+
+        filtered_points = prot.surf_points[lig_scores>T_new]
+        filtered_scores = lig_scores[lig_scores>T_new]
+        if len(filtered_points)<5:
+            return () 
+
+        clustering = self.ms.fit(filtered_points)
+        labels = clustering.labels_
+        
+        unique_l,freq = np.unique(labels,return_counts=True)
+    
+        if len(unique_l[freq>=5])!=0:
+            unique_l = unique_l[freq>=5]    # keep clusters with 5 points and more
+        else:
+            return ()
+        
+        if unique_l[0]==-1:                 # discard the "unclustered" cluster
+            unique_l = unique_l[1:]    
+        
+        clusters = [(filtered_points[labels==l],filtered_scores[labels==l]) for l in unique_l]  # noqa: E741
+        
+        return clusters
+        
+    def extract_bsites(self,prot,lig_scores):
+        clusters = self._cluster_points(prot,lig_scores)
+        if len(clusters)==0:
+            print('No binding site found')
+            return
+        for cluster in clusters:
+            prot.add_bsite(cluster)
+        prot.sort_bsites()
+        prot.write_bsites()
+        
+        

varidock-0.1.0/varidock/broker/deepsurf/features.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python2
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Oct 21 11:46:54 2019
+
+@author: smylonas
+"""
+
+
+from .tfbio_data import Featurizer,make_grid
+from .utils import rotation
+import numpy as np
+     
+
+class KalasantyFeaturizer:
+    def __init__(self,gridSize,voxelSize):
+        grid_limit = (gridSize/2-0.5)*voxelSize
+        grid_radius = grid_limit*np.sqrt(3)             
+        self.neigh_radius = 4 + grid_radius   # 4 > 2*R_vdw
+        self.featurizer = Featurizer(save_molecule_codes=False)
+        self.grid_resolution = voxelSize
+        self.max_dist = (gridSize-1)*voxelSize/2 
+    
+    def get_channels(self,mol):
+        _, self.channels = self.featurizer.get_features(mol)  # returns only heavy atoms
+    
+    def grid_feats(self,point,normal,mol_coords):
+        neigh_atoms = np.sqrt(np.sum((mol_coords-point)**2,axis=1))<self.neigh_radius
+        Q = rotation(normal)
+        Q_inv = np.linalg.inv(Q)
+        transf_coords = np.transpose(mol_coords[neigh_atoms]-point)
+        rotated_mol_coords = np.matmul(Q_inv,transf_coords)
+        features = make_grid(np.transpose(rotated_mol_coords),self.channels[neigh_atoms],self.grid_resolution,self.max_dist)[0]
+        
+        return features
+        
+        

varidock-0.1.0/varidock/broker/deepsurf/net/resnet_3d.py

@@ -0,0 +1,180 @@
+"""
+Created on Thu Nov  1 12:04:04 2018
+
+@author: smylonas
+"""
+
+import tensorflow as tf
+from tf_slim import layers
+from tf_slim import add_arg_scope,arg_scope
+from tf_slim.layers import utils
+from tensorflow.python.ops import math_ops
+from tensorflow.python.ops import nn_ops
+from tensorflow.python.ops import variable_scope
+from . import resnet_3d_utils
+
+resnet_arg_scope = resnet_3d_utils.resnet_arg_scope
+
+
+@add_arg_scope
+def resid_unit(inputs,
+               depth,
+               depth_bottleneck,
+               stride,
+               rate=1,
+               outputs_collections=None,
+               scope=None):
+  """Residual unit with BN after convolutions.
+  This is the original residual unit proposed in [1]. See Fig. 1(a) of [2] for
+  its definition. 
+  When putting together two consecutive ResNet blocks that use this unit, one
+  should use stride = 2 in the last unit of the first block.
+  Args:
+    inputs: A tensor of size [batch, height, width, channels].
+    depth: The depth of the ResNet unit output.
+    depth_bottleneck: The depth of the bottleneck layers.
+    stride: The ResNet unit's stride. Determines the amount of downsampling of
+      the units output compared to its input.
+    rate: An integer, rate for atrous convolution.
+    outputs_collections: Collection to add the ResNet unit output.
+    scope: Optional variable_scope.
+  Returns:
+    The ResNet unit's output.
+  """
+  with variable_scope.variable_scope(scope, 'resid_v1', [inputs]) as sc:
+   # print (inputs.shape)
+    depth_in = utils.last_dimension(inputs.get_shape(), min_rank=5)
+    if depth == depth_in:
+      shortcut = resnet_3d_utils.subsample(inputs, stride, 'shortcut')
+    else:
+      shortcut = layers.conv3d(
+          inputs,
+          depth, [1, 1, 1],
+          stride=stride,
+          activation_fn=None,
+          scope='shortcut')
+
+    residual = resnet_3d_utils.conv3d_same(inputs, depth_bottleneck, 3, stride=1, scope='conv1')   
+    residual = layers.conv3d(residual, depth_bottleneck, 3, stride, scope='conv2')
+
+    output = nn_ops.relu(shortcut + residual)
+
+    return utils.collect_named_outputs(outputs_collections, sc.name, output)
+
+
+def resnet_v1(inputs,
+              blocks,
+              num_classes=None,
+              is_training=True,
+              global_pool=True,
+              output_stride=None,
+              include_root_block=True,
+              reuse=None,
+              scope=None):
+  """Generator for v1 ResNet models.
+  Args:
+    inputs: A tensor of size [batch, height_in, width_in, channels].
+    blocks: A list of length equal to the number of ResNet blocks. Each element
+      is a resnet_utils.Block object describing the units in the block.
+    num_classes: Number of predicted classes for classification tasks. If None
+      we return the features before the logit layer.
+    is_training: whether batch_norm layers are in training mode.
+    global_pool: If True, we perform global average pooling before computing the
+      logits. Set to True for image classification, False for dense prediction.
+    output_stride: If None, then the output will be computed at the nominal
+      network stride. If output_stride is not None, it specifies the requested
+      ratio of input to output spatial resolution.
+    include_root_block: If True, include the initial convolution followed by
+      max-pooling, if False excludes it.
+    reuse: whether or not the network and its variables should be reused. To be
+      able to reuse 'scope' must be given.
+    scope: Optional variable_scope.
+  Returns:
+    net: A rank-4 tensor of size [batch, height_out, width_out, channels_out].
+      If global_pool is False, then height_out and width_out are reduced by a
+      factor of output_stride compared to the respective height_in and width_in,
+      else both height_out and width_out equal one. If num_classes is None, then
+      net is the output of the last ResNet block, potentially after global
+      average pooling. If num_classes is not None, net contains the pre-softmax
+      activations.
+    end_points: A dictionary from components of the network to the corresponding
+      activation.
+  Raises:
+    ValueError: If the target output_stride is not valid.
+  """
+  with variable_scope.variable_scope(
+      scope, 'resnet_v1', [inputs], reuse=reuse) as sc:
+    end_points_collection = sc.original_name_scope + '_end_points'
+    with arg_scope(
+        [layers.conv3d, resid_unit, resnet_3d_utils.stack_blocks_dense],
+        outputs_collections=end_points_collection):
+      with arg_scope([layers.batch_norm], is_training=is_training):
+        net = inputs
+        net = resnet_3d_utils.stack_blocks_dense(net, blocks, output_stride)
+        if global_pool:
+          net = math_ops.reduce_mean(net, [1, 2, 3], name='pool5', keepdims=True)
+        if num_classes is not None:
+          net = layers.conv3d(
+              net,
+              num_classes, [1, 1, 1],
+              activation_fn=None,
+              normalizer_fn=None,
+              scope='logits')
+          
+        # Convert end_points_collection into a dictionary of end_points.
+        end_points = utils.convert_collection_to_dict(end_points_collection)
+        if num_classes is not None and num_classes != 1:
+          end_points['predictions'] = layers.softmax(net, scope='predictions')
+          net = tf.squeeze(net)
+        elif num_classes == 1:
+          net = tf.squeeze(net)                                                    
+          end_points['probs'] = tf.nn.sigmoid(net)
+       
+        return net, end_points
+
+
+def resnet_v1_block(scope, depth_out, num_units, stride):
+  """Args:
+    scope: The scope of the block.
+    base_depth: The depth of the bottleneck layer for each unit.
+    num_units: The number of units in the block.
+    stride: The stride of the block, implemented as a stride in the last unit.
+      All other units have stride=1.
+  Returns:
+    A resnet_v1 bottleneck block.
+  """
+  return resnet_3d_utils.Block(scope, resid_unit, [{
+      'depth': depth_out,
+      'depth_bottleneck': depth_out,
+      'stride': 1
+  }] * (num_units - 1) + [{
+      'depth': depth_out,
+      'depth_bottleneck': depth_out,
+      'stride': stride
+  }])
+
+
+def resnet_v1_18(inputs,
+                 num_classes,
+                 is_training,
+                 global_pool=True,
+                 output_stride=None,
+                 reuse=None,
+                 scope='resnet3d_v1_18'):
+  blocks = [
+      resnet_v1_block('block1', depth_out=64, num_units=2, stride=2),
+      resnet_v1_block('block2', depth_out=128, num_units=2, stride=2),
+      resnet_v1_block('block3', depth_out=256, num_units=2, stride=2),
+      resnet_v1_block('block4', depth_out=512, num_units=2, stride=1) 
+  ]
+  return resnet_v1(
+      inputs,
+      blocks,
+      num_classes,
+      is_training,
+      global_pool,
+      output_stride,
+      include_root_block=False,
+      reuse=reuse,
+      scope=scope)
+