rename attribute basename to attachment_name in external table

datajoint/external.py

@@ -54,7 +54,7 @@ def definition(self):
         hash  : uuid    #  hash of contents (blob), of filename + contents (attach), or relative filepath (filepath)
         ---
         size      :bigint unsigned     # size of object in bytes
-        basename=null : varchar(255)  # the filename of an attachment
+        attachment_name=null : varchar(255)  # the filename of an attachment
         filepath=null : varchar(1000)  # relative filepath or attachment filename
         contents_hash=null : uuid      # used for the filepath datatype 
         timestamp=CURRENT_TIMESTAMP  :timestamp   # automatic timestamp
@@ -179,26 +179,26 @@ def get(self, uuid):
     # --- ATTACHMENTS ---
 
     def upload_attachment(self, local_path):
-        basename = Path(local_path).name
-        uuid = uuid_from_file(local_path, init_string=basename + '\0')
-        external_path = self._make_uuid_path(uuid, '.' + basename)
+        attachment_name = Path(local_path).name
+        uuid = uuid_from_file(local_path, init_string=attachment_name + '\0')
+        external_path = self._make_uuid_path(uuid, '.' + attachment_name)
         self._upload_file(local_path, external_path)
         # insert tracking info
         self.connection.query("""
-        INSERT INTO {tab} (hash, size, basename) 
-        VALUES (%s, {size}, "{basename}") 
+        INSERT INTO {tab} (hash, size, attachment_name) 
+        VALUES (%s, {size}, "{attachment_name}") 
         ON DUPLICATE KEY UPDATE timestamp=CURRENT_TIMESTAMP""".format(
                 tab=self.full_table_name,
                 size=Path(local_path).stat().st_size,
-                basename=basename), args=[uuid.bytes])
+                attachment_name=attachment_name), args=[uuid.bytes])
         return uuid
 
-    def get_attachment_basename(self, uuid):
-        return (self & {'hash': uuid}).fetch1('basename')
+    def get_attachment_name(self, uuid):
+        return (self & {'hash': uuid}).fetch1('attachment_name')
 
-    def download_attachment(self, uuid, basename, download_path):
+    def download_attachment(self, uuid, attachment_name, download_path):
         """ save attachment from memory buffer into the save_path """
-        external_path = self._make_uuid_path(uuid, '.' + basename)
+        external_path = self._make_uuid_path(uuid, '.' + attachment_name)
         self._download_file(external_path, download_path)
 
     # --- FILEPATH ---
@@ -274,10 +274,10 @@ def fetch_external_paths(self, **fetch_kwargs):
         """
         fetch_kwargs.update(as_dict=True)
         paths = []
-        for item in self.fetch('hash', 'basename', 'filepath', **fetch_kwargs):
-            if item['basename']:
+        for item in self.fetch('hash', 'attachment_name', 'filepath', **fetch_kwargs):
+            if item['attachment_name']:
                 # attachments
-                path = self._make_uud_path(item['hash'], '.' + item['basename'])
+                path = self._make_uuid_path(item['hash'], '.' + item['attachment_name'])
             elif item['filepath']:
                 # external filepaths
                 path = self._make_external_filepath(item['filepath'])
@@ -341,6 +341,9 @@ def __init__(self, schema):
         self.schema = schema
         self._tables = {}
 
+    def __repr__(self):
+        return "\n   ".join(["External tables for schema {schema}:".format(schema=self.schema)] + list(self))
+
     def __getitem__(self, store):
         """
         Triggers the creation of an external table.

datajoint/fetch.py

@@ -59,24 +59,24 @@ def _get(connection, attr, data, squeeze, download_path):
         # 3. if exists and checksum passes then return the local filepath
         # 4. Otherwise, download the remote file and return the new filepath
         _uuid = uuid.UUID(bytes=data) if attr.is_external else None
-        basename = (extern.get_attachment_basename(_uuid) if attr.is_external
+        attachment_name = (extern.get_attachment_name(_uuid) if attr.is_external
                     else data.split(b"\0", 1)[0].decode())
-        local_filepath = Path(download_path) / basename
+        local_filepath = Path(download_path) / attachment_name
         if local_filepath.is_file():
             attachment_checksum = _uuid if attr.is_external else hash.uuid_from_buffer(data)
-            if attachment_checksum == hash.uuid_from_file(local_filepath, init_string=basename + '\0'):
+            if attachment_checksum == hash.uuid_from_file(local_filepath, init_string=attachment_name + '\0'):
                 return adapt(local_filepath)  # checksum passed, no need to download again
             # generate the next available alias filename
             for n in itertools.count():
                 f = local_filepath.parent / (local_filepath.stem + '_%04x' % n + local_filepath.suffix)
                 if not f.is_file():
                     local_filepath = f
                     break
-                if attachment_checksum == hash.uuid_from_file(f, init_string=basename + '\0'):
+                if attachment_checksum == hash.uuid_from_file(f, init_string=attachment_name + '\0'):
                     return adapt(f)  # checksum passed, no need to download again
         # Save attachment
         if attr.is_external:
-            extern.download_attachment(_uuid, basename, local_filepath)
+            extern.download_attachment(_uuid, attachment_name, local_filepath)
         else:
             # write from buffer
             safe_write(local_filepath, data.split(b"\0", 1)[1])

tests/test_blob_migrate.py

@@ -203,5 +203,5 @@ def test_query():
         dj.config['cache'] = os.path.expanduser('~/temp/dj-cache')
 
         test_mod = dj.create_virtual_module('test_mod', 'djtest_blob_migrate')
-        r = test_mod.A.fetch('blob_share')
-        assert_equal(test_mod.A.fetch('blob_share')[1][1], 2)
+        r = test_mod.A.fetch('blob_share', order_by='id')
+        assert_equal(r[1][1], 2)