aldepyde 0.0.0a38__tar.gz → 0.0.0a43__tar.gz

{aldepyde-0.0.0a38 → aldepyde-0.0.0a43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aldepyde
-Version: 0.0.0a38
+Version: 0.0.0a43
 Summary: A package of chemistry and biochemical tools
 Author-email: Nate McMurray <nate.mcmurray13@gmail.com>
 License: MIT License

{aldepyde-0.0.0a38 → aldepyde-0.0.0a43}/aldepyde/__init__.py

@@ -7,10 +7,11 @@ from aldepyde.cache.cachemanager import CacheManager
 
 
 _cache_manager = CacheManager(initialize=False)
-def create_cache(max_memory="2gib") -> CacheManager:
+def use_cache(max_memory="2gib", path=None) -> CacheManager:
     global _cache_manager
-    _cache_manager = _cache_manager(max_memory=max_memory,
-                                    initialize=True)
+    _cache_manager = CacheManager(path=path, initialize=True)
+    _cache_manager.enable()
+    _cache_manager.set_max_memory(max_memory)
     return _cache_manager
 
 def get_cache() -> CacheManager:
@@ -20,7 +21,7 @@ def get_cache() -> CacheManager:
 
 from importlib import import_module
 
-__all__ = ["rand_utils", "biomolecule", "fetcher"]
+__all__ = ["generators", "biomolecule_old", "fetcher"]
 
 def __getattr__(name):
     if name in __all__:

{aldepyde-0.0.0a38 → aldepyde-0.0.0a43}/aldepyde/_config.py

@@ -83,10 +83,10 @@ class _configuration():
     ####################
     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
+            if os.path.exists(s):  # Try and read as a data file
                 with open(s, "r") as jp:
                     s = json.load(jp)
-            else:  # Try and read as a json string
+            else:  # Try and read as a data 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:
@@ -107,7 +107,7 @@ class _configuration():
             return json.dumps(self._settings, indent=indent)
         return self._settings
 
-    def Save(self, path: str="config.json", indent: str=""):
+    def Save(self, path: str="config.data", indent: str=""):
         with open(path, "w") as jp:
             json.dump(self._settings, jp, indent=indent)
 

aldepyde-0.0.0a43/aldepyde/biomolecule/structure.py

@@ -0,0 +1,60 @@
+from typing import List, Tuple, Optional, Dict
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Atom():
+    serial: str
+    name: str
+    coord: Tuple[float, float, float]
+    occupancy: float
+    b_factor: float
+    is_het: bool
+    element: Optional[str]
+    charge: Optional[str]
+    altloc: Optional[str]
+
+
+@dataclass
+class Residue():
+    name: str
+    id: str
+    ins_code: Optional[str]
+    atoms: List[Atom] = field(default_factory=list)
+
+    def add_atom(self, atom: Atom) -> None:
+        self.atoms.append(atom)
+
+@dataclass
+class Chain():
+    id: str
+    residues: Dict[str, Residue] = field(default_factory=dict)
+
+    def add_residue(self, residue: Residue):
+        self.residues[residue.id] = residue
+        # self.residues.append(residue)
+
+    def get_residue(self, id):
+        return self.residues[id]
+
+@dataclass
+class Model:
+    id: str
+    chains: Dict[str, Chain] = field(default_factory=dict)
+
+    def add_chain(self, chain: Chain) -> None:
+        self.chains[chain.id] = chain
+        # self.chains.append(chain)
+
+    def get_chain(self, id) -> Chain:
+        return self.chains[id]
+
+@dataclass
+class Structure:
+    id: str
+    # title: str = ""
+    models: Dict[str, Model] = field(default_factory=dict)
+
+    def add_model(self, model: Model) -> None:
+        self.models[model.id] = model
+        # self.models.append(model)

{aldepyde-0.0.0a38/aldepyde/biomolecule → aldepyde-0.0.0a43/aldepyde/biomolecule_old}/_AtomFactory.py

@@ -1,4 +1,4 @@
-from aldepyde.biomolecule._Atom import Atom as atom
+from aldepyde.biomolecule_old._Atom import Atom as atom
 
 __all__ = ['CreateAtom', 'CreateEnforced', 'CreateDummy']
 

{aldepyde-0.0.0a38/aldepyde/biomolecule → aldepyde-0.0.0a43/aldepyde/biomolecule_old}/__init__.py

@@ -15,4 +15,4 @@ __all__ =  list(set(_amino_acid.__all__.copy()) |
 
 import sys
 
-sys.stderr.write("Note that the `biomolecule` submodule is not yet fully tested and may be unstable")
+sys.stderr.write("Note that the `biomolecule_old` submodule is not yet fully tested and may be unstable")

aldepyde-0.0.0a43/aldepyde/biomolecule_old/_amino_acid.py

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

aldepyde-0.0.0a43/aldepyde/biomolecule_old/_dna.py

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

{aldepyde-0.0.0a38/aldepyde/biomolecule → aldepyde-0.0.0a43/aldepyde/biomolecule_old}/_pdb.py

@@ -1,6 +1,6 @@
 # Submodule for reading, writing, and fetching PDB/mmcif files
 from aldepyde.configurable import Configurable
-from aldepyde.data import RemoteFileHandler
+from aldepyde.remode_data import RemoteFileHandler
 from ._AtomFactory import *
 from ._Atom import Atom
 from aldepyde import cache
@@ -232,7 +232,7 @@ class PDB(Configurable):
         # url = r'https://files.rcsb.org/download/' + prot.strip() + '.pdb'
         # try:
         #     with urllib.request.urlopen(url) as f:
-        #         self.biomolecule.SetFetch(f.read().decode('utf-8'))
+        #         self.biomolecule_old.SetFetch(f.read().decode('utf-8'))
         #         self._Parse(hold_pdb)
         #         return True
         # except urllib.error.URLError:
@@ -256,11 +256,11 @@ class PDB(Configurable):
 
 # class PDB:
 #     def __init__(self):
-#         self.biomolecule = biomolecule()
+#         self.biomolecule_old = biomolecule_old()
 #         # print(apalib.j_data.GetJson())
 #
 #     def Current(self):
-#         return self.biomolecule
+#         return self.biomolecule_old
 #
 #     def FetchFASTA(self, prot):
 #         import urllib.request
@@ -287,7 +287,7 @@ class PDB(Configurable):
 #         url = r'https://files.rcsb.org/download/' + prot.strip() + '.pdb'
 #         try:
 #             with urllib.request.urlopen(url) as f:
-#                 self.biomolecule.SetFetch(f.read().decode('utf-8'))
+#                 self.biomolecule_old.SetFetch(f.read().decode('utf-8'))
 #                 self._Parse(hold_pdb)
 #                 return True
 #         except urllib.error.URLError:
@@ -298,15 +298,15 @@ class PDB(Configurable):
 #
 #     def Read(self, path, hold_pdb=False):
 #         with open(path, 'r') as fp:
-#             self.biomolecule.SetFetch(fp.read())
+#             self.biomolecule_old.SetFetch(fp.read())
 #             self._Parse(hold_pdb)
 #
 #     # Wrapper for the ParsePDB file to allow functionality with a fetched protein
 #     def _Parse(self, hold_pdb=False):
 #         try:
-#             if self.biomolecule.GetFetch() is None:
+#             if self.biomolecule_old.GetFetch() is None:
 #                 raise apaExcept.NoFetchError
-#             return self._ParsePDB(self.biomolecule.GetFetch(), hold_pdb)
+#             return self._ParsePDB(self.biomolecule_old.GetFetch(), hold_pdb)
 #             # return self._ParsePDB(self.container.GetFetch().splitlines())
 #         except apaExcept.NoFetchError as e:
 #             sys.stderr.write(e.message)
@@ -314,10 +314,10 @@ class PDB(Configurable):
 #
 #     #PDB standard described here: https://www.wwpdb.org/documentation/file-format-content/format33/v3.3.html
 #     def _ParsePDB(self, raw_pdb, hold_pdb=False):
-#         self.biomolecule.ClearAll()
+#         self.biomolecule_old.ClearAll()
 #         remark350 = ""
 #         if hold_pdb:
-#             self.biomolecule.SetFetch(raw_pdb)
+#             self.biomolecule_old.SetFetch(raw_pdb)
 #         for line in raw_pdb.splitlines():
 #             # print(line)
 #             if line[0:6] == 'ATOM  ' or line[0:6] == 'HETATM':
@@ -326,8 +326,8 @@ class PDB(Configurable):
 #                 remark350 += line + "\n"
 #
 #         symmetry_groups = self._ParseRemark350(remark350)
-#         self.biomolecule._AddSymmetry(symmetry_groups)
-#         self.biomolecule._PostParseEvaluations()
+#         self.biomolecule_old._AddSymmetry(symmetry_groups)
+#         self.biomolecule_old._PostParseEvaluations()
 #     def _ParseRemark350(self, remark350):
 #         lines = remark350.splitlines()
 #         lines.append("END")
@@ -352,22 +352,22 @@ class PDB(Configurable):
 #                 symLines.append([BIOMT, int(id), float(x), float(y), float(z) ,float(m)])
 #             elif symFlag:
 #                 symFlag = False
-#                 biomolecule = {}
-#                 biomolecule['chains'] = chains
+#                 biomolecule_old = {}
+#                 biomolecule_old['chains'] = chains
 #                 for sl in symLines:
-#                     if sl[1] not in biomolecule.keys():
-#                         biomolecule[sl[1]] = []
-#                     biomolecule[sl[1]].append([sl[0]] + sl[2:])
-#                 biomolecules.append(biomolecule)
+#                     if sl[1] not in biomolecule_old.keys():
+#                         biomolecule_old[sl[1]] = []
+#                     biomolecule_old[sl[1]].append([sl[0]] + sl[2:])
+#                 biomolecules.append(biomolecule_old)
 #             #I hate PDB file format
 #         for i in range(len(biomolecules)):
-#             biomolecule = biomolecules[i]
-#             for key in biomolecule.keys():
-#                 biomolecule[key].sort(key=lambda x:x[0])
-#                 for i in range(len(biomolecule[key])):
+#             biomolecule_old = biomolecules[i]
+#             for key in biomolecule_old.keys():
+#                 biomolecule_old[key].sort(key=lambda x:x[0])
+#                 for i in range(len(biomolecule_old[key])):
 #                     if key == "chains":
 #                         continue
-#                     biomolecule[key][i].pop(0)
+#                     biomolecule_old[key][i].pop(0)
 #         return biomolecules
 #
 #     def _ExtractAtomAndResidue(self, line):
@@ -392,22 +392,22 @@ class PDB(Configurable):
 #             resType = "HETATM"
 #         else:
 #             resType = self.DetermineResType(resName)
-#         residue = self.biomolecule.AddResidue(resType, resSeq, resName, chainID)
+#         residue = self.biomolecule_old.AddResidue(resType, resSeq, resName, chainID)
 #         residue.InsertAtom(atom)
 #
 #     def DetermineResType(self, res_code):
-#         if data.ValidateRNA(res_code):
+#         if remode_data.ValidateRNA(res_code):
 #             return 'RNA'
-#         elif data.ValidateDNA(res_code):
+#         elif remode_data.ValidateDNA(res_code):
 #             return 'DNA'
-#         elif data.ValidateAA(res_code):
+#         elif remode_data.ValidateAA(res_code):
 #             return "AA"
 #         else:
 #             return "HETATM"
 #
 #     #Remove all of the waters from the current fetch. Probably make this more general for any HETATM group. Make a wrapper?
 #     def RemoveWater(self):
-#         h_chains = self.biomolecule.GetHETATMChains()
+#         h_chains = self.biomolecule_old.GetHETATMChains()
 #         for chain in h_chains.keys():
 #             h_chains[chain] = {key: value for (key, value) in h_chains[chain].items() if value.GetResName().upper() != 'HOH'}
 #
@@ -420,7 +420,7 @@ class PDB(Configurable):
 #
 #     def AddChain(self, collection, name=None):
 #         if name is None:
-#             chains = list(self.biomolecule.Chains.keys())
+#             chains = list(self.biomolecule_old.Chains.keys())
 #             for i in range(26):
 #                 if chr(ord('z') - i) not in chains:
 #                     name = chr(ord('z') - i)
@@ -433,23 +433,23 @@ class PDB(Configurable):
 #             residue.SetChainID(name)
 #             for atom in residue.GetAtoms():
 #                 atom.SetChainID(name)
-#         self.biomolecule.AddChain(name)
-#         self.biomolecule.Chains[name] = collection
+#         self.biomolecule_old.AddChain(name)
+#         self.biomolecule_old.Chains[name] = collection
 #
 #     def WritePDB(self, fp):
-#         s = sorted(self.biomolecule.DumpResidues(), key=lambda x: x.seqNum)
+#         s = sorted(self.biomolecule_old.DumpResidues(), key=lambda x: x.seqNum)
 #         with open(fp, "w") as f:
 #             for res in s:
 #                 f.write(res.WriteForPDB())
 #
 #     #Write contents to FASTA
 #     def ToFASTA(self):
-#         ls = self.biomolecule.AsList(ordered=True)
+#         ls = self.biomolecule_old.AsList(ordered=True)
 #         retStr = ""
 #         for r in ls:
-#             if data.ValidateAA(r.resName):
-#                 name = data.Map("Amino Acids", r.resName)
-#                 retStr += data.GetJson()["Amino Acids"][name]["1code"]
+#             if remode_data.ValidateAA(r.resName):
+#                 name = remode_data.Map("Amino Acids", r.resName)
+#                 retStr += remode_data.GetJson()["Amino Acids"][name]["1code"]
 #             elif r.resName.upper() != "HOH":
 #                 retStr += "X"
 #         return retStr

aldepyde-0.0.0a43/aldepyde/biomolecule_old/_rna.py

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

{aldepyde-0.0.0a38 → aldepyde-0.0.0a43}/aldepyde/cache/_cache.py

@@ -5,7 +5,7 @@
 # import re # We're getting spicy with this
 # import gzip
 # from io import BytesIO, TextIOWrapper
-# import json
+# import data
 # from dataclasses import dataclass
 # from aldepyde.env import ENV
 #
@@ -72,21 +72,21 @@
 #
 #     def load(self, path):
 #         with open(path, "r") as fp:
-#             settings = json.load(fp)
+#             settings = data.load(fp)
 #         self._enabled = settings['enabled']
 #         self._max_memory = settings['max_memory']
 #
 #     def _save_cache(self):
 #         marker = os.path.join(self._path, self.cache_marker)
 #         # with open(marker, "r") as fp:
-#         #     settings = json.load(fp)
+#         #     settings = data.load(fp)
 #         settings = {}
 #         settings["version"] = self.version
 #         settings["enabled"] = self._enabled
 #         settings["path"] = self._path
 #         settings["max_memory"] = self._max_memory
 #         with open(marker, "w") as fp:
-#             fp.write(json.dumps(settings, indent=2))
+#             fp.write(data.dumps(settings, indent=2))
 #
 #     def designate_cache(self, path) -> None:
 #         os.makedirs(self._path, exist_ok=True)

{aldepyde-0.0.0a38 → aldepyde-0.0.0a43}/aldepyde/cache/cachemanager.py

@@ -2,6 +2,8 @@ import os
 import sys
 import json
 from dataclasses import dataclass
+from io import BytesIO
+
 from aldepyde.env import ENV
 from .utils import _parse_memory, _convert_memory_bytes, _convert_memory_bits
 
@@ -11,9 +13,7 @@ def requires_enabled(func):
         if hasattr(cls, "enabled") and cls.enabled and cls._initialized:
             return func(cls, *args, **kwargs)
         else:
-            print("Cache manager not initialized")
-            pass
-
+            return None
     return wrapper
 
 
@@ -23,6 +23,7 @@ class CacheManager():
             self._initialized = False
             return
         self._initialized = True
+        self.enable()
         self._cache_marker = ".aldepyde_cache"
         self.fingerprint = "adpy."
         if path is None:
@@ -30,7 +31,11 @@ class CacheManager():
         else:
             self._path = path
         if os.path.exists(self.marker_location()):
-            self.load_manager()
+            try:
+                self.load_manager()
+            except json.decoder.JSONDecodeError:
+                self.load_defaults()
+                self.save_settings()
         else:
             self.load_defaults()
             self.save_settings()
@@ -58,7 +63,7 @@ class CacheManager():
         return f"{self.__dict__}"
 
     @requires_enabled
-    def marker_location(self):
+    def marker_location(self) -> str:
         return os.path.join(self._path, self._cache_marker)
 
     # Saves settings to a location. If a path is specified, the results are saved to that location
@@ -70,8 +75,8 @@ class CacheManager():
         elif os.path.isdir(path):
             path = os.path.join(path, self._cache_marker)
         with open(path, 'w') as fp:
-            for v in vars(self):
-                print(v)
+            # for v in vars(self):
+            #     print(v)
             fp.write(json.dumps(vars(self), indent=2))
 
     @requires_enabled
@@ -95,6 +100,9 @@ class CacheManager():
     def _enabled_and_initialized(self):
         return self.enabled and self._initialized
 
+    def is_enabled(self):
+        return self.enabled
+
     @requires_enabled
     def load_defaults(self):
         self._cache_marker = ".aldepyde_cache"
@@ -103,9 +111,17 @@ class CacheManager():
         self.enabled = True
 
     @requires_enabled
-    def _inside(self, f):
+    def _inside(self, f) -> str:
         return os.path.join(self._path, f)
 
+    @requires_enabled
+    def peek(self, name):
+        files = []
+        for file in self.list_cache():
+            if name.lower() in file.lower():
+                files.append(file)
+        return files
+
     # Requires a filename, not a path. The path will be self._path
     @requires_enabled
     def _is_safe_to_delete(self, filename):
@@ -132,16 +148,23 @@ class CacheManager():
                 os.remove(self._inside(file))
                 print(f"Deleting {file}")
 
-    @requires_enabled
-    def get(self, file) -> str | None:
-        if not self._enabled_and_initialized():
-            return None
-        return self._inside(file) if self.exists(file) else None
+    # @requires_enabled
+    # def get(self, file) -> str | None:
+    #     if not self._enabled_and_initialized():
+    #         return None
+    #     return self._inside(file) if self.exists(file) else None
 
     # TODO Create a with cache_manager.open(...) setup here
     # def open(self, filename):
     #     pass
 
+    @requires_enabled
+    def retrieve(self, filename:str) -> str|None:
+        if self.exists(filename):
+            return self._inside(filename)
+        else:
+            return None
+
     @requires_enabled
     def exists(self, filename):
         return os.path.isfile(self._inside(filename))