Merge pull request #889 from guzman-raphael/adjustments

Minor adjustments for release

Author: dimitri-yatsenko

.coveragerc

@@ -3,3 +3,4 @@ branch = False
 source = datajoint
 
 [report]
+show_missing = True

.github/workflows/development.yaml

@@ -36,7 +36,7 @@ jobs:
       - name: Run primary tests
         env:
           UID: "1001"
-          GID: "116"
+          GID: "121"
           PY_VER: ${{matrix.py_ver}}
           MYSQL_VER: ${{matrix.mysql_ver}}
           ALPINE_VER: "3.10"

CHANGELOG.md

@@ -12,8 +12,14 @@
 * Bugfix - Regression error on joins with same attribute name (#857) PR #878
 * Bugfix - Error when `fetch1('KEY')` when `dj.config['fetch_format']='frame'` set (#876) PR #880, #878
 * Bugfix - Error when cascading deletes in tables with many, complex keys (#883, #886) PR #839
+* Add deprecation warning for `_update`. PR #889
+* Add `purge_query_cache` utility. PR #889
+* Add tests for query caching and permissive join and restriction. PR #889
 * Drop support for Python 3.5
 
+### 0.12.9 -- Mar 12, 2021
+* Fix bug with fetch1 with `dj.config['fetch_format']="frame"`. (#876) PR #880
+
 ### 0.12.8 -- Jan 12, 2021
 * table.children, .parents, .descendents, and ancestors can return queryable objects. PR #833
 * Load dependencies before querying dependencies. (#179) PR #833

LNX-docker-compose.yml

@@ -1,4 +1,4 @@
-# docker-compose -f LNX-docker-compose.yml --env-file LNX.env up --build --exit-code-from app
+# docker-compose -f LNX-docker-compose.yml --env-file LNX.env up --exit-code-from app --build
 version: '2.2'
 x-net: &net
   networks:
@@ -78,7 +78,7 @@ services:
       - |
         set -e
         pip install --user -r test_requirements.txt
-        pip install --user .
+        pip install -e .
         pip freeze | grep datajoint
         nosetests -vsw tests --with-coverage --cover-package=datajoint
         coveralls

datajoint/condition.py

@@ -84,7 +84,8 @@ def prep_value(k, v):
                 try:
                     v = uuid.UUID(v)
                 except (AttributeError, ValueError):
-                    raise DataJointError('Badly formed UUID {v} in restriction by `{k}`'.format(k=k, v=v)) from None
+                    raise DataJointError(
+                        'Badly formed UUID {v} in restriction by `{k}`'.format(k=k, v=v))
             return "X'%s'" % v.bytes.hex()
         if isinstance(v, (datetime.date, datetime.datetime, datetime.time, decimal.Decimal)):
             return '"%s"' % v

datajoint/connection.py

@@ -218,7 +218,7 @@ def connect(self):
                               k == 'ssl' and self.conn_info['ssl_input'] is None)})
         self._conn.autocommit(True)
 
-    def set_query_cache(self, query_cache):
+    def set_query_cache(self, query_cache=None):
         """
         When query_cache is not None, the connection switches into the query caching mode, which entails:
         1. Only SELECT queries are allowed.
@@ -228,6 +228,14 @@ def set_query_cache(self, query_cache):
         """
         self._query_cache = query_cache
 
+    def purge_query_cache(self):
+        """ Purges all query cache. """
+        if 'query_cache' in config and isinstance(config['query_cache'], str) and \
+                pathlib.Path(config['query_cache']).is_dir():
+            path_iter = pathlib.Path(config['query_cache']).glob('**/*')
+            for path in path_iter:
+                path.unlink()
+
     def close(self):
         self._conn.close()
 

datajoint/expression.py

@@ -193,15 +193,15 @@ def restrict_in_place(self, restriction):
 
     def __and__(self, restriction):
         """
-        Restriction operator
+        Restriction operator e.g. q1 & q2.
         :return: a restricted copy of the input argument
         See QueryExpression.restrict for more detail.
         """
         return self.restrict(restriction)
 
     def __xor__(self, restriction):
         """
-        Restriction operator ignoring compatibility check.
+        Permissive restriction operator ignoring compatibility check  e.g. q1 ^ q2.
         """
         if inspect.isclass(restriction) and issubclass(restriction, QueryExpression):
             restriction = restriction()
@@ -211,22 +211,33 @@ def __xor__(self, restriction):
 
     def __sub__(self, restriction):
         """
-        Inverted restriction
+        Inverted restriction e.g. q1 - q2.
         :return: a restricted copy of the input argument
         See QueryExpression.restrict for more detail.
         """
         return self.restrict(Not(restriction))
 
     def __neg__(self):
+        """
+        Convert between restriction and inverted restriction e.g. -q1.
+        :return: target restriction
+        See QueryExpression.restrict for more detail.
+        """
         if isinstance(self, Not):
             return self.restriction
         return Not(self)
 
     def __mul__(self, other):
-        """ join of query expressions `self` and `other` """
+        """
+        join of query expressions `self` and `other` e.g. q1 * q2.
+        """
         return self.join(other)
 
     def __matmul__(self, other):
+        """
+        Permissive join of query expressions `self` and `other` ignoring compatibility check
+            e.g. q1 @ q2.
+        """
         if inspect.isclass(other) and issubclass(other, QueryExpression):
             other = other()  # instantiate
         return self.join(other, semantic_check=False)
@@ -271,7 +282,7 @@ def join(self, other, semantic_check=True, left=False):
         return result
 
     def __add__(self, other):
-        """union"""
+        """union e.g. q1 + q2."""
         return Union.create(self, other)
 
     def proj(self, *attributes, **named_attributes):
@@ -424,7 +435,7 @@ def tail(self, limit=25, **fetch_kwargs):
         return self.fetch(order_by="KEY DESC", limit=limit, **fetch_kwargs)[::-1]
 
     def __len__(self):
-        """ :return: number of elements in the result set """
+        """:return: number of elements in the result set e.g. len(q1)."""
         return self.connection.query(
             'SELECT count(DISTINCT {fields}) FROM {from_}{where}'.format(
                 fields=self.heading.as_sql(self.primary_key, include_aliases=False),
@@ -433,7 +444,8 @@ def __len__(self):
 
     def __bool__(self):
         """
-        :return: True if the result is not empty. Equivalent to len(self) > 0 but often faster.
+        :return: True if the result is not empty. Equivalent to len(self) > 0 but often
+            faster e.g. bool(q1).
         """
         return bool(self.connection.query(
             'SELECT EXISTS(SELECT 1 FROM {from_}{where})'.format(
@@ -442,19 +454,30 @@ def __bool__(self):
 
     def __contains__(self, item):
         """
-        returns True if item is found in the .
+        returns True if a restriction results with any records e.g. restriction in q1.
         :param item: any restriction
         (item in query_expression) is equivalent to bool(query_expression & item) but may be
         executed more efficiently.
         """
         return bool(self & item)  # May be optimized e.g. using an EXISTS query
 
     def __iter__(self):
+        """
+        returns an iterator-compatible QueryExpression object e.g. iter(q1).
+
+        :param self: iterator-compatible QueryExpression object
+        """
         self._iter_only_key = all(v.in_key for v in self.heading.attributes.values())
         self._iter_keys = self.fetch('KEY')
         return self
 
     def __next__(self):
+        """
+        returns the next record on an iterator-compatible QueryExpression object
+            e.g. next(q1).
+
+        :param self: fetch1 record
+        """
         try:
             key = self._iter_keys.pop(0)
         except AttributeError:
@@ -490,6 +513,11 @@ def cursor(self, offset=0, limit=None, order_by=None, as_dict=False):
         return self.connection.query(sql, as_dict=as_dict)
 
     def __repr__(self):
+        """
+        returns the string representation of a QueryExpression object e.g. str(q1).
+
+        :param self: String version of query result
+        """
         return super().__repr__() if config['loglevel'].lower() == 'debug' else self.preview()
 
     def preview(self, limit=None, width=None):

datajoint/table.py

@@ -7,6 +7,7 @@
 import logging
 import uuid
 import re
+import warnings
 from pathlib import Path
 from .settings import config
 from .declare import declare, alter
@@ -568,6 +569,9 @@ def _update(self, attrname, value=None):
             >>> (v2p.Mice() & key)._update('mouse_dob', '2011-01-01')
             >>> (v2p.Mice() & key)._update( 'lens')   # set the value to NULL
         """
+        warnings.warn(
+            '`_update` is a deprecated function to be removed in datajoint 0.14. '
+            'Use `.update1` instead.')
         if len(self) != 1:
             raise DataJointError('Update is only allowed on one tuple at a time')
         if attrname not in self.heading:

datajoint/version.py

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

docs-parts/computation/01-autopopulate_lang1.rst

@@ -11,7 +11,7 @@
         """
 
         def make(self, key):
-            img = (test.Image & key).fetch1['image']
+            img = (test.Image & key).fetch1('image')
             key['filtered_image'] = myfilter(img)
             self.insert(key)