pyjess 0.3.3__cp312-cp312-macosx_10_13_x86_64.whl → 0.4.1__cp312-cp312-macosx_10_13_x86_64.whl

pyjess/_jess.pyi

@@ -1,6 +1,6 @@
 import os
 import typing
-from typing import Any, Generic, Union, Optional, Sequence, Iterator, Iterable, List, TextIO, Sized, TypeVar
+from typing import Any, Generic, Union, Optional, Sequence, Iterator, Iterable, List, TextIO, Sized, TypeVar, Tuple
 
 try:
     from typing import Literal
@@ -13,6 +13,8 @@ MATCH_MODE = Literal[
 
 _SELF = TypeVar("_SELF")
 
+__version__: str
+
 class Molecule(Sequence[Atom]):
     @classmethod
     def load(cls, file: Union[TextIO, str, os.PathLike[str]], id: Optional[str] = None, ignore_endmdl: bool = False) -> Molecule: ...
@@ -26,9 +28,14 @@ class Molecule(Sequence[Atom]):
     def __getitem__(self: _SELF, index: slice) -> _SELF: ...
     @typing.overload
     def __getitem__(self: _SELF, index: Union[int, slice]) -> Union[Atom, _SELF]: ...
+    def __copy__(self) -> Molecule: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __reduce__(self) -> Tuple[Any, ...]: ...
     @property
     def id(self) -> Optional[str]: ...
     def conserved(self: _SELF, cutoff: float = 0.0) -> _SELF: ...
+    def copy(self) -> Molecule: ...
 
 class Atom:
     @classmethod
@@ -54,7 +61,11 @@ class Atom:
         element: str = "",
         charge: int = 0,
     ): ...
+    def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __reduce__(self) -> Tuple[Any, ...]: ...
     def __repr__(self) -> str: ...
+    def __copy__(self) -> Atom: ...
     @property
     def serial(self) -> int: ...
     @property
@@ -85,6 +96,7 @@ class Atom:
     def y(self) -> float: ...
     @property
     def z(self) -> float: ...
+    def copy(self) -> Atom: ...
 
 class TemplateAtom:
     @classmethod
@@ -105,6 +117,10 @@ class TemplateAtom:
         match_mode: MATCH_MODE = 0,
     ): ...
     def __repr__(self) -> str: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __reduce__(self) -> Tuple[Any, ...]: ...
+    def __copy__(self: _SELF) -> _SELF: ...
     @property
     def match_mode(self) -> MATCH_MODE: ...
     @property
@@ -118,11 +134,12 @@ 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: ...
 
 class Template(Sequence[TemplateAtom]):
     @classmethod
@@ -137,10 +154,15 @@ class Template(Sequence[TemplateAtom]):
     def __getitem__(self: _SELF, index: slice) -> _SELF: ...
     @typing.overload
     def __getitem__(self: _SELF, index: Union[int, slice]) -> Union[TemplateAtom, _SELF]: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __reduce__(self) -> Tuple[Any, ...]: ...
+    def __copy__(self) -> Template: ...
     @property
     def id(self) -> str: ...
     @property
     def dimension(self) -> int: ...
+    def copy(self) -> Template: ...
 
 _T = TypeVar("_T", bound=Template)
 
@@ -184,6 +206,10 @@ class Jess(Generic[_T], Sequence[_T]):
     def __getitem__(self, index: slice) -> Jess[_T]: ...
     @typing.overload
     def __getitem__(self, index: Union[int, slice]) -> Union[_T, Jess[_T]]: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __copy__(self: _SELF) -> _SELF: ...
+    def __reduce__(self) -> Tuple[Any, ...]: ...
     def query(
         self,
         molecule: Molecule,

pyjess/_jess.pyx

@@ -43,7 +43,9 @@ from jess.tess_atom cimport TessAtom as _TessAtom
 # --- Python imports ---------------------------------------------------------
 
 import contextlib
+import functools
 import io
+import itertools
 import os
 import warnings
 
@@ -53,10 +55,11 @@ __version__ = PROJECT_VERSION
 
 cdef inline void copy_token(char* dst, const char* src, size_t n) noexcept nogil:
     cdef size_t i
-    strncpy(dst, src, n)
     for i in range(n):
-        if dst[i] == ord(' ') or dst[i] == 0:
+        if src[i] == ord(' ') or src[i] == 0:
             dst[i] = ord('_')
+        else:
+            dst[i] = src[i]
     dst[n] = 0
 
 @contextlib.contextmanager
@@ -68,9 +71,12 @@ def nullcontext(return_value=None):
 cdef class Molecule:
     """A molecule structure, as a sequence of `Atom` objects.
 
-    .. versionchanged:: 0.2.2
+    .. versionadded:: 0.2.2
        Support identifiers of arbitrary length.
 
+    .. versionadded:: 0.4.0
+       Equality, hashing and pickle protocol support.
+
     """
     cdef _Molecule* _mol
     cdef str        _id
@@ -204,6 +210,26 @@ cdef class Molecule:
             atom._atom = <_Atom*> jess.molecule.Molecule_atom(self._mol, index_)
             return atom
 
+    def __copy__(self):
+        return self.copy()
+
+    def __eq__(self, object other):
+        cdef Molecule other_
+        if not isinstance(other, Molecule):
+            return NotImplemented
+        other_ = other
+        if self._id != other_._id:
+            return False
+        if self._mol.count != other_._mol.count:
+            return False
+        return all(x == y for x,y in zip(self, other_))
+
+    def __hash__(self):
+        return hash((self._id, *(hash(x) for x in self)))
+
+    def __reduce__(self):
+        return type(self), (list(self), self.id)
+
     def __sizeof__(self):
         assert self._mol is not NULL
         return (
@@ -229,9 +255,44 @@ cdef class Molecule:
             ]
         )
 
+    cpdef Molecule copy(self):
+        """Create a copy of this molecule and its atoms.
+
+        Returns:
+            `~pyjess.Molecule`: A newly allocated molecule with the same
+            identifier and atoms.
+
+        .. versionadded:: 0.4.0
+
+        """
+        cdef Molecule copy = Molecule.__new__(Molecule)
+        cdef size_t   size = sizeof(_Molecule) + self._mol.count * sizeof(_Atom*)
+
+        with nogil:
+            # allocate molecule storage
+            copy._mol = <_Molecule*> malloc(size)
+            if copy._mol is NULL:
+                raise MemoryError("Failed to allocate molecule")
+            # copy molecule attributes
+            copy._mol.count = self._mol.count
+            memset(copy._mol.id, b' ', 5)
+            # copy molecule atoms
+            for i in range(self._mol.count):
+                copy._mol.atom[i] = <_Atom*> malloc(sizeof(_Atom))
+                if copy._mol.atom[i] is NULL:
+                    raise MemoryError("Failed to allocate atom")
+                memcpy(copy._mol.atom[i], self._mol.atom[i], sizeof(_Atom))
+
+        copy._id = self._id
+        return copy
+
 
 cdef class Atom:
     """A single atom in a molecule.
+
+    .. versionadded:: 0.4.0
+       Equality, hashing and pickle protocol support.
+
     """
     cdef object owner
     cdef bint   owned
@@ -297,11 +358,11 @@ cdef class Atom:
         str chain_id,
         int residue_number,
         str insertion_code,
-        float x,
-        float y,
-        float z,
-        float occupancy = 0.0,
-        float temperature_factor = 0.0,
+        double x,
+        double y,
+        double z,
+        double occupancy = 0.0,
+        double temperature_factor = 0.0,
         str segment = '',
         str element = '',
         int charge = 0,
@@ -336,7 +397,7 @@ cdef class Atom:
         self._atom.serial = serial
         self._atom.altLoc = ord(altloc)
         self._atom.chainID1 = ord(chain_id[0]) if len(chain_id) > 0 else 0
-        self._atom.chainID2 = ord(chain_id[1]) if len(chain_id) > 1 else ord('0')
+        self._atom.chainID2 = ord(chain_id[1]) if len(chain_id) > 1 else ord(' ')
         self._atom.resSeq = residue_number
         self._atom.iCode = ord(insertion_code)
         self._atom.x[0] = x
@@ -354,29 +415,38 @@ cdef class Atom:
             _name.insert(0, ord('_'))
         copy_token(self._atom.name, _name.ljust(4, b'\0'), 4)
 
+    def __copy__(self):
+        return self.copy()
+
+    cdef dict _state(self):
+        return {
+            "serial": self.serial,
+            "name": self.name,
+            "altloc": self.altloc,
+            "residue_name": self.residue_name,
+            "chain_id": self.chain_id,
+            "residue_number": self.residue_number,
+            "insertion_code": self.insertion_code,
+            "x": self.x,
+            "y": self.y,
+            "z": self.z,
+            "temperature_factor": self.temperature_factor,
+            "occupancy": self.occupancy,
+            "segment": self.segment,
+            "element": self.element,
+            "charge": self.charge,
+        }
+
+    def __reduce__(self):
+        cdef dict state = self._state()
+        return functools.partial(type(self), **state), ()
+
     def __repr__(self):
         cdef str  ty   = type(self).__name__
-        cdef list args = [
-            f"serial={self.serial!r}",
-            f"name={self.name!r}",
-            f"altloc={self.altloc!r}",
-            f"residue_name={self.residue_name!r}",
-            f"chain_id={self.chain_id!r}",
-            f"residue_number={self.residue_number!r}",
-            f"x={self.x!r}",
-            f"y={self.y!r}",
-            f"z={self.z!r}",
-            f"segment={self.segment!r}",
-            f"insertion_code={self.insertion_code!r}",
-        ]
-        if self.occupancy:
-            args.append(f"occupancy={self.occupancy!r}")
-        if self.temperature_factor:
-            args.append(f"temperature_factor={self.temperature_factor!r}")
-        if self.element:
-            args.append(f"element={self.element!r}")
-        if self.charge:
-            args.append(f"charge={self.charge!r}")
+        cdef list args = []
+        for k,v in self._state().items():
+            if v is not None:
+                args.append(f"{k}={v!r}")
         return f"{ty}({', '.join(args)})"
 
     def __sizeof__(self):
@@ -385,6 +455,17 @@ cdef class Atom:
             size += sizeof(_Atom)
         return size
 
+    def __eq__(self, object other):
+        cdef Atom other_
+        if not isinstance(other, Atom):
+            return NotImplemented
+        other_ = other
+        # FIXME: it should be possible to do a memcmp here.
+        return self._state() == other_._state()  
+
+    def __hash__(self):
+        return hash(tuple(self._state().values()))
+
     @property
     def serial(self):
         """`int`: The atom serial number.
@@ -484,9 +565,29 @@ cdef class Atom:
         assert self._atom is not NULL
         return self._atom.x[2]
 
+    cpdef Atom copy(self):
+        """Create a copy of this atom.
+
+        Returns:
+            `~pyjess.Atom`: A newly allocated atom with identical attributes.
+
+        .. versionadded:: 0.4.0
+
+        """
+        cdef Atom copy = Atom.__new__(Atom)
+        copy._atom = <_Atom*> malloc(sizeof(_Atom))
+        if copy._atom is NULL:
+            raise MemoryError("Failed to allocate atom")
+        memcpy(copy._atom, self._atom, sizeof(_Atom))
+        return copy
+
 
 cdef class TemplateAtom:
     """A single template atom.
+
+    .. versionadded:: 0.4.0
+       Equality, hashing and pickle protocol support.
+
     """
     cdef object     owner
     cdef bint       owned
@@ -630,23 +731,42 @@ cdef class TemplateAtom:
                 raise ValueError(f"Invalid residue name: {name!r}")
             copy_token(self._atom.resName[m], _name.ljust(3, b'\0'), 3)
 
+    cdef dict _state(self):
+        return {
+            "chain_id": self.chain_id,
+            "residue_number": self.residue_number,
+            "x": self.x,
+            "y": self.y,
+            "z": self.z,
+            "residue_names": self.residue_names,
+            "atom_names": self.atom_names,
+            "distance_weight": self.distance_weight,
+            "match_mode": self.match_mode,
+        }
+
     def __repr__(self):
         cdef str  ty   = type(self).__name__
-        cdef list args = [
-            f"chain_id={self.chain_id!r}",
-            f"residue_number={self.residue_number!r}",
-            f"x={self.x!r}",
-            f"y={self.y!r}",
-            f"z={self.z!r}",
-            f"residue_names={self.residue_names!r}",
-            f"atom_names={self.atom_names!r}",
-        ]
-        if self.distance_weight:
-            args.append(f"distance_weight={self.distance_weight!r}")
-        if self.match_mode:
-            args.append(f"match_mode={self.match_mode!r}")
+        cdef list args = []
+        for k, v in self._state().items():
+            args.append(f"{k}={v!r}")
         return f"{ty}({', '.join(args)})"
 
+    def __copy__(self):
+        return self.copy()
+
+    def __eq__(self, object other):
+        cdef TemplateAtom other_
+        if not isinstance(other, TemplateAtom):
+            return NotImplemented
+        other_ = other
+        return self._state() == other_._state()
+
+    def __hash__(self):
+        return hash(tuple(self._state().values()))
+
+    def __reduce__(self):
+        return functools.partial(type(self), **self._state()), ()
+
     def __sizeof__(self):
         assert self._atom is not NULL
 
@@ -708,7 +828,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
 
@@ -717,11 +841,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
 
@@ -730,7 +858,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):
@@ -739,9 +867,25 @@ cdef class TemplateAtom:
         assert self._atom is not NULL
         return self._atom.distWeight
 
+    cpdef TemplateAtom copy(self):
+        """Create a copy of this template atom.
+
+        Returns:
+            `~pyjess.TemplateAtom`: A new template atom object with 
+            identical attributes.
+            
+        .. versionadded:: 0.4.0
+        
+        """
+        return type(self)(**self._state())
+
 
 cdef class Template:
     """A template, as a sequence of `TemplateAtom` objects.
+
+    .. versionadded:: 0.4.0
+       Equality, hashing and pickle protocol support.
+
     """
     cdef object         owner
     cdef bint           owned
@@ -858,6 +1002,9 @@ cdef class Template:
         residues = { self._tess.atom[i].resSeq for i in range(count) }
         self._tess.dim = len(residues)
 
+    def __copy__(self):
+        return self.copy()
+
     def __len__(self):
         assert self._tpl is not NULL
         return self._tess.count
@@ -884,6 +1031,28 @@ cdef class Template:
             atom._atom = self._tess.atom[index_]
             return atom
 
+    def __eq__(self, object other):
+        cdef Template other_
+        if not isinstance(other, Template):
+            return NotImplemented
+        other_ = other
+        if self.id != other_.id:
+            return False
+        if self.dimension != other_.dimension:
+            return False
+        if len(self) != len(other_):
+            return False
+        return all(x == y for x,y in zip(self, other_))
+
+    def __hash__(self):
+        return hash((
+            self.id,
+            *(hash(x) for x in self)
+        ))
+
+    def __reduce__(self):
+        return type(self), (list(self), self.id)
+
     def __sizeof__(self):
         assert self._tess is not NULL
 
@@ -927,6 +1096,12 @@ cdef class Template:
         assert self._tess is not NULL
         return self._tess.dim
 
+    cpdef Template copy(self):
+        return Template(
+            self,
+            self.id
+        )
+
 
 cdef class Query:
     """A query over templates with a given molecule.
@@ -1177,10 +1352,14 @@ cdef class Hit:
 
 cdef class Jess:
     """A handle to run Jess over a list of templates.
+
+    .. versionadded:: 0.4.0
+       Equality, hashing and pickle protocol support.
+
     """
     cdef _Jess* _jess
     cdef dict   _indices
-    cdef list   _templates
+    cdef tuple  _templates
     cdef size_t length
 
     def __cinit__(self):
@@ -1208,10 +1387,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
@@ -1219,9 +1398,27 @@ 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()
+
+    def __reduce__(self):
+        return type(self), (self._templates,)
+
+    def __eq__(self, object other):
+        cdef Jess other_
+        if not isinstance(other, Jess):
+            return NotImplemented
+        other_ = other
+        return self._templates == other_._templates
+
+    def __hash__(self):
+        return hash((Jess, self._templates))
+
     def __len__(self):
         return self.length
 
@@ -1239,6 +1436,17 @@ cdef class Jess:
                 raise IndexError(index)
             return self._templates[index_]
 
+    cpdef Jess copy(self):
+        """Create a copy of the `Jess` object.
+
+        Returns:
+            `~pyjess.Jess`: A `Jess` object containing the same templates.
+
+        .. versionadded:: 0.4.0
+
+        """
+        return type(self)(self._templates)
+
     def query(
         self,
         Molecule molecule,

pyjess/tests/test_atom.py

@@ -1,4 +1,6 @@
+import ctypes
 import unittest
+import pickle
 
 from .._jess import Atom
 
@@ -25,6 +27,25 @@ class TestAtom(unittest.TestCase):
         self.assertEqual(atom.segment, '')
         self.assertEqual(atom.element, 'C')
         self.assertEqual(atom.charge, 0)
+
+    def test_init_consistency(self):
+        loaded = Atom.loads("ATOM     39  CA  PRO A 469     -14.948   2.091  10.228  1.00 27.71           C")
+        created = Atom(
+            serial=loaded.serial,
+            name=loaded.name,
+            residue_name=loaded.residue_name,
+            chain_id=loaded.chain_id,
+            altloc=loaded.altloc,
+            insertion_code=loaded.insertion_code,
+            residue_number=loaded.residue_number,
+            x=loaded.x,
+            y=loaded.y,
+            z=loaded.z,
+            occupancy=loaded.occupancy,
+            temperature_factor=loaded.temperature_factor,
+            element=loaded.element,
+        )
+        self.assertEqual(loaded, created)
         
     def test_init_invalid_chain_id(self):
         self.assertRaises(ValueError, self._create_atom, chain_id="too long")
@@ -35,6 +56,22 @@ class TestAtom(unittest.TestCase):
     def test_init_invalid_residue_name(self):
         self.assertRaises(ValueError, self._create_atom, residue_name="too long")
 
+    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)
+
     def test_repr_roundtrip(self):
         atom = self._create_atom()
         copy = eval(repr(atom))
@@ -51,4 +88,24 @@ class TestAtom(unittest.TestCase):
         self.assertEqual(atom.charge, copy.charge)
         self.assertEqual(atom.x, copy.x)
         self.assertEqual(atom.y, copy.y)
-        self.assertEqual(atom.z, copy.z)
+        self.assertEqual(atom.z, copy.z)
+        self.assertEqual(atom, copy)
+
+    def test_pickle_roundtrip(self):
+        atom = self._create_atom()
+        copy = pickle.loads(pickle.dumps(atom))
+        self.assertEqual(atom.serial, copy.serial)
+        self.assertEqual(atom.altloc, copy.altloc)
+        self.assertEqual(atom.name, copy.name)
+        self.assertEqual(atom.residue_name, copy.residue_name)
+        self.assertEqual(atom.residue_number, copy.residue_number)
+        self.assertEqual(atom.element, copy.element)
+        self.assertEqual(atom.insertion_code, copy.insertion_code)
+        self.assertEqual(atom.chain_id, copy.chain_id)
+        self.assertEqual(atom.occupancy, copy.occupancy)
+        self.assertEqual(atom.temperature_factor, copy.temperature_factor)
+        self.assertEqual(atom.charge, copy.charge)
+        self.assertEqual(atom.x, copy.x)
+        self.assertEqual(atom.y, copy.y)
+        self.assertEqual(atom.z, copy.z)
+        self.assertEqual(atom, copy)

pyjess/tests/test_jess.py

@@ -1,6 +1,7 @@
 import math
 import unittest
 import sys
+import pickle
 
 from .._jess import Template, Molecule, Jess
 from .utils import files
@@ -20,6 +21,59 @@ 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:
+            template1 = Template.load(f)
+        with files(data).joinpath("template_02.qry").open() as f:
+            template2 = Template.load(f)
+        jess = Jess([template1, template2])
+        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:
+            template1 = Template.load(f)
+        with files(data).joinpath("template_02.qry").open() as f:
+            template2 = Template.load(f)
+        jess = Jess([template1, template2])
+        copy = pickle.loads(pickle.dumps(jess))
+        self.assertEqual(jess, copy)
+
     @unittest.skipUnless(sys.implementation.name == "cpython", "only available on CPython")
     @unittest.skipUnless(files, "importlib.resources not available")
     def test_sizeof(self):

pyjess/tests/test_molecule.py

@@ -1,4 +1,5 @@
 import os
+import pickle
 import unittest
 import tempfile
 import textwrap
@@ -83,4 +84,58 @@ class TestMolecule(unittest.TestCase):
         self.assertEqual(mol2.id, mol.id)
         self.assertEqual(len(mol2), 2)
         self.assertEqual(mol2[0].name, "CA")
-        self.assertEqual(mol2[1].name, "C")
+        self.assertEqual(mol2[1].name, "C")
+
+    def test_hash(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(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 = [
+            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 = mol1.copy()
+        self.assertEqual(list(mol1), list(mol2))
+        self.assertEqual(mol1.id, mol2.id)
+        self.assertEqual(mol1, mol2)
+
+    def test_pickle_roundtrip(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 = pickle.loads(pickle.dumps(mol1))
+        self.assertEqual(list(mol1), list(mol2))
+        self.assertEqual(mol1.id, mol2.id)
+        self.assertEqual(mol1, mol2)

pyjess/tests/test_template.py

@@ -1,4 +1,5 @@
 import os
+import pickle
 import unittest
 import tempfile
 import textwrap
@@ -29,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)
 
@@ -41,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)
 
@@ -54,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)
 
@@ -85,3 +86,32 @@ class TestTemplate(unittest.TestCase):
         tpl1 = Template.loads(TEMPLATE, id="tpl1")
         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()
+        self.assertEqual(len(tpl1), len(tpl2))
+        self.assertEqual(tpl1, 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)

pyjess/tests/test_template_atom.py

@@ -1,5 +1,6 @@
 import unittest
 import sys
+import pickle
 
 from .._jess import TemplateAtom
 
@@ -9,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)
@@ -31,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()
@@ -43,8 +60,33 @@ class TestTemplateAtom(unittest.TestCase):
     def test_init_invalid_residue_name(self):
         self.assertRaises(ValueError, self._create_atom, residue_names=["something"])
 
+    def test_init_consistency(self):
+        loaded = TemplateAtom.loads("ATOM      1  NE  ARG A1136       3.953   0.597  -1.721 K")
+        created = TemplateAtom(
+            chain_id=loaded.chain_id, 
+            residue_number=loaded.residue_number,
+            x=loaded.x,
+            y=loaded.y,
+            z=loaded.z,
+            residue_names=loaded.residue_names,
+            atom_names=loaded.atom_names,
+            distance_weight=loaded.distance_weight,
+            match_mode=loaded.match_mode
+        )
+        for attribute in ("atom_names", "residue_names", "chain_id", "x", "y", "z", "match_mode"):
+            self.assertEqual(getattr(loaded, attribute), getattr(created, attribute))
+        self.assertEqual(loaded, created)
+
     def test_repr_roundtrip(self):
         atom = self._create_atom()
         copy = eval(repr(atom))
         for attribute in ("atom_names", "residue_names", "chain_id", "x", "y", "z", "match_mode"):
-            self.assertEqual(getattr(copy, attribute), getattr(atom, attribute))
+            self.assertEqual(getattr(copy, attribute), getattr(atom, attribute))
+        self.assertEqual(atom, copy)
+
+    def test_pickle_roundtrip(self):
+        atom = self._create_atom()
+        copy = pickle.loads(pickle.dumps(atom))
+        for attribute in ("atom_names", "residue_names", "chain_id", "x", "y", "z", "match_mode"):
+            self.assertEqual(getattr(copy, attribute), getattr(atom, attribute))
+        self.assertEqual(atom, copy)

{pyjess-0.3.3.dist-info → pyjess-0.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyjess
-Version: 0.3.3
+Version: 0.4.1
 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>
@@ -25,7 +25,7 @@ License: MIT License
         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
         SOFTWARE.
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License

{pyjess-0.3.3.dist-info → pyjess-0.4.1.dist-info}/RECORD

@@ -1,21 +1,21 @@
-pyjess-0.3.3.dist-info/RECORD,,
-pyjess-0.3.3.dist-info/WHEEL,sha256=Vqw9orcNesD9-KuxFaWjC_hI-wCEiyMbR5lwnn6Nrrk,116
-pyjess-0.3.3.dist-info/METADATA,sha256=wjCjJAgH4YolUjgoysZ9FIIPDcWeXQcNs7MY6nWp1Bc,10786
-pyjess-0.3.3.dist-info/licenses/COPYING,sha256=W3hXwpT6UtiSFrO8yeDddZLU5tKIAX238e0N5slPQGA,1098
-pyjess/_jess.cpython-312-darwin.so,sha256=p8lu0QGZh0yF48E7nHc7gL0z1GLSTMWHooH8XDkfzF4,276504
-pyjess/_jess.pyi,sha256=kpvEKrznUbXs-q8RDiIWZmX8y55AE_ugrGR45a4SpD0,5849
+pyjess-0.4.1.dist-info/RECORD,,
+pyjess-0.4.1.dist-info/WHEEL,sha256=Vqw9orcNesD9-KuxFaWjC_hI-wCEiyMbR5lwnn6Nrrk,116
+pyjess-0.4.1.dist-info/METADATA,sha256=iHTTiJz29i7uRreAEeB_ow4-DArxSGb5Nz2Y9N4RblQ,10785
+pyjess-0.4.1.dist-info/licenses/COPYING,sha256=W3hXwpT6UtiSFrO8yeDddZLU5tKIAX238e0N5slPQGA,1098
+pyjess/_jess.cpython-312-darwin.so,sha256=sZ3A5-0GA_fOJVkkFESSJavV_k-DUKWh3XIJu0lggeA,313944
+pyjess/_jess.pyi,sha256=QIQSeQgNG-w0QZTuvacHjnv3IlEfV-3AOll9To3ZdM4,6899
 pyjess/CMakeLists.txt,sha256=Oa0pniEQx9jXyFCJGyrswn9ahWSSVuW1madyeP6StoI,35
 pyjess/__init__.py,sha256=h4XXLdS4FnyVa-MBs_k3eZMG1jWxeiOJnwfBaJA9gyQ,745
 pyjess/.gitignore,sha256=uQBOufp4v50qn0aZKv6zbSo00cjfB-v9KySog7rlmIU,19
-pyjess/_jess.pyx,sha256=EV6aLunqq8lmqXd5o0p_04YN6LmZJx8Td76Ep44ZSus,41745
+pyjess/_jess.pyx,sha256=E7D4tvgjnGo9q-YdWGdO-r472NdJanUEs8hYbB6rBaM,47303
 pyjess/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyjess/tests/__init__.py,sha256=MdHWtr6A8S4TBWlkoj4olFK2FXAGc5uJdbWtgFrDLpk,528
-pyjess/tests/test_molecule.py,sha256=i9nWe7RRw06hND9rtGUkjIHzfAz3ZVKH0GVT1PjfK04,3407
+pyjess/tests/test_molecule.py,sha256=RHBE0yL_j71nQOwXJ6t_PzkZi4BaFPY5Q0VwKWM6elk,5311
 pyjess/tests/utils.py,sha256=dsaphex7qomJCvSHWnVy79iYDPGiL59xqGAtRoVAeWc,196
-pyjess/tests/test_atom.py,sha256=RziIlTWteOVawhbRPTmcBDGjf6FrSlInqnMQLR9UDQY,2450
-pyjess/tests/test_jess.py,sha256=bWPsEGcNqr3gjj6iWqdwGX8IT5jaTTkTexOKhMPHWvw,7619
-pyjess/tests/test_template.py,sha256=WM5DRvFxa8NEUl_U4PWppsFq2Dw6pZQskbnCu6jgZm8,3465
-pyjess/tests/test_template_atom.py,sha256=diQ9TCsStLeUkk4lUHkL-oQZWgMzDhW_LMnjik5MM1Y,1781
+pyjess/tests/test_atom.py,sha256=omNznNbRXMDt2j1plAUlfWPGCfmtkYpj2jysEX1zQuY,4631
+pyjess/tests/test_jess.py,sha256=mgHx6kDW5yzdvZiiybAVrd1J4k3Li3r-t4le6RFEE5o,9757
+pyjess/tests/test_template.py,sha256=XMLELYRB4j7xavziZ-ntq15PjhNHNfJJkctUq9BkvEI,4541
+pyjess/tests/test_template_atom.py,sha256=s9tJ_SAgvKeGwbVjaTWY-EtsUeQp3eu4NF5ja3oO_84,3405
 pyjess/tests/data/pdb1lnb.pdb,sha256=E9Jjy4qQ75O1UKIXcVyVJHE1XDNx1Rb7ENPVrehW6N8,270054
 pyjess/tests/data/1AMY.pdb,sha256=t2CaGLdOyPrhyeMpe1TbwZ8u7QmfxCIG1Pit8-vzvgo,319221
 pyjess/tests/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0