pyjess 0.4.0__pp37-pypy37_pp73-win_amd64.whl → 0.5.0__pp37-pypy37_pp73-win_amd64.whl

pyjess/_jess.pyi

@@ -39,7 +39,7 @@ class Molecule(Sequence[Atom]):
 
 class Atom:
     @classmethod
-    def load(cls, file: Union[str, bytes, os.PathLike[Any], TextIO]) -> Atom: ...
+    def load(cls, file: Union[TextIO, str, os.PathLike[str]]) -> Atom: ...
     @classmethod
     def loads(cls, text: str) -> Atom: ...
     def __init__(
@@ -100,7 +100,7 @@ class Atom:
 
 class TemplateAtom:
     @classmethod
-    def load(cls, file: Union[str, bytes, os.PathLike[Any], TextIO]) -> Atom: ...
+    def load(cls, file: Union[TextIO, str, os.PathLike[str]]) -> Atom: ...
     @classmethod
     def loads(cls, text: str) -> TemplateAtom: ...
     def __init__(
@@ -134,9 +134,9 @@ class TemplateAtom:
     @property
     def z(self) -> float: ...
     @property
-    def atom_names(self) -> List[str]: ...
+    def atom_names(self) -> Tuple[str, ...]: ...
     @property
-    def residue_names(self) -> List[str]: ...
+    def residue_names(self) -> Tuple[str, ...]: ...
     @property
     def distance_weight(self) -> float: ...
     def copy(self: _SELF) -> _SELF: ...
@@ -188,14 +188,13 @@ class Hit(Generic[_T]):
     @property
     def template(self) -> _T: ...
     @property
-    def molecule(self) -> Molecule: ...
-    @property
     def determinant(self) -> float: ...
     @property
     def log_evalue(self) -> float: ...
     @property
     def evalue(self) -> float: ...
     def atoms(self, transform: bool = True) -> List[Atom]: ...
+    def molecule(self, transform: bool = False) -> Molecule: ...
 
 class Jess(Generic[_T], Sequence[_T]):
     def __init__(self, templates: Iterable[_T] = ()): ...

pyjess/_jess.pyx

@@ -461,7 +461,7 @@ cdef class Atom:
             return NotImplemented
         other_ = other
         # FIXME: it should be possible to do a memcmp here.
-        return self._state() == other_._state()  
+        return self._state() == other_._state()
 
     def __hash__(self):
         return hash(tuple(self._state().values()))
@@ -598,11 +598,16 @@ cdef class TemplateAtom:
         """Load a template atom from the given file.
 
         Arguments:
-            file (file-like object): A file-like object opened in
-                text mode to read the template atom from.
+            file (str, os.PathLike or file-like object): A file-like object
+                opened in text or binary mode to read the template atom from.
 
         """
-        return cls.loads(file.read())
+        try:
+            handle = open(file)
+        except TypeError:
+            handle = nullcontext(file)
+        with handle as f:
+            return cls.loads(f.read())
 
     @classmethod
     def loads(cls, text):
@@ -828,7 +833,11 @@ cdef class TemplateAtom:
 
     @property
     def atom_names(self):
-        """`list` of `str`: The different atom names for this atom.
+        """`tuple` of `str`: The different atom names for this atom.
+
+        .. versionchanged:: 0.4.1
+           Property now returns a `tuple` rather than a `list`.
+
         """
         assert self._atom is not NULL
 
@@ -837,11 +846,15 @@ cdef class TemplateAtom:
 
         for i in range(self._atom.nameCount):
             l.append(self._atom.name[i].replace(b'_', b'').decode())
-        return l
+        return tuple(l)
 
     @property
     def residue_names(self):
-        """`list` of `str`: The different residue names for this atom.
+        """`tuple` of `str`: The different residue names for this atom.
+
+        .. versionchanged:: 0.4.1
+           Property now returns a `tuple` rather than a `list`.
+
         """
         assert self._atom is not NULL
 
@@ -850,7 +863,7 @@ cdef class TemplateAtom:
 
         for i in range(self._atom.resNameCount):
             l.append(self._atom.resName[i].replace(b'_', b'').decode())
-        return l
+        return tuple(l)
 
     @property
     def distance_weight(self):
@@ -863,11 +876,11 @@ cdef class TemplateAtom:
         """Create a copy of this template atom.
 
         Returns:
-            `~pyjess.TemplateAtom`: A new template atom object with 
+            `~pyjess.TemplateAtom`: A new template atom object with
             identical attributes.
-            
+
         .. versionadded:: 0.4.0
-        
+
         """
         return type(self)(**self._state())
 
@@ -886,10 +899,42 @@ cdef class Template:
 
     @classmethod
     def loads(cls, text, str id = None):
+        """Load a template from a string.
+
+        Arguments:
+            file (`str`, `os.PathLike`, or file-like object): Either the path
+                to a file, or a file-like object opened in **text mode**
+                containing the template.
+            id (`str`, optional): The identifier of the template. By default,
+                the parser will take the one from the ``PDB_ID`` remark if
+                found in the header.
+
+        Returns:
+            `~pyjess.Template`: The template parsed from the given string.
+
+        See Also:
+            `Template.load` to load a template from a file-like object or
+            from a path.
+
+        """
         return cls.load(io.StringIO(text), id=id)
 
     @classmethod
     def load(cls, file, str id = None):
+        """Load a template from the given file.
+
+        Arguments:
+            file (`str`, `os.PathLike` or file-like object): Either the
+                path to a file, or a file-like object opened in **text mode**
+                to read the template from.
+            id (`str`, optional): The identifier of the template. By default,
+                the parser will take the one from the ``PDB_ID`` remark if
+                found in the header.
+
+        Returns:
+            `~pyjess.Template`: The template parsed from the given file.
+
+        """
         try:
             handle = open(file)
         except TypeError:
@@ -1037,10 +1082,10 @@ cdef class Template:
         return all(x == y for x,y in zip(self, other_))
 
     def __hash__(self):
-        return hash(
+        return hash((
             self.id,
             *(hash(x) for x in self)
-        )
+        ))
 
     def __reduce__(self):
         return type(self), (list(self), self.id)
@@ -1173,7 +1218,7 @@ cdef class Query:
         hit._sup = NULL
         hit._atoms = NULL
         hit.rmsd = INFINITY
-        hit.molecule = self.molecule
+        hit._molecule = self.molecule
         hit_tpl = NULL
 
         # search the next hit without the GIL to allow parallel queries.
@@ -1253,7 +1298,7 @@ cdef class Hit:
 
     cdef readonly double   rmsd
     cdef readonly Template template
-    cdef readonly Molecule molecule
+    cdef          Molecule _molecule
 
     def __dealloc__(self):
         jess.super.Superposition_free(self._sup)
@@ -1284,7 +1329,7 @@ cdef class Hit:
         cdef double e
 
         with nogil:
-            n = jess.molecule.Molecule_count(self.molecule._mol)
+            n = jess.molecule.Molecule_count(self._molecule._mol)
             e = self.template._tpl.logE(self.template._tpl, self.rmsd, n)
         return e
 
@@ -1296,7 +1341,7 @@ cdef class Hit:
         cdef double e
 
         with nogil:
-            n = jess.molecule.Molecule_count(self.molecule._mol)
+            n = jess.molecule.Molecule_count(self._molecule._mol)
             e = exp(self.template._tpl.logE(self.template._tpl, self.rmsd, n))
         return e
 
@@ -1341,6 +1386,45 @@ cdef class Hit:
 
         return atoms
 
+    cpdef Molecule molecule(self, bint transform=False):
+        """Get the molecule matching the template.
+
+        Arguments:
+            transform (`bool`): Whether or not to transform coordinates
+                of the molecule atoms into template frame.
+
+        Returns:
+            `~pyjess.Molecule`: The matching molecule, optionally
+            rotated to match the template coordinate.
+
+        .. versionadded:: 0.5.0
+
+        """
+        assert self.template._tpl is not NULL
+        assert self._sup is not NULL
+
+        cdef _Atom*        atom
+        cdef Molecule      mol
+        cdef size_t        i
+        cdef size_t        j
+        cdef size_t        k
+        cdef const double* M    = jess.super.Superposition_rotation(self._sup)
+        cdef const double* c    = jess.super.Superposition_centroid(self._sup, 0)
+        cdef const double* v    = jess.super.Superposition_centroid(self._sup, 1)
+
+        if not transform:
+            return self._molecule
+
+        mol = self._molecule.copy()
+        for k in range(mol._mol.count):
+            atom = mol._mol.atom[i]
+            for i in range(3):
+                atom.x[i] = v[i]
+                for j in range(3):
+                    atom.x[i] += M[3*i + j] * (self._molecule._mol.atom[k].x[j] - c[j])
+
+        return mol
+
 
 cdef class Jess:
     """A handle to run Jess over a list of templates.
@@ -1351,7 +1435,7 @@ cdef class Jess:
     """
     cdef _Jess* _jess
     cdef dict   _indices
-    cdef list   _templates
+    cdef tuple  _templates
     cdef size_t length
 
     def __cinit__(self):
@@ -1379,10 +1463,10 @@ cdef class Jess:
         """
         cdef Template   template
         cdef _Template* tpl
+        cdef list       _templates = []
 
         self._jess = jess.jess.Jess_create()
         self._indices = {}
-        self._templates = []
 
         for template in templates:
             # NOTE: the Jess storage owns the data, so we make a copy of the
@@ -1390,9 +1474,11 @@ cdef class Jess:
             tpl = template._tpl.copy(template._tpl)
             jess.jess.Jess_addTemplate(self._jess, tpl)
             self._indices[<size_t> tpl] = self.length
-            self._templates.append(template)
+            _templates.append(template)
             self.length += 1
 
+        self._templates = tuple(_templates)
+
     def __copy__(self):
         return self.copy()
 
@@ -1407,7 +1493,7 @@ cdef class Jess:
         return self._templates == other_._templates
 
     def __hash__(self):
-        return hash(tuple(hash(t) for t in self._templates))
+        return hash((Jess, self._templates))
 
     def __len__(self):
         return self.length

pyjess/tests/test_atom.py

@@ -59,9 +59,18 @@ class TestAtom(unittest.TestCase):
     def test_hash(self):
         a1 = self._create_atom()
         a2 = self._create_atom()
-        self.assertEqual(a1, a2)
         self.assertEqual(hash(a1), hash(a2))
         self.assertIsNot(a1, a2)
+        a3 = self._create_atom(x=1.0)
+        self.assertNotEqual(hash(a1), hash(a3))
+
+    def test_eq(self):
+        a1 = self._create_atom()
+        a2 = self._create_atom()
+        self.assertEqual(a1, a2)
+        self.assertIsNot(a1, a2)
+        a3 = self._create_atom(x=1.0)
+        self.assertNotEqual(a1, a3)
 
     def test_repr_roundtrip(self):
         atom = self._create_atom()

pyjess/tests/test_jess.py

@@ -21,6 +21,13 @@ class TestJess(unittest.TestCase):
         hits = jess.query(mol, 2, 2, 4)
         self.assertRaises(StopIteration, next, hits)
 
+    def test_hash_empty(self):
+        j1 = Jess()
+        j2 = Jess()
+        self.assertEqual(j1, j2)
+        self.assertEqual(hash(j1), hash(j2))
+        self.assertIsNot(j1, j2)
+
     @unittest.skipUnless(files, "importlib.resources not available")
     def test_copy(self):
         with files(data).joinpath("template_01.qry").open() as f:
@@ -31,6 +38,32 @@ class TestJess(unittest.TestCase):
         copy = jess.copy()
         self.assertEqual(jess, copy)
 
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_hash(self):
+        with files(data).joinpath("template_01.qry").open() as f:
+            template1 = Template.load(f)
+        with files(data).joinpath("template_02.qry").open() as f:
+            template2 = Template.load(f)
+        j1 = Jess([template1, template2])
+        j2 = Jess([template1, template2])
+        self.assertEqual(hash(j1), hash(j2))
+        self.assertIsNot(j1, j2)
+        j3 = Jess([template1])
+        self.assertNotEqual(hash(j1), hash(j3))
+
+    @unittest.skipUnless(files, "importlib.resources not available")
+    def test_eq(self):
+        with files(data).joinpath("template_01.qry").open() as f:
+            template1 = Template.load(f)
+        with files(data).joinpath("template_02.qry").open() as f:
+            template2 = Template.load(f)
+        j1 = Jess([template1, template2])
+        j2 = Jess([template1, template2])
+        self.assertEqual(j1, j2)
+        self.assertIsNot(j1, j2)
+        j3 = Jess([template1])
+        self.assertNotEqual(j1, j3)
+
     @unittest.skipUnless(files, "importlib.resources not available")
     def test_pickle_roundtrip(self):
         with files(data).joinpath("template_01.qry").open() as f:

pyjess/tests/test_molecule.py

@@ -96,7 +96,23 @@ class TestMolecule(unittest.TestCase):
         mol1 = Molecule(atoms)
         mol2 = Molecule(atoms)
         self.assertEqual(hash(mol1), hash(mol2))
+        self.assertIsNot(mol1, mol2)
+        mol3 = Molecule(atoms[:-1])
+        self.assertNotEqual(hash(mol1), hash(mol3))
+
+    def test_eq(self):
+        atoms = [
+            self._create_atom(serial=1, name='N'),
+            self._create_atom(serial=2, name='CA'),
+            self._create_atom(serial=3, name='C'),
+            self._create_atom(serial=4, name='O'),
+        ]
+        mol1 = Molecule(atoms)
+        mol2 = Molecule(atoms)
         self.assertEqual(mol1, mol2)
+        self.assertIsNot(mol1, mol2)
+        mol3 = Molecule(atoms[:-1])
+        self.assertNotEqual(mol1, mol3)
 
     def test_copy(self):
         atoms = [

pyjess/tests/test_template.py

@@ -30,9 +30,9 @@ class TestTemplate(unittest.TestCase):
         template = Template.loads(TEMPLATE)
         self.assertEqual(len(template), 11)
         self.assertEqual(template.dimension, 5)
-        self.assertEqual(template[0].residue_names, ["LYS"])
-        self.assertEqual(template[0].atom_names, ["NZ"])
-        self.assertEqual(template[1].atom_names, ["CG"])
+        self.assertEqual(template[0].residue_names, ("LYS",))
+        self.assertEqual(template[0].atom_names, ("NZ",))
+        self.assertEqual(template[1].atom_names, ("CG",))
         self.assertEqual(template[2].residue_number, 1132)
         self.assertEqual(template[-1].residue_number, 1150)
 
@@ -42,9 +42,9 @@ class TestTemplate(unittest.TestCase):
             f.write(TEMPLATE)
             f.flush()
             template = Template.load(f.name)
-        self.assertEqual(template[0].residue_names, ["LYS"])
-        self.assertEqual(template[0].atom_names, ["NZ"])
-        self.assertEqual(template[1].atom_names, ["CG"])
+        self.assertEqual(template[0].residue_names, ("LYS",))
+        self.assertEqual(template[0].atom_names, ("NZ",))
+        self.assertEqual(template[1].atom_names, ("CG",))
         self.assertEqual(template[2].residue_number, 1132)
         self.assertEqual(template[-1].residue_number, 1150)
 
@@ -55,9 +55,9 @@ class TestTemplate(unittest.TestCase):
             f.flush()
             f.seek(0)
             template = Template.load(f)
-        self.assertEqual(template[0].residue_names, ["LYS"])
-        self.assertEqual(template[0].atom_names, ["NZ"])
-        self.assertEqual(template[1].atom_names, ["CG"])
+        self.assertEqual(template[0].residue_names, ("LYS",))
+        self.assertEqual(template[0].atom_names, ("NZ",))
+        self.assertEqual(template[1].atom_names, ("CG",))
         self.assertEqual(template[2].residue_number, 1132)
         self.assertEqual(template[-1].residue_number, 1150)
 
@@ -87,6 +87,23 @@ class TestTemplate(unittest.TestCase):
         tpl2 = tpl1[1:4]
         self.assertEqual(len(tpl2), 3)
 
+    def test_hash(self):
+        tpl1 = Template.loads(TEMPLATE, id="tpl1")
+        tpl2 = Template.loads(TEMPLATE, id="tpl1")
+        self.assertEqual(tpl1, tpl2)
+        self.assertEqual(hash(tpl1), hash(tpl2))
+        self.assertIsNot(tpl1, tpl2)
+        tpl3 = Template.loads(TEMPLATE, id="tpl3")
+        self.assertNotEqual(hash(tpl1), hash(tpl3))
+
+    def test_eq(self):
+        tpl1 = Template.loads(TEMPLATE, id="tpl1")
+        tpl2 = Template.loads(TEMPLATE, id="tpl1")
+        self.assertEqual(tpl1, tpl2)
+        self.assertIsNot(tpl1, tpl2)
+        tpl3 = Template.loads(TEMPLATE, id="tpl3")
+        self.assertNotEqual(tpl1, tpl3)
+
     def test_copy(self):
         tpl1 = Template.loads(TEMPLATE, id="tpl1")
         tpl2 = tpl1.copy()

pyjess/tests/test_template_atom.py

@@ -10,8 +10,8 @@ class TestTemplateAtom(unittest.TestCase):
     def test_load(self):
         atom = TemplateAtom.loads("ATOM      1  NE  ARG A1136       3.953   0.597  -1.721 K")
         self.assertEqual(atom.match_mode, 1)
-        self.assertEqual(atom.atom_names, ["NE"])
-        self.assertEqual(atom.residue_names, ["ARG", "LYS"])
+        self.assertEqual(atom.atom_names, ("NE",))
+        self.assertEqual(atom.residue_names, ("ARG", "LYS",))
         self.assertEqual(atom.chain_id, "A")
         self.assertEqual(atom.residue_number, 1136)
         self.assertEqual(atom.x, 3.953)
@@ -32,6 +32,22 @@ class TestTemplateAtom(unittest.TestCase):
         default.update(kwargs)
         return TemplateAtom(**default)
 
+    def test_hash(self):
+        a1 = self._create_atom()
+        a2 = self._create_atom()
+        self.assertEqual(hash(a1), hash(a2))
+        self.assertIsNot(a1, a2)
+        a3 = self._create_atom(x=1.0)
+        self.assertNotEqual(hash(a1), hash(a3))
+
+    def test_eq(self):
+        a1 = self._create_atom()
+        a2 = self._create_atom()
+        self.assertEqual(a1, a2)
+        self.assertIsNot(a1, a2)
+        a3 = self._create_atom(x=1.0)
+        self.assertNotEqual(a1, a3)
+
     @unittest.skipUnless(sys.implementation.name == "cpython", "only available on CPython")
     def test_sizeof(self):
         atom = self._create_atom()

{pyjess-0.4.0.dist-info → pyjess-0.5.0.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: pyjess
-Version: 0.4.0
+Version: 0.5.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>
 License: MIT License
         
-        Copyright (c) 2024 Martin Larralde <martin.larralde@embl.de>
+        Copyright (c) 2024-2025 Martin Larralde <martin.larralde@embl.de>
         
         Permission is hereby granted, free of charge, to any person obtaining a copy
         of this software and associated documentation files (the "Software"), to deal
@@ -51,6 +51,7 @@ Project-URL: Changelog, https://github.com/althonos/pyjess/blob/master/CHANGELOG
 Project-URL: Coverage, https://codecov.io/gh/althonos/pyjess/
 Project-URL: Builds, https://github.com/althonos/pyjess/actions
 Project-URL: Pypi, https://pypi.org/project/pyjess
+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"
@@ -83,8 +84,8 @@ Jess is an algorithm for constraint-based structural template matching
 proposed by Jonathan Barker *et al.*[\[1\]](#ref1). It can be used to identify
 catalytic residues from a known template inside a protein structure. Jess
 is an evolution of TESS, a geometric hashing algorithm developed by
-Andrew Wallace *et al.*[\[2\]](#ref2), removing some pre-computation and 
-structural requirements from the original algorithm. Jess was further 
+Andrew Wallace *et al.*[\[2\]](#ref2), removing some pre-computation and
+structural requirements from the original algorithm. Jess was further
 updated and maintained by [Ioannis Riziotis](https://github.com/iriziotis)
 during his PhD in the [Thornton group](https://www.ebi.ac.uk/research/thornton/).
 
@@ -105,34 +106,44 @@ as well as the code required to compile from source with Cython:
 $ pip install pyjess
 ```
 
-<!-- Otherwise, PyJess is also available as a [Bioconda](https://bioconda.github.io/)
+Otherwise, PyJess is also available as a [Bioconda](https://bioconda.github.io/)
 package:
 ```console
 $ conda install -c bioconda pyjess
-``` -->
+```
 
 Check the [*install* page](https://pyjess.readthedocs.io/en/stable/install.html)
 of the documentation for other ways to install PyJess on your machine.
 
+
+## 🔖 Citation
+
+PyJess is scientific software, and builds on top of Jess. Please cite
+Jess if you are using it in an academic work, for instance as:
+
+> PyJess, a Python library binding to Jess (Barker *et al.*, 2003).
+
+
 ## 💡 Example
 
 Load templates to be used as references from different template files:
 
 ```python
-import glob
+import pathlib
 import pyjess
 
 templates = []
-for path in sorted(glob.iglob("vendor/jess/examples/template_*.qry")):
-    templates.append(Template.load(path, id=os.path.basename(path)))
+for path in sorted(pathlib.Path("vendor/jess/examples").glob("template_*.qry")):
+    with path.open() as file:
+        templates.append(pyjess.Template.load(file, id=path.stem))
 ```
 
 Create a `Jess` instance and use it to query a molecule (a PDB structure)
 against the stored templates:
 
 ```python
-jess = Jess(templates)
-mol = Molecule("vendor/jess/examples/test_pdbs/pdb1a0p.ent")
+jess = pyjess.Jess(templates)
+mol = pyjess.Molecule.load("vendor/jess/examples/test_pdbs/pdb1a0p.ent")
 query = jess.query(mol, rmsd_threshold=2.0, distance_cutoff=3.0, max_dynamic_distance=3.0)
 ```
 
@@ -162,7 +173,7 @@ with multiprocessing.ThreadPool() as pool:
     hits = pool.map(jess.query, molecules)
 ```
 
-*⚠️ Prior to PyJess `v0.2.1`, the Jess code was running some thread-unsafe operations which have now been patched. 
+*⚠️ Prior to PyJess `v0.2.1`, the Jess code was running some thread-unsafe operations which have now been patched.
 If running Jess in parallel, make sure to use `v0.2.1` or later to use the code patched with re-entrant functions*.
 
 <!-- ## ⏱️ Benchmarks -->

{pyjess-0.4.0.dist-info → pyjess-0.5.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
 pyjess/.gitignore,sha256=u14v4OOy8U50Kp9SUKU8DupCG-mQIuel47gdbNDmAwg,21
 pyjess/__init__.py,sha256=Xe9GBQUBm9ik-ty5tcE3UQ9Ip1p-C_IGvTPuGULolng,766
-pyjess/_jess.pyi,sha256=DD1ZMKSbgCBKPiTVZc8ojmkYJcgjSESqyMIHIqL1exg,7110
-pyjess/_jess.pypy37-pp73-win_amd64.pyd,sha256=mPgyG7W9kpSlP05W8_fJtHtrIQRw4hs6xnTH2kldjWU,236544
-pyjess/_jess.pyx,sha256=pU8KKFLyRHGwieDmG9AZNhCuctGCti3BkrOW-NyW-gM,48525
+pyjess/_jess.pyi,sha256=oWlqpqnhOKFcq2UCpGJrUJaZZF1ZlLodKxINwoR3vrw,7118
+pyjess/_jess.pypy37-pp73-win_amd64.pyd,sha256=nOid-PzdGDGaCBnLr9SFpIDfnP0OaQYzqA4n6U3ZQtQ,240640
+pyjess/_jess.pyx,sha256=rC2Dd_mNy4OhlN7QtQv0IZE7Q82TlXKkpq82v-gCiZY,51537
 pyjess/CMakeLists.txt,sha256=H9eXbrFcGF2OLP8muQctb4cOb27Qp2uZj5KRjoDAROg,36
 pyjess/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyjess/tests/__init__.py,sha256=h83kBzYKH_i1InkM8mOA23zE3PBaB9lrNDCuhC8LOl4,544
@@ -13,13 +13,13 @@ pyjess/tests/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 pyjess/tests/data/pdb1lnb.pdb,sha256=F8A6OdRly5c-pxsDw1LjTFINI75r1HaKaYB_eXv1QuM,273388
 pyjess/tests/data/template_01.qry,sha256=izCIhUUTEk-IvQowhSVLiJaCAhpPbyvrfyoR4Q6-Pm0,616
 pyjess/tests/data/template_02.qry,sha256=5IYRTqsvO_roB2INLwfFDEaWJW9VRcXdbK4oe8VKMxE,618
-pyjess/tests/test_atom.py,sha256=UJhb9VJR4Hm6g0eIlkypnnUf3jcGC6csbGuTL7VGF30,4449
-pyjess/tests/test_jess.py,sha256=XItj6F0XBe_cmsRmgGnyu81wah6bVdfFXEcmO2EZRg0,8686
-pyjess/tests/test_molecule.py,sha256=lT9ZdW1aWrrQR95iRBET3NJYIKlNT3IiRMadD_RUSgs,4879
-pyjess/tests/test_template.py,sha256=LJGKHc7BzDdl42nHVF0-6m92alBogWXQneeE0tkobQQ,3986
-pyjess/tests/test_template_atom.py,sha256=W6Iruh7f4gNiohkTHN1hcjDBByWiYTlyXcGmD_I-Pdw,2992
+pyjess/tests/test_atom.py,sha256=clLN9IVuivadztGtagDhdPBDGoMkUgs41lEWuTCCmFA,4741
+pyjess/tests/test_jess.py,sha256=kBmsFAl7tmCAFamk3JqGAwttI6SJiAl3aLJUO-9FmOA,9976
+pyjess/tests/test_molecule.py,sha256=9k6uiTeOWc5NiO7epyxY9lm_GgksPb7-o-ZcNFNxutw,5452
+pyjess/tests/test_template.py,sha256=AIN-ba5-YTnGdT9SGPU4q45AZ03QnPE769WyItSpoPs,4657
+pyjess/tests/test_template_atom.py,sha256=oK8cfKe4_k3Pm1PqoTTxTzAoeUVLiCFsg6QmiTQ-RCQ,3496
 pyjess/tests/utils.py,sha256=Z7rUPC-D8dZlRfHAnLaXHUg6M10D3zFvNiwDvvHA3xc,202
-pyjess-0.4.0.dist-info/METADATA,sha256=vaDoU5JzpxXjRTl-M43Stw7evHX75QHWTexO_TF7_DE,10785
-pyjess-0.4.0.dist-info/WHEEL,sha256=GcwMogo_AzsTpUmdn3_tpF9yY9Mv6Ok8VFrdrPp_Aoc,111
-pyjess-0.4.0.dist-info/licenses/COPYING,sha256=WpSMpnu8fCvYt4QNIp0SCsWgeXIRr1KEXBfqiPwrPZ4,1119
-pyjess-0.4.0.dist-info/RECORD,,
+pyjess-0.5.0.dist-info/METADATA,sha256=qsP6LSYDn0V3i8bpx2KZw3w8pmH5zad6gIAnjfL053o,11121
+pyjess-0.5.0.dist-info/WHEEL,sha256=GcwMogo_AzsTpUmdn3_tpF9yY9Mv6Ok8VFrdrPp_Aoc,111
+pyjess-0.5.0.dist-info/licenses/COPYING,sha256=Iyx2bRDPnLgoEzW2KVanb61cjhW8lnhJNU-mjS-KhIY,1124
+pyjess-0.5.0.dist-info/RECORD,,

{pyjess-0.4.0.dist-info → pyjess-0.5.0.dist-info}/licenses/COPYING

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Martin Larralde <martin.larralde@embl.de>
+Copyright (c) 2024-2025 Martin Larralde <martin.larralde@embl.de>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal