mempro 0.3.2__tar.gz → 0.3.3__tar.gz

{mempro-0.3.2 → mempro-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mempro
-Version: 0.3.2
+Version: 0.3.3
 Summary: Membrane Protein Orientation in Lipid Bilayers
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{mempro-0.3.2 → mempro-0.3.3}/mempro/Insane4MemPrO.py

@@ -2780,10 +2780,15 @@ def get_charge(lz,uz):
 	pcharge = 0
 	for ind,j in enumerate(protein.atoms):
 		pos = protein.coord[ind]
-		if not j[0].strip().startswith('v') and j[1:3] != last:
+		if protein_q is not None:
+			if(pos[2] > lz and pos[2] < uz):
+				pcharge += protein_q[ind]
+		elif not j[0].strip().startswith('v') and j[1:3] != last:
 			if(pos[2] > lz and pos[2] < uz):
 				pcharge += charges.get(j[1].strip(),0)  
 		last = j[1:3]
+	if protein_q is not None:
+		pcharge = int(round(pcharge))
 	total_charge = mcharge+pgcharge+pcharge
 	return total_charge,pcharge,mcharge,pgcharge
 
@@ -3363,6 +3368,7 @@ Input/output related options
 	("-o",	  Option(str,		 1,		None, "Output GRO file: Membrane with Protein")),
 	("-o_f",	  Option(str,		 1,		None, "Folder for additional files (Default: InsaneData)")),
 	("-p",	  Option(str,		 1,		None, "Optional rudimentary topology file")),
+	("-p_top",	  Option(str,		 1,		None, "Topology (.top) of the protein in -f, e.g. from martinize2. Protein charges are taken from it, including the termini, instead of from residue names")),
 	("-ct",	  Option(str,		 1,		None, "This will create a template of the membrane only.")),
 	("-in_t",	  Option(str,		 1,		None, "Input template for placement of multiple proteins.")),
 	("-fs",	  Option(str,		 1,		None, "Input text file with multiple proteins")),
@@ -3607,17 +3613,39 @@ def read_lipid_itp(fn):
 		if not lines:
 			continue
 		name = lines[0][0]
-		atoms, charge, sec = [], 0.0, None
+		atoms, resnames, qs, sec = [], [], [], None
 		for l in lines[1:]:
 			if l[0].startswith("["):
 				sec = "".join(l).strip("[]")
 			elif sec == "atoms" and len(l) >= 7 and not l[0].startswith("#"):
 				atoms.append(l[4])
-				charge += float(l[6])
-		mols[name] = {"atoms": atoms, "charge": int(round(charge)), "build": builds.get(name)}
+				resnames.append(l[3])
+				qs.append(float(l[6]))
+		mols[name] = {"atoms": atoms, "resnames": resnames, "charges": qs, "charge": int(round(sum(qs))), "build": builds.get(name)}
 	return mols
 
 
+# Charge of each bead of the molecules in a topology (.top), in order, with its residue name
+def read_top_charges(fn):
+	top_dir = os.path.dirname(os.path.abspath(fn))
+	with open(fn) as f:
+		txt = f.read()
+	mols = read_lipid_itp(fn)
+	for inc in re.findall(r'^\s*#include\s+"([^"]+)"', txt, re.M):
+		path = inc if os.path.isabs(inc) else os.path.join(top_dir, inc)
+		if os.path.exists(path):
+			mols.update(read_lipid_itp(path))
+	beads = []
+	for line in txt.split("[ molecules ]")[-1].splitlines() if "[ molecules ]" in txt else []:
+		l = line.split(";")[0].split()
+		if len(l) != 2:
+			continue
+		if l[0] not in mols:
+			raise KeyError("molecule %s in %s has no [ atoms ] in the included itps" % (l[0], fn))
+		beads += list(zip(mols[l[0]]["resnames"], mols[l[0]]["charges"]))*int(l[1])
+	return beads
+
+
 # The Martini 3 lipidome, for lipids without a built-in template
 lipidome_file = os.path.join(os.path.dirname(os.path.abspath(__file__)), "lipidome_m3.dat")
 if os.path.exists(lipidome_file):
@@ -3638,9 +3666,13 @@ for fn in lipid_itps:
 		if mol["build"]:
 			kv = mol["build"]
 			define_lipid(name, kv.get("alhead",""), kv.get("allink",""), kv.get("altail",""))
-		elif name in lipidsa and name in used_lipids:
+		elif name in lipidsa:
 			beads = [b for b in lipidsa[name][1].split() if b != "-"]
-			if beads != mol["atoms"]:
+			if beads != mol["atoms"] and len(beads) == len(mol["atoms"]):
+				# Same beads under other names (e.g. CARD in the Martini 3 lipidome): take the names from the topology
+				names = iter(mol["atoms"])
+				lipidsa[name] = (lipidsa[name][0], " ".join(b if b == "-" else next(names) for b in lipidsa[name][1].split()))
+			elif beads != mol["atoms"] and name in used_lipids:
 				print("WARNING: The bead names of %s in %s differ from the template (%s); the built lipid will not match the topology" % (name, fn, " ".join(beads)), file=sys.stderr)
 
 # Add specified lipid definition to insane lipid library
@@ -3730,6 +3762,7 @@ elif options["-z"].value:
 
 protein  = Structure()
 protein_lip = Structure()
+protein_q = None # Charge of each protein bead, from -p_top
 prot	 = []
 xshifts  = [0] # Shift in x direction per protein
 
@@ -4940,6 +4973,17 @@ if(Num_PGL > 0):
 
 # Charge of the system so far
 
+# Residue names miss charges that are not on side chains, e.g. the termini, so take them from the protein topology if given
+if options["-p_top"].value and protein:
+	try:
+		beads = read_top_charges(options["-p_top"].value)
+	except (OSError, KeyError) as e:
+		beads = []
+		print("; WARNING: Could not read protein charges from %s (%s)" % (options["-p_top"].value, e), file=sys.stderr)
+	if len(beads) == len(protein.atoms) and all(r[:4] == a[1].strip()[:4] for (r, _), a in zip(beads, protein.atoms)):
+		protein_q = [q for _, q in beads]
+	elif beads:
+		print("; WARNING: The %d beads in %s do not match the %d protein beads in -f, so protein charges are inferred from residue names" % (len(beads), options["-p_top"].value, len(protein.atoms)), file=sys.stderr)
 
 charge,pcharge,mcharge,pgcharge = get_charge(0,pbcz)
 

{mempro-0.3.2 → mempro-0.3.3}/mempro/MemPrO.py

@@ -3436,6 +3436,11 @@ def add_Reses(Res, Resitp):
                 Beadtype[bt] = current_beadtype_no
                 current_beadtype_no += 1
 
+    if len(restobead_add) == 0:
+        # Without bead types the residue cannot be placed, and load_cg_pdb would fail with an IndexError
+        print("ERROR: Additional residue "+Res+" has no [ atoms ] entries in "+Resitp+". Add its definition to this itp (-res_itp).")
+        sys.exit(1)
+
     ResToBead.append(restobead_add)
 
     

{mempro-0.3.2 → mempro-0.3.3}/mempro.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mempro
-Version: 0.3.2
+Version: 0.3.3
 Summary: Membrane Protein Orientation in Lipid Bilayers
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{mempro-0.3.2 → mempro-0.3.3}/mempro.egg-info/SOURCES.txt

@@ -16,4 +16,5 @@ mempro.egg-info/requires.txt
 mempro.egg-info/top_level.txt
 tests/test_footprint.py
 tests/test_insane4mempro.py
+tests/test_residues.py
 tests/test_sort.py

{mempro-0.3.2 → mempro-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mempro"
-version = "0.3.2"
+version = "0.3.3"
 description = "Membrane Protein Orientation in Lipid Bilayers"
 readme = "README.md"
 requires-python = ">=3.11"

{mempro-0.3.2 → mempro-0.3.3}/tests/test_footprint.py

@@ -3,11 +3,9 @@ Tests for the per-leaflet protein footprint (-footprint map, docs/footprint-desi
 
 Run from the repository root with:  python -m unittest discover tests
 The synthetic-shape tests call the footprint block directly (well under a second each); the build tests run
-Insane4MemPrO on small synthetic proteins (a few seconds each). The QmcA test builds a 234k-bead system and only runs
-with MEMPRO_SLOW_TESTS=1.
+Insane4MemPrO on small synthetic proteins (a few seconds each).
 """
 
-import gzip
 import os
 import re
 import shutil
@@ -21,7 +19,6 @@ import numpy as np
 ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 INSANE = os.path.join(ROOT, "mempro", "Insane4MemPrO.py")
 LEAFLETS = os.path.join(ROOT, "mempro", "leaflet_check.py")
-QMCA = os.path.join(ROOT, "tests", "data", "QmcA")
 sys.path.insert(0, os.path.join(ROOT, "mempro"))
 import leaflet_check  # noqa: E402
 
@@ -302,27 +299,10 @@ class TestEnclosedBuild(unittest.TestCase):
             inside = heads[np.linalg.norm(heads - 5.0, axis=1) < 1.3]
             self.assertGreater(len(inside), 0)
             self.assertLess(len(inside), 10)
+            # Lipids start at least LIPID_MIN_SPACING (0.55 nm) apart, but the head bead sits 0.125 nm off the lipid
+            # axis in a random direction, plus a kick of up to 0.1 nm in x and y, so heads can come within 0.16 nm
             d = np.linalg.norm(heads[:, None] - heads[None], axis=2) + 10 * np.eye(len(heads))
-            self.assertGreater(d.min(), 0.3)
-
-
-@unittest.skipUnless(os.environ.get("MEMPRO_SLOW_TESTS"), "set MEMPRO_SLOW_TESTS=1 to build QmcA (234k beads)")
-class TestQmcA(unittest.TestCase):
-    def test_leaflets_matched(self):
-        tmp = tempfile.mkdtemp(prefix="qmca_test_")
-        TMP_DIRS.append(tmp)
-        with gzip.open(os.path.join(QMCA, "protein-cg_rank_1.pdb.gz"), "rt") as f, open(os.path.join(tmp, "prot.pdb"), "w") as g:
-            g.write(f.read())
-        cmd = [sys.executable, INSANE, "-f", "prot.pdb", "-x", "32.11502", "-y", "32.262005", "-z", "24.711554",
-               "-l", "POPE:8", "-l", "POPG:2", "-sol", "W", "-negi_c0", "CL", "-posi_c0", "NA", "-footprint", "map",
-               "-o", "sys.gro", "-p", "topol.top"]
-        out = subprocess.run(cmd, cwd=tmp, capture_output=True, text=True)
-        self.assertEqual(out.returncode, 0, out.stderr[-3000:])
-        (fp_up, _, _), (fp_lo, _, _) = map_leaflets(out.stdout + out.stderr)
-        self.assertGreater(fp_lo, 3 * fp_up)  # the soluble cap rests on the lower headgroups
-        chk = subprocess.run([sys.executable, LEAFLETS, os.path.join(tmp, "sys.gro"), "-insane", INSANE], capture_output=True, text=True)
-        diff = float(re.search(r"Differential strain \(upper - lower\): (\S+)%", chk.stdout).group(1))
-        self.assertLess(abs(diff), 1.0)
+            self.assertGreater(d.min(), 0.15)
 
 
 if __name__ == "__main__":

{mempro-0.3.2 → mempro-0.3.3}/tests/test_insane4mempro.py

@@ -217,6 +217,64 @@ class TestLipidome(unittest.TestCase):
         self.assertEqual(membrane_charge(log), -counts["XXES"])
         self.assertIn("WARNING: The bead names of POPC", log)
 
+    def test_lipid_itp_bead_names_by_position(self):
+        """Martini 3 lipidome CARD has no ;@INSANE line and renamed beads; the names come from the itp."""
+        tmp = tempfile.mkdtemp(prefix="insane_itp_")
+        TMP_DIRS.append(tmp)
+        itp = os.path.join(tmp, "card.itp")
+        beads = ("GLC PO41 GL11 GL21 C1A1 D2A1 C3A1 C4A1 C1B1 C2B1 C3B1 C4B1 "
+                 "PO42 GL12 GL22 C1A2 D2A2 C3A2 C4A2 C1B2 C2B2 C3B2 C4B2").split()
+        with open(itp, "w") as f:
+            f.write("[ moleculetype ]\nCARD 1\n[ atoms ]\n")
+            for i, b in enumerate(beads):
+                f.write("%d C1 1 CARD %s %d %s\n" % (i + 1, b, i + 1, "-1.0" if b.startswith("PO") else "0"))
+        log, counts, gro = build(["-x", "10", "-y", "10", "-z", "10", "-l", "POPE:9", "-l", "CARD:1", "-lipid_itp", itp])
+        self.assertGreater(counts["CARD"], 0)
+        self.assertEqual(residue_beads(gro, "CARD"), beads)
+        self.assertNotIn("WARNING: The bead names of CARD", log)
+
+
+class TestProteinCharge(unittest.TestCase):
+    """A lipoprotein chain: CYST has a neutral N-terminus, so the C-terminal -1 is not cancelled as residue names assume."""
+
+    def setUp(self):
+        self.dir = tempfile.mkdtemp(prefix="insane_charge_")
+        TMP_DIRS.append(self.dir)
+        resnames = ["CYST"] + ["LEU"] * 19
+        with open(os.path.join(self.dir, "prot.pdb"), "w") as f:
+            for i, r in enumerate(resnames):
+                f.write("ATOM  %5d  BB  %-4sA%4d    %8.3f%8.3f%8.3f  1.00  0.00\n" % (i + 1, r, i + 1, 50.0, 50.0, -28.5 + 3 * i))
+            f.write("END\n")
+        with open(os.path.join(self.dir, "chain.itp"), "w") as f:
+            f.write("[ moleculetype ]\nchain 1\n\n[ atoms ]\n")
+            for i, r in enumerate(resnames):
+                f.write("%d P5 %d %s BB %d %s\n" % (i + 1, i + 1, r, i + 1, "-1" if i == len(resnames) - 1 else "0.0"))
+
+    def write_top(self, copies):
+        top = os.path.join(self.dir, "prot.top")
+        with open(top, "w") as f:
+            f.write('#include "martini.itp"\n#include "chain.itp"\n\n[ molecules ]\nchain %d\n' % copies)
+        return top
+
+    def ions(self, extra):
+        log, counts, _ = build(["-f", os.path.join(self.dir, "prot.pdb"), "-x", "10", "-y", "10", "-z", "10", "-l", "POPE"] + extra)
+        return log, counts.get("NA", 0) - counts.get("CL", 0)
+
+    def test_residue_names_miss_terminus(self):
+        log, excess = self.ions([])
+        self.assertIn("Charge of protein: 0.0", log)
+        self.assertEqual(excess, 0)
+
+    def test_charge_from_topology(self):
+        log, excess = self.ions(["-p_top", self.write_top(1)])
+        self.assertIn("Charge of protein: -1.0", log)
+        self.assertEqual(excess, 1)
+
+    def test_mismatched_topology_falls_back(self):
+        log, excess = self.ions(["-p_top", self.write_top(2)])
+        self.assertIn("do not match the 20 protein beads", log)
+        self.assertIn("Charge of protein: 0.0", log)
+
 
 class TestLeafletCheck(unittest.TestCase):
     def run_check(self, gro):

mempro-0.3.3/tests/test_residues.py

@@ -0,0 +1,46 @@
+"""
+Tests for additional residues (-res / -res_itp).
+
+Run from the repository root with:  python -m unittest discover tests
+The test runs MemPrO on the QmcA CG structure and stops while the additional residues are read (a few seconds).
+"""
+
+import gzip
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+MEMPRO = os.path.join(ROOT, "mempro", "MemPrO.py")
+QMCA_CG = os.path.join(ROOT, "tests", "data", "QmcA", "QmcA-cg.pdb.gz")
+
+
+class TestAdditionalResidues(unittest.TestCase):
+
+    def setUp(self):
+        self.tmp = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, self.tmp, ignore_errors=True)
+        self.cg = os.path.join(self.tmp, "QmcA-cg.pdb")
+        with gzip.open(QMCA_CG, "rt") as src, open(self.cg, "w") as dst:
+            dst.write(src.read())
+
+    def test_residue_missing_from_itp(self):
+        """A -res residue with no [ atoms ] entries in -res_itp stops with a clear error and a non-zero exit code."""
+        itp = os.path.join(self.tmp, "residues.itp")
+        with open(itp, "w") as f:
+            f.write("[ moleculetype ]\nPOPE 1\n\n[ atoms ]\n1 Q5 1 POPE NH3 1 1.0\n")
+
+        result = subprocess.run([sys.executable, MEMPRO, "-f", self.cg, "-o", os.path.join(self.tmp, "out"),
+                                 "-res", "CYST", "-res_itp", itp],
+                                capture_output=True, text=True, timeout=600)
+
+        self.assertNotEqual(result.returncode, 0)
+        self.assertIn("Additional residue CYST has no [ atoms ] entries", result.stdout)
+        self.assertNotIn("IndexError", result.stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()