Add project.new_recipe() to automatically return a typed recipe creator + add prepare recipe creator

Author: cstenac

dataikuapi/dss/dataset.py

@@ -481,7 +481,7 @@ def new_code_recipe(self, type, code=None, recipe_name=None):
 
     def new_grouping_recipe(self, first_group_by, recipe_name=None):
         if recipe_name is None:
-            recipe_name = "grouping_recipe_from_%s" % (self.dataset_name)
+            recipe_name = "group_%s" % (self.dataset_name)
         builder = recipe.GroupingRecipeCreator(recipe_name, self.project)
         builder.with_input(self.dataset_name)
         builder.with_group_key(first_group_by)

dataikuapi/dss/project.py

@@ -1,6 +1,7 @@
 import time, warnings, sys, os.path as osp
 from .dataset import DSSDataset, DSSManagedDatasetCreationHelper
 from .recipe import DSSRecipe
+from . import recipe
 from .managedfolder import DSSManagedFolder
 from .savedmodel import DSSSavedModel
 from .job import DSSJob, DSSJobWaiter
@@ -829,13 +830,9 @@ def list_recipes(self):
 
     def get_recipe(self, recipe_name):
         """
-        Get a handle to interact with a specific recipe
-       
-        Args:
-            recipe_name: the name of the desired recipe
-        
-        Returns:
-            A :class:`dataikuapi.dss.recipe.DSSRecipe` recipe handle
+        Gets a :class:`dataikuapi.dss.recipe.DSSRecipe` handle to interact with a recipe
+        :param str recipe_name: The name of the recipe
+        :rtype :class:`dataikuapi.dss.recipe.DSSRecipe`
         """
         return DSSRecipe(self.client, self.project_key, recipe_name)
 
@@ -862,6 +859,67 @@ def create_recipe(self, recipe_proto, creation_settings):
                        body = definition)['name']
         return DSSRecipe(self.client, self.project_key, recipe_name)
 
+    def new_recipe(self, type, name):
+        """
+        Initializes the creation of a new recipe. Returns a :class:`dataikuapi.dss.recipe.DSSRecipeCreator`
+        or one of its subclasses to complete the creation of the recipe.
+
+        Usage example:
+
+        .. code-block:: python
+
+            grouping_recipe_builder = project.new_recipe("grouping")
+            grouping_recipe_builder.with_input("dataset_to_group_on")
+            # Create a new managed dataset for the output in the "filesystem_managed" connection
+            grouping_recipe_builder.with_new_output("grouped_dataset", "filesystem_managed")                                    
+            grouping_recipe_builder.with_group_key("column")
+            recipe = grouping_recipe_builder.build()
+
+            # After the recipe is created, you can edit its settings
+            recipe_settings = recipe.get_settings()
+            recipe_settings.set_column_aggregations("value", sum=True)
+            recipe_settings.save()
+
+            # And you may need to apply new schemas to the outputs
+            recipe.compute_schema_updates().apply()
+
+        :param str type: Type of the recipe
+        :rtype: :class:`dataikuapi.dss.recipe.DSSRecipeCreator`
+        """
+
+        if type == "grouping":
+            return recipe.GroupingRecipeCreator(name, self)
+        elif type == "window":
+            return recipe.WindowRecipeCreator(name, self)
+        elif type == "sync":
+            return recipe.SyncRecipeCreator(name, self)
+        elif type == "sort":
+            return recipe.SortRecipeCreator(name, self)
+        elif type == "topn":
+            return recipe.TopNRecipeCreator(name, self)
+        elif type == "distinct":
+            return recipe.DistinctRecipeCreator(name, self)
+        elif type == "join":
+            return recipe.JoinRecipeCreator(name, self)
+        elif type == "vstack":
+            return recipe.StackRecipeCreator(name, self)
+        elif type == "sampling":
+            return recipe.SamplingRecipeCreator(name, self)
+        elif type == "split":
+            return recipe.SplitRecipeCreator(name, self)
+        elif type == "prepare" or type == "shaker":
+            return recipe.PrepareRecipeCreator(name, self)
+        elif type == "prediction_scoring":
+            return recipe.PredictionScoringRecipeCreator(name, self)
+        elif type == "clustering_scoring":
+            return recipe.ClusteringScoringRecipeCreator(name, self)
+        elif type == "download":
+            return recipe.DownloadRecipeCreator(name, self)
+        elif type == "sql_query":
+            return recipe.SQLQueryRecipeCreator(name, self)
+        elif type in ["python", "r", "sql_script", "pyspark", "sparkr", "spark_scala", "shell"]:
+            return recipe.CodeRecipeCreator(name, type, self)
+
     ########################################################
     # Flow
     ########################################################

dataikuapi/dss/recipe.py

@@ -17,7 +17,7 @@ def __init__(self, client, project_key, recipe_name):
     # Dataset deletion
     ########################################################
 
-    def compute_schema_update(self):
+    def compute_schema_updates(self):
         """
         Computes which updates are required to the outputs of this recipe.
         The required updates are returned as a :class:`RequiredSchemaUpdates` object, which then
@@ -27,7 +27,7 @@ def compute_schema_update(self):
 
         .. code-block:: python
 
-            required_updates = recipe.compute_schema_update()
+            required_updates = recipe.compute_schema_updates()
             if required_updates.any_action_required():
                 print("Some schemas will be updated")
 
@@ -318,14 +318,25 @@ def replace_output(self, current_output_ref, new_output_ref):
 
 # Old name
 class DSSRecipeDefinitionAndPayload(DSSRecipeSettings):
+    """
+    Deprecated. Settings of a recipe. Do not create this directly, use :meth:`DSSRecipe.get_settings`
+    """
     pass
 
 class GroupingRecipeSettings(DSSRecipeSettings):
+    """
+    Settings of a grouping recipe. Do not create this directly, use :meth:`DSSRecipe.get_settings`
+    """
     def clear_grouping_keys(self):
+        """Removes all grouping keys from this grouping recipe"""
         self._payload_to_obj()
         self.obj_payload["keys"] = []
 
     def add_grouping_key(self, column):
+        """
+        Adds grouping on a column
+        :param str column: Column to group on
+        """
         self._payload_to_obj()
         self.obj_payload["keys"].append({"column":column})
 
@@ -584,6 +595,13 @@ class DistinctRecipeCreator(SingleOutputRecipeCreator):
     def __init__(self, name, project):
         SingleOutputRecipeCreator.__init__(self, 'distinct', name, project)
 
+class PrepareRecipeCreator(SingleOutputRecipeCreator):
+    """
+    Create a Prepare recipe
+    """
+    def __init__(self, name, project):
+        SingleOutputRecipeCreator.__init__(self, 'shaker', name, project)
+
 class GroupingRecipeCreator(SingleOutputRecipeCreator):
     """
     Create a Group recipe
@@ -782,7 +800,7 @@ def __init__(self, name, project):
 class RequiredSchemaUpdates(object):
     """
     Representation of the updates required to the schema of the outputs of a recipe.
-    Do not create this class directly, use :meth:`DSSRecipe.compute_schema_update`
+    Do not create this class directly, use :meth:`DSSRecipe.compute_schema_updates`
     """
 
     def __init__(self, recipe, data):