.populate() call now returns a dict with success_count and error_list

Author: Thinh Nguyen

datajoint/autopopulate.py

@@ -160,7 +160,6 @@ def populate(
         max_calls=None,
         display_progress=False,
         processes=1,
-        return_success_count=False,
         make_kwargs=None,
     ):
         """
@@ -177,12 +176,13 @@ def populate(
         :param max_calls: if not None, populate at most this many keys
         :param display_progress: if True, report progress_bar
         :param processes: number of processes to use. Set to None to use all cores
-        :param return_success_count: if True, return the count of successful `make()` calls.
-            If suppress_errors is also True, returns a tuple: (success_count, errors)
         :param make_kwargs: Keyword arguments which do not affect the result of computation
             to be passed down to each ``make()`` call. Computation arguments should be
             specified within the pipeline e.g. using a `dj.Lookup` table.
         :type make_kwargs: dict, optional
+        :return: a dict with two keys
+            "success_count": the count of successful ``make()`` calls in this ``populate()`` call
+            "error_list": the error list if "suppress_errors" is set to True, otherwise None
         """
         if self.connection.in_transaction:
             raise DataJointError("Populate cannot be called during a transaction.")
@@ -275,12 +275,10 @@ def handler(signum, frame):
         if reserve_jobs:
             signal.signal(signal.SIGTERM, old_handler)
 
-        if suppress_errors and return_success_count:
-            return sum(success_list), error_list
-        if suppress_errors:
-            return error_list
-        if return_success_count:
-            return sum(success_list)
+        return {
+            "success_count": sum(success_list),
+            "error_list": error_list if suppress_errors else None,
+        }
 
     def _populate1(
         self, key, jobs, suppress_errors, return_exception_objects, make_kwargs=None
@@ -291,7 +289,8 @@ def _populate1(
         :param key: dict specifying job to populate
         :param suppress_errors: bool if errors should be suppressed and returned
         :param return_exception_objects: if True, errors must be returned as objects
-        :return: (key, error) when suppress_errors=True, otherwise None
+        :return: (key, error) when suppress_errors=True,
+            True if successfully invoke one `make()` call, otherwise None
         """
         make = self._make_tuples if hasattr(self, "_make_tuples") else self.make
 

tests_old/test_autopopulate.py

@@ -57,17 +57,17 @@ def test_populate_with_success_count(self):
         # test simple populate
         assert_true(self.subject, "root tables are empty")
         assert_false(self.experiment, "table already filled?")
-        success_count = self.experiment.populate(return_success_count=True)
+        ret = self.experiment.populate()
+        success_count = ret["success_count"]
         assert_equal(len(self.experiment.key_source & self.experiment), success_count)
 
         # test restricted populate
         assert_false(self.trial, "table already filled?")
         restriction = self.subject.proj(animal="subject_id").fetch("KEY")[0]
         d = self.trial.connection.dependencies
         d.load()
-        success_count, _ = self.trial.populate(
-            restriction, return_success_count=True, suppress_errors=True
-        )
+        ret = self.trial.populate(restriction, suppress_errors=True)
+        success_count = ret["success_count"]
         assert_equal(len(self.trial.key_source & self.trial), success_count)
 
     def test_populate_exclude_error_and_ignore_jobs(self):