Rip off ideas from Trac's utilities

untitaker · untitaker · commit 4cd90b9130e0 · 2015-04-05T22:33:46.000+02:00
http://www.edgewall.org/docs/tags-trac-0.11.7/epydoc/trac.util-pysrc.html
diff --git a/README.rst b/README.rst
@@ -27,12 +27,10 @@ Features that distinguish it from other similar libraries (see alternatives_).
   controlled with the ``overwrite`` parameter.
 
 - Windows support, although untested. The MSDN resources are not very explicit
-  about which operations are atomic. This requires ``pywin32``.
+  about which operations are atomic.
 
 - Simple high-level API that wraps a very flexible class-based API.
 
-- Consistent error handling across platforms.
-
 
 How it works
 ============
@@ -43,7 +41,7 @@ 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_) through stdlib's ``ctypes`` with the appropriate flags.
 
 Note that with ``link`` and ``unlink``, there's a timewindow where the file
 might be available under two entries in the filesystem: The name of the
diff --git a/atomicwrites/__init__.py b/atomicwrites/__init__.py
@@ -9,57 +9,44 @@
 
 PY2 = sys.version_info[0] == 2
 
+text_type = unicode if PY2 else str
 
-class _FileExistsError(OSError if PY2 else FileExistsError):
-    errno = errno.EEXIST
 
-class _FileNotFoundError(OSError if PY2 else FileNotFoundError):
-    errno = errno.ENOENT
+def _path_to_unicode(x):
+    if not isinstance(x, text_type):
+        return x.decode(sys.getfilesystemencoding())
+    return x
 
 
 if sys.platform != 'win32':
-    @contextlib.contextmanager
-    def handle_errors():
-        yield
-
     def _replace_atomic(src, dst):
         os.rename(src, dst)
 
     def _move_atomic(src, dst):
         os.link(src, dst)
         os.unlink(src)
 else:
-    import win32api
-    import win32file
-    import pywintypes
+    from ctypes import windll, WinError
 
-    _windows_default_flags = win32file.MOVEFILE_WRITE_THROUGH
-    _windows_error_table = {
-        183: _FileExistsError,
-        3: _FileNotFoundError
-    }
+    _MOVEFILE_REPLACE_EXISTING = 0x1
+    _MOVEFILE_WRITE_THROUGH = 0x8
+    _windows_default_flags = _MOVEFILE_WRITE_THROUGHr
 
-    @contextlib.contextmanager
-    def handle_errors():
-        try:
-            yield
-        except pywintypes.error as e:
-            native_cls = _windows_error_table.get(e.winerror, OSError)
-            new_e = native_cls(e)
-            new_e.windows_error = e
-            raise new_e
+    def _handle_errors(rv):
+        if not rv:
+            raise WinError()
 
     def _replace_atomic(src, dst):
-        win32api.MoveFileEx(
-            src, dst,
-            win32file.MOVEFILE_REPLACE_EXISTING | _windows_default_flags
-        )
+        _handle_errors(windll.kernel32.MoveFileExW(
+            _path_to_unicode(src), _path_to_unicode(dst),
+            _windows_default_flags | _MOVEFILE_REPLACE_EXISTING
+        ))
 
     def _move_atomic(src, dst):
-        win32api.MoveFileEx(
-            src, dst,
+        _handle_errors(windll.kernel32.MoveFileExW(
+            _path_to_unicode(src), _path_to_unicode(dst),
             _windows_default_flags
-        )
+        ))
 
 
 def replace_atomic(src, dst):
@@ -70,8 +57,7 @@ def replace_atomic(src, dst):
     Both paths must reside on the same filesystem for the operation to be
     atomic.
     '''
-    with handle_errors():
-        return _replace_atomic(src, dst)
+    return _replace_atomic(src, dst)
 
 
 def move_atomic(src, dst):
@@ -83,8 +69,7 @@ def move_atomic(src, dst):
     Both paths must reside on the same filesystem for the operation to be
     atomic.
     '''
-    with handle_errors():
-        return _move_atomic(src, dst)
+    return _move_atomic(src, dst)
 
 
 class AtomicWriter(object):
diff --git a/docs/index.rst b/docs/index.rst
@@ -13,10 +13,11 @@ Errorhandling
 
 All filesystem errors are subclasses of :py:exc:`OSError`.
 
-- On UNIX systems, errors from the Python stdlib calls are simply uncaught.
-- On Windows systems, PyWin32 errors are wrapped such that they somewhat
-  resemble the stdlib exceptions. The original PyWin32 exception object is
-  available as ``e.windows_error`` (with ``e`` being the thrown exception).
+- On UNIX systems, errors from the Python stdlib calls are thrown.
+- On Windows systems, errors from Python's ``ctypes`` are thrown.
+
+In either case, the ``errno`` attribute on the throws exception maps to an
+errorcode in the ``errno`` module.
 
 Low-level API
 -------------
diff --git a/setup.py b/setup.py
@@ -14,12 +14,6 @@
     version = str(ast.literal_eval(_version_re.search(
         f.read().decode('utf-8')).group(1)))
 
-
-deps = []
-if sys.platform == 'win32':
-    # http://sourceforge.net/p/pywin32/bugs/680/
-    deps.append('pypiwin32')
-
 setup(
     name='atomicwrites',
     version=version,
@@ -31,5 +25,4 @@
     long_description=open('README.rst').read(),
     packages=find_packages(exclude=['tests.*', 'tests']),
     include_package_data=True,
-    install_requires=deps
 )
