[#386][#389] only load timestamps when requested

Author: d-w-moore

README.rst

@@ -432,6 +432,12 @@ or even:
 
 >>> album.metadata(admin = True)[meta.name] = meta
 
+In v1.1.5, the "timestamps" keyword is provided to enable the loading of create and modify timestamps
+for every AVU returned from the server:
+
+>>> avus = album.metadata(timestamps = True).items()
+>>> avus[0].create_time
+datetime.datetime(2022, 9, 19, 15, 26, 7)
 
 Atomic operations on metadata
 -----------------------------

irods/manager/metadata_manager.py

@@ -21,18 +21,24 @@ class InvalidAtomicAVURequest(Exception): pass
 
 class MetadataManager(Manager):
 
+    @property
+    def use_timestamps(self):
+        return getattr(self,'_use_ts',False)
+
     __kw = {}  # default (empty) keywords
 
     def _updated_keywords(self,opts):
         kw_ = self.__kw.copy()
         kw_.update(opts)
         return kw_
 
-    def __call__(self, admin = False, **irods_kw_opt):
-        x = copy.copy(self)
-        irods_kw_opt.update([() if not admin else (kw.ADMIN_KW,"")])
-        x.__kw = irods_kw_opt
-        return x
+    def __call__(self, admin = False, timestamps = False, **irods_kw_opt):
+        if admin:
+            irods_kw_opt.update([(kw.ADMIN_KW,"")])
+        new_self = copy.copy(self)
+        new_self._use_ts = timestamps
+        new_self.__kw = irods_kw_opt
+        return new_self
 
     @staticmethod
     def _model_class_to_resource_type(model_cls):
@@ -69,17 +75,24 @@ def get(self, model_cls, path):
             'R': [Resource.name == path],
             'u': [User.name == path]
         }[resource_type]
-        results = self.sess.query(model.id, model.name, model.value, model.units, model.create_time, model.modify_time)\
-            .filter(*conditions).all()
+
+        columns = (model.id, model.name, model.value, model.units)
+        if self.use_timestamps:
+            columns += (model.create_time, model.modify_time)
+        results = self.sess.query(*columns).filter(*conditions).all()
+
+        def meta_opts(row):
+            opts = {'avu_id': row[model.id]}
+            if self.use_timestamps:
+                opts.update(create_time = row[model.create_time], modify_time=row[model.modify_time])
+            return opts
+
         return [iRODSMeta(
-            row[model.name],
-            row[model.value],
-            row[model.units],
-            avu_id=row[model.id],
-            create_time=row[model.create_time],
-            modify_time=row[model.modify_time],
-
-        ) for row in results]
+                    row[model.name],
+                    row[model.value],
+                    row[model.units],
+                    **meta_opts(row))
+               for row in results]
 
     def add(self, model_cls, path, meta, **opts):
         # Avoid sending request with empty argument(s)

irods/meta.py

@@ -76,9 +76,10 @@ def __init__(self, operation, avu, **kw):
 
 class iRODSMetaCollection(object):
 
-    def __call__(self, admin = False, **opts):
+    def __call__(self, admin = False, timestamps = False, **opts):
         x = copy.copy(self)
-        x._manager = (x._manager)(admin, **opts)
+        x._manager = (x._manager)(admin, timestamps, **opts)
+        x._reset_metadata()
         return x
 
     def __init__(self, manager, model_cls, path):

irods/test/meta_test.py

@@ -3,6 +3,8 @@
 from __future__ import absolute_import
 import os
 import sys
+import time
+import datetime
 import unittest
 from irods.meta import (iRODSMeta, AVUOperation, BadAVUOperationValue, BadAVUOperationKeyword)
 from irods.manager.metadata_manager import InvalidAtomicAVURequest
@@ -393,6 +395,49 @@ def test_irodsmetacollection_data_obj(self):
         test_obj.unlink(force=True)
 
 
+    @staticmethod
+    def check_timestamps(metadata_accessor, key):
+        avu = metadata_accessor[key]
+        create = getattr(avu,'create_time',None)
+        modify = getattr(avu,'modify_time',None)
+        return (create,modify)
+
+
+    def test_timestamp_access_386(self):
+        with helpers.make_session() as session:
+            def units():
+                return str(time.time())
+            d = None
+            try:
+                d = session.data_objects.create('/tempZone/home/rods/issue_386')
+
+                # Test metadata access without timestamps
+
+                meta = d.metadata
+                avu = iRODSMeta('no_ts','val',units())
+                meta.set(avu)
+                self.assertEqual((None, None),		# Assert no timestamps are stored.
+                                 self.check_timestamps(meta, key = avu.name))
+
+                # -- Test metadata access with timestamps
+
+                meta_ts = meta(timestamps = True)
+                avu_use_ts = iRODSMeta('use_ts','val',units())
+                meta_ts.set(avu_use_ts)
+                time.sleep(1.5)
+                now = datetime.datetime.utcnow()
+                time.sleep(1.5)
+                avu_use_ts.units = units()
+                meta_ts.set(avu_use_ts)			# Set an AVU with modified units.
+
+                (create, modify) = self.check_timestamps(meta_ts, key = avu_use_ts.name)
+
+                self.assertLess(create, now)		#  Ensure timestamps are in proper order.
+                self.assertLess(now, modify)
+            finally:
+                if d: d.unlink(force = True)
+                helpers.remove_unused_metadata(session)
+
 if __name__ == '__main__':
     # let the tests find the parent irods lib
     sys.path.insert(0, os.path.abspath('../..'))