aldepyde 0.0.0a2__py3-none-any.whl → 0.0.0a33__py3-none-any.whl

aldepyde/__init__.py

@@ -2,5 +2,30 @@ __version__ = "0.0.0a2"
 __author__ = "Nate McMurray"
 __description__ = "A module for mangling biomolecules"
 
-from aldepyde._config import _config
-config = _config()
+from ._config import _configuration
+from aldepyde.cache.cachemanager import CacheManager
+
+
+_cache_manager = CacheManager(initialize=False)
+def create_cache(max_memory="2gib") -> CacheManager:
+    global _cache_manager
+    _cache_manager = _cache_manager(max_memory=max_memory,
+                                    initialize=True)
+    return _cache_manager
+
+def get_cache() -> CacheManager:
+    global _cache_manager
+    return _cache_manager
+
+
+from importlib import import_module
+
+__all__ = ["rand", "biomolecule", "fetcher"]
+
+def __getattr__(name):
+    if name in __all__:
+        return import_module(f".{name}", __name__)
+    raise AttributeError(name)
+
+def __dir__():
+    return sorted(list(globals().keys()) + __all__)

aldepyde/_config.py

@@ -1,51 +1,113 @@
+import re
 import sys
+import os
+import json
+# TODO Consider version information in config
+# from aldepyde import __version__
 
-class _config():
+class _configuration():
+
+    class VERSION_SETTINGS():  # There's probably a better way to do this, but it feels neat so I'm keeping it for now
+        def __init__(self):
+            self.settings = {
+                "verbose": False,
+                "angle_mode": "degrees",
+                "enable_cache": True,
+                "cache_path": os.path.join(os.getcwd(), "aldepyde_cache"),
+                "cache_max_memory": "500mib"
+            }
     def __init__(self):
-        self.settings = {
-            "verbose": False,
-            "angle_mode": "degrees"
-        }
-        self._setters = {
-            "verbose" : (self.SetVerbose, [True, False]),
-            "angle_mode": (self.SetAngleMode, ["degrees", "radians"])
-        }
-
-    def _Verify(self, key, value) -> None:
-        if value not in self._setters[key][1]:
-            print(f"Incorrect value for ({key} <-- {value})\n\tAllowed values: {self._setters[key][1]}", file=sys.stderr)
-            raise ValueError("See above")
+        s = self.VERSION_SETTINGS()
+        self._settings = s.settings
+        self._setters = { # TODO Finish fixing this
+                "verbose": self.SetVerbose,
+                "angle_mode": self.SetAngleMode,
+                "enable_cache": self.SetEnableCache,
+                "cache_path": self.SetCachePath,
+                "cache_max_memory": self.SetCacheMaxMemory
+            }
+
+    # def _Verify(self, key, value) -> None:
+    #     if value not in self._setters[key][1]:
+    #         print(f"Incorrect value for ({key} <-- {value})\n\tAllowed values: {self._setters[key][1]}", file=sys.stderr)
+    #         raise ValueError("See above")
+
+    def _Verify(self, key: str, accepted: list, value: object) -> None:
+        if True not in [True for x in accepted if value == x or (isinstance(x, type) and isinstance(value, x))]:
+            raise ValueError
+        # if value not in accepted:
+        #     # print(f"Incorrect value for ({key} <-- {value})\n\tAllowed values: {accepted}", file=sys.stderr)
+        #     raise ValueError(f"Incorrect value for ({key} <-- {value})\n\tAllowed values: {accepted}")
 
     def __getitem__(self, item):
-        return self.settings[item]
-    def GetVerbose(self) -> bool:
-        return self.settings['verbose']
+        return self._settings[item]
 
-    def SetVerbose(self, v: bool) -> None:
-        self._Verify('verbose', v)
-        self.settings['verbose'] = v
+    def GetVerbose(self) -> bool:
+        return self._settings['verbose']
 
+    def SetVerbose(self, enabled: bool) -> None:
+        # I'm choosing to not be defensive here.
+        # Ima be honest, if you break the module with a verbosity boolean, that's on you
+        self._settings['verbose'] = enabled
 
     def GetAngleMode(self) -> str:
-        return self.settings['angle_mode']
+        return self._settings['angle_mode']
 
     def SetAngleMode(self, a_type: str) -> None:
         self._Verify('angle_mode', a_type)
-        self.settings['angle_mode'] = a_type
-
-    def Load(self, s: dict) -> None:
-        if set(s.keys()) != set(self._setters.keys()): # Mismatch in settings
-            missing_settings = "".join([f"\t-{k} : {v[1]}\n" for k, v in self._setters.items() if k not in s.keys()])
-            extra_settings = "".join([f"\t-{k}\n" for k in s.keys() if k not in self._setters.keys()])
-            print(f"Input config does not match expectations.", file=sys.stderr)
-            if len(missing_settings) != 0:
-                print(f"Please include the following:\n{missing_settings}", end="", file=sys.stderr)
-            if len(extra_settings) != 0:
-                print(f"Please remove the following:\n{extra_settings}", file=sys.stderr)
-            raise KeyError("See above")
-        for key in self._setters.keys():
+        self._settings['angle_mode'] = a_type
+
+    def SetEnableCache(self, enabled:bool) -> None:
+        self._Verify('enable_cache', [bool], enabled)
+        self._settings['enable_cache'] = enabled
+
+    def SetCachePath(self, path: str) -> None:
+        # TODO Consider making the new cache directory immediately
+        self._settings['cache_path'] = path
+
+    def GetCachePath(self) -> str:
+        return self._settings['cache_path']
+
+    def GetEnabledCache(self) -> bool:
+        return self._settings['enable_cache']
+
+    def SetCacheMaxMemory(self, max_memory: str|int) -> None:
+        max_memory = str(max_memory)
+        if re.fullmatch("[0-9]*[kmg]i?b", max_memory) is None:
+            raise ValueError
+        self._settings['cache_max_memory'] = max_memory
+
+    def GetCacheMaxMemory(self) -> str:
+        return self._settings['cache_max_memory']
+
+    ####################
+    def Load(self, s: dict | str, ignore_missing=False) -> None:
+        if isinstance(s, str):
+            if os.path.exists(s):  # Try and read as a json file
+                with open(s, "r") as jp:
+                    s = json.load(jp)
+            else:  # Try and read as a json string
+                s = json.loads(s)
+        extra_settings = "".join([f"\t-{k}\n" for k in s.keys() if k not in self._setters.keys()])
+        if len(extra_settings) != 0:
+            print(f"Please remove the following config settings:\n{extra_settings}", file=sys.stderr)
+            raise KeyError("Input config does not match expectations")
+        missing_settings = "".join([f"\t-{k} : {v[1]}\n" for k, v in self._setters.items() if k not in s.keys()])
+        if len(missing_settings) != 0 and not ignore_missing:
+            print(f"Please include the following config settings:\n{missing_settings}", end="", file=sys.stderr)
+            raise KeyError("Input config does not match expectations")
+        if ignore_missing:
+            vs = self.VERSION_SETTINGS()
+            self._settings = vs.settings
+        for key in s.keys():
             self._setters[key][0](s[key])
 
-    def GetConfig(self) -> dict:
-        return self.settings
+    def GetConfig(self, as_string=False, indent="") -> dict | str:
+        if as_string:
+            return json.dumps(self._settings, indent=indent)
+        return self._settings
+
+    def Save(self, path: str="config.json", indent: str=""):
+        with open(path, "w") as jp:
+            json.dump(self._settings, jp, indent=indent)
 

aldepyde/biomolecule/Residue.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+
+class Residue(ABC):
+
+    def __init__(self):
+        self.atoms = None
+        self.resID = None
+        self.resName = None
+

aldepyde/biomolecule/_Atom.py

@@ -0,0 +1,95 @@
+__all__ = ['Atom']
+
+class Atom():
+    def __init__(self,
+                 record_name: str = None,
+                 serial: str = None,
+                 name: str = None,
+                 altLoc: str = None,
+                 resName: str = None,
+                 chainID: str = None,
+                 resSeq: str = None,
+                 iCode: str = None,
+                 x: str = None,
+                 y: str = None,
+                 z: str = None,
+                 occupancy: str = None,
+                 tempFactor: str = None,
+                 element: str = None,
+                 charge: str = None
+        ):
+        self.SetRecordName(record_name)
+        self.SetSerial(serial)
+        self.SetAltLoc(altLoc)
+        self.SetResName(resName)
+        self.SetChainID(chainID)
+        self.SetResSeq(resSeq)
+        self.SetiCode(iCode)
+        self.SetXYZ(x, y, z)
+        self.SetOccupancy(occupancy)
+        self.SetTempFactor(tempFactor)
+        self.SetElement(element)
+        self.SetCharge(charge)
+        self.SetName(name) # Do this last to extract the element
+
+    def SetRecordName(self, record_name: str) -> None:
+        self.record_name = record_name
+
+    def SetSerial(self, serial: str | int | None) -> None:
+        self.serial = int(serial)
+
+    def SetName(self, name) -> None:
+        # TODO Extrapolate the element from the name
+        self.name = name
+
+    def SetAltLoc(self, altLoc: str | None) -> None:
+        self.altLoc = altLoc
+
+    def SetResName(self, resName: str | None) -> None:
+        self.resName = resName
+
+    def SetChainID(self, chainID: str | None) -> None:
+        self.chainID = chainID
+
+    def SetResSeq(self, resSeq: str | None) -> None:
+        self.resSeq = resSeq
+
+    def SetiCode(self, iCode: str | None) -> None:
+        self.iCode = iCode
+
+    def SetXYZ(self, x: str | float | None, y: str | float | None, z: str | float | None) -> None:
+        self.x = float(x) if x is not None else None
+        self.y = float(y) if y is not None else None
+        self.z = float(z) if z is not None else None
+
+    def SetX(self, x: str | float | None):
+        self.x = float(x) if x is not None else None
+
+    def SetY(self, x: str | float | None):
+        self.x = float(x) if x is not None else None
+
+    def SetZ(self, x: str | float | None):
+        self.x = float(x) if x is not None else None
+
+    def SetOccupancy(self, occupancy: str | float | None) -> None:
+        self.occupancy = float(occupancy) if occupancy is not None else None
+
+    def SetTempFactor(self, tempFactor: str | float | None) -> None:
+        self.tempFactor = float(tempFactor) if tempFactor is not None else None
+
+    def SetElement(self, element: str | None) -> None:
+        self.element = element
+
+    def SetCharge(self, charge: str | None) -> None:
+        self.charge = charge
+
+    def Distance(self, other: 'Atom') -> float:
+        return ((self.x - other.x)**2 + (self.y - other.y)**2 + (self.z - other.z)**2)**(.5)
+
+    # In case you want to treat aldepyde like that other importable module that shall not be named
+    def __sub__(self, other):
+        return self.Distance(other)
+
+    def __str__(self):
+        return f"{self.record_name} {self.serial} {self.resName}"
+

aldepyde/biomolecule/_AtomFactory.py

@@ -0,0 +1,71 @@
+from aldepyde.biomolecule._Atom import Atom as atom
+
+__all__ = ['CreateAtom', 'CreateEnforced', 'CreateDummy']
+
+def CreateAtom(  # General atom
+        record_name: str| None = None,
+        serial: str | int | None = None,
+        name: str | None = None,
+        altLoc: str | None = None,
+        resName: str | None = None,
+        chainID: str | None = None,
+        resSeq: str | None = None,
+        iCode: str | None = None,
+        x: str | float | None = None,
+        y: str | float |  None = None,
+        z: str | float |  None = None,
+        occupancy: str | float |  None = None,
+        tempFactor: str | float |  None = None,
+        element: str | None = None,
+        charge: str | None = None
+) -> atom:
+    return atom(record_name=record_name, serial=serial, name=name, altLoc=altLoc, resName=resName,
+                chainID=chainID, resSeq=resSeq, iCode=iCode, x=x, y=y, z=z,
+                occupancy=occupancy, tempFactor=tempFactor, element=element,
+                charge=charge)
+
+def CreateEnforced( # The type of atom from the parsers. Enforce what's required by PDB standard
+        serial: str,
+        name: str,
+        altLoc: str,
+        resName: str,
+        chainID: str,
+        resSeq: str,
+        iCode: str,
+        x: str,
+        y: str,
+        z: str,
+        occupancy: str,
+        tempFactor: str,
+        record_name: str = None,
+        element: str | None = None,
+        charge: str | None = None
+) -> atom:
+    return atom(serial=serial, name=name, altLoc=altLoc, resName=resName,
+                chainID=chainID, resSeq=resSeq, iCode=iCode, x=x, y=y, z=z,
+                occupancy=occupancy, tempFactor=tempFactor, element=element,
+                charge=charge, record_name=record_name)
+
+
+def CreateDummy( # As the name implies
+        record_name: str| None = "HETATM",
+        serial: str | int = "-1",
+        name: str = "PS",
+        altLoc: str = "",
+        resName: str = "PSD",
+        chainID: str = "$P",
+        resSeq: str = "PSD",
+        iCode: str = "",
+        x: str | float = "0.0",
+        y: str | float = "0.0",
+        z: str | float = "0.0",
+        occupancy: str | float = "0.0",
+        tempFactor: str | float = "0.0",
+        element: str | None = "PS",
+        charge: str | None = None
+) -> atom:
+    return atom(record_name=record_name, serial=serial, name=name, altLoc=altLoc, resName=resName,
+                chainID=chainID, resSeq=resSeq, iCode=iCode, x=x, y=y, z=z,
+                occupancy=occupancy, tempFactor=tempFactor, element=element,
+                charge=charge)
+

aldepyde/biomolecule/__init__.py

@@ -0,0 +1,18 @@
+from ._amino_acid import *
+from ._Atom import *
+from ._AtomFactory import *
+from ._dna import *
+from ._pdb import *
+# from .Residue import * # This probably doesn't need to be revealed to the user
+from ._rna import *
+
+__all__ =  list(set(_amino_acid.__all__.copy()) |
+           set(_Atom.__all__.copy()) |
+           set(_AtomFactory.__all__.copy()) |
+           set(_dna.__all__.copy()) |
+           set(_pdb.__all__.copy()) |
+           set(_rna.__all__.copy()))
+
+import sys
+
+sys.stderr.write("Note that the `biomolecule` submodule is not yet fully tested and may be unstable")

aldepyde/biomolecule/_amino_acid.py

@@ -0,0 +1,6 @@
+from aldepyde.biomolecule.Residue import Residue
+
+__all__ = ['amino_acid']
+
+class amino_acid(Residue):
+    pass

aldepyde/biomolecule/_dna.py

@@ -0,0 +1,6 @@
+from aldepyde.biomolecule.Residue import Residue
+
+__all__ = ['dna']
+
+class dna(Residue):
+    pass