pdbnucleicacids 0.1.0__tar.gz

pdbnucleicacids-0.1.0/AUTHORS.rst

@@ -0,0 +1,13 @@
+=======
+Credits
+=======
+
+Development Lead
+----------------
+
+* Alessandro Pandolfi <alessandro.pandolfi@protonmail.com>
+
+Contributors
+------------
+
+None yet. Why not be the first?

pdbnucleicacids-0.1.0/CONTRIBUTING.rst

@@ -0,0 +1,135 @@
+.. highlight:: shell
+
+============
+Contributing
+============
+
+Contributions are welcome, and they are greatly appreciated! Every little bit
+helps, and credit will always be given.
+
+You can contribute in many ways:
+
+Types of Contributions
+----------------------
+
+Report Bugs
+~~~~~~~~~~~
+
+Report bugs at https://gitlab.com/MorfeoRenai/pdbnucleicacids/-/issues
+
+If you are reporting a bug, please include:
+
+* Your operating system name and version.
+* Any details about your local setup that might be helpful in troubleshooting.
+* Detailed steps to reproduce the bug.
+
+Fix Bugs
+~~~~~~~~
+
+Look through the GitHub issues for bugs. Anything tagged with "bug" and "help
+wanted" is open to whoever wants to implement it.
+
+Implement Features
+~~~~~~~~~~~~~~~~~~
+
+Look through the GitHub issues for features. Anything tagged with "enhancement"
+and "help wanted" is open to whoever wants to implement it.
+
+Write Documentation
+~~~~~~~~~~~~~~~~~~~
+
+PDBNucleicAcids could always use more documentation, whether as part of the
+official PDBNucleicAcids docs, in docstrings, or even on the web in blog posts,
+articles, and such.
+
+Submit Feedback
+~~~~~~~~~~~~~~~
+
+The best way to send feedback is to file an issue at https://gitlab.com/MorfeoRenai/pdbnucleicacids/-/issues
+
+If you are proposing a feature:
+
+* Explain in detail how it would work.
+* Keep the scope as narrow as possible, to make it easier to implement.
+* Remember that this is a volunteer-driven project, and that contributions
+  are welcome :)
+
+Get Started!
+------------
+
+Ready to contribute? Here's how to set up `pdbnucleicacids` for local development.
+
+1. Fork the `pdbnucleicacids` repo on GitHub.
+2. Clone your fork locally::
+
+    $ git clone git@gitlab.com:your_name_here/pdbnucleicacids.git
+
+3. Install your local copy into a virtualenv. Assuming you have virtualenvwrapper installed, this is how you set up your fork for local development::
+
+    $ mkvirtualenv pdbnucleicacids
+    $ cd pdbnucleicacids/
+    $ pip install -r requirements-dev.txt
+
+4. Create a branch for local development::
+
+    $ git checkout -b name-of-your-bugfix-or-feature
+
+   Now you can make your changes locally.
+
+5. When you're done making changes, check that your changes pass flake8 and the
+   tests, including testing other Python versions with tox::
+
+    $ make lint
+    $ make test
+    Or
+    $ make test-all
+
+   To get flake8 and tox, just pip install them into your virtualenv.
+
+6. Commit your changes and push your branch to GitHub::
+
+    $ git add .
+    $ git commit -m "Your detailed description of your changes."
+    $ git push origin name-of-your-bugfix-or-feature
+
+7. Submit a pull request through the GitHub website.
+
+Pull Request Guidelines
+-----------------------
+
+Before you submit a pull request, check that it meets these guidelines:
+
+1. The pull request should include tests.
+2. If the pull request adds functionality, the docs should be updated. Put
+   your new functionality into a function with a docstring, and add the
+   feature to the list in README.rst.
+3. The pull request should work for Python 3.5, 3.6, 3.7 and 3.8, and for PyPy.
+   Make sure that the tests pass for all supported Python versions.
+
+Tips
+----
+
+To run a subset of tests::
+
+
+    $ make test
+
+Deploying
+---------
+
+A reminder for the maintainers on how to deploy.
+Make sure all your changes are committed (including an entry in HISTORY.rst).
+Then run::
+
+$ bump-my-version patch # possible: major / minor / patch
+$ git push
+$ git push --tags
+
+
+Code of Conduct
+---------------
+
+Please note that this project is released with a `Contributor Code of Conduct`_.
+By participating in this project you agree to abide by its terms.
+
+.. _`Contributor Code of Conduct`: CODE_OF_CONDUCT.rst

pdbnucleicacids-0.1.0/HISTORY.rst

@@ -0,0 +1,8 @@
+=======
+History
+=======
+
+0.1.0 (2024-09-18)
+------------------
+
+* First release on PyPI.

pdbnucleicacids-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024, Alessandro Pandolfi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+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.
+

pdbnucleicacids-0.1.0/MANIFEST.in

@@ -0,0 +1,11 @@
+include AUTHORS.rst
+include CONTRIBUTING.rst
+include HISTORY.rst
+include LICENSE
+include README.rst
+
+recursive-include tests *
+recursive-exclude * __pycache__
+recursive-exclude * *.py[co]
+
+recursive-include docs *.rst conf.py Makefile make.bat *.jpg *.png *.gif

pdbnucleicacids-0.1.0/PDBNucleicAcids/BasePairRules.py

@@ -0,0 +1,188 @@
+"""Classes with rules for proper base pairing."""
+
+import warnings
+
+# from Bio.PDB.vectors import calc_dihedral
+from Bio.PDB.Residue import Residue
+from Bio.PDB.Atom import Atom
+from Bio.PDB.Polypeptide import is_nucleic
+
+# absolute imports
+from PDBNucleicAcids.Geometry import angle_between_planes, plane_separation
+
+
+class dsDNAWatsonCrickBasePairRules:
+    """
+    Rules for Watson-Crick base pairs in double-strand DNA.
+
+    Parameters
+    ----------
+    max_distance : float | int, optional
+        Maximum distance between nucleotide bases, in Armstrong.
+        The default is 3.5.
+    max_angle : float | int, optional
+        Maximum angle between the planes of the bases, in degrees.
+        The default is 65.
+    max_stagger : float | int, optional
+        Maximum vertical distance between the planes of the bases, in degrees.
+        The default is 65.
+
+    """
+
+    def __init__(
+        self,
+        max_distance: float | int = 4,
+        max_angle: float | int = 65,
+        max_stagger: float | int = 2.5,
+        # dihedral_range: tuple[int, float] = (90, 150),
+    ):
+        self.complementary_pairs: set[tuple[str]] = {
+            ("DA", "DT"),
+            ("DT", "DA"),
+            ("DG", "DC"),
+            ("DC", "DG"),
+        }
+
+        # parameters taken from
+        # http://forum.x3dna.org/faqs/
+        # how-to-fix-missing-(superfluous)-base-pairs-identified-by-find_pair/
+        self.max_distance = max_distance
+        self.max_angle = max_angle
+        self.max_stagger = max_stagger
+        # self.dihedral_angle_range = dihedral_range
+
+    def atoms_from_base_ring(self, base: Residue) -> tuple[Atom] | None:
+        """Get atoms from the ring of a base."""
+        if base.get_resname() in ["DA", "DG"]:  # Purine
+            atoms: tuple[Atom] = (base["N1"], base["C2"], base["C6"])
+        elif base.get_resname() in ["DT", "DC"]:  # Pirimidine
+            atoms: tuple[Atom] = (base["N3"], base["C2"], base["C4"])
+        elif base.get_resname() == "HOH":  # Water
+            atoms = None
+        else:  # Hetero-residue?
+            warnings.warn(
+                f"{base.full_id} has no atoms from base ring. Might \
+be hetero-residue non-standard-base."
+            )
+            atoms = None
+        return atoms
+
+    def atom_from_central_hbond(self, base) -> Atom | None:
+        """Get central H-bond atom of a base."""
+        atoms = self.atoms_from_base_ring(base)
+        if atoms:
+            return atoms[0]
+        else:
+            return None
+
+    def distance(self, base1, base2) -> float | None:
+        """Compute distance between central H-bond atoms of two bases."""
+        atom1 = self.atom_from_central_hbond(base1)
+        atom2 = self.atom_from_central_hbond(base2)
+        if atom1 is not None and atom2 is not None:
+            return atom1 - atom2
+        else:
+            return None
+
+    def angle_between_bases(
+        self, base1: Residue, base2: Residue
+    ) -> float | None:
+        """Compute angle between between planes of two bases."""
+        atom_list1 = self.atoms_from_base_ring(base1)
+        atom_list2 = self.atoms_from_base_ring(base2)
+        if atom_list1 is None or atom_list2 is None:
+            return None
+        plane1 = (atom.coord for atom in atom_list1)
+        plane2 = (atom.coord for atom in atom_list2)
+        return angle_between_planes(plane1, plane2)
+
+    def stagger(self, base1: Residue, base2: Residue) -> float | None:
+        """Compute vertical stagger between between planes of two bases."""
+        atom_list1 = self.atoms_from_base_ring(base1)
+        atom_list2 = self.atoms_from_base_ring(base2)
+        if atom_list1 is None or atom_list2 is None:
+            return None
+        plane1 = (atom.coord for atom in atom_list1)
+        plane2 = (atom.coord for atom in atom_list2)
+        return plane_separation(plane1, plane2)
+
+    # def dihedrals(self, base1, base2) -> float:
+    #     atom1, atom2, atom3 = self.atoms_from_base_ring(base1)
+    #     atom4, atom5, atom6 = self.atoms_from_base_ring(base2)
+
+    #     v1, v2, v3, v4, v5, v6 = (
+    #         atom1.get_vector(),
+    #         atom2.get_vector(),
+    #         atom3.get_vector(),
+    #         atom4.get_vector(),
+    #         atom5.get_vector(),
+    #         atom6.get_vector(),
+    #     )
+    #     dihedral1 = calc_dihedral(v1, v2, v3, v4)
+    #     dihedral2 = calc_dihedral(v1, v5, v6, v4)
+
+    #     return (dihedral1, dihedral2)
+
+    def is_different_residue(self, base1: Residue, base2: Residue) -> bool:
+        """Check if two bases are distinct bases."""
+        return base1 != base2
+
+    def is_complementary(self, base1: Residue, base2: Residue) -> bool:
+        """Check if two bases are complementary."""
+        pair: tuple[str] = (base1.get_resname(), base2.get_resname())
+        return pair in self.complementary_pairs
+
+    def is_from_different_chain(self, base1: Residue, base2: Residue) -> bool:
+        """Check if two bases are from distinct chains."""
+        return base1.parent != base2.parent
+
+    def is_valid_distance(self, base1: Residue, base2: Residue) -> bool:
+        """Check validity of distance between central two bases."""
+        dist = self.distance(base1, base2)
+        if dist is not None:
+            return dist <= self.max_distance
+        else:
+            return False
+
+    def is_valid_angle(self, base1: Residue, base2: Residue) -> bool:
+        """Check validity of angle between between planes of the bases."""
+        angle = self.angle_between_bases(base1, base2)
+        if angle is not None:
+            return angle <= self.max_angle or angle >= 180 - self.max_angle
+        else:
+            False
+
+    def is_valid_stagger(self, base1: Residue, base2: Residue) -> bool:
+        """Check validity of stagger between between planes of the bases."""
+        # TODO to be used
+        return self.stagger(base1, base2) <= self.max_stagger
+
+    def is_candidate(self, base1: Residue, base2: Residue) -> bool:
+        """
+        Check if (base1, base2) is a likely base pair.
+
+        Use all the constraint methods to infer if base2 is likely to be
+        paired with base1.
+        """
+        if not is_nucleic(base1, standard=False):
+            # TODO add warning
+            return False
+        elif not is_nucleic(base2, standard=False):
+            return False
+        elif not is_nucleic(base1, standard=True):
+            # TODO add warning
+            return False
+        elif not is_nucleic(base2, standard=True):
+            return False
+        elif not self.is_different_residue(base1, base2):
+            return False
+        elif not self.is_complementary(base1, base2):
+            return False
+        elif not self.is_from_different_chain(base1, base2):
+            return False
+        elif not self.is_valid_distance(base1, base2):
+            return False
+        elif not self.is_valid_angle(base1, base2):
+            return False
+        else:
+            return True

pdbnucleicacids-0.1.0/PDBNucleicAcids/Geometry.py

@@ -0,0 +1,176 @@
+"""Functions that address atom geometry."""
+
+import numpy as np
+
+# from Bio.PDB.Atom import Atom
+
+
+def calculate_normal_vector(v1, v2, v3) -> np.float64:
+    """Compute normal vector from three 3D points."""
+    u1 = v2 - v1
+    u2 = v3 - v1
+
+    # Calcolo del vettore normale
+    normal = np.cross(u1, u2)
+
+    # Normalizzazione manuale del vettore normale
+    norm = np.linalg.norm(normal)
+    if norm == 0:
+        raise ValueError("Vettore normale nullo")
+    normal_normalized = normal / norm
+
+    return normal_normalized
+
+
+def angle_between_vectors(v1, v2) -> np.float64:
+    """Compute angle between two vectors."""
+    cos_theta = np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))
+
+    return np.degrees(np.arccos(np.clip(cos_theta, -1.0, 1.0)))
+
+
+def angle_between_planes(plane1, plane2) -> np.float64:
+    """Compute angle between two planes, composed of three 3D points each."""
+    v1, v2, v3 = plane1
+    v4, v5, v6 = plane2
+
+    normal1 = calculate_normal_vector(v1, v2, v3)
+    normal2 = calculate_normal_vector(v4, v5, v6)
+
+    angle = angle_between_vectors(normal1, normal2)
+
+    return angle
+
+
+def plane_separation(plane1, plane2) -> np.float64:
+    """Calcola la distanza verticale tra due piani."""
+    v1, v2, v3 = plane1
+    v4, v5, v6 = plane2
+
+    # Ottieni i vettori normali
+    normal1 = calculate_normal_vector(v1, v2, v3)
+    # normal2 = calculate_normal_vector(v4, v5, v6)
+
+    # Ottieni i centri dei piani
+    center1 = np.mean(plane1, axis=0)
+    center2 = np.mean(plane2, axis=0)
+
+    # Calcola il vettore tra i centri dei due piani
+    center_vector = center2 - center1
+
+    # Proietta il vettore tra i centri lungo la direzione del normale del
+    # primo piano
+    separation: np.float64 = abs(np.dot(center_vector, normal1))
+
+    return separation
+
+
+# def angle_between_3_atoms(atom1: Atom, atom2: Atom, atom3: Atom) -> float:
+#     """
+#     Get angle in degrees between three atoms. OBSOLETE.
+
+#     Atom 1 has the angle that is returned
+
+#     Parameters
+#     ----------
+#     atom1 : Bio.PDB.Atom.Atom
+#         First atom, on which the returned angle rests.
+#     atom2 : Bio.PDB.Atom.Atom
+#         Second atom.
+#     atom3 : Bio.PDB.Atom.Atom
+#         Third atom.
+
+#     Returns
+#     -------
+#     float
+#         Angle between the three atoms, measured in degrees.
+
+#     """
+#     # get coordinate vectors
+#     p1: np.array = atom1.coord
+#     p2: np.array = atom2.coord
+#     p3: np.array = atom3.coord
+
+#     # Calculate the vectors
+#     v1 = p2 - p1  # from p1 to p2
+#     v2 = p3 - p1  # from p1 to p3
+
+#     # Calculate the angle in radians
+#     # rule of the cosine
+#     angle_radians = np.arccos(
+#         np.clip(
+#             np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2)),
+#             -1.0,
+#             1.0,
+#         )
+#     )
+
+#     # Convert to degrees, cast into float
+#     angle_degrees = np.degrees(angle_radians)
+#     angle_degrees = float(angle_degrees)
+
+#     return angle_degrees
+
+
+# def dihedral_angle_between_4_atoms(
+#     atom1: Atom, atom2: Atom, atom3: Atom, atom4: Atom
+# ) -> float:
+#     """
+#     Get dihedral angle in degrees between four atoms. OBSOLETE.
+
+#     The first plane rests of the dihedral angle rests on the first three
+#     atoms while the second rests on the last three. `atom1` and `atom2`
+#     are in common between the two planes.
+
+#     Parameters
+#     ----------
+#     atom1 : Bio.PDB.Atom.Atom
+#         First atom.
+#     atom2 : Bio.PDB.Atom.Atom
+#         Second atom.
+#     atom3 : Bio.PDB.Atom.Atom
+#         Third atom.
+#     atom4 : Bio.PDB.Atom.Atom
+#         Forth atom.
+
+#     Returns
+#     -------
+#     float
+#         Dihedral angle between the four atoms, measured in degrees.
+
+#     """
+#     # Punti tridimensionali, 4 atomi
+#     p1 = atom1.coord
+#     p2 = atom2.coord
+#     p3 = atom3.coord
+#     p4 = atom4.coord
+
+#     # Vettori tra i punti
+#     v1 = p2 - p1
+#     v2 = p3 - p2
+#     v3 = p4 - p3
+
+#     # Vettori normali ai piani
+#     n1 = np.cross(v1, v2)
+#     n2 = np.cross(v2, v3)
+
+#     # Vettore di riferimento per la direzione
+#     m = np.cross(n1, v2)
+
+#     # Normalizzazione dei vettori
+#     n1 /= np.linalg.norm(n1)
+#     n2 /= np.linalg.norm(n2)
+#     m /= np.linalg.norm(m)
+
+#     # Calcola coseno e seno dell'angolo
+#     cos_theta = np.dot(n1, n2)
+#     sin_theta = np.dot(m, n2)
+
+#     # Calcola l'angolo diedro
+#     theta = np.arctan2(sin_theta, cos_theta)
+
+#     # Converti l'angolo da radianti a gradi e castalo in float
+#     theta_deg = np.degrees(theta)
+#     theta_deg = float(theta_deg)
+
+#     return theta_deg