added first iteration of easy_publish

dlhub_sdk/client.py

@@ -13,6 +13,13 @@
 from mdf_toolbox.globus_search.search_helper import SEARCH_LIMIT
 from funcx.sdk.client import FuncXClient
 
+from dlhub_sdk.models.servables.keras import KerasModel
+from dlhub_sdk.models.servables.pytorch import TorchModel
+from dlhub_sdk.models.servables.python import PythonClassMethodModel
+from dlhub_sdk.models.servables.python import PythonStaticMethodModel
+from dlhub_sdk.models.servables.tensorflow import TensorFlowModel
+from dlhub_sdk.models.servables.sklearn import ScikitLearnModel
+
 from dlhub_sdk.config import DLHUB_SERVICE_ADDRESS, CLIENT_ID
 from dlhub_sdk.utils.futures import DLHubFuture
 from dlhub_sdk.utils.schemas import validate_against_dlhub_schema
@@ -24,6 +31,10 @@
 logger = logging.getLogger(__name__)
 
 
+class HelpMessage(Exception):
+    """Raised from another error to provide the user an additional message"""
+
+
 class DLHubClient(BaseClient):
     """Main class for interacting with the DLHub service
 
@@ -336,6 +347,60 @@ def get_result(self, task_id, verbose=False):
             result = result[0]
         return result
 
+    def easy_publish(self, title: str, creators: Union[str, list[str]], short_name: str, servable_type: str, serv_options: dict[str, Any]):
+        """Simplified publishing method for servables
+
+        Args:
+            title (string): title for the servable
+            creators (string | list): either the creator's name (FamilyName, GivenName) or a list of the creators' names
+            short_name (string): shorthand name for the servable
+            servable_type (string): the type of the servable, must be a member of ("static_method",
+                                                                                   "class_method",
+                                                                                   "keras",
+                                                                                   "pytorch",
+                                                                                   "tensorflow",
+                                                                                   "sklearn") more information on servable types can be found here:
+                                                                                   https://dlhub-sdk.readthedocs.io/en/latest/servable-types.html
+            serv_options (dict): the servable_type specific arguments that are necessary for publishing
+        Returns:
+            (string): task id of this submission, can be used to check for success
+        Raises:
+            ValueError: If the given servable_type is not in the list of acceptable types
+            Exception: If the serv_options are incomplete or the request to publish results in an error
+        """
+        # conversion table for model string names to classes
+        models = {"static_method": PythonStaticMethodModel,
+                  "class_method": PythonClassMethodModel,
+                  "keras": KerasModel,
+                  "pytorch": TorchModel,
+                  "tensorflow": TensorFlowModel,
+                  "sklearn": ScikitLearnModel}
+
+        # raise an error if the provided servable_type is invalid
+        model = models.get(servable_type)
+        if model is None:
+            raise ValueError(f"dl.easy_publish given invalid servable type: {servable_type}, please refer to the docstring")
+
+        # attempt to construct the model and raise a helpful error if needed
+        try:
+            model_info = model.create_model(**serv_options)
+        except Exception as e:
+            help_err = HelpMessage(f"Help can be found here:\nhttps://dlhub-sdk.readthedocs.io/en/latest/source/dlhub_sdk.models.servables.html#"
+                                   f"{model.__module__}.{model.__name__}.create_model")
+            raise help_err from e
+
+        # set the required datacite fields
+        model_info.set_title(title)
+        creators = [creators] if isinstance(creators, str) else creators  # handle the case where creators is a string
+        model_info.set_creators(creators, [])  # we do not ask for affiliations
+        model_info.set_name(short_name)
+
+        # perform the publish
+        task_id = self.publish_servable(model_info)
+
+        # return the id of the publish task
+        return task_id
+
     def publish_servable(self, model):
         """Submit a servable to DLHub
 

dlhub_sdk/models/servables/python.py

@@ -153,8 +153,8 @@ class PythonStaticMethodModel(BasePythonServableModel):
     """
 
     @classmethod
-    def create_model(cls, module, method, autobatch=False, function_kwargs=None):
-        """Initialize the method
+    def create_model(cls, module=None, method=None, autobatch=False, function_kwargs=None, *, f=None):
+        """Initialize the method based on the provided arguments
 
         Args:
             module (string): Name of the module holding the function
@@ -163,7 +163,17 @@ def create_model(cls, module, method, autobatch=False, function_kwargs=None):
                 Calls :code:`map(f, list)`
             function_kwargs (dict): Names and values of any other argument of the function to set
                 the values must be JSON serializable.
+            f (object): Function pointer to the Python function to be published
+        Raises:
+            TypeError: If there is no valid way to process the given arguments
         """
+        # determine which set of acceptable parameters was given, or err if invalid (valid would be f | module & method)
+        if f is not None:
+            module, method = f.__module__, f.__name__  # if f is provided, assign its module and method names
+        elif module is None or method is None:
+            raise TypeError("PythonStaticMethodModel.create_model was not provided valid arguments. Please provide either a funtion pointer"
+                            " or the module and name of the desired static function")
+
         output = super(PythonStaticMethodModel, cls).create_model(method, function_kwargs)
 
         output.servable.methods["run"].method_details.update({
@@ -175,13 +185,12 @@ def create_model(cls, module, method, autobatch=False, function_kwargs=None):
     @classmethod
     def from_function_pointer(cls, f, autobatch=False, function_kwargs=None):
         """Construct the module given a function pointer
-
         Args:
-            f (object): A function pointer
+            f (object): Function pointer to the Python function to be published
             autobatch (bool): Whether to run function on an iterable of entries
             function_kwargs (dict): Any default options for this function
         """
-        return cls.create_model(f.__module__, f.__name__, autobatch, function_kwargs)
+        return cls.create_model(f=f, autobatch=autobatch, function_kwargs=function_kwargs)
 
     def _get_handler(self):
         return 'python.PythonStaticMethodServable'

dlhub_sdk/tests/test_dlhub_client.py

@@ -2,6 +2,7 @@
 
 import mdf_toolbox
 from pytest import fixture, raises, mark
+from pytest_mock import mocker  # your editor may fail to detect its usage
 
 from dlhub_sdk.models.servables.python import PythonStaticMethodModel
 from dlhub_sdk.utils.futures import DLHubFuture
@@ -73,9 +74,9 @@ def test_run(dl):
     assert res.result(timeout=60) == 'Hello world!'
 
 
-@mark.skipif(not is_gha, reason='Avoid running this test except on larger-scale tests of the system')
-@mark.skip
-def test_submit(dl):
+# @mark.skipif(not is_gha, reason='Avoid running this test except on larger-scale tests of the system')
+# @mark.skip
+def test_submit(dl, mocker):
     # Make an example function
     model = PythonStaticMethodModel.create_model('numpy.linalg', 'norm')
     model.dlhub.test = True
@@ -84,8 +85,24 @@ def test_submit(dl):
     model.set_inputs('ndarray', 'Array to be normed', shape=[None])
     model.set_outputs('number', 'Norm of the array')
 
+    # make dummy reply for patch to return
+    class DummyReply:
+        def __init__(self) -> None:
+            self.status_code = 200
+
+        def json(self) -> dict[str, str]:
+            return {"task_id": "bf06d72e-0478-11ed-97f9-4b1381555b22"}  # valid task id, status is known to be FAILED
+
+    # patch requests.post
+    mocker.patch("requests.post", return_value=DummyReply())
+
     # Submit the model
-    dl.publish_servable(model)
+    task_id = dl.publish_servable(model)
+    assert task_id == "bf06d72e-0478-11ed-97f9-4b1381555b22"
+
+    # Submit the model using easy publish
+    task_id = dl.easy_publish("Norm of a 1D Array", "Developer, Some", "1d_norm", "static_method", {"module": "numpy.linalg", "method": "norm"})
+    assert task_id == "bf06d72e-0478-11ed-97f9-4b1381555b22"
 
 
 def test_describe_model(dl):

dlhub_sdk/utils/validation.py

@@ -36,7 +36,7 @@ def _type_name_to_type(name: str) -> Union[type, Tuple[type]]:
     try:
         return type_table.get(name) or __builtins__[name]  # getattr(__builtins__, name) if __builtins__ is a module
     except KeyError:  # AttributeError if __builtins__ is a module
-        raise ValueError(f"found an unknown type name in servable metadata: {name}")
+        raise ValueError(f"found an unknown type name in servable metadata: {name}") from None
 
 
 def _generate_err(err_type: Exception, path: List[Tuple[str, Hashable]], expected: type = None, given: type = None, *, msg: str = None) -> Exception: