Added preserve_time parameter to all copy/move/mirror functions.

If `preserve_time` is set to True, the call tries to preserve the atime, ctime, and mtime timestamps on the file after the copy. The value is currently not actually used; places in code that have to be adapted are marked with `TODO(preserve_time)`.

Author: atollk

fs/_bulk.py

@@ -124,13 +124,16 @@ def __exit__(
         if traceback is None and self.errors:
             raise BulkCopyFailed(self.errors)
 
-    def copy(self, src_fs, src_path, dst_fs, dst_path):
-        # type: (FS, Text, FS, Text) -> None
+    def copy(self, src_fs, src_path, dst_fs, dst_path, preserve_time=False):
+        # type: (FS, Text, FS, Text, bool) -> None
         """Copy a file from one fs to another."""
         if self.queue is None:
             # This should be the most performant for a single-thread
-            copy_file_internal(src_fs, src_path, dst_fs, dst_path)
+            copy_file_internal(
+                src_fs, src_path, dst_fs, dst_path, preserve_time=preserve_time
+            )
         else:
+            # TODO(preserve_time)
             src_file = src_fs.openbin(src_path, "r")
             try:
                 dst_file = dst_fs.openbin(dst_path, "w")

fs/base.py

@@ -387,15 +387,23 @@ def close(self):
         """
         self._closed = True
 
-    def copy(self, src_path, dst_path, overwrite=False):
-        # type: (Text, Text, bool) -> None
+    def copy(
+        self,
+        src_path,  # type: Text
+        dst_path,  # type: Text
+        overwrite=False,  # type: bool
+        preserve_time=False,  # type: bool
+    ):
+        # type: (...) -> None
         """Copy file contents from ``src_path`` to ``dst_path``.
 
         Arguments:
             src_path (str): Path of source file.
             dst_path (str): Path to destination file.
             overwrite (bool): If `True`, overwrite the destination file
                 if it exists (defaults to `False`).
+            preserve_time (bool): If `True`, try to preserve atime, ctime,
+                and mtime of the resource (defaults to `False`).
 
         Raises:
             fs.errors.DestinationExists: If ``dst_path`` exists,
@@ -404,22 +412,31 @@ def copy(self, src_path, dst_path, overwrite=False):
                 ``dst_path`` does not exist.
 
         """
+        # TODO(preserve_time)
         with self._lock:
             if not overwrite and self.exists(dst_path):
                 raise errors.DestinationExists(dst_path)
             with closing(self.open(src_path, "rb")) as read_file:
                 # FIXME(@althonos): typing complains because open return IO
                 self.upload(dst_path, read_file)  # type: ignore
 
-    def copydir(self, src_path, dst_path, create=False):
-        # type: (Text, Text, bool) -> None
+    def copydir(
+        self,
+        src_path,  # type: Text
+        dst_path,  # type: Text
+        create=False,  # type: bool
+        preserve_time=False,  # type: bool
+    ):
+        # type: (...) -> None
         """Copy the contents of ``src_path`` to ``dst_path``.
 
         Arguments:
             src_path (str): Path of source directory.
             dst_path (str): Path to destination directory.
             create (bool): If `True`, then ``dst_path`` will be created
                 if it doesn't exist already (defaults to `False`).
+            preserve_time (bool): If `True`, try to preserve atime, ctime,
+                and mtime of the resource (defaults to `False`).
 
         Raises:
             fs.errors.ResourceNotFound: If the ``dst_path``
@@ -431,7 +448,7 @@ def copydir(self, src_path, dst_path, create=False):
                 raise errors.ResourceNotFound(dst_path)
             if not self.getinfo(src_path).is_dir:
                 raise errors.DirectoryExpected(src_path)
-            copy.copy_dir(self, src_path, self, dst_path)
+            copy.copy_dir(self, src_path, self, dst_path, preserve_time=preserve_time)
 
     def create(self, path, wipe=False):
         # type: (Text, bool) -> bool
@@ -1004,15 +1021,17 @@ def lock(self):
         """
         return self._lock
 
-    def movedir(self, src_path, dst_path, create=False):
-        # type: (Text, Text, bool) -> None
+    def movedir(self, src_path, dst_path, create=False, preserve_time=False):
+        # type: (Text, Text, bool, bool) -> None
         """Move directory ``src_path`` to ``dst_path``.
 
         Arguments:
             src_path (str): Path of source directory on the filesystem.
             dst_path (str): Path to destination directory.
             create (bool): If `True`, then ``dst_path`` will be created
                 if it doesn't exist already (defaults to `False`).
+        preserve_time (bool): If `True`, try to preserve atime, ctime,
+            and mtime of the resources (defaults to `False`).
 
         Raises:
             fs.errors.ResourceNotFound: if ``dst_path`` does not exist,
@@ -1022,7 +1041,7 @@ def movedir(self, src_path, dst_path, create=False):
         with self._lock:
             if not create and not self.exists(dst_path):
                 raise errors.ResourceNotFound(dst_path)
-            move.move_dir(self, src_path, self, dst_path)
+            move.move_dir(self, src_path, self, dst_path, preserve_time=preserve_time)
 
     def makedirs(
         self,

fs/copy.py

@@ -24,6 +24,7 @@ def copy_fs(
     walker=None,  # type: Optional[Walker]
     on_copy=None,  # type: Optional[_OnCopy]
     workers=0,  # type: int
+    preserve_time=False,  # type: bool
 ):
     # type: (...) -> None
     """Copy the contents of one filesystem to another.
@@ -39,6 +40,8 @@ def copy_fs(
             dst_path)``.
         workers (int): Use `worker` threads to copy data, or ``0`` (default) for
             a single-threaded copy.
+        preserve_time (bool): If `True`, try to preserve atime, ctime,
+            and mtime of the resources (defaults to `False`).
 
     """
     return copy_dir(
@@ -52,6 +55,7 @@ def copy_fs_if_newer(
     walker=None,  # type: Optional[Walker]
     on_copy=None,  # type: Optional[_OnCopy]
     workers=0,  # type: int
+    preserve_time=False,  # type: bool
 ):
     # type: (...) -> None
     """Copy the contents of one filesystem to another, checking times.
@@ -72,10 +76,19 @@ def copy_fs_if_newer(
             dst_path)``.
         workers (int): Use ``worker`` threads to copy data, or ``0`` (default) for
             a single-threaded copy.
+        preserve_time (bool): If `True`, try to preserve atime, ctime,
+            and mtime of the resources (defaults to `False`).
 
     """
     return copy_dir_if_newer(
-        src_fs, "/", dst_fs, "/", walker=walker, on_copy=on_copy, workers=workers
+        src_fs,
+        "/",
+        dst_fs,
+        "/",
+        walker=walker,
+        on_copy=on_copy,
+        workers=workers,
+        preserve_time=preserve_time,
     )
 
 
@@ -113,6 +126,7 @@ def copy_file(
     src_path,  # type: Text
     dst_fs,  # type: Union[FS, Text]
     dst_path,  # type: Text
+    preserve_time=False,  # type: bool
 ):
     # type: (...) -> None
     """Copy a file from one filesystem to another.
@@ -124,15 +138,20 @@ def copy_file(
         src_path (str): Path to a file on the source filesystem.
         dst_fs (FS or str): Destination filesystem (instance or URL).
         dst_path (str): Path to a file on the destination filesystem.
+        preserve_time (bool): If `True`, try to preserve atime, ctime,
+            and mtime of the resource (defaults to `False`).
 
     """
     with manage_fs(src_fs, writeable=False) as _src_fs:
         with manage_fs(dst_fs, create=True) as _dst_fs:
             if _src_fs is _dst_fs:
                 # Same filesystem, so we can do a potentially optimized
                 # copy
-                _src_fs.copy(src_path, dst_path, overwrite=True)
+                _src_fs.copy(
+                    src_path, dst_path, overwrite=True, preserve_time=preserve_time
+                )
             else:
+                # TODO(preserve_time)
                 # Standard copy
                 with _src_fs.lock(), _dst_fs.lock():
                     if _dst_fs.hassyspath(dst_path):
@@ -148,6 +167,7 @@ def copy_file_internal(
     src_path,  # type: Text
     dst_fs,  # type: FS
     dst_path,  # type: Text
+    preserve_time=False,  # type: bool
 ):
     # type: (...) -> None
     """Copy a file at low level, without calling `manage_fs` or locking.
@@ -162,12 +182,15 @@ def copy_file_internal(
         src_path (str): Path to a file on the source filesystem.
         dst_fs (FS): Destination filesystem.
         dst_path (str): Path to a file on the destination filesystem.
+        preserve_time (bool): If `True`, try to preserve atime, ctime,
+            and mtime of the resource (defaults to `False`).
 
     """
     if src_fs is dst_fs:
         # Same filesystem, so we can do a potentially optimized
         # copy
-        src_fs.copy(src_path, dst_path, overwrite=True)
+        src_fs.copy(src_path, dst_path, overwrite=True, preserve_time=preserve_time)
+        # TODO(preserve_time)
     elif dst_fs.hassyspath(dst_path):
         with dst_fs.openbin(dst_path, "w") as write_file:
             src_fs.download(src_path, write_file)
@@ -181,6 +204,7 @@ def copy_file_if_newer(
     src_path,  # type: Text
     dst_fs,  # type: Union[FS, Text]
     dst_path,  # type: Text
+    preserve_time=False,  # type: bool
 ):
     # type: (...) -> bool
     """Copy a file from one filesystem to another, checking times.
@@ -196,6 +220,8 @@ def copy_file_if_newer(
         src_path (str): Path to a file on the source filesystem.
         dst_fs (FS or str): Destination filesystem (instance or URL).
         dst_path (str): Path to a file on the destination filesystem.
+        preserve_time (bool): If `True`, try to preserve atime, ctime,
+            and mtime of the resource (defaults to `False`).
 
     Returns:
         bool: `True` if the file copy was executed, `False` otherwise.
@@ -207,15 +233,23 @@ def copy_file_if_newer(
                 # Same filesystem, so we can do a potentially optimized
                 # copy
                 if _source_is_newer(_src_fs, src_path, _dst_fs, dst_path):
-                    _src_fs.copy(src_path, dst_path, overwrite=True)
+                    _src_fs.copy(
+                        src_path, dst_path, overwrite=True, preserve_time=preserve_time
+                    )
                     return True
                 else:
                     return False
             else:
                 # Standard copy
                 with _src_fs.lock(), _dst_fs.lock():
                     if _source_is_newer(_src_fs, src_path, _dst_fs, dst_path):
-                        copy_file_internal(_src_fs, src_path, _dst_fs, dst_path)
+                        copy_file_internal(
+                            _src_fs,
+                            src_path,
+                            _dst_fs,
+                            dst_path,
+                            preserve_time=preserve_time,
+                        )
                         return True
                     else:
                         return False
@@ -225,6 +259,7 @@ def copy_structure(
     src_fs,  # type: Union[FS, Text]
     dst_fs,  # type: Union[FS, Text]
     walker=None,  # type: Optional[Walker]
+    preserve_time=False,  # type: bool
 ):
     # type: (...) -> None
     """Copy directories (but not files) from ``src_fs`` to ``dst_fs``.
@@ -235,6 +270,8 @@ def copy_structure(
         walker (~fs.walk.Walker, optional): A walker object that will be
             used to scan for files in ``src_fs``. Set this if you only
             want to consider a sub-set of the resources in ``src_fs``.
+        preserve_time (bool): If `True`, try to preserve atime, ctime,
+            and mtime of the resource (defaults to `False`).
 
     """
     walker = walker or Walker()
@@ -253,6 +290,7 @@ def copy_dir(
     walker=None,  # type: Optional[Walker]
     on_copy=None,  # type: Optional[_OnCopy]
     workers=0,  # type: int
+    preserve_time=False,  # type: bool
 ):
     # type: (...) -> None
     """Copy a directory from one filesystem to another.
@@ -270,6 +308,8 @@ def copy_dir(
             ``(src_fs, src_path, dst_fs, dst_path)``.
         workers (int): Use ``worker`` threads to copy data, or ``0`` (default) for
             a single-threaded copy.
+        preserve_time (bool): If `True`, try to preserve atime, ctime,
+            and mtime of the resources (defaults to `False`).
 
     """
     on_copy = on_copy or (lambda *args: None)
@@ -297,7 +337,13 @@ def dst():
                     for info in files:
                         src_path = info.make_path(dir_path)
                         dst_path = info.make_path(copy_path)
-                        copier.copy(_src_fs, src_path, _dst_fs, dst_path)
+                        copier.copy(
+                            _src_fs,
+                            src_path,
+                            _dst_fs,
+                            dst_path,
+                            preserve_time=preserve_time,
+                        )
                         on_copy(_src_fs, src_path, _dst_fs, dst_path)
 
 
@@ -309,6 +355,7 @@ def copy_dir_if_newer(
     walker=None,  # type: Optional[Walker]
     on_copy=None,  # type: Optional[_OnCopy]
     workers=0,  # type: int
+    preserve_time=False,  # type: bool
 ):
     # type: (...) -> None
     """Copy a directory from one filesystem to another, checking times.
@@ -331,6 +378,8 @@ def copy_dir_if_newer(
             ``(src_fs, src_path, dst_fs, dst_path)``.
         workers (int): Use ``worker`` threads to copy data, or ``0`` (default) for
             a single-threaded copy.
+        preserve_time (bool): If `True`, try to preserve atime, ctime,
+            and mtime of the resources (defaults to `False`).
 
     """
     on_copy = on_copy or (lambda *args: None)
@@ -381,5 +430,11 @@ def dst():
                             )
 
                         if do_copy:
-                            copier.copy(_src_fs, dir_path, _dst_fs, copy_path)
+                            copier.copy(
+                                _src_fs,
+                                dir_path,
+                                _dst_fs,
+                                copy_path,
+                                preserve_time=preserve_time,
+                            )
                             on_copy(_src_fs, dir_path, _dst_fs, copy_path)

fs/mirror.py

@@ -57,6 +57,7 @@ def mirror(
     walker=None,  # type: Optional[Walker]
     copy_if_newer=True,  # type: bool
     workers=0,  # type: int
+    preserve_time=False,  # type: bool
 ):
     # type: (...) -> None
     """Mirror files / directories from one filesystem to another.
@@ -73,6 +74,8 @@ def mirror(
         workers (int): Number of worker threads used
             (0 for single threaded). Set to a relatively low number
             for network filesystems, 4 would be a good start.
+        preserve_time (bool): If `True`, try to preserve atime, ctime,
+            and mtime of the resources (defaults to `False`).
 
     """
 
@@ -92,13 +95,19 @@ def dst():
                     walker=walker,
                     copy_if_newer=copy_if_newer,
                     copy_file=copier.copy,
+                    preserve_time=preserve_time,
                 )
 
 
 def _mirror(
-    src_fs, dst_fs, walker=None, copy_if_newer=True, copy_file=copy_file_internal
+    src_fs,  # type: FS
+    dst_fs,  # type: FS
+    walker=None,  # type: Optional[Walker]
+    copy_if_newer=True,  # type: bool
+    copy_file=copy_file_internal,  # type: Callable[[FS, str, FS, str, bool], None]
+    preserve_time=False,  # type: bool
 ):
-    # type: (FS, FS, Optional[Walker], bool, Callable[[FS, str, FS, str], None]) -> None
+    # type: (...) -> None
     walker = walker or Walker()
     walk = walker.walk(src_fs, namespaces=["details"])
     for path, dirs, files in walk:
@@ -122,7 +131,7 @@ def _mirror(
                     # Compare file info
                     if copy_if_newer and not _compare(_file, dst_file):
                         continue
-            copy_file(src_fs, _path, dst_fs, _path)
+            copy_file(src_fs, _path, dst_fs, _path, preserve_time)
 
         # Make directories
         for _dir in dirs: