🚨 fix lint

"""

import logging

import numpy as np

from typing import Any, Optional, Tuple

from typing import Any, List, Optional, Tuple

from deepchem.models import Model

from deepchem.utils import rdkit_util

from deepchem.utils import coordinate_box_utils as box_utils

from deepchem.utils.rdkit_util import load_molecule

from deepchem.utils.coordinate_box_utils \

  import CoordinateBox, get_face_boxes, merge_overlapping_boxes

from deepchem.utils.fragment_util import get_contact_atom_indices

logger = logging.getLogger(__name__)

def extract_active_site(protein_file: str,

                        ligand_file: str,

                        cutoff: float = 4.0

                       ) -> Tuple[box_utils.CoordinateBox, np.ndarray]:

                       ) -> Tuple[CoordinateBox, np.ndarray]:

  """Extracts a box for the active site.

  Parameters

  Returns

  -------

  Tuple[CoordinateBox, np.ndarray]

    A tuple of `(CoordinateBox, np.ndarray)` where the second entry is

    of shape `(N, 3)` with `N` the number of atoms in the active site.

  """

  protein = rdkit_util.load_molecule(protein_file, add_hydrogens=False)

  ligand = rdkit_util.load_molecule(

      ligand_file, add_hydrogens=True, calc_charges=True)

  protein = load_molecule(protein_file, add_hydrogens=False)

  ligand = load_molecule(ligand_file, add_hydrogens=True, calc_charges=True)

  protein_contacts, ligand_contacts = get_contact_atom_indices(

      [protein, ligand], cutoff=cutoff)

  protein_coords = protein[0]

  y_max = int(np.ceil(np.amax(pocket_coords[:, 1])))

  z_min = int(np.floor(np.amin(pocket_coords[:, 2])))

  z_max = int(np.ceil(np.amax(pocket_coords[:, 2])))

  box = box_utils.CoordinateBox((x_min, x_max), (y_min, y_max), (z_min, z_max))

  box = CoordinateBox((x_min, x_max), (y_min, y_max), (z_min, z_max))

  return (box, pocket_coords)

  Based on https://www.ncbi.nlm.nih.gov/pmc/articles/PMC4112621/pdf/1472-6807-14-18.pdf

  """

  def __init__(self, scoring_model: Optional[Model] = None, pad: int = 5):

  def __init__(self, scoring_model: Optional[Model] = None, pad: float = 5.0):

    """Initialize the pocket finder.

    Parameters

    ----------

    scoring_model: `dc.models.Model`, optional

      If specified, use this model to prune pockets.

    pad: int, optional (default 5)

    pad: float, optional (default 5.0)

      The number of angstroms to pad around a binding pocket's atoms

      to get a binding pocket box.

    """

    self.scoring_model = scoring_model

    self.pad = pad

  def find_all_pockets(self, protein_file: str):

  def find_all_pockets(self, protein_file: str) -> List[CoordinateBox]:

    """Find list of binding pockets on protein.

    Parameters

    ----------

    protein_file: str

      Protein to load in.

    Returns

    -------

    List[CoordinateBox]

      List of binding pockets on protein. Each pocket is a `CoordinateBox`

    """

    coords, _ = rdkit_util.load_molecule(protein_file)

    return box_utils.get_face_boxes(coords, self.pad)

    coords, _ = load_molecule(protein_file)

    return get_face_boxes(coords, self.pad)

  def find_pockets(self, macromolecule_file: str):

  def find_pockets(self, macromolecule_file: str) -> List[CoordinateBox]:

    """Find list of suitable binding pockets on protein.

    This function computes putative binding pockets on this protein.

    Returns

    -------

    List[CoordinateBox]

      List of pockets. Each pocket is a `CoordinateBox`

    """

    coords = rdkit_util.load_molecule(

        macromolecule_file, add_hydrogens=False, calc_charges=False)[0]

    boxes = box_utils.get_face_boxes(coords, self.pad)

    boxes = box_utils.merge_overlapping_boxes(boxes)

    coords, _ = load_molecule(

        macromolecule_file, add_hydrogens=False, calc_charges=False)

    boxes = get_face_boxes(coords, self.pad)

    boxes = merge_overlapping_boxes(boxes)

    return boxes

from typing import Optional, Tuple

from deepchem.dock.binding_pocket import BindingPocketFinder

from deepchem.utils import rdkit_util

from deepchem.utils import mol_xyz_util

from deepchem.utils import geometry_utils

from deepchem.utils import vina_utils

from deepchem.utils import download_url

from deepchem.utils import get_data_dir

from deepchem.utils import download_url, get_data_dir

from deepchem.utils.mol_xyz_util import get_molecule_range

from deepchem.utils.geometry_utils import compute_centroid

from deepchem.utils.rdkit_util import load_molecule, write_molecule

from deepchem.utils.vina_utils import load_docked_ligands, write_vina_conf

logger = logging.getLogger(__name__)

    protein_name = os.path.basename(protein_file).split(".")[0]

    protein_hyd = os.path.join(out_dir, "%s_hyd.pdb" % protein_name)

    protein_pdbqt = os.path.join(out_dir, "%s.pdbqt" % protein_name)

    protein_mol = rdkit_util.load_molecule(

    protein_mol = load_molecule(

        protein_file, calc_charges=True, add_hydrogens=True)

    rdkit_util.write_molecule(protein_mol[1], protein_hyd, is_protein=True)

    rdkit_util.write_molecule(protein_mol[1], protein_pdbqt, is_protein=True)

    write_molecule(protein_mol[1], protein_hyd, is_protein=True)

    write_molecule(protein_mol[1], protein_pdbqt, is_protein=True)

    # Get protein centroid and range

    if centroid is not None and box_dims is not None:

    else:

      if self.pocket_finder is None:

        logger.info("Pockets not specified. Will use whole protein to dock")

        protein_centroid = geometry_utils.compute_centroid(protein_mol[0])

        protein_range = mol_xyz_util.get_molecule_range(protein_mol[0])

        protein_centroid = compute_centroid(protein_mol[0])

        protein_range = get_molecule_range(protein_mol[0])

        box_dims = protein_range + 5.0

        centroids, dimensions = [protein_centroid], [box_dims]

      else:

    ligand_name = os.path.basename(ligand_file).split(".")[0]

    ligand_pdbqt = os.path.join(out_dir, "%s.pdbqt" % ligand_name)

    ligand_mol = rdkit_util.load_molecule(

    ligand_mol = load_molecule(

        ligand_file, calc_charges=True, add_hydrogens=True)

    rdkit_util.write_molecule(ligand_mol[1], ligand_pdbqt)

    write_molecule(ligand_mol[1], ligand_pdbqt)

    docked_complexes = []

    all_scores = []

      logger.info("Box dimensions: %s" % str(box_dims))

      # Write Vina conf file

      conf_file = os.path.join(out_dir, "conf.txt")

      vina_utils.write_vina_conf(

      write_vina_conf(

          protein_pdbqt,

          ligand_pdbqt,

          protein_centroid,

            self.vina_cmd, conf_file, log_file, out_pdbqt)

      # FIXME: We should use `subprocess.run` instead of `call`

      call(args, shell=True)

      ligands, scores = vina_utils.load_docked_ligands(out_pdbqt)

      ligands, scores = load_docked_ligands(out_pdbqt)

      docked_complexes += [(protein_mol[1], ligand) for ligand in ligands]

      all_scores += scores

ignore = 

    E111,  # Indentation is not a multiple of four

    E114,  # Indentation is not a multiple of four (comment)

    E121,  # continuation line under-indented for hanging indent

    E124,  # Closing bracket does not match visual indentation

    E125,  # Continuation line with same indent as next logical line

    E129,  # Visually indented line with same indent as next logical line