1 files changed, 112 insertions, 0 deletions
diff --git a/third_party/python/atomicwrites/PKG-INFO b/third_party/python/atomicwrites/PKG-INFO
new file mode 100644
index 0000000000..eec6b7c305
--- /dev/null
+++ b/third_party/python/atomicwrites/PKG-INFO
@@ -0,0 +1,112 @@
+Metadata-Version: 1.0
+Name: atomicwrites
+Version: 1.1.5
+Summary: Atomic file writes.
+Home-page: https://github.com/untitaker/python-atomicwrites
+Author: Markus Unterwaditzer
+Author-email: markus@unterwaditzer.net
+License: MIT
+Description: ===================
+        python-atomicwrites
+        ===================
+        
+        .. image:: https://travis-ci.org/untitaker/python-atomicwrites.svg?branch=master
+            :target: https://travis-ci.org/untitaker/python-atomicwrites
+        
+        .. image:: https://ci.appveyor.com/api/projects/status/vadc4le3c27to59x/branch/master?svg=true
+           :target: https://ci.appveyor.com/project/untitaker/python-atomicwrites/branch/master
+        
+        Atomic file writes.
+        
+        .. code-block:: python
+        
+            from atomicwrites import atomic_write
+        
+            with atomic_write('foo.txt', overwrite=True) as f:
+                f.write('Hello world.')
+                # "foo.txt" doesn't exist yet.
+        
+            # Now it does.
+        
+        
+        Features that distinguish it from other similar libraries (see `Alternatives and Credit`_):
+        
+        - Race-free assertion that the target file doesn't yet exist. This can be
+          controlled with the ``overwrite`` parameter.
+        
+        - Windows support, although not well-tested. The MSDN resources are not very
+          explicit 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
+        ============
+        
+        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_ 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
+        temporary file, and the name of the target file.
+        
+        Also note that the permissions of the target file may change this way. In some
+        situations a ``chmod`` can be issued without any concurrency problems, but
+        since that is not always the case, this library doesn't do it by itself.
+        
+        .. _MoveFileEx: https://msdn.microsoft.com/en-us/library/windows/desktop/aa365240%28v=vs.85%29.aspx
+        
+        fsync
+        -----
+        
+        On POSIX, ``fsync`` is invoked on the temporary file after it is written (to
+        flush file content and metadata), and on the parent directory after the file is
+        moved (to flush filename).
+        
+        ``fsync`` does not take care of disks' internal buffers, but there don't seem
+        to be any standard POSIX APIs for that. On OS X, ``fcntl`` is used with
+        ``F_FULLFSYNC`` instead of ``fsync`` for that reason.
+        
+        On Windows, `_commit <https://msdn.microsoft.com/en-us/library/17618685.aspx>`_
+        is used, but there are no guarantees about disk internal buffers.
+        
+        Alternatives and Credit
+        =======================
+        
+        Atomicwrites is directly inspired by the following libraries (and shares a
+        minimal amount of code):
+        
+        - The Trac project's `utility functions
+          <http://www.edgewall.org/docs/tags-trac-0.11.7/epydoc/trac.util-pysrc.html>`_,
+          also used in `Werkzeug <http://werkzeug.pocoo.org/>`_ and
+          `mitsuhiko/python-atomicfile
+          <https://github.com/mitsuhiko/python-atomicfile>`_. The idea to use
+          ``ctypes`` instead of ``PyWin32`` originated there.
+        
+        - `abarnert/fatomic <https://github.com/abarnert/fatomic>`_. Windows support
+          (based on ``PyWin32``) was originally taken from there.
+        
+        Other alternatives to atomicwrites include:
+        
+        - `sashka/atomicfile <https://github.com/sashka/atomicfile>`_. Originally I
+          considered using that, but at the time it was lacking a lot of features I
+          needed (Windows support, overwrite-parameter, overriding behavior through
+          subclassing).
+        
+        - The `Boltons library collection <https://github.com/mahmoud/boltons>`_
+          features a class for atomic file writes, which seems to have a very similar
+          ``overwrite`` parameter. It is lacking Windows support though.
+        
+        License
+        =======
+        
+        Licensed under the MIT, see ``LICENSE``.
+        
+Platform: UNKNOWN