openprotein-python 0.3.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

openprotein/__init__.py

@@ -3,79 +3,97 @@ from openprotein._version import __version__
 from openprotein.base import APISession
 from openprotein.api.jobs import JobsAPI, Job
 from openprotein.api.data import DataAPI
-from openprotein.api.poet import PoetAPI
+from openprotein.api.align import AlignAPI
 from openprotein.api.embedding import EmbeddingAPI
 from openprotein.api.train import TrainingAPI
 from openprotein.api.design import DesignAPI
-from openprotein.api.predict import PredictAPI
 from openprotein.api.fold import FoldAPI
+from openprotein.api.jobs import load_job
+
 
 class OpenProtein(APISession):
     """
     The base class for accessing OpenProtein API functionality.
     """
 
+    _embedding = None
+    _fold = None
+    _align = None
+    _jobs = None
+    _data = None
+    _train = None
+    _design = None
+
     def wait(self, job: Job, *args, **kwargs):
         return job.wait(self, *args, **kwargs)
-    
+
     wait_until_done = wait
 
+    def load_job(self, job_id):
+        return load_job(self, job_id)
+
     @property
-    def jobs(self):
+    def jobs(self) -> JobsAPI:
         """
         The jobs submodule gives access to functionality for listing jobs and checking their status.
         """
-        return JobsAPI(self)
-    
+        if self._jobs is None:
+            self._jobs = JobsAPI(self)
+        return self._jobs
+
     @property
-    def data(self):
+    def data(self) -> DataAPI:
         """
-        The data submodule gives access to functionality for uploading and accessing user data. 
+        The data submodule gives access to functionality for uploading and accessing user data.
         """
-        return DataAPI(self)
-    
-    @property 
-    def train(self):
+        if self._data is None:
+            self._data = DataAPI(self)
+        return self._data
+
+    @property
+    def train(self) -> TrainingAPI:
         """
-        The train submodule gives access to functionality for training and validating ML models. 
+        The train submodule gives access to functionality for training and validating ML models.
         """
-        return TrainingAPI(self)
+        if self._train is None:
+            self._train = TrainingAPI(self)
+        return self._train
 
     @property
-    def poet(self):
+    def align(self) -> AlignAPI:
         """
         The PoET submodule gives access to the PoET generative model and MSA and prompt creation interfaces.
         """
-        return PoetAPI(self)
-    
+        if self._align is None:
+            self._align = AlignAPI(self)
+        return self._align
+
     @property
-    def embedding(self):
+    def embedding(self) -> EmbeddingAPI:
         """
         The embedding submodule gives access to protein embedding models and their inference endpoints.
         """
-        return EmbeddingAPI(self)
+        if self._embedding is None:
+            self._embedding = EmbeddingAPI(self)
+        return self._embedding
 
-    @property 
-    def predict(self):
-        """
-        The predict submodule gives access to sequence predictions using models from train. 
-        """
-        return PredictAPI(self)
-    
     @property
-    def design(self):
+    def design(self) -> DesignAPI:
         """
-        The design submodule gives access to functionality for designing new sequences using models from train. 
+        The design submodule gives access to functionality for designing new sequences using models from train.
         """
-        return DesignAPI(self)
+        if self._design is None:
+            self._design = DesignAPI(self)
+        return self._design
 
-    
     @property
-    def fold(self):
+    def fold(self) -> FoldAPI:
         """
-        The fold submodule gives access to functionality for folding sequences and returning PDBs. 
+        The fold submodule gives access to functionality for folding sequences and returning PDBs.
         """
-        return FoldAPI(self)
-    
+        if self._fold is None:
+            self._fold = FoldAPI(self)
+        return self._fold
+
 
 connect = OpenProtein

openprotein/api/__init__.py

@@ -2,6 +2,6 @@ from . import data
 from . import design
 from . import train 
 from . import predict
-from . import poet 
+from . import align 
 from . import embedding
 from . import fold