Added preserve_time parameter to move, copy, and mirror

CHANGELOG.md

@@ -21,6 +21,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Better documentation of the `writable` parameter of `fs.open_fs`, and
   hint about using `fs.wrap.read_only` when a read-only filesystem is
   required. Closes [#441](https://github.com/PyFilesystem/pyfilesystem2/issues/441).
+- Copy and move operations now provide a parameter `preserve_time` that, when
+  passed as `True`, makes sure the "mtime" of the destination file will be
+  the same as that of the source file.
 
 ### Changed
 

fs/_bulk.py

@@ -13,12 +13,11 @@
 
 from .copy import copy_file_internal
 from .errors import BulkCopyFailed
-from .tools import copy_file_data
 
 if typing.TYPE_CHECKING:
     from .base import FS
     from types import TracebackType
-    from typing import IO, List, Optional, Text, Type
+    from typing import List, Optional, Text, Type
 
 
 class _Worker(threading.Thread):
@@ -56,20 +55,30 @@ def __call__(self):
 class _CopyTask(_Task):
     """A callable that copies from one file another."""
 
-    def __init__(self, src_file, dst_file):
-        # type: (IO, IO) -> None
-        self.src_file = src_file
-        self.dst_file = dst_file
+    def __init__(
+        self,
+        src_fs,  # type: FS
+        src_path,  # type: Text
+        dst_fs,  # type: FS
+        dst_path,  # type: Text
+        preserve_time,  # type: bool
+    ):
+        # type: (...) -> None
+        self.src_fs = src_fs
+        self.src_path = src_path
+        self.dst_fs = dst_fs
+        self.dst_path = dst_path
+        self.preserve_time = preserve_time
 
     def __call__(self):
         # type: () -> None
-        try:
-            copy_file_data(self.src_file, self.dst_file, chunk_size=1024 * 1024)
-        finally:
-            try:
-                self.src_file.close()
-            finally:
-                self.dst_file.close()
+        copy_file_internal(
+            self.src_fs,
+            self.src_path,
+            self.dst_fs,
+            self.dst_path,
+            preserve_time=self.preserve_time,
+        )
 
 
 class Copier(object):
@@ -88,7 +97,7 @@ def __init__(self, num_workers=4):
     def start(self):
         """Start the workers."""
         if self.num_workers:
-            self.queue = Queue(maxsize=self.num_workers)
+            self.queue = Queue()
             self.workers = [_Worker(self) for _ in range(self.num_workers)]
             for worker in self.workers:
                 worker.start()
@@ -124,18 +133,14 @@ 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:
-            src_file = src_fs.openbin(src_path, "r")
-            try:
-                dst_file = dst_fs.openbin(dst_path, "w")
-            except Exception:
-                src_file.close()
-                raise
-            task = _CopyTask(src_file, dst_file)
+            task = _CopyTask(src_fs, src_path, dst_fs, dst_path, preserve_time)
             self.queue.put(task)

fs/base.py

@@ -22,6 +22,7 @@
 import six
 
 from . import copy, errors, fsencode, iotools, move, tools, walk, wildcard
+from .copy import copy_mtime
 from .glob import BoundGlobber
 from .mode import validate_open_mode
 from .path import abspath, join, normpath
@@ -393,15 +394,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 mtime of the
+                resource (defaults to `False`).
 
         Raises:
             fs.errors.DestinationExists: If ``dst_path`` exists,
@@ -417,16 +426,25 @@ def copy(self, src_path, dst_path, overwrite=False):
             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
+            copy_mtime(self, src_path, self, dst_path)
 
-    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 mtime of the
+                resource (defaults to `False`).
 
         Raises:
             fs.errors.ResourceNotFound: If the ``dst_path``
@@ -440,7 +458,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
@@ -1027,15 +1045,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 mtime of the
+                resources (defaults to `False`).
 
         Raises:
             fs.errors.ResourceNotFound: if ``dst_path`` does not exist,
@@ -1047,7 +1067,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,
@@ -1092,8 +1112,8 @@ def makedirs(
                     raise
             return self.opendir(path)
 
-    def move(self, src_path, dst_path, overwrite=False):
-        # type: (Text, Text, bool) -> None
+    def move(self, src_path, dst_path, overwrite=False, preserve_time=False):
+        # type: (Text, Text, bool, bool) -> None
         """Move a file from ``src_path`` to ``dst_path``.
 
         Arguments:
@@ -1102,6 +1122,8 @@ def move(self, src_path, dst_path, overwrite=False):
                 file will be written to.
             overwrite (bool): If `True`, destination path will be
                 overwritten if it exists.
+            preserve_time (bool): If `True`, try to preserve mtime of the
+                resources (defaults to `False`).
 
         Raises:
             fs.errors.FileExpected: If ``src_path`` maps to a
@@ -1133,6 +1155,7 @@ def move(self, src_path, dst_path, overwrite=False):
             with self.open(src_path, "rb") as read_file:
                 # FIXME(@althonos): typing complains because open return IO
                 self.upload(dst_path, read_file)  # type: ignore
+            copy_mtime(self, src_path, self, dst_path)
             self.remove(src_path)
 
     def open(