aldepyde 0.0.0a2__tar.gz → 0.0.0a32__tar.gz

{aldepyde-0.0.0a2 → aldepyde-0.0.0a32}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: aldepyde
-Version: 0.0.0a2
+Version: 0.0.0a32
 Summary: A package of chemistry and biochemical tools
 Author-email: Nate McMurray <nate.mcmurray13@gmail.com>
 License: MIT License
@@ -35,10 +35,11 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Dynamic: license-file
 
 <p align="left"><img src="https://github.com/cathepsin/aldepyde/blob/main/Aldepyde%20rough.png" height="250"/></p>
 
-#### A module for mangling biomolecules
+### A module for mangling biomolecules
 ---
 AldePYde is a module of spite. Being frustrated with either the lack of obscure potential or the difficult and steep learning curve of other similar modules,
 I made this. Here I present my various tools for chem/bioinformatics. This is all very much a work-in-progress, especially as I move over functionality from my

{aldepyde-0.0.0a2 → aldepyde-0.0.0a32}/README.md

@@ -1,6 +1,6 @@
 <p align="left"><img src="https://github.com/cathepsin/aldepyde/blob/main/Aldepyde%20rough.png" height="250"/></p>
 
-#### A module for mangling biomolecules
+### A module for mangling biomolecules
 ---
 AldePYde is a module of spite. Being frustrated with either the lack of obscure potential or the difficult and steep learning curve of other similar modules,
 I made this. Here I present my various tools for chem/bioinformatics. This is all very much a work-in-progress, especially as I move over functionality from my

aldepyde-0.0.0a32/aldepyde/__init__.py

@@ -0,0 +1,50 @@
+__version__ = "0.0.0a2"
+__author__ = "Nate McMurray"
+__description__ = "A module for mangling biomolecules"
+
+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
+
+# def get_cache() -> _cache_handler:
+#     global _cache
+#     # if _cache.null:
+#     #     return create_cache()
+#     return _cache
+
+# def SaveConfig(path: str="config.json", indent: str = "") -> None:
+#     global _config
+#     get_config().Save(path=path, indent=indent)
+#
+#
+# def LoadConfig(s: dict | str, ignore_missing=False) -> None:
+#     global _config
+#     get_config().Load(s, ignore_missing=ignore_missing)
+
+
+# from . import rand
+# from . import biomolecule
+# from . import fetcher
+
+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-0.0.0a32/aldepyde/_config.py

@@ -0,0 +1,113 @@
+import re
+import sys
+import os
+import json
+# TODO Consider version information in config
+# from aldepyde import __version__
+
+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):
+        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']
+
+    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']
+
+    def SetAngleMode(self, a_type: str) -> None:
+        self._Verify('angle_mode', a_type)
+        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, 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-0.0.0a32/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-0.0.0a32/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-0.0.0a32/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-0.0.0a32/aldepyde/biomolecule/__init__.py

@@ -0,0 +1,15 @@
+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()))
+

aldepyde-0.0.0a32/aldepyde/biomolecule/_amino_acid.py

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

aldepyde-0.0.0a32/aldepyde/biomolecule/_dna.py

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