Merge pull request #474 from dimitri-yatsenko/master

update release info for version 0.10.1

Author: Chris Turner

CHANGELOG.md

@@ -1,7 +1,11 @@
 ## Release notes
-### 0.10.1 -- Work in progress
+### 0.10.1 
+* Fix ERD Tooltip message (#431)
 * Networkx 2.0 support (#443)
-* Sped up queries (#428)
+* Fix insert from query with skip_duplicates=True (#451)
+* Sped up queries (#458)
+* Bugfix in restriction of the form (A & B) * B (#463)
+* Improved error messages (#466)
 
 ### 0.10.0 -- January 10, 2018 
 * Deletes are more efficient (#424)

datajoint/__init__.py

@@ -1,8 +1,10 @@
 """
-DataJoint for Python is a high-level programming interface for MySQL databases
-to support data processing chains in science labs. DataJoint is built on the
-foundation of the relational data model and prescribes a consistent method for
-organizing, populating, and querying data.
+DataJoint for Python is a framework for building data piplines using MySQL databases 
+to represent pipeline structure and bulk storage systems for large objects.
+DataJoint is built on the foundation of the relational data model and prescribes a 
+consistent method for organizing, populating, and querying data.
+
+The DataJoint data model is described in https://arxiv.org/abs/1807.11104
 
 DataJoint is free software under the LGPL License. In addition, we request
 that any use of DataJoint leading to a publication be acknowledged in the publication.
@@ -18,7 +20,7 @@
 from .version import __version__
 
 __author__ = "Dimitri Yatsenko, Edgar Y. Walker, and Fabian Sinz at Baylor College of Medicine"
-__date__ = "July 26, 2017"
+__date__ = "August 24, 2018"
 __all__ = ['__author__', '__version__',
            'config', 'conn', 'kill', 'BaseRelation',
            'Connection', 'Heading', 'FreeRelation', 'Not', 'schema',
@@ -71,17 +73,19 @@ class key:
 from .errors import DataJointError, DuplicateError
 
 
-def create_virtual_module(modulename, dbname):
+def create_virtual_module(module_name, schema_name, create_schema=False, create_tables=False):
     """
-    Creates a python module with the given name from a database name in mysql with datajoint tables.
-    Automatically creates the classes of the appropriate tier in the module.
+    Creates a python module with the given name from the name of a schema on the server and
+    automatically adds classes to it corresponding to the tables in the schema.
 
-    :param modulename: desired name of the module
-    :param dbname:     name of the database in mysql
-    :return: the python module
+    :param module_name: displayed module name
+    :param schema_name: name of the database in mysql
+    :param create_schema: if True, create the schema on the database server
+    :param create_tables: if True, module.schema can be used as the decorator for declaring new 
+    :return: the python module containing classes from the schema object and the table classes
     """
-    mod = ModuleType(modulename)
-    s = schema(dbname, mod.__dict__)
-    s.spawn_missing_classes()
-    mod.__dict__['schema'] = s
-    return mod
+    module = ModuleType(module_name)
+    _schema = schema(schema_name, create_schema=create_schema, create_tables=create_tables)
+    _schema.spawn_missing_classes(context=module.__dict__)
+    module.__dict__['schema'] = _schema
+    return module

datajoint/base_relation.py

@@ -21,7 +21,7 @@
 
 class BaseRelation(RelationalOperand):
     """
-    BaseRelation is an abstract class that represents a base relation, i.e. a table in the database.
+    BaseRelation is an abstract class that represents a base relation, i.e. a table in the schema.
     To make it a concrete class, override the abstract properties specifying the connection,
     table name, database, context, and definition.
     A Relation implements insert and delete methods in addition to inherited relational operators.
@@ -56,7 +56,7 @@ def context(self):
 
     def declare(self):
         """
-        Use self.definition to declare the table in the database
+        Use self.definition to declare the table in the schema.
         """
         try:
             sql, uses_external = declare(self.full_table_name, self.definition, self._context)
@@ -108,7 +108,7 @@ def children(self, primary=None):
     @property
     def is_declared(self):
         """
-        :return: True is the table is declared in the database
+        :return: True is the table is declared in the schema.
         """
         return self.connection.query(
             'SHOW TABLES in `{database}` LIKE "{table_name}"'.format(
@@ -117,7 +117,7 @@ def is_declared(self):
     @property
     def full_table_name(self):
         """
-        :return: full table name in the database
+        :return: full table name in the schema
         """
         return r"`{0:s}`.`{1:s}`".format(self.database, self.table_name)
 
@@ -541,8 +541,8 @@ def _update(self, attrname, value=None):
 
 def lookup_class_name(name, context, depth=3):
     """
-    given a table name in the form `database`.`table_name`, find its class in the context.
-    :param name: `database`.`table_name`
+    given a table name in the form `schema_name`.`table_name`, find its class in the context.
+    :param name: `schema_name`.`table_name`
     :param context: dictionary representing the namespace
     :param depth: search depth into imported modules, helps avoid infinite recursion.
     :return: class name found in the context or None if not found
@@ -599,14 +599,14 @@ def __repr__(self):
     @property
     def table_name(self):
         """
-        :return: the table name in the database
+        :return: the table name in the schema
         """
         return self._table_name
 
 
 class Log(BaseRelation):
     """
-    The log table for each database.
+    The log table for each schema.
     Instances are callable.  Calls log the time and identifying information along with the event.
     """
 

datajoint/connection.py

@@ -1,5 +1,5 @@
 """
-This module hosts the Connection class that manages the connection to the mysql database,
+This module hosts the Connection class that manages the connection to the database,
  and the `conn` function that provides access to a persistent connection in datajoint.
 """
 import warnings
@@ -92,11 +92,12 @@ def connect(self):
         """
         with warnings.catch_warnings():
             warnings.filterwarnings('ignore', '.*deprecated.*')
-            self._conn = client.connect(init_command=self.init_fun,
-                                        sql_mode="NO_ZERO_DATE,NO_ZERO_IN_DATE,ERROR_FOR_DIVISION_BY_ZERO,"
-                                                 "STRICT_TRANS_TABLES,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION",
-                                        charset=config['connection.charset'],
-                                        **self.conn_info)
+            self._conn = client.connect(
+                init_command=self.init_fun,
+                sql_mode="NO_ZERO_DATE,NO_ZERO_IN_DATE,ERROR_FOR_DIVISION_BY_ZERO,"
+                         "STRICT_TRANS_TABLES,NO_AUTO_CREATE_USER,NO_ENGINE_SUBSTITUTION",
+                charset=config['connection.charset'],
+                **self.conn_info)
 
     def register(self, schema):
         self.schemas[schema.database] = schema

datajoint/erd.py

@@ -197,6 +197,31 @@ def __mul__(self, arg):
             self.nodes_to_show.intersection_update(arg.nodes_to_show)
             return self
 
+        def topological_sort(self):
+            """
+            :return:  list of nodes in topological order
+            """
+
+            def _unite(lst):
+                """
+                reorder list so that parts immediately follow their masters without breaking the topological order.
+                Without this correction, simple topological sort may insert other descendants between master and parts
+                :example:
+                _unite(['a', 'a__q', 'b', 'c', 'c__q', 'b__q', 'd', 'a__r'])
+                -> ['a', 'a__q', 'a__r', 'b', 'b__q', 'c', 'c__q', 'd']
+                """
+                if len(lst) <= 2:
+                    return lst
+                el = lst.pop()
+                lst = _unite(lst)
+                if '__' in el:
+                    master = el.split('__')[0]
+                    if not lst[-1].startswith(master):
+                        return _unite(lst[:-1] + [el, lst[-1]])
+                return lst + [el]
+
+            return _unite(list(nx.algorithms.dag.topological_sort(self.subgraph(self.nodes_to_show))))
+
         def _make_graph(self):
             """
             Make the self.graph - a graph object ready for drawing

datajoint/fetch.py

@@ -19,8 +19,8 @@ def to_dicts(recarray):
 
 class Fetch:
     """
-    A fetch object that handles retrieving elements from the database table.
-    :param relation: relation the fetch object fetches data from
+    A fetch object that handles retrieving elements from the table expression.
+    :param relation: the table expression to fetch from
     """
 
     def __init__(self, relation):

datajoint/relational_operand.py

@@ -94,7 +94,9 @@ def heading(self):
 
     @property
     def distinct(self):
-        """True if the DISTINCT modifier is required to turn the query into a relation"""
+        """
+        :return: True if the DISTINCT modifier is required to make valid result
+        """
         return self._distinct
 
     @property