Merge pull request #57 from dataiku/fix/dss70-function-mutable-args

style: make all mutable function arguments "None" and init in function body

Author: nicolasservel

dataikuapi/dss/macro.py

@@ -33,16 +33,20 @@ def get_definition(self):
         return self.definition
 
 
-    def run(self, params={}, admin_params={}, wait=True):
+    def run(self, params=None, admin_params=None, wait=True):
         """
         Run the macro from the project
 
-        :param params: parameters to the macro run
-        :param admin_params: admin parameters to the macro run (if the authentication of
-                             the api client does not cover admin rights, they are ignored)
+        :param dict params: parameters to the macro run (defaults to `{}`)
+        :param dict admin_params: admin parameters to the macro run (if the authentication of
+                             the api client does not cover admin rights, they are ignored, defaults to `{}`)
         :param wait: if True, the call blocks until the run is finished
         :returns: a run identifier to use to abort or retrieve results
         """
+        if params is None:
+            params = {}
+        if admin_params is None:
+            admin_params = {}
         return self.client._perform_json(
             "POST", "/projects/%s/runnables/%s" % (self.project_key, self.runnable_type), 
             params={'wait':wait}, body={'params':params, 'adminParams':admin_params})['runId']
@@ -88,4 +92,3 @@ def get_result(self, run_id, as_type=None):
         else:
             return resp.raw
 
-

dataikuapi/dss/ml.py

@@ -1322,11 +1322,11 @@ def train(self, session_name=None, session_description=None):
         self.wait_train_complete()
         return self.get_trained_models_ids(session_id = train_ret["sessionId"])
 
-    def ensemble(self, model_ids=[], method=None):
+    def ensemble(self, model_ids=None, method=None):
         """
         Create an ensemble model of a set of models
         
-        :param list model_ids: A list of model identifiers
+        :param list model_ids: A list of model identifiers (defaults to `[]`)
         :param str method: the ensembling method. One of: AVERAGE, PROBA_AVERAGE, MEDIAN, VOTE, LINEAR_MODEL, LOGISTIC_MODEL
 
         This method waits for the ensemble train to complete. If you want to train asynchronously, use :meth:`start_ensembling` and :meth:`wait_train_complete`
@@ -1340,6 +1340,8 @@ def ensemble(self, model_ids=[], method=None):
         :return: A model identifier
         :rtype: string
         """
+        if model_ids is None:
+            model_ids = []
         train_ret = self.start_ensembling(model_ids, method)
         self.wait_train_complete()
         return train_ret
@@ -1363,18 +1365,20 @@ def start_train(self, session_name=None, session_description=None):
                 "POST", "/projects/%s/models/lab/%s/%s/train" % (self.project_key, self.analysis_id, self.mltask_id), body=session_info)
 
 
-    def start_ensembling(self, model_ids=[], method=None):
+    def start_ensembling(self, model_ids=None, method=None):
         """
         Creates asynchronously a new ensemble models of a set of models.
 
-        :param list model_ids: A list of model identifiers
+        :param list model_ids: A list of model identifiers (defaults to `[]`)
         :param str method: the ensembling method (AVERAGE, PROBA_AVERAGE, MEDIAN, VOTE, LINEAR_MODEL, LOGISTIC_MODEL)
 
         This returns immediately, before train is complete. To wait for train to complete, use :meth:`wait_train_complete`
 
         :return: the model identifier of the ensemble
         :rtype: string
         """
+        if model_ids is None:
+            model_ids = []
         ensembling_request = {
                             "method" : method,
                             "modelsIds" : model_ids

dataikuapi/dss/project.py

@@ -49,12 +49,12 @@ def delete(self, drop_data=False):
     # Project export
     ########################################################
 
-    def get_export_stream(self, options = {}):
+    def get_export_stream(self, options=None):
         """
         Return a stream of the exported project
         You need to close the stream after download. Failure to do so will result in the DSSClient becoming unusable.
 
-        :param dict options: Dictionary of export options. The following options are available:
+        :param dict options: Dictionary of export options (defaults to `{}`). The following options are available:
 
             * exportUploads (boolean): Exports the data of Uploaded datasets - default False
             * exportManagedFS (boolean): Exports the data of managed Filesystem datasets - default False
@@ -70,15 +70,31 @@ def get_export_stream(self, options = {}):
         :returns: a file-like obbject that is a stream of the export archive
         :rtype: file-like
         """
+        if options is None:
+            options = {}
         return self.client._perform_raw(
             "POST", "/projects/%s/export" % self.project_key, body=options).raw
 
-    def export_to_file(self, path, options={}):
+    def export_to_file(self, path, options=None):
         """
         Export the project to a file
         
         :param str path: the path of the file in which the exported project should be saved
+        :param dict options: Dictionary of export options (defaults to `{}`). The following options are available:
+
+            * exportUploads (boolean): Exports the data of Uploaded datasets - default False
+            * exportManagedFS (boolean): Exports the data of managed Filesystem datasets - default False
+            * exportAnalysisModels (boolean): Exports the models trained in analysis - default False
+            * exportSavedModels (boolean): Exports the models trained in saved models - default False
+            * exportManagedFolders (boolean): Exports the data of managed folders - default False
+            * exportAllInputDatasets (boolean): Exports the data of all input datasets - default False
+            * exportAllDatasets (boolean): Exports the data of all datasets - default False
+            * exportAllInputManagedFolders (boolean): Exports the data of all input managed folders - default False
+            * exportGitRepositoy (boolean): Exports the Git repository history - default False
+            * exportInsightsData (boolean): Exports the data of static insights - default False
         """
+        if options is None:
+            options = {}
         with open(path, 'wb') as f:
             export_stream = self.client._perform_raw(
                 "POST", "/projects/%s/export" % self.project_key, body=options)
@@ -98,7 +114,7 @@ def duplicate(self, target_project_key,
                   export_saved_models=True,
                   export_git_repository=True,
                   export_insights_data=True,
-                  remapping={},
+                  remapping=None,
                   target_project_folder=None):
         """
         Duplicate the project
@@ -110,13 +126,14 @@ def duplicate(self, target_project_key,
         :param bool export_saved_models:
         :param bool export_git_repository:
         :param bool export_insights_data:
-        :param dict remapping: dict of connections to be remapped for the new project
+        :param dict remapping: dict of connections to be remapped for the new project (defaults to `{}`)
         :param target_project_folder: the project folder where to put the duplicated project
         :type target_project_folder: A :class:`dataikuapi.dss.projectfolder.DSSProjectFolder
         :returns: A dict containing the original and duplicated project's keys
         :rtype: :class:`ProjectDuplicateResult`
         """
-
+        if remapping is None:
+            remapping = {}
         obj = {
             "targetProjectName": target_project_name,
             "targetProjectKey": target_project_key,
@@ -211,7 +228,7 @@ def get_dataset(self, dataset_name):
         return DSSDataset(self.client, self.project_key, dataset_name)
 
     def create_dataset(self, dataset_name, type,
-                params={}, formatType=None, formatParams={}):
+                params=None, formatType=None, formatParams=None):
         """
         Create a new dataset in the project, and return a handle to interact with it.
 
@@ -225,13 +242,17 @@ def create_dataset(self, dataset_name, type,
         
         :param string dataset_name: the name for the new dataset
         :param string type: the type of the dataset
-        :param dict params: the parameters for the type, as a JSON object
+        :param dict params: the parameters for the type, as a JSON object (defaults to `{}`)
         :param string formatType: an optional format to create the dataset with (only for file-oriented datasets)
-        :param string formatParams: the parameters to the format, as a JSON object (only for file-oriented datasets)
+        :param dict formatParams: the parameters to the format, as a JSON object (only for file-oriented datasets, default to `{}`)
         
         Returns:
             A :class:`dataikuapi.dss.dataset.DSSDataset` dataset handle
         """
+        if params is None:
+            params = {}
+        if formatParams is None:
+            formatParams = {}
         obj = {
             "name" : dataset_name,
             "projectKey" : self.project_key,
@@ -676,18 +697,20 @@ def get_scenario(self, scenario_id):
         """
         return DSSScenario(self.client, self.project_key, scenario_id)
 
-    def create_scenario(self, scenario_name, type, definition={'params': {}}):
+    def create_scenario(self, scenario_name, type, definition=None):
         """
         Create a new scenario in the project, and return a handle to interact with it
 
         :param str scenario_name: The name for the new scenario. This does not need to be unique
                                 (although this is strongly recommended)
         :param str type: The type of the scenario. MUst be one of 'step_based' or 'custom_python'
-        :param object definition: the JSON definition of the scenario. Use ``get_definition(with_status=False)`` on an
-                existing ``DSSScenario`` object in order to get a sample definition object
+        :param dict definition: the JSON definition of the scenario. Use ``get_definition(with_status=False)`` on an
+                existing ``DSSScenario`` object in order to get a sample definition object (defaults to `{'params': {}}`)
 
         :returns: a :class:`.scenario.DSSScenario` handle to interact with the newly-created scenario
         """
+        if definition is None:
+            definition = {'params': {}}
         definition['type'] = type
         definition['name'] = scenario_name
         scenario_id = self.client._perform_json("POST", "/projects/%s/scenarios/" % self.project_key,
@@ -790,12 +813,14 @@ def get_tags(self):
         """
         return self.client._perform_json("GET", "/projects/%s/tags" % self.project_key)
 
-    def set_tags(self, tags={}):
+    def set_tags(self, tags=None):
         """
         Set the tags of this project.
-        @param obj: must be a modified version of the object returned by list_tags
+        :param dict tags: must be a modified version of the object returned by list_tags (defaults to `{}`)
         """
-        return self.client._perform_empty("PUT", "/projects/%s/tags" % self.project_key, body = tags)
+        if tags is None:
+            tags = {}
+        return self.client._perform_empty("PUT", "/projects/%s/tags" % self.project_key, body=tags)
 
 
     ########################################################

dataikuapi/dss/scenario.py

@@ -20,12 +20,14 @@ def abort(self):
         return self.client._perform_json(
             "POST", "/projects/%s/scenarios/%s/abort" % (self.project_key, self.id))
 
-    def run(self, params={}):
+    def run(self, params=None):
         """
         Requests a run of the scenario, which will start after a few seconds.
 
-        :params dict params: additional parameters that will be passed to the scenario through trigger params
+        :params dict params: additional parameters that will be passed to the scenario through trigger params (defaults to `{}`)
         """
+        if params is None:
+            params = {}
         trigger_fire = self.client._perform_json(
             "POST", "/projects/%s/scenarios/%s/run" % (self.project_key, self.id), body=params)
         return DSSTriggerFire(self, trigger_fire)
@@ -47,16 +49,16 @@ def get_trigger_fire(self, trigger_id, trigger_run_id):
             })
         return DSSTriggerFire(self, trigger_fire)
 
-    def run_and_wait(self, params={}, no_fail=False):
+    def run_and_wait(self, params=None, no_fail=False):
         """
         Requests a run of the scenario, which will start after a few seconds. Wait the end of the run to complete.
 
-        Args:
-            params: additional parameters that will be passed to the scenario through trigger params
+        :param dict params: additional parameters that will be passed to the scenario through trigger params (defaults to `{}`)
 
-        Returns:
-            A :class:`dataikuapi.dss.admin.DSSScenarioRun` run handle
+        :return: A :class:`dataikuapi.dss.admin.DSSScenarioRun` run handle
         """
+        if params is None:
+            params = {}
         trigger_fire = self.run(params)
         scenario_run = trigger_fire.wait_for_scenario_run(no_fail)
         waiter = DSSScenarioRunWaiter(scenario_run, trigger_fire)