External storage, enhancements, bugfixes

datajoint/autopopulate.py

@@ -20,15 +20,15 @@ class AutoPopulate:
     """
     AutoPopulate is a mixin class that adds the method populate() to a Relation class.
     Auto-populated relations must inherit from both Relation and AutoPopulate,
-    must define the property `key_source`, and must define the callback method _make_tuples.
+    must define the property `key_source`, and must define the callback method `make`.
     """
     _key_source = None
 
     @property
     def key_source(self):
         """
         :return: the relation whose primary key values are passed, sequentially, to the
-                `_make_tuples` method when populate() is called.The default value is the
+                ``make`` method when populate() is called.The default value is the
                 join of the parent relations. Users may override to change the granularity
                 or the scope of populate() calls.
         """
@@ -42,13 +42,15 @@ def key_source(self):
                 self._key_source *= FreeRelation(self.connection, parents.pop(0)).proj()
         return self._key_source
 
-    def _make_tuples(self, key):
+
+    def make(self, key):
         """
-        Derived classes must implement method _make_tuples that fetches data from tables that are
+        Derived classes must implement method `make` that fetches data from tables that are
         above them in the dependency hierarchy, restricting by the given key, computes dependent
         attributes, and inserts the new tuples into self.
         """
-        raise NotImplementedError('Subclasses of AutoPopulate must implement the method "_make_tuples"')
+        raise NotImplementedError('Subclasses of AutoPopulate must implement the method `make`')
+
 
     @property
     def target(self):
@@ -68,7 +70,7 @@ def _job_key(self, key):
     def populate(self, *restrictions, suppress_errors=False, reserve_jobs=False,
 		 order="original", limit=None, max_calls=None, display_progress=False):
         """
-        rel.populate() calls rel._make_tuples(key) for every primary key in self.key_source
+        rel.populate() calls rel.make(key) for every primary key in self.key_source
         for which there is not already a tuple in rel.
 
         :param restrictions: a list of restrictions each restrict (rel.key_source - target.proj())
@@ -120,6 +122,8 @@ def handler(signum, frame):
         call_count = count()
         logger.info('Found %d keys to populate' % len(keys))
 
+        make = self._make_tuples if hasattr(self, '_make_tuples') else self.make
+
         for key in (tqdm(keys) if display_progress else keys):
             if max_calls is not None and call_count >= max_calls:
                 break
@@ -133,7 +137,7 @@ def handler(signum, frame):
                     logger.info('Populating: ' + str(key))
                     next(call_count)
                     try:
-                        self._make_tuples(dict(key))
+                        make(dict(key))
                     except (KeyboardInterrupt, SystemExit, Exception) as error:
                         try:
                             self.connection.cancel_transaction()

datajoint/base_relation.py

@@ -538,7 +538,7 @@ def lookup_class_name(name, context, depth=3):
                 except AttributeError:
                     pass  # not a UserRelation -- cannot have part tables.
                 else:
-                    for part in (getattr(member, p) for p in parts):
+                    for part in (getattr(member, p) for p in parts if hasattr(member, p)):
                         if inspect.isclass(part) and issubclass(part, BaseRelation) and part.full_table_name == name:
                             return '.'.join([node['context_name'], member_name, part.__name__]).lstrip('.')
             elif node['depth'] > 0 and inspect.ismodule(member) and member.__name__ != 'datajoint':

datajoint/version.py

@@ -1 +1 @@
-__version__ = "0.8.2"
+__version__ = "0.9.0"