Merge pull request #870 from dimitri-yatsenko/cascade-delete

Cascade delete

Author: guzman-raphael

datajoint/fetch.py

@@ -149,26 +149,30 @@ def __call__(self, *attrs, offset=None, limit=None, order_by=None, format=None,
                 attrs = list(self._expression.primary_key) + [
                     a for a in attrs if a not in self._expression.primary_key]
         if as_dict is None:
-            as_dict = bool(attrs)  # default to True for "KEY" and False when fetching entire result
+            as_dict = bool(attrs)  # default to True for "KEY" and False otherwise
         # format should not be specified with attrs or is_dict=True
         if format is not None and (as_dict or attrs):
             raise DataJointError('Cannot specify output format when as_dict=True or '
                                  'when attributes are selected to be fetched separately.')
         if format not in {None, "array", "frame"}:
-            raise DataJointError('Fetch output format must be in {{"array", "frame"}} but "{}" was given'.format(format))
+            raise DataJointError(
+                'Fetch output format must be in '
+                '{{"array", "frame"}} but "{}" was given'.format(format))
 
         if not (attrs or as_dict) and format is None:
             format = config['fetch_format']  # default to array
             if format not in {"array", "frame"}:
-                raise DataJointError('Invalid entry "{}" in datajoint.config["fetch_format"]: use "array" or "frame"'.format(
-                    format))
+                raise DataJointError(
+                    'Invalid entry "{}" in datajoint.config["fetch_format"]: '
+                    'use "array" or "frame"'.format(format))
 
         if limit is None and offset is not None:
             warnings.warn('Offset set, but no limit. Setting limit to a large number. '
                           'Consider setting a limit explicitly.')
             limit = 8000000000  # just a very large number to effect no limit
 
-        get = partial(_get, self._expression.connection, squeeze=squeeze, download_path=download_path)
+        get = partial(_get, self._expression.connection,
+                      squeeze=squeeze, download_path=download_path)
         if attrs:  # a list of attributes provided
             attributes = [a for a in attrs if not is_key(a)]
             ret = self._expression.proj(*attributes)
@@ -179,19 +183,22 @@ def __call__(self, *attrs, offset=None, limit=None, order_by=None, format=None,
             if attrs_as_dict:
                 ret = [{k: v for k, v in zip(ret.dtype.names, x) if k in attrs} for x in ret]
             else:
-                return_values = [
-                    list((to_dicts if as_dict else lambda x: x)(ret[self._expression.primary_key])) if is_key(attribute)
-                    else ret[attribute] for attribute in attrs]
+                return_values = [list(
+                    (to_dicts if as_dict else lambda x: x)(ret[self._expression.primary_key]))
+                                 if is_key(attribute) else ret[attribute]
+                                 for attribute in attrs]
                 ret = return_values[0] if len(attrs) == 1 else return_values
         else:  # fetch all attributes as a numpy.record_array or pandas.DataFrame
-            cur = self._expression.cursor(as_dict=as_dict, limit=limit, offset=offset, order_by=order_by)
+            cur = self._expression.cursor(
+                as_dict=as_dict, limit=limit, offset=offset, order_by=order_by)
             heading = self._expression.heading
             if as_dict:
-                ret = [dict((name, get(heading[name], d[name])) for name in heading.names) for d in cur]
+                ret = [dict((name, get(heading[name], d[name]))
+                            for name in heading.names) for d in cur]
             else:
                 ret = list(cur.fetchall())
                 record_type = (heading.as_dtype if not ret else np.dtype(
-                    [(name, type(value))   # use the first element to determine the type for blobs
+                    [(name, type(value))   # use the first element to determine blob type
                         if heading[name].is_blob and isinstance(value, numbers.Number)
                         else (name, heading.as_dtype[name])
                         for value, name in zip(ret[0], heading.as_dtype.names)]))
@@ -208,15 +215,15 @@ def __call__(self, *attrs, offset=None, limit=None, order_by=None, format=None,
 
 class Fetch1:
     """
-    Fetch object for fetching exactly one row.
-    :param relation: relation the fetch object fetches data from
+    Fetch object for fetching the result of a query yielding one row.
+    :param expression: a query expression to fetch from.
     """
-    def __init__(self, relation):
-        self._expression = relation
+    def __init__(self, expression):
+        self._expression = expression
 
     def __call__(self, *attrs, squeeze=False, download_path='.'):
         """
-        Fetches the expression results from the database when the expression is known to yield only one entry.
+        Fetches the result of a query expression that yields one entry.
 
         If no attributes are specified, returns the result as a dict.
         If attributes are specified returns the corresponding results as a tuple.
@@ -225,7 +232,8 @@ def __call__(self, *attrs, squeeze=False, download_path='.'):
         d = rel.fetch1()   # as a dictionary
         a, b = rel.fetch1('a', 'b')   # as a tuple
 
-        :params *attrs: attributes to return when expanding into a tuple. If empty, the return result is a dict
+        :params *attrs: attributes to return when expanding into a tuple.
+                 If attrs is empty, the return result is a dict
         :param squeeze:  When true, remove extra dimensions from arrays in attributes
         :param download_path: for fetches that download data, e.g. attachments
         :return: the one tuple in the relation in the form of a dict
@@ -236,17 +244,20 @@ def __call__(self, *attrs, squeeze=False, download_path='.'):
             cur = self._expression.cursor(as_dict=True)
             ret = cur.fetchone()
             if not ret or cur.fetchone():
-                raise DataJointError('fetch1 should only be used for relations with exactly one tuple')
+                raise DataJointError('fetch1 requires exactly one tuple in the input set.')
             ret = dict((name, _get(self._expression.connection, heading[name], ret[name],
                                    squeeze=squeeze, download_path=download_path))
                        for name in heading.names)
         else:  # fetch some attributes, return as tuple
             attributes = [a for a in attrs if not is_key(a)]
-            result = self._expression.proj(*attributes).fetch(squeeze=squeeze, download_path=download_path)
+            result = self._expression.proj(*attributes).fetch(
+                squeeze=squeeze, download_path=download_path)
             if len(result) != 1:
-                raise DataJointError('fetch1 should only return one tuple. %d tuples were found' % len(result))
+                raise DataJointError(
+                    'fetch1 should only return one tuple. %d tuples found' % len(result))
             return_values = tuple(
-                next(to_dicts(result[self._expression.primary_key])) if is_key(attribute) else result[attribute][0]
+                next(to_dicts(result[self._expression.primary_key]))
+                if is_key(attribute) else result[attribute][0]
                 for attribute in attrs)
             ret = return_values[0] if len(attrs) == 1 else return_values
         return ret

datajoint/table.py

@@ -378,7 +378,7 @@ def delete(self, transaction=True, safemode=None):
         :param transaction: if True, use the entire delete becomes an atomic transaction.
         :param safemode: If True, prohibit nested transactions and prompt to confirm. Default is dj.config['safemode'].
         """
-        safemode = safemode or config['safemode']
+        safemode = config['safemode'] if safemode is None else safemode
 
         # Start transaction
         if transaction:
@@ -408,11 +408,13 @@ def delete(self, transaction=True, safemode=None):
                 self.connection.cancel_transaction()
         else:
             if not safemode or user_choice("Commit deletes?", default='no') == 'yes':
-                self.connection.commit_transaction()
+                if transaction:
+                    self.connection.commit_transaction()
                 if safemode:
                     print('Deletes committed.')
             else:
-                self.connection.cancel_transaction()
+                if transaction:
+                    self.connection.cancel_transaction()
                 if safemode:
                     print('Deletes cancelled')
 

datajoint/version.py

@@ -1,3 +1,3 @@
-__version__ = "0.13.dev3"
+__version__ = "0.13.dev4"
 
 assert len(__version__) <= 10  # The log table limits version to the 10 characters