Untested Windows support, API rewrite

untitaker · untitaker · commit 12ef667f5c9e · 2015-02-05T14:32:36.000+01:00
diff --git a/atomicwrites/__init__.py b/atomicwrites/__init__.py
@@ -1,19 +1,75 @@
-import codecs
 import contextlib
 import os
+import sys
 import tempfile
 
 __version__ = '0.1.1'
 
+if sys.platform != 'win32':
+    def replace_atomic(src, dst):
+        os.rename(src, dst)
 
-class AtomicWriterBase(object):
+    def move_atomic(src, dst):
+        os.link(src, dst)
+        os.unlink(src)
+else:
+    import win32api
+    import win32con
+
+    _windows_default_flags = win32con.WRITE_THROUGH
+
+    def replace_atomic(src, dst):
+        win32api.MoveFileEx(
+            src, dst,
+            win32con.MOVEFILE_REPLACE_EXISTING | _windows_default_flags
+        )
+
+    def move_atomic(src, dst):
+        win32api.MoveFileEx(
+            src, dst,
+            _windows_default_flags
+        )
+
+
+replace_atomic.__doc__ = \
     '''
-    A helper class for performing atomic writes. Not fully implemented, you
-    should use a subclass of it instead. Usage::
+    Move ``src`` to ``dst``. If ``dst`` exists, it will be silently
+    overwritten.
+
+    Both paths must reside on the same filesystem for the operation to be
+    atomic.
+    ''' + (replace_atomic.__doc__ or '')
+
+
+move_atomic.__doc__ = \
+    '''
+    Move ``src`` to ``dst``. There might a timewindow where both filesystem
+    entries exist. If ``dst`` already exists, an error will be raised.
+
+    Both paths must reside on the same filesystem for the operation to be
+    atomic.
+    ''' + (move_atomic.__doc__ or '')
 
-        with MyWriter(path).open() as f:
+
+class AtomicWriter(object):
+    '''
+    A helper class for performing atomic writes. Usage::
+
+        with AtomicWriter(path).open() as f:
             f.write(...)
 
+
+    It uses a temporary file in the same directory as the given path. This
+    ensures that the temporary file resides on the same filesystem.
+
+    The temporary file will then be atomically moved to the target location: On
+    POSIX, it will use ``rename`` if files should be overwritten, otherwise a
+    combination of ``link`` and ``unlink``. On Windows, it uses ``MoveFileEx``
+    (see MSDN_) with the appropriate flags.
+
+    .. _MSDN::
+        https://msdn.microsoft.com/en-us/library/windows/desktop/aa365240%28v=vs.85%29.aspx
+
     :param path: The destination filepath. May or may not exist.
     :param overwrite: If set to false, an error is raised if ``path`` exists.
         Either way, the operation is atomic.
@@ -24,16 +80,10 @@ def __init__(self, path, overwrite=False):
         self._overwrite = overwrite
 
     def open(self, mode='w'):
-        '''Prepare the temporary file object and return it.'''
-        raise NotImplementedError()
-
-    def commit(self):
-        '''Move the temporary file to the target location.'''
-        raise NotImplementedError()
-
-    def rollback(self):
-        '''Clean up all temporary resources.'''
-        raise NotImplementedError()
+        '''
+        Open the temporary file.
+        '''
+        return self._open(lambda: self.get_fileobject(mode=mode))
 
     @contextlib.contextmanager
     def _open(self, get_fileobject):
@@ -46,39 +96,25 @@ def _open(self, get_fileobject):
         else:
             self.commit()
 
-
-class PosixAtomicWriter(AtomicWriterBase):
-    '''
-    An implementation of :py:class:`AtomicWriterBase` for POSIX-compliant
-    filesystems. It uses temporary files in the same directory.
-    '''
-
     def get_fileobject(self, mode):
         '''Return the temporary path to use.'''
         tmpdir = os.path.dirname(self._path)
         f = tempfile.NamedTemporaryFile(mode=mode, dir=tmpdir, delete=False)
         self._tmppath = f.name
         return f
 
-    def open(self, mode='w', **open_kwargs):
-        '''
-        Open the temporary file. Any arguments will be passed on to the builtin
-        ``open`` function.
-        '''
-        return self._open(lambda: self.get_fileobject(mode=mode))
-
     def commit(self):
+        '''Move the temporary file to the target location.'''
         if self._overwrite:
             os.rename(self._tmppath, self._path)  # atomic
         else:
             os.link(self._tmppath, self._path)  # atomic, fails if file exists
             os.unlink(self._tmppath)
 
     def rollback(self):
+        '''Clean up all temporary resources.'''
         os.unlink(self._tmppath)
 
-AtomicWriter = PosixAtomicWriter  # for current OS
-
 
 def atomic_write(path, mode='w', overwrite=False, writer_cls=AtomicWriter,
                  **open_kwargs):
diff --git a/docs/index.rst b/docs/index.rst
@@ -10,15 +10,12 @@ API
 Low-level API
 -------------
 
-.. autoclass:: AtomicWriterBase
-   :members: open
+.. autofunction:: replace_atomic
 
-.. autoclass:: PosixAtomicWriter
-   :members: open
+.. autofunction:: move_atomic
 
-.. class:: AtomicWriter
-
-   Automatically selected writer for the current OS.
+.. autoclass:: AtomicWriter
+   :members:
 
 License
 -------
diff --git a/setup.py b/setup.py
@@ -2,6 +2,7 @@
 
 import ast
 import re
+import sys
 
 from setuptools import find_packages, setup
 
@@ -14,6 +15,10 @@
         f.read().decode('utf-8')).group(1)))
 
 
+deps = []
+if sys.platform == 'win32':
+    deps.append('pywin32')
+
 setup(
     name='atomicwrites',
     version=version,
@@ -24,5 +29,6 @@
     license='MIT',
     long_description=open('README.rst').read(),
     packages=find_packages(exclude=['tests.*', 'tests']),
-    include_package_data=True
+    include_package_data=True,
+    install_requires=deps
 )
