pyjess 0.5.2__pp310-pypy310_pp73-win_amd64.whl → 0.7.0__pp310-pypy310_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:
@@ -204,7 +226,7 @@ class TestJess(unittest.TestCase):
             self.assertAlmostEqual(hit.log_evalue, -2.04, places=1)
 
     @unittest.skipUnless(files, "importlib.resources not available")
-    def test_mcsa_query(self):
+    def test_mcsa_query_no_reorder(self):
         with files(data).joinpath("1.3.3.tpl").open() as f:
             template = Template.load(f)
             jess = Jess([template])
@@ -213,7 +235,7 @@ class TestJess(unittest.TestCase):
         with files(data).joinpath("1AMY+1.3.3.txt").open() as f:
             results = list(filter(None, f.read().split("REMARK")))
 
-        hits = list(jess.query(molecule, 2, 4, 4))
+        hits = list(jess.query(molecule, 2, 4, 4, reorder=False))
         self.assertEqual(len(hits), len(results))
         for hit, block in zip(hits, results):
             self.assertIs(hit.template, template)
@@ -251,3 +273,102 @@ 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_mcsa_query_reorder(self):
+        with files(data).joinpath("1.3.3.tpl").open() as f:
+            template = Template.load(f)
+            jess = Jess([template])
+        with files(data).joinpath("1AMY.pdb").open() as f:
+            molecule = Molecule.load(f)
+        with files(data).joinpath("1AMY+1.3.3.txt").open() as f:
+            results = list(filter(None, f.read().split("REMARK")))
+
+        hits = list(jess.query(molecule, 2, 4, 4, reorder=True))
+        self.assertEqual(len(hits), len(results))
+
+        # `reorder=True` means that we may get results in a different order
+        # to Jess, so we need to match the hits in the file by residue number
+        # to make sure we compare them consistently.
+        
+        results_by_serials = {}
+        for block in results:
+            lines = block.strip().splitlines()
+            serials = tuple([ int(line.split()[1]) for line in lines[1:-1] ])
+            results_by_serials[serials] = block
+
+        for hit in hits:
+            self.assertIs(hit.template, template)
+            block = results_by_serials[tuple(atom.serial for atom in hit.atoms(False))]
+
+            lines = block.strip().splitlines()
+            query_id, rmsd, template_id, _, determinant, _, logE = lines[0].split()
+            self.assertEqual(query_id, "1AMY")
+            self.assertAlmostEqual(float(rmsd), hit.rmsd, places=3)
+            self.assertAlmostEqual(float(determinant), hit.determinant, places=1)
+            self.assertAlmostEqual(float(logE), hit.log_evalue, places=1)
+
+            atom_lines = lines[1:-1]
+            atoms = hit.atoms()
+            self.assertEqual(len(atoms), len(atom_lines))
+            for atom, atom_line in zip(atoms, atom_lines):
+                self.assertEqual(atom.serial, int(atom_line[7:12]))
+                self.assertEqual(atom.name, atom_line[13:17].strip())
+                self.assertEqual(atom.residue_name, atom_line[17:21].strip())
+                self.assertEqual(atom.chain_id, atom_line[21:23].strip())
+                self.assertEqual(atom.residue_number, int(atom_line[23:27]))
+                self.assertAlmostEqual(atom.x, float(atom_line[31:39]), places=3)
+                self.assertAlmostEqual(atom.y, float(atom_line[39:47]), places=3)
+                self.assertAlmostEqual(atom.z, float(atom_line[47:55]), places=3)
+                self.assertAlmostEqual(atom.occupancy, float(atom_line[55:61]), places=3)
+                self.assertAlmostEqual(atom.temperature_factor, float(atom_line[61:67]), places=3)
+
+            atoms = hit.atoms(transform=False)
+            self.assertEqual(len(atoms), len(atom_lines))
+            for atom, atom_line in zip(atoms, atom_lines):
+                self.assertEqual(atom.serial, int(atom_line[7:12]))
+                self.assertEqual(atom.name, atom_line[13:17].strip())
+                self.assertEqual(atom.residue_name, atom_line[17:21].strip())
+                self.assertEqual(atom.chain_id, atom_line[21:23].strip())
+                self.assertEqual(atom.residue_number, int(atom_line[23:27]))
+                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)