Implemented decorator-based binding.

datajoint/__init__.py

@@ -5,6 +5,8 @@
 __version__ = "0.2"
 __all__ = ['__author__', '__version__',
            'Connection', 'Heading', 'Relation', 'FreeRelation', 'Not',
+           'Relation',
+           'Manual', 'Lookup', 'Imported', 'Computed',
            'AutoPopulate', 'conn', 'DataJointError', 'blob']
 
 
@@ -15,26 +17,6 @@ class DataJointError(Exception):
     pass
 
 
-class TransactionError(DataJointError):
-    """
-    Base class for errors specific to DataJoint internal operation.
-    """
-    def __init__(self, msg, f, args=None, kwargs=None):
-        super(TransactionError, self).__init__(msg)
-        self.operations = (f, args if args is not None else tuple(),
-                           kwargs if kwargs is not None else {})
-
-    def resolve(self):
-        f, args, kwargs = self.operations
-        return f(*args, **kwargs)
-
-
-    @property
-    def culprit(self):
-        return self.operations[0].__name__
-
-
-
 # ----------- loads local configuration from file ----------------
 from .settings import Config, CONFIGVAR, LOCALCONFIG, logger, log_levels
 config = Config()
@@ -56,8 +38,9 @@ def culprit(self):
 # ------------- flatten import hierarchy -------------------------
 from .connection import conn, Connection
 from .relation import Relation
+from .user_relations import Manual, Lookup, Imported, Computed, Subordinate
 from .autopopulate import AutoPopulate
 from . import blob
 from .relational_operand import Not
-from .free_relation import FreeRelation
-from .heading import Heading
+from .heading import Heading
+from .relation import schema

datajoint/autopopulate.py

@@ -1,5 +1,5 @@
 from .relational_operand import RelationalOperand
-from . import DataJointError, TransactionError, Relation
+from . import DataJointError, Relation
 import abc
 import logging
 
@@ -37,56 +37,54 @@ def _make_tuples(self, key):
     def target(self):
         return self
 
-    def populate(self, restriction=None, suppress_errors=False, reserve_jobs=False, max_attempts=10):
+    def populate(self, restriction=None, suppress_errors=False, reserve_jobs=False):
         """
         rel.populate() calls rel._make_tuples(key) for every primary key in self.populate_relation
         for which there is not already a tuple in rel.
 
         :param restriction: restriction on rel.populate_relation - target
         :param suppress_errors: suppresses error if true
         :param reserve_jobs: currently not implemented
-        :param max_attempts: maximal number of times a TransactionError is caught before populate gives up
         """
 
         assert not reserve_jobs, NotImplemented   # issue #5
         error_list = [] if suppress_errors else None
         if not isinstance(self.populate_relation, RelationalOperand):
             raise DataJointError('Invalid populate_relation value')
 
-        self.conn.cancel_transaction()  # rollback previous transaction, if any
+        self.connection.cancel_transaction()  # rollback previous transaction, if any
 
         if not isinstance(self, Relation):
-            raise DataJointError('Autopopulate is a mixin for Relation and must therefore subclass Relation')
+            raise DataJointError(
+                'AutoPopulate is a mixin for Relation and must therefore subclass Relation')
 
         unpopulated = (self.populate_relation - self.target) & restriction
         for key in unpopulated.project():
-            self.conn.start_transaction()
+            self.connection.start_transaction()
             if key in self.target:  # already populated
-                self.conn.cancel_transaction()
+                self.connection.cancel_transaction()
             else:
                 logger.info('Populating: ' + str(key))
                 try:
-                    for attempts in range(max_attempts):
-                        try:
-                            self._make_tuples(dict(key))
-                            break
-                        except TransactionError as tr_err:
-                            self.conn.cancel_transaction()
-                            tr_err.resolve()
-                            self.conn.start_transaction()
-                            logger.info('Transaction error in {0:s}.'.format(tr_err.culprit))
-                    else:
-                        raise DataJointError(
-                            '%s._make_tuples failed after %i attempts, giving up' % (self.__class__,max_attempts))
+                    self._make_tuples(dict(key))
                 except Exception as error:
-                    self.conn.cancel_transaction()
+                    self.connection.cancel_transaction()
                     if not suppress_errors:
                         raise
                     else:
                         logger.error(error)
                         error_list.append((key, error))
                 else:
-                    self.conn.commit_transaction()
+                    self.connection.commit_transaction()
         logger.info('Done populating.')
         return error_list
 
+
+    def progress(self):
+        """
+        report progress of populating this table
+        """
+        total = len(self.populate_relation)
+        remaining = len(self.populate_relation - self.target)
+        print('Remaining %d of %d (%2.1f%%)' % (remaining, total, 100*remaining/total)
+              if remaining else 'Complete', flush=True)

datajoint/blob.py

@@ -1,29 +1,30 @@
 import zlib
-import collections
+from collections import OrderedDict
 import numpy as np
 from . import DataJointError
 
-mxClassID = collections.OrderedDict(
+mxClassID = OrderedDict((
     # see http://www.mathworks.com/help/techdoc/apiref/mxclassid.html
-    mxUNKNOWN_CLASS=None,
-    mxCELL_CLASS=None,   # TODO: implement
-    mxSTRUCT_CLASS=None,   # TODO: implement
-    mxLOGICAL_CLASS=np.dtype('bool'),
-    mxCHAR_CLASS=np.dtype('c'),
-    mxVOID_CLASS=None,
-    mxDOUBLE_CLASS=np.dtype('float64'),
-    mxSINGLE_CLASS=np.dtype('float32'),
-    mxINT8_CLASS=np.dtype('int8'),
-    mxUINT8_CLASS=np.dtype('uint8'),
-    mxINT16_CLASS=np.dtype('int16'),
-    mxUINT16_CLASS=np.dtype('uint16'),
-    mxINT32_CLASS=np.dtype('int32'),
-    mxUINT32_CLASS=np.dtype('uint32'),
-    mxINT64_CLASS=np.dtype('int64'),
-    mxUINT64_CLASS=np.dtype('uint64'),
-    mxFUNCTION_CLASS=None)
+    ('mxUNKNOWN_CLASS', None),
+    ('mxCELL_CLASS', None),   # TODO: implement
+    ('mxSTRUCT_CLASS', None),   # TODO: implement
+    ('mxLOGICAL_CLASS', np.dtype('bool')),
+    ('mxCHAR_CLASS', np.dtype('c')),
+    ('mxVOID_CLASS', None),
+    ('mxDOUBLE_CLASS', np.dtype('float64')),
+    ('mxSINGLE_CLASS', np.dtype('float32')),
+    ('mxINT8_CLASS', np.dtype('int8')),
+    ('mxUINT8_CLASS', np.dtype('uint8')),
+    ('mxINT16_CLASS', np.dtype('int16')),
+    ('mxUINT16_CLASS', np.dtype('uint16')),
+    ('mxINT32_CLASS', np.dtype('int32')),
+    ('mxUINT32_CLASS', np.dtype('uint32')),
+    ('mxINT64_CLASS', np.dtype('int64')),
+    ('mxUINT64_CLASS', np.dtype('uint64')),
+    ('mxFUNCTION_CLASS', None)))
 
 reverseClassID = {v: i for i, v in enumerate(mxClassID.values())}
+dtypeList = list(mxClassID.values())
 
 
 def pack(obj):
@@ -41,6 +42,7 @@ def pack(obj):
         obj, imaginary = np.real(obj), np.imag(obj)
 
     type_number = reverseClassID[obj.dtype]
+    assert dtypeList[type_number] is obj.dtype, 'ambigous or unknown array type'
     blob += np.asarray(type_number, dtype=np.uint32).tostring()
     blob += np.int8(is_complex).tostring() + b'\0\0\0'
     blob += obj.tostring()
@@ -72,9 +74,10 @@ def unpack(blob):
     p += 8
     array_shape = np.fromstring(blob[p:p+8*dimensions], dtype=np.uint64)
     p += 8 * dimensions
-    mx_type, dtype = [q for q in mxClassID.items()][np.fromstring(blob[p:p+4], dtype=np.uint32)[0]]
+    type_number = np.fromstring(blob[p:p+4], dtype=np.uint32)[0]
+    dtype = dtypeList[type_number]
     if dtype is None:
-        raise DataJointError('Unsupported MATLAB data type '+mx_type+' in blob')
+        raise DataJointError('Unsupported MATLAB data type '+type_number+' in blob')
     p += 4
     is_complex = np.fromstring(blob[p:p+4], dtype=np.uint32)[0]
     p += 4