pyjess 0.6.0__pp38-pypy38_pp73-win_amd64.whl → 0.7.0__pp38-pypy38_pp73-win_amd64.whl

pyjess/tests/data/1sur.qry

@@ -0,0 +1,26 @@
+REMARK TEMPLATE
+REMARK CLUSTER 1_1_1
+REMARK REPRESENTING 1 CATALYTIC SITES
+REMARK ID 1sur_AA204-AA208-A204-A208
+REMARK MCSA_ID 279
+REMARK PDB_ID 1sur
+REMARK UNIPROT_ID P17854
+REMARK EC 1.8.4.8
+REMARK ENZYME PAPS REDUCTASE
+REMARK EXPERIMENTAL_METHOD X-ray diffraction
+REMARK RESOLUTION 2.0
+REMARK ORGANISM_NAME Escherichia coli
+REMARK ORGANISM_ID 562
+ATOM      0  NE1ZTRPAA 204      38.872   1.684 110.358 W     0.00 
+ATOM      0  CZ2ZTRPAA 204      41.345   1.476 110.794 W     0.00 
+ATOM      0  CH2ZTRPAA 204      42.567   1.626 110.193 W     0.00 
+ATOM      3  CE1ZTYRAA 208      40.509  -1.903  99.734 Y     0.00 
+ATOM      3  CZ ZTYRAA 208      41.503  -1.926  98.771 Y     0.00 
+ATOM      1  OH ZTYRAA 208      41.320  -2.643  97.607 Y     0.00 
+ATOM      0  NE1ZTRP A 204      43.868   1.684  54.342 W     0.00 
+ATOM      0  CZ2ZTRP A 204      41.395   1.476  53.906 W     0.00 
+ATOM      0  CH2ZTRP A 204      40.173   1.626  54.507 W     0.00 
+ATOM      3  CE1ZTYR A 208      42.231  -1.903  64.966 Y     0.00 
+ATOM      3  CZ ZTYR A 208      41.237  -1.926  65.929 Y     0.00 
+ATOM      1  OH ZTYR A 208      41.420  -2.643  67.093 Y     0.00 
+END

pyjess/tests/data/4.1.2.tpl

@@ -0,0 +1,23 @@
+REMARK TEMPLATE
+REMARK CLUSTER 4_1_2
+REMARK REPRESENTING 10 CATALYTIC SITES
+REMARK ID 2om2_A48-A43-A200-A204-A178
+REMARK MCSA_ID 533
+REMARK PDB_ID 2om2
+REMARK UNIPROT_ID P63096
+REMARK EC None
+REMARK ENZYME Guanine nucleotide-binding protein G(i), alpha-1 subunit, Regulator of G-protein signalling 14 GoLoco motif peptide
+REMARK EXPERIMENTAL_METHOD X-ray diffraction
+REMARK RESOLUTION 2.2
+REMARK ORGANISM_NAME Homo sapiens
+REMARK ORGANISM_ID 9606
+ATOM      3  CA ZTHR A  48      33.911 -23.654   9.552 T     0.53 
+ATOM      3  CB ZTHR A  48      34.739 -23.239   8.310 T     0.53 
+ATOM      1  OG1ZTHR A  48      36.129 -23.451   8.587 T     0.53 
+ATOM      3  CD ZGLU A  43      42.537 -29.462   7.690 E     2.08 
+ATOM      3  OE1ZGLU A  43      42.721 -29.948   8.832 E     2.08 
+ATOM      3  OE2ZGLU A  43      42.492 -28.227   7.487 E     2.08 
+ATOM      0  CZ ZARG A 178      43.760 -26.926  10.370 R     2.35 
+ATOM      3  NH1ZARG A 178      42.887 -26.457   9.483 R     2.35 
+ATOM      3  NH2ZARG A 178      44.119 -28.202  10.324 R     2.35 
+END

pyjess/tests/data/5ayx.EF.pdb

@@ -0,0 +1,63 @@
+HEADER    TRANSFERASE                             14-SEP-15   XXXX              
+TITLE     CRYSTAL STRUCTURE OF HUMAN QUINOLINATE PHOSPHORIBOSYLTRANSFERASE      
+KEYWDS    QUINOLINATE PHOSPHORIBOSYLTRANSFERASE, NAD BIOSYNTHESIS, NADC,        
+KEYWDS   2 TRANSFERASE                                                          
+EXPDTA    X-RAY DIFFRACTION                                                                                                             
+ATOM   8512  CA  GLU E  25      11.770  12.101 -30.191  1.00 63.41           C  
+ATOM   8513  C   GLU E  25      10.568  12.472 -31.076  1.00 64.47           C  
+ATOM   8514  O   GLU E  25      10.268  13.659 -31.267  1.00 66.51           O  
+ATOM   8515  CB  GLU E  25      12.924  11.548 -31.040  1.00 54.61           C  
+ATOM   8516  CG  GLU E  25      13.586  12.566 -31.990  1.00 63.15           C  
+ATOM   8517  CD  GLU E  25      14.447  11.902 -33.089  1.00 67.48           C  
+ATOM   8518  OE1 GLU E  25      14.041  10.820 -33.594  1.00 62.27           O  
+ATOM   8519  OE2 GLU E  25      15.524  12.460 -33.441  1.00 60.34           O  
+ATOM   9342  N   THR E 141      25.198   6.504 -40.031  1.00 49.91           N  
+ATOM   9343  CA  THR E 141      24.509   7.667 -39.509  1.00 44.30           C  
+ATOM   9344  C   THR E 141      24.749   7.734 -38.010  1.00 45.10           C  
+ATOM   9345  O   THR E 141      24.587   6.721 -37.320  1.00 49.53           O  
+ATOM   9346  CB  THR E 141      23.029   7.628 -39.780  1.00 40.72           C  
+ATOM   9347  OG1 THR E 141      22.810   7.411 -41.175  1.00 41.17           O  
+ATOM   9348  CG2 THR E 141      22.434   8.970 -39.391  1.00 45.90           C  
+ATOM   9371  N   ARG E 145      23.925   3.473 -35.427  1.00 47.01           N  
+ATOM   9372  CA  ARG E 145      24.909   2.456 -35.770  1.00 50.52           C  
+ATOM   9373  C   ARG E 145      24.310   1.065 -35.674  1.00 48.71           C  
+ATOM   9374  O   ARG E 145      24.441   0.255 -36.598  1.00 51.91           O  
+ATOM   9375  CB  ARG E 145      26.130   2.594 -34.858  1.00 58.30           C  
+ATOM   9376  CG  ARG E 145      27.168   1.485 -34.964  1.00 56.80           C  
+ATOM   9377  CD  ARG E 145      28.472   1.971 -34.388  1.00 64.04           C  
+ATOM   9378  NE  ARG E 145      29.055   3.032 -35.219  1.00 79.49           N  
+ATOM   9379  CZ  ARG E 145      30.083   3.803 -34.855  1.00 77.12           C  
+ATOM   9380  NH1 ARG E 145      30.556   4.728 -35.687  1.00 73.39           N  
+ATOM   9381  NH2 ARG E 145      30.640   3.659 -33.657  1.00 73.96           N  
+TER   10377      GLU E 289                                                      
+ATOM  10557  N   GLU F  25      28.218   6.773 -28.434  1.00 49.27           N  
+ATOM  10558  CA  GLU F  25      28.033   5.648 -29.351  1.00 50.31           C  
+ATOM  10559  C   GLU F  25      29.332   5.286 -30.079  1.00 60.13           C  
+ATOM  10560  O   GLU F  25      29.595   4.101 -30.330  1.00 65.02           O  
+ATOM  10561  CB  GLU F  25      26.927   5.992 -30.358  1.00 47.14           C  
+ATOM  10562  CG  GLU F  25      26.451   4.872 -31.285  1.00 50.18           C  
+ATOM  10563  CD  GLU F  25      25.906   5.376 -32.657  1.00 59.80           C  
+ATOM  10564  OE1 GLU F  25      26.512   6.292 -33.298  1.00 59.65           O  
+ATOM  10565  OE2 GLU F  25      24.859   4.843 -33.098  1.00 56.23           O  
+ATOM  11388  N   THR F 141      15.709   9.909 -40.611  1.00 43.47           N  
+ATOM  11389  CA  THR F 141      16.342   8.887 -39.789  1.00 44.34           C  
+ATOM  11390  C   THR F 141      16.089   9.169 -38.311  1.00 43.54           C  
+ATOM  11391  O   THR F 141      16.316  10.292 -37.851  1.00 43.12           O  
+ATOM  11392  CB  THR F 141      17.841   8.832 -40.073  1.00 43.56           C  
+ATOM  11393  OG1 THR F 141      18.060   8.851 -41.489  1.00 42.17           O  
+ATOM  11394  CG2 THR F 141      18.442   7.560 -39.505  1.00 42.11           C  
+ATOM  11417  N   ARG F 145      16.934  13.489 -36.682  1.00 42.82           N  
+ATOM  11418  CA  ARG F 145      15.914  14.290 -37.338  1.00 43.06           C  
+ATOM  11419  C   ARG F 145      16.352  15.741 -37.468  1.00 47.81           C  
+ATOM  11420  O   ARG F 145      16.166  16.358 -38.527  1.00 49.55           O  
+ATOM  11421  CB  ARG F 145      14.611  14.145 -36.548  1.00 52.52           C  
+ATOM  11422  CG  ARG F 145      13.463  15.093 -36.850  1.00 52.54           C  
+ATOM  11423  CD  ARG F 145      12.613  15.162 -35.593  1.00 56.72           C  
+ATOM  11424  NE  ARG F 145      11.200  15.447 -35.811  1.00 61.47           N  
+ATOM  11425  CZ  ARG F 145      10.285  15.372 -34.842  1.00 73.92           C  
+ATOM  11426  NH1 ARG F 145       9.005  15.653 -35.090  1.00 71.75           N  
+ATOM  11427  NH2 ARG F 145      10.657  15.007 -33.615  1.00 69.36           N  
+TER   12486      GLU F 289                                                      
+ENDMDL                                                                          
+MASTER        0    0    0   76   71    0    0    612499    6    0  144          
+END                                                                             

pyjess/tests/test_doctest.py

@@ -0,0 +1,78 @@
+# coding: utf-8
+"""Test doctest contained tests in every file of the module.
+"""
+
+import configparser
+import doctest
+import importlib
+import json
+import gzip
+import os
+import pkgutil
+import re
+import shutil
+import sys
+import types
+import warnings
+from unittest import mock
+
+import pyjess
+
+
+def _load_tests_from_module(tests, module, globs, setUp=None, tearDown=None):
+    """Load tests from module, iterating through submodules."""
+    for attr in (getattr(module, x) for x in dir(module) if not x.startswith("_")):
+        if isinstance(attr, types.ModuleType):
+            suite = doctest.DocTestSuite(
+                attr,
+                globs,
+                setUp=setUp,
+                tearDown=tearDown,
+                optionflags=+doctest.ELLIPSIS,
+            )
+            tests.addTests(suite)
+    return tests
+
+
+def load_tests(loader, tests, ignore):
+    """`load_test` function used by unittest to find the doctests."""
+    _current_cwd = os.getcwd()
+
+    def setUp(self):
+        warnings.simplefilter("ignore")
+        os.chdir(os.path.realpath(os.path.join(__file__, os.path.pardir, "data")))
+
+    def tearDown(self):
+        os.chdir(_current_cwd)
+        warnings.simplefilter(warnings.defaultaction)
+
+    # doctests are not compatible with `green`, so we may want to bail out
+    # early if `green` is running the tests
+    if sys.argv[0].endswith("green"):
+        return tests
+
+    # recursively traverse all library submodules and load tests from them
+    packages = [None, pyjess]
+    for pkg in iter(packages.pop, None):
+        for (_, subpkgname, subispkg) in pkgutil.walk_packages(pkg.__path__):
+            # do not import __main__ module to avoid side effects!
+            if subpkgname == "__main__" or subpkgname.startswith("tests") or subpkgname.startswith("cli"):
+                continue
+            # import the submodule and add it to the tests
+            module = importlib.import_module(".".join([pkg.__name__, subpkgname]))
+            globs = dict(pyjess=pyjess, **module.__dict__)
+            tests.addTests(
+                doctest.DocTestSuite(
+                    module,
+                    globs=globs,
+                    setUp=setUp,
+                    tearDown=tearDown,
+                    optionflags=+doctest.ELLIPSIS,
+                )
+            )
+            # if the submodule is a package, we need to process its submodules
+            # as well, so we add it to the package queue
+            if subispkg and subpkgname != "tests":
+                packages.append(module)
+
+    return tests

pyjess/tests/test_hit.py

@@ -2,6 +2,7 @@ import math
 import unittest
 import sys
 import pickle
+import textwrap
 
 from .._jess import Template, Molecule, Jess
 from .utils import files
@@ -9,12 +10,14 @@ from . import data
 
 
 class TestHit(unittest.TestCase):
+    
+    maxDiff = None
 
     @unittest.skipUnless(files, "importlib.resources not available")
     @classmethod
     def setUpClass(cls):
         with files(data).joinpath("template_01.qry").open() as f:
-            template = Template.load(f)
+            template = Template.load(f, id="T1")
             jess = Jess([template])
         with files(data).joinpath("pdb1lnb.pdb").open() as f:
             molecule = Molecule.load(f)
@@ -30,4 +33,25 @@ class TestHit(unittest.TestCase):
         self.assertEqual(self.hit.template, hit.template)
         self.assertListEqual(self.hit.atoms(transform=True), hit.atoms(transform=True))
         self.assertListEqual(self.hit.atoms(transform=False), hit.atoms(transform=False))
-        self.assertEqual(self.hit.molecule(transform=False), hit.molecule(transform=False))
+        self.assertEqual(self.hit.molecule(transform=False), hit.molecule(transform=False))
+
+    def test_dumps(self):
+        expected = textwrap.dedent(
+            """
+            REMARK 1LNB 0.555 T1 Det= 1.0 log(E)~ -2.04
+            ATOM   1112  ND1 HIS E 142       4.157  -2.574   4.091  1.00 10.22
+            ATOM   1115  NE2 HIS E 142       3.805  -2.316   1.890  1.00 16.00
+            ATOM   1123  OE1 GLU E 143       0.480  -4.544  -0.363  1.00 14.72
+            ATOM   1124  OE2 GLU E 143       1.870  -6.097   0.337  1.00 22.48
+            ATOM   1145  CG  HIS E 146       0.031   0.017   0.019  1.00 12.45
+            ATOM   1146  ND1 HIS E 146       0.823   1.160   0.000  1.00 15.79
+            ATOM   1147  CD2 HIS E 146       0.878  -1.064   0.006  1.00 20.85
+            ATOM   1148  CE1 HIS E 146       2.115   0.777  -0.013  1.00 13.50
+            ATOM   1149  NE2 HIS E 146       2.181  -0.553  -0.032  1.00 12.44
+            ATOM   1298  OE1 GLU E 166       6.432  -0.605   1.056  1.00 16.03
+            ATOM   1299  OE2 GLU E 166       4.839   0.070  -0.343  1.00 19.31
+            ENDMDL
+            """
+        ).strip()
+        actual = self.hit.dumps().strip()
+        self.assertMultiLineEqual(actual, expected)

pyjess/tests/test_jess.py

@@ -92,7 +92,6 @@ class TestJess(unittest.TestCase):
         self.assertEqual(len(jess[:1]), 1)
         self.assertEqual(len(jess[1:]), 0)
 
-
     @unittest.skipUnless(files, "importlib.resources not available")
     def test_multiple_query_split(self):
         with files(data).joinpath("template_01.qry").open() as f:
@@ -132,6 +131,29 @@ class TestJess(unittest.TestCase):
         hits = list(jess.query(molecule, 1, 2, 2))
         self.assertIsInstance(hits[0].template, MyTemplate)
 
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_query_max_candidates(self):
+        with files(data).joinpath("template_01.qry").open() as f:
+            template = Template.load(f)
+            jess = Jess([template])
+        with files(data).joinpath("pdb1lnb.pdb").open() as f:
+            molecule = Molecule.load(f)
+
+        hits = list(jess.query(molecule, 2, 5, 5))
+        self.assertEqual(len(hits), 3)
+
+        hits = list(jess.query(molecule, 2, 5, 5, max_candidates=3))
+        self.assertEqual(len(hits), 3)
+
+        hits = list(jess.query(molecule, 2, 5, 5, max_candidates=2))
+        self.assertEqual(len(hits), 2)
+
+        hits = list(jess.query(molecule, 2, 5, 5, max_candidates=1))
+        self.assertEqual(len(hits), 1)
+
+        with self.assertRaises(ValueError):
+            hits = list(jess.query(molecule, 2, 5, 5, max_candidates=-1))
+        
     @unittest.skipUnless(files, "importlib.resources not available")
     def test_query(self):
         with files(data).joinpath("template_01.qry").open() as f:
@@ -311,3 +333,42 @@ class TestJess(unittest.TestCase):
                 self.assertAlmostEqual(atom.occupancy, float(atom_line[55:61]), places=3)
                 self.assertAlmostEqual(atom.temperature_factor, float(atom_line[61:67]), places=3)
 
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_ignore_chain_none(self):
+        with files(data).joinpath("4.1.2.tpl").open() as f:
+            template = Template.load(f)
+            jess = Jess([template])
+        with files(data).joinpath("5ayx.EF.pdb").open() as f:
+            molecule = Molecule.load(f)
+        
+        hits = list(jess.query(molecule, 3, 3, 3, ignore_chain=None))
+        self.assertEqual(len(hits), 0)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_ignore_chain_residues(self):
+        with files(data).joinpath("4.1.2.tpl").open() as f:
+            template = Template.load(f)
+            jess = Jess([template])
+        with files(data).joinpath("5ayx.EF.pdb").open() as f:
+            molecule = Molecule.load(f)
+        
+        hits = list(jess.query(molecule, 3, 3, 3, ignore_chain="residues"))
+        self.assertEqual(len(hits), 2)
+        for hit in hits:
+            atoms = hit.atoms(transform=False)
+            for i in range(1, len(atoms)):
+                if atoms[i-1].residue_number == atoms[i].residue_number:
+                    self.assertEqual(atoms[i-1].chain_id, atoms[i].chain_id)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_ignore_chain_atoms(self):
+        with files(data).joinpath("4.1.2.tpl").open() as f:
+            template = Template.load(f)
+            jess = Jess([template])
+        with files(data).joinpath("5ayx.EF.pdb").open() as f:
+            molecule = Molecule.load(f)
+        
+        hits = list(jess.query(molecule, 3, 3, 3, ignore_chain="atoms"))
+        self.assertEqual(len(hits), 7)
+        
+        

pyjess/tests/test_molecule.py

@@ -1,12 +1,31 @@
+import itertools
 import os
 import pickle
 import unittest
 import tempfile
 import textwrap
 import sys
+import warnings
 
+from .utils import files
+from . import data
 from .._jess import Atom, Molecule
 
+try:
+    import gemmi
+except ImportError:
+    gemmi = None
+
+try:
+    import Bio.PDB
+except ImportError:
+    Bio = None
+
+try:
+    from biotite.structure.io.pdb import PDBFile
+except ImportError:
+    PDBFile = None
+
 MOLECULE = textwrap.dedent(
     """
     HEADER    DNA RECOMBINATION                       05-DEC-97   1A0P              
@@ -22,6 +41,38 @@ MOLECULE = textwrap.dedent(
 
 class TestMolecule(unittest.TestCase):
 
+    def assertHeteroAtomEqual(self, a1, a2):
+        # self.assertEqual(a1.serial, a2.serial)
+        self.assertEqual(a1.name, a2.name)
+        self.assertEqual(a1.altloc, a2.altloc)
+        self.assertEqual(a1.residue_name, a2.residue_name)
+        # self.assertEqual(a1.chain_id, a2.chain_id)
+        # self.assertEqual(a1.residue_number, a2.residue_number)
+        self.assertEqual(a1.insertion_code, a2.insertion_code)
+        self.assertEqual(a1.element, a2.element)
+        self.assertAlmostEqual(a1.x, a2.x, places=5)
+        self.assertAlmostEqual(a1.y, a2.y, places=5)
+        self.assertAlmostEqual(a1.z, a2.z, places=5)
+        self.assertAlmostEqual(a1.occupancy, a2.occupancy, places=5)
+        self.assertAlmostEqual(a1.temperature_factor, a2.temperature_factor, places=5)
+        self.assertAlmostEqual(a1.charge, a2.charge, places=5)
+
+    def assertAtomEqual(self, a1, a2):
+        self.assertEqual(a1.serial, a2.serial)
+        self.assertEqual(a1.name, a2.name)
+        self.assertEqual(a1.altloc, a2.altloc)
+        self.assertEqual(a1.residue_name, a2.residue_name)
+        self.assertEqual(a1.chain_id, a2.chain_id)
+        self.assertEqual(a1.residue_number, a2.residue_number)
+        self.assertEqual(a1.insertion_code, a2.insertion_code)
+        self.assertEqual(a1.element, a2.element)
+        self.assertAlmostEqual(a1.x, a2.x, places=5)
+        self.assertAlmostEqual(a1.y, a2.y, places=5)
+        self.assertAlmostEqual(a1.z, a2.z, places=5)
+        self.assertAlmostEqual(a1.occupancy, a2.occupancy, places=5)
+        self.assertAlmostEqual(a1.temperature_factor, a2.temperature_factor, places=5)
+        self.assertAlmostEqual(a1.charge, a2.charge, places=5)
+
     def _create_atom(self, **kwargs):
         default = dict(serial=1, name='N', altloc=' ', residue_name='GLN', chain_id='A', residue_number=3, x=8.171, y=-51.403, z=42.886, segment='', insertion_code=' ', occupancy=1.0, temperature_factor=55.63, charge=0, element='N')
         default.update(kwargs)
@@ -139,3 +190,98 @@ class TestMolecule(unittest.TestCase):
         self.assertEqual(list(mol1), list(mol2))
         self.assertEqual(mol1.id, mol2.id)
         self.assertEqual(mol1, mol2)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    @unittest.skipUnless(gemmi, "gemmi not available")
+    def test_load_consistency_no_skip_hetatm(self):
+        with files(data).joinpath("1AMY.pdb").open() as f:
+            pdb_molecule = Molecule.load(f, format="pdb")
+        with files(data).joinpath("1AMY.cif").open() as f:
+            with warnings.catch_warnings():
+                warnings.simplefilter('ignore')
+                cif_molecule = Molecule.load(f, format="cif")
+        self.assertEqual(len(cif_molecule), 3339)
+        self.assertEqual(len(pdb_molecule), 3339)
+        for pdb_atom, cif_atom in itertools.islice(zip(pdb_molecule, cif_molecule), 3184):
+            self.assertAtomEqual(pdb_atom, cif_atom)
+        for pdb_atom, cif_atom in itertools.islice(zip(pdb_molecule, cif_molecule), 3184, 3339):
+            self.assertHeteroAtomEqual(pdb_atom, cif_atom)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    @unittest.skipUnless(gemmi, "gemmi not available")
+    def test_load_consistency_no_skip_hetatm_use_author(self):
+        with files(data).joinpath("1AMY.pdb").open() as f:
+            pdb_molecule = Molecule.load(f, format="pdb")
+        with files(data).joinpath("1AMY.cif").open() as f:
+            cif_molecule = Molecule.load(f, format="cif", use_author=True)
+        self.assertEqual(len(cif_molecule), 3339)
+        self.assertEqual(len(pdb_molecule), 3339)
+        for pdb_atom, cif_atom in itertools.islice(zip(pdb_molecule, cif_molecule), 3184):
+            self.assertAtomEqual(pdb_atom, cif_atom)
+        for pdb_atom, cif_atom in itertools.islice(zip(pdb_molecule, cif_molecule), 3184, 3339):
+            self.assertHeteroAtomEqual(pdb_atom, cif_atom)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    @unittest.skipUnless(gemmi, "gemmi not available")
+    def test_load_consistency_skip_hetatm(self):
+        with files(data).joinpath("1AMY.pdb").open() as f:
+            pdb_molecule = Molecule.load(f, format="pdb", skip_hetatm=True)
+        with files(data).joinpath("1AMY.cif").open() as f:
+            cif_molecule = Molecule.load(f, format="cif", skip_hetatm=True)
+        self.assertEqual(len(cif_molecule), 3184)
+        self.assertEqual(len(pdb_molecule), 3184)
+        for pdb_atom, cif_atom in itertools.islice(zip(pdb_molecule, cif_molecule), 3184):
+            self.assertAtomEqual(pdb_atom, cif_atom)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    @unittest.skipUnless(gemmi, "gemmi not available")
+    def test_load_consistency_skip_hetatm_use_author(self):
+        with files(data).joinpath("1AMY.pdb").open() as f:
+            pdb_molecule = Molecule.load(f, format="pdb", skip_hetatm=True)
+        with files(data).joinpath("1AMY.cif").open() as f:
+            cif_molecule = Molecule.load(f, format="cif", skip_hetatm=True, use_author=True)
+        self.assertEqual(len(cif_molecule), 3184)
+        self.assertEqual(len(pdb_molecule), 3184)
+        for pdb_atom, cif_atom in itertools.islice(zip(pdb_molecule, cif_molecule), 3184):
+            self.assertAtomEqual(pdb_atom, cif_atom)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    @unittest.skipUnless(Bio, "biopython not available")
+    def test_from_biopython(self):
+        parser = Bio.PDB.PDBParser()
+        with files(data).joinpath("1AMY.pdb").open() as f:
+            structure = parser.get_structure('1amy', f)
+            bio_mol = Molecule.from_biopython(structure)
+        with files(data).joinpath("1AMY.pdb").open() as f:
+            pdb_mol = Molecule.load(f, format="pdb")
+        self.assertEqual(len(pdb_mol), 3339)
+        self.assertEqual(len(bio_mol), 3339)
+        for pdb_atom, bio_atom in zip(pdb_mol, bio_mol):
+            self.assertAtomEqual(pdb_atom, bio_atom)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    @unittest.skipUnless(gemmi, "gemmi not available")
+    def test_from_gemmi(self):
+        with files(data).joinpath("1AMY.pdb").open() as f:
+            structure = gemmi.read_pdb_string(f.read())
+            gemmi_mol = Molecule.from_gemmi(structure[0])
+        with files(data).joinpath("1AMY.pdb").open() as f:
+            pdb_mol = Molecule.load(f, format="pdb")
+        self.assertEqual(len(pdb_mol), 3339)
+        self.assertEqual(len(gemmi_mol), 3339)
+        for pdb_atom, gemmi_atom in zip(pdb_mol, gemmi_mol):
+            self.assertAtomEqual(pdb_atom, gemmi_atom)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    @unittest.skipUnless(PDBFile, "biotite not available")
+    def test_from_biotite(self):
+        with files(data).joinpath("1AMY.pdb").open() as f:
+            pdb_file = PDBFile.read(f)
+            structure = pdb_file.get_structure(altloc="all", extra_fields=["atom_id", "b_factor", "occupancy", "charge"])
+            biotite_mol = Molecule.from_biotite(structure[0])
+        with files(data).joinpath("1AMY.pdb").open() as f:
+            pdb_mol = Molecule.load(f, format="pdb")
+        self.assertEqual(len(pdb_mol), 3339)
+        self.assertEqual(len(biotite_mol), 3339)
+        for pdb_atom, biotite_atom in zip(pdb_mol, biotite_mol):
+            self.assertAtomEqual(pdb_atom, biotite_atom)

pyjess/tests/test_template.py

@@ -6,6 +6,8 @@ import textwrap
 import sys
 
 from .._jess import Template
+from .utils import files
+from . import data
 
 TEMPLATE = textwrap.dedent(
     """
@@ -109,9 +111,16 @@ class TestTemplate(unittest.TestCase):
         tpl2 = tpl1.copy()
         self.assertEqual(len(tpl1), len(tpl2))
         self.assertEqual(tpl1, tpl2)
+        self.assertEqual(list(tpl1), list(tpl2))
 
     def test_pickle_roundtrip(self):
         tpl1 = Template.loads(TEMPLATE, id="tpl1")
         tpl2 = pickle.loads(pickle.dumps(tpl1))
         self.assertEqual(len(tpl1), len(tpl2))
-        self.assertEqual(tpl1, tpl2)
+        self.assertEqual(tpl1, tpl2)
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_dimension_multiple_chains(self):
+        with files(data).joinpath("1sur.qry").open() as f:
+            template1 = Template.load(f)
+        self.assertEqual(template1.dimension, 4)

{pyjess-0.6.0.dist-info → pyjess-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: pyjess
-Version: 0.6.0
+Version: 0.7.0
 Summary: Cython bindings and Python interface to JESS, a 3D template matching software.
 Keywords: bioinformatics,structure,template,matching
 Author-Email: Martin Larralde <martin.larralde@embl.de>
@@ -56,6 +56,8 @@ Project-URL: PiWheels, https://piwheels.org/project/pyjess/
 Requires-Python: >=3.7
 Provides-Extra: test
 Requires-Dist: importlib-resources; python_version < "3.9" and extra == "test"
+Provides-Extra: cif
+Requires-Dist: gemmi~=0.7.0; extra == "cif"
 Description-Content-Type: text/markdown
 
 # 🐍🔍 PyJess [![Stars](https://img.shields.io/github/stars/althonos/pyjess.svg?style=social&maxAge=3600&label=Star)](https://github.com/althonos/pyjess/stargazers)
@@ -115,7 +117,7 @@ package:
 $ conda install -c bioconda pyjess
 ```
 
-Check the [*install* page](https://pyjess.readthedocs.io/en/stable/install.html)
+Check the [*install* page](https://pyjess.readthedocs.io/en/stable/guide/install.html)
 of the documentation for other ways to install PyJess on your machine.
 
 
@@ -129,7 +131,9 @@ Jess if you are using it in an academic work, for instance as:
 
 ## 💡 Example
 
-Load [`Template`](https://pyjess.readthedocs.io/en/latest/api/template.html#pyjess.Template) 
+#### Prepare templates
+
+Load [`Template`](https://pyjess.readthedocs.io/en/latest/api/template.html#pyjess.Template)
 objects to be used as references from different template files:
 
 ```python
@@ -141,15 +145,46 @@ for path in sorted(pathlib.Path("vendor/jess/examples").glob("template_*.qry")):
     templates.append(pyjess.Template.load(path, id=path.stem))
 ```
 
-Create a [`Jess`](https://pyjess.readthedocs.io/en/latest/api/jess.html#pyjess.Jess) instance and use it to query a [`Molecule`](https://pyjess.readthedocs.io/en/latest/api/molecule.html#pyjess.Molecule) (a PDB structure)
-against the stored templates:
+#### Prepare query structures
+
+Load a [`Molecule`](https://pyjess.readthedocs.io/en/latest/api/molecule.html#pyjess.Molecule)
+(a PDB structure) from a PDB file, create one with the Python API, or
+convert it from a [`Bio.Model`](https://biopython.org/docs/1.76/api/Bio.PDB.Model.html),
+[`gemmi.Model`](https://gemmi.readthedocs.io/en/latest/mol.html#model),
+or [`biotite.structure.AtomArray`](https://www.biotite-python.org/latest/apidoc/biotite.structure.AtomArray.html)
+object:
 
 ```python
-jess = pyjess.Jess(templates)
+# load from PDB file or mmCIF file
 mol = pyjess.Molecule.load("vendor/jess/examples/test_pdbs/pdb1a0p.ent")
+
+# load with BioPython
+parser = Bio.PDB.PDBParser()
+structure = parser.get_structure('pdb1a0p', "vendor/jess/examples/test_pdbs/pdb1a0p.ent")
+mol = Molecule.from_biopython(structure, id="1a0p")
+
+# load with Gemmi
+structure = gemmi.read_pdb_string("vendor/jess/examples/test_pdbs/pdb1a0p.ent")
+mol = Molecule.from_gemmi(structure[0], id="1a0p")
+
+# load with Biotite
+pdb_file = biotite.structure.io.pdb.PDBFile.read(f)
+structure = pdb_file.get_structure(altloc="all", extra_fields=["atom_id", "b_factor", "occupancy", "charge"])
+mol = Molecule.from_biotite(structure[0])
+```
+
+### Match templates
+
+Create a [`Jess`](https://pyjess.readthedocs.io/en/latest/api/jess.html#pyjess.Jess)
+instance and use it to query a against the stored templates:
+
+```python
+jess = pyjess.Jess(templates)
 query = jess.query(mol, rmsd_threshold=2.0, distance_cutoff=3.0, max_dynamic_distance=3.0)
 ```
 
+### Process hits
+
 The hits are computed iteratively, and the different output statistics are
 computed on-the-fly when requested:
 
@@ -160,13 +195,19 @@ for hit in query:
         print(atom.name, atom.x, atom.y, atom.z)
 ```
 
+Hits can also be rendered in PDB format like in the original Jess output,
+either by writing to a file directly, or to a Python string:
+```python
+for hit in query:
+    hit.dump(sys.stdout, format="pdb")
+```
 
 ## 🧶 Thread-safety
 
-Once a [`Jess`](https://pyjess.readthedocs.io/en/latest/api/jess.html#pyjess.Jess) 
+Once a [`Jess`](https://pyjess.readthedocs.io/en/latest/api/jess.html#pyjess.Jess)
 instance has been created, the templates cannot be edited anymore,
-making the [`Jess.query`](https://pyjess.readthedocs.io/en/latest/api/jess.html#pyjess.Jess.query) method re-entrant and thread-safe. This allows querying 
-several molecules against the same templates in parallel using e.g a 
+making the [`Jess.query`](https://pyjess.readthedocs.io/en/latest/api/jess.html#pyjess.Jess.query) method re-entrant and thread-safe. This allows querying
+several molecules against the same templates in parallel using e.g a
 [`ThreadPool`](https://docs.python.org/3/library/multiprocessing.html#multiprocessing.pool.ThreadPool):
 
 ```python
@@ -183,9 +224,9 @@ If running Jess in parallel, make sure to use `v0.2.1` or later to use the code
 
 ## ⏱️ Benchmarks
 
-The following table reports the runtime of PyJess to match $n=132$ protein 
-structures to the $m=7607$ templates of 
-[EnzyMM](https://github.com/RayHackett/enzymm), using $J=12$ threads to parallelize.
+The following table reports the runtime of PyJess to match N=132 protein
+structures to the M=7607 templates of
+[EnzyMM](https://github.com/RayHackett/enzymm), using J=12 threads to parallelize.
 
 | Version     | Runtime (s) | Match Speed (N * M / s * J) | Speedup     |
 | ----------- | ----------- | --------------------------- | ----------- |
@@ -193,10 +234,11 @@ structures to the $m=7607$ templates of
 | ``v0.5.0``  | 586.3       | 142.7                       | x1.05       |
 | ``v0.5.1``  | 365.6       | 228.9                       | x1.69       |
 | ``v0.5.2``  | 327.2       | 255.7                       | x1.88       |
-| ``v0.6.0``  | 54.5        | 1535.4                      | **x11.34**  |
+| ``v0.6.0``  | 54.5        | 1535.4                      | x11.34      |
+| ``v0.7.0``  | 52.4        | 1597.5                      | **x11.80**  |
 
-*Benchmarks were run on a quiet [i7-1255U](https://www.intel.com/content/www/us/en/products/sku/226259/intel-core-i71255u-processor-12m-cache-up-to-4-70-ghz/specifications.html) CPU running @4.70GHz with 10 physical cores / 12 logical
-cores.*
+*Benchmarks were run on a quiet [i7-1255U](https://www.intel.com/content/www/us/en/products/sku/226259/intel-core-i71255u-processor-12m-cache-up-to-4-70-ghz/specifications.html)
+CPU running @4.70GHz with 10 physical cores / 12 logical cores.*
 
 ## 💭 Feedback
 
@@ -224,7 +266,8 @@ in the [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) format.
 
 ## ⚖️ License
 
-This library is provided under the [MIT License](https://choosealicense.com/licenses/mit/). The JESS code is distributed under the [MIT License](https://choosealicense.com/licenses/mit/) as well.
+This library is provided under the [MIT License](https://choosealicense.com/licenses/mit/).
+The JESS code is distributed under the [MIT License](https://choosealicense.com/licenses/mit/) as well.
 
 *This project is in no way not affiliated, sponsored, or otherwise endorsed
 by the JESS authors. It was developed