Bump version

macOS 11.x will occasionally identify as 10.16, since there was no real
reason to prevent on all supported platforms allow.

.gitignore

@@ -0,0 +1,8 @@
+*.pyc
+*.egg-info
+/build
+/dist
+.DS_Store
+/.tox
+__pycache__
+/env

.hgignore

@@ -1,5 +0,0 @@
-syntax: glob
-
-*.pyc
-build
-.DS_Store

.travis.yml

@@ -0,0 +1,33 @@
+language: python
+matrix:
+  include:
+    - os: windows
+      language: sh
+      python: "3.8"
+      env: "PATH=/c/Python38:/c/Python38/Scripts:$PATH"
+      # Perform the manual steps on windows to install python3
+      before_install:
+        - choco install python --version=3.8.6
+        - python -m pip install --upgrade pip
+      before_script:
+        - export TOXENV=py38
+    - python: "2.7"
+    - python: "3.4"
+    - python: "3.5"
+    - python: "3.6"
+    - python: "3.7"
+    - python: "3.8"
+    - python: "3.9"
+    - python: "nightly"  # 3.10
+      before_script:
+        - export TOXENV=py310
+    - python: "2.7"
+      arch: ppc64le
+    - python: "3.6"
+      arch: ppc64le
+install:
+  - python -m pip install tox
+before_script:
+  - export TOXENV=$(echo py$TRAVIS_PYTHON_VERSION | tr -d .)
+script:
+  - python -m tox

CHANGES

@@ -1,4 +0,0 @@
-Version 1.0.0 -- 2010/04/07
----
-
-* Initial Release

CHANGES.rst

@@ -0,0 +1,79 @@
+Changes
+=======
+
+Version 1.7.0a -- 2020/04/20
+----------------------------
+* Add console_script entry point (#50)
+* Increased python CI versions (#52, #54)
+* Fix minor issue in setup.py (#53)
+* Fix issue with windows tests importing modules on non-windows (#55)
+* Unit test cleanups, rewrites, and flake8 cleanups
+* Windows: Fix legacy windows platform for multi-byte unicode and add tests
+* macOS: Add alternative pyobjc version to potentially improve compatibility (#51)
+
+Version 1.6.0b1 -- 2020/06/18
+-----------------------------
+
+* Add main method which allows calling via ``python -m send2trash somefile``
+* Windows: Add support for using IFileOperation when pywin32 is present on Vista and newer
+* Add support for passing multiple files at once in a list
+* Windows: Batch multi-file calls to improve performance (#42)
+* Windows: Fix issue with SHFileOperation failing silently when path is not found (#33)
+
+Version 1.5.0 -- 2018/02/16
+---------------------------
+
+* More specific error when failing to create XDG fallback trash directory (#20)
+* Windows: Workaround for long paths (#23)
+
+Version 1.4.2 -- 2017/11/17
+---------------------------
+
+* Fix incompatibility with Python 3.6 on Windows. (#18)
+
+Version 1.4.1 -- 2017/08/07
+---------------------------
+
+* Fix crash on Windows introduced in v1.4.0. Oops... (#14)
+
+Version 1.4.0 -- 2017/08/07
+---------------------------
+
+* Use ``bytes`` instead of ``str`` for internal path handling in ``plat_other``. (#13)
+
+Version 1.3.1 -- 2017/07/31
+---------------------------
+
+* Throw ``WindowsError`` instead of ``OSError`` in ``plat_win``. (#7)
+* Fix ``TypeError`` on python 2 in ``plat_other``. (#12)
+
+Version 1.3.0 -- 2013/07/19
+---------------------------
+
+* Added support for Gnome's GIO.
+* Merged Python 3 and Python 2 versions in a single codebase.
+
+Version 1.2.0 -- 2011/03/16
+---------------------------
+
+* Improved ``plat_other`` to follow freedesktop.org trash specification.
+
+Version 1.1.0 -- 2010/10/18
+---------------------------
+
+* Converted compiled modules to ctypes so that cross-platform compilation isn't necessary anymore.
+
+Version 1.0.2 -- 2010/07/10
+---------------------------
+
+* Fixed bugs with external volumes in plat_other.
+
+Version 1.0.1 -- 2010/04/19
+---------------------------
+
+* Fixed memory leak in OS X module.
+
+Version 1.0.0 -- 2010/04/07
+---------------------------
+
+* Initial Release

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010, Hardcoded Software Inc., http://www.hardcoded.net
+Copyright (c) 2017, Virgil Dupras
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
@@ -7,4 +7,4 @@ Redistribution and use in source and binary forms, with or without modification,
     * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
     * Neither the name of Hardcoded Software Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

MANIFEST.in

@@ -0,0 +1 @@
+include CHANGES.rst LICENSE

README

@@ -1,25 +0,0 @@
-==================================================
-Send2Trash -- Send files to trash on all platforms
-==================================================
-
-Send2Trash is a small package that sends files to the Trash (or Recycle Bin) *natively* and on
-*all platforms*. On OS X, it uses native ``FSMoveObjectToTrashSync`` Cocoa calls, on Windows, it uses native (and ugly) ``SHFileOperation`` win32 calls. On other platforms, it moves the file to the first folder it finds that looks like a trash (so far, it's known to work on Ubuntu).
-
-Installation
-------------
-
-Download the source from http://hg.hardcoded.net/send2trash and install it with::
-
->>> sudo python setup.py install
-
-On Windows, you'll need Visual Studio 2008 to compile it. Note that the install you'll get will not be a "universal" package. If you install it on OS X, only the "osx" module will be compiled, and if you install it on Windows, only the "win" module will be compiled.
-
-To have a cross-platform package you can ship around, you'll have compile the package on both platforms and merge the results so that both compiled modules are in the same package.
-
-Usage
------
-
->>> from send2trash import send2trash
->>> send2trash('some_file')
-
-When there's a problem ``OSError`` is raised.

README.rst

@@ -0,0 +1,52 @@
+==================================================
+Send2Trash -- Send files to trash on all platforms
+==================================================
+
+Send2Trash is a small package that sends files to the Trash (or Recycle Bin) *natively* and on
+*all platforms*. On OS X, it uses native ``FSMoveObjectToTrashSync`` Cocoa calls. On Windows, it
+uses native ``IFileOperation`` call if on Vista or newer and pywin32 is installed or falls back 
+to ``SHFileOperation`` calls. On other platforms, if `PyGObject`_ and `GIO`_ are available, it 
+will use this.  Otherwise, it will fallback to its own implementation of the `trash specifications 
+from freedesktop.org`_.
+
+``ctypes`` is used to access native libraries, so no compilation is necessary.
+
+Send2Trash supports Python 2.7 and up (Python 3 is supported).
+
+Status: Additional Help Welcome
+-------------------------------
+
+Additional help is welcome for supporting this package.  Specifically help with the OSX and Linux 
+issues and fixes would be most appreciated.
+
+Installation
+------------
+
+You can download it with pip::
+
+    python -m pip install -U send2trash
+
+or you can download the source from http://github.com/arsenetar/send2trash and install it with::
+
+    >>> python setup.py install
+
+Usage
+-----
+
+>>> from send2trash import send2trash
+>>> send2trash('some_file')
+>>> send2trash(['some_file1', 'some_file2'])
+
+On Freedesktop platforms (Linux, BSD, etc.), you may not be able to efficiently
+trash some files. In these cases, an exception ``send2trash.TrashPermissionError``
+is raised, so that the application can handle this case. This inherits from
+``PermissionError`` (``OSError`` on Python 2). Specifically, this affects
+files on a different device to the user's home directory, where the root of the
+device does not have a ``.Trash`` directory, and we don't have permission to
+create a ``.Trash-$UID`` directory.
+
+For any other problem, ``OSError`` is raised.
+
+.. _PyGObject: https://wiki.gnome.org/PyGObject
+.. _GIO: https://developer.gnome.org/gio/
+.. _trash specifications from freedesktop.org: http://freedesktop.org/wiki/Specifications/trash-spec/

modules/send2trash_osx.c

@@ -1,44 +0,0 @@
-/* Copyright 2010 Hardcoded Software (http://www.hardcoded.net)
-
-This software is licensed under the "BSD" License as described in the "LICENSE" file, 
-which should be included with this package. The terms are also available at 
-http://www.hardcoded.net/licenses/bsd_license
-*/
-
-#define PY_SSIZE_T_CLEAN
-#include "Python.h"
-#include <CoreServices/CoreServices.h>
-
-static PyObject* send2trash_osx_send(PyObject *self, PyObject *args)
-{
-    UInt8 *utf8_chars;
-    FSRef fp;
-    OSStatus op_result;
-    
-    if (!PyArg_ParseTuple(args, "es", "utf-8", &utf8_chars)) {
-        return NULL;
-    }
-    
-	FSPathMakeRefWithOptions(utf8_chars, kFSPathMakeRefDoNotFollowLeafSymlink, &fp, NULL);
-	op_result = FSMoveObjectToTrashSync(&fp, NULL, kFSFileOperationDefaultOptions);
-	if (op_result != noErr) {
-        PyErr_SetString(PyExc_OSError, GetMacOSStatusCommentString(op_result));
-        return NULL;
-    }
-    return Py_None;
-}
-
-static PyMethodDef TrashMethods[] = {
-    {"send",  send2trash_osx_send, METH_VARARGS, ""},
-    {NULL, NULL, 0, NULL}
-};
-
-PyMODINIT_FUNC
-init_send2trash_osx(void)
-{
-    PyObject *m = Py_InitModule("_send2trash_osx", TrashMethods);
-    if (m == NULL) {
-        return;
-    }
-}
-

modules/send2trash_win.c

@@ -1,68 +0,0 @@
-/* Copyright 2010 Hardcoded Software (http://www.hardcoded.net)
-
-This software is licensed under the "BSD" License as described in the "LICENSE" file, 
-which should be included with this package. The terms are also available at 
-http://www.hardcoded.net/licenses/bsd_license
-*/
-
-#define PY_SSIZE_T_CLEAN
-#include "Python.h"
-
-#define WINDOWS_LEAN_AND_MEAN
-#include "windows.h"
-#include "shlobj.h"
-
-/* WARNING: If the filepath is not fully qualified, Windows deletes the file
-   rather than sending it to trash. 
- */
-
-static PyObject* send2trash_win_send(PyObject *self, PyObject *args)
-{
-    SHFILEOPSTRUCTW op;
-    PyObject *filepath;
-    Py_ssize_t len;
-    WCHAR filechars[MAX_PATH+1];
-    int r;
-    
-    if (!PyArg_ParseTuple(args, "O", &filepath)) {
-        return NULL;
-    }
-    
-    if (!PyUnicode_Check(filepath)) {
-        PyErr_SetString(PyExc_TypeError, "Unicode filename required");
-        return NULL;
-    }
-    
-    len = PyUnicode_GET_SIZE(filepath);
-    memcpy(filechars, PyUnicode_AsUnicode(filepath), sizeof(WCHAR)*len);
-    filechars[len] = '\0';
-    filechars[len+1] = '\0';
-
-    op.hwnd = 0;
-    op.wFunc = FO_DELETE;
-    op.pFrom = (LPCWSTR)&filechars;
-    op.pTo = NULL;
-    op.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_SILENT;
-    r = SHFileOperationW(&op);
-    
-    if (r != 0) {
-        PyErr_Format(PyExc_OSError, "Couldn't perform operation. Error code: %d", r);
-        return NULL;
-    }
-    
-    return Py_None;
-}
-
-static PyMethodDef TrashMethods[] = {
-    {"send",  send2trash_win_send, METH_VARARGS, ""},
-    {NULL, NULL, 0, NULL}
-};
-
-PyMODINIT_FUNC
-init_send2trash_win(void)
-{
-    PyObject *m = Py_InitModule("_send2trash_win", TrashMethods);
-    if (m == NULL) {
-        return;
-    }
-}

send2trash/IFileOperationProgressSink.py

@@ -0,0 +1,105 @@
+# Sample implementation of IFileOperationProgressSink that just prints
+# some basic info
+
+import pythoncom
+from win32com.shell import shell, shellcon
+from win32com.server.policy import DesignatedWrapPolicy
+
+
+class FileOperationProgressSink(DesignatedWrapPolicy):
+    _com_interfaces_ = [shell.IID_IFileOperationProgressSink]
+    _public_methods_ = [
+        "StartOperations",
+        "FinishOperations",
+        "PreRenameItem",
+        "PostRenameItem",
+        "PreMoveItem",
+        "PostMoveItem",
+        "PreCopyItem",
+        "PostCopyItem",
+        "PreDeleteItem",
+        "PostDeleteItem",
+        "PreNewItem",
+        "PostNewItem",
+        "UpdateProgress",
+        "ResetTimer",
+        "PauseTimer",
+        "ResumeTimer",
+    ]
+
+    def __init__(self):
+        self._wrap_(self)
+        self.newItem = None
+
+    def PreDeleteItem(self, flags, item):
+        # Can detect cases where to stop via flags and condition below, however the operation
+        # does not actual stop, we can resort to raising an exception as that does stop things
+        # but that may need some additional considerations before implementing.
+        return (
+            0 if flags & shellcon.TSF_DELETE_RECYCLE_IF_POSSIBLE else 0x80004005
+        )  # S_OK, or E_FAIL
+
+    def PostDeleteItem(self, flags, item, hrDelete, newlyCreated):
+        if newlyCreated:
+            self.newItem = newlyCreated.GetDisplayName(shellcon.SHGDN_FORPARSING)
+
+    def StartOperations(self):
+        pass
+
+    def FinishOperations(self, Result):
+        pass
+
+    def PreRenameItem(self, Flags, Item, NewName):
+        pass
+
+    def PostRenameItem(self, Flags, Item, NewName, hrRename, NewlyCreated):
+        pass
+
+    def PreMoveItem(self, Flags, Item, DestinationFolder, NewName):
+        pass
+
+    def PostMoveItem(
+        self, Flags, Item, DestinationFolder, NewName, hrMove, NewlyCreated
+    ):
+        pass
+
+    def PreCopyItem(self, Flags, Item, DestinationFolder, NewName):
+        pass
+
+    def PostCopyItem(
+        self, Flags, Item, DestinationFolder, NewName, hrCopy, NewlyCreated
+    ):
+        pass
+
+    def PreNewItem(self, Flags, DestinationFolder, NewName):
+        pass
+
+    def PostNewItem(
+        self,
+        Flags,
+        DestinationFolder,
+        NewName,
+        TemplateName,
+        FileAttributes,
+        hrNew,
+        NewItem,
+    ):
+        pass
+
+    def UpdateProgress(self, WorkTotal, WorkSoFar):
+        pass
+
+    def ResetTimer(self):
+        pass
+
+    def PauseTimer(self):
+        pass
+
+    def ResumeTimer(self):
+        pass
+
+
+def CreateSink():
+    return pythoncom.WrapObject(
+        FileOperationProgressSink(), shell.IID_IFileOperationProgressSink
+    )

send2trash/__init__.py

@@ -1,14 +1,21 @@
-# Copyright 2010 Hardcoded Software (http://www.hardcoded.net)
+# Copyright 2013 Hardcoded Software (http://www.hardcoded.net)
 
-# This software is licensed under the "BSD" License as described in the "LICENSE" file, 
-# which should be included with this package. The terms are also available at 
+# This software is licensed under the "BSD" License as described in the "LICENSE" file,
+# which should be included with this package. The terms are also available at
 # http://www.hardcoded.net/licenses/bsd_license
 
 import sys
 
-if sys.platform == 'darwin':
-    from plat_osx import send2trash
-elif sys.platform == 'win32':
-    from plat_win import send2trash
+from .exceptions import TrashPermissionError  # noqa: F401
+
+if sys.platform == "darwin":
+    from .plat_osx import send2trash
+elif sys.platform == "win32":
+    from .plat_win import send2trash
 else:
-    from plat_other import send2trash
+    try:
+        # If we can use gio, let's use it
+        from .plat_gio import send2trash
+    except ImportError:
+        # Oh well, let's fallback to our own Freedesktop trash implementation
+        from .plat_other import send2trash  # noqa: F401

send2trash/__main__.py

@@ -0,0 +1,33 @@
+# encoding: utf-8
+# Copyright 2017 Virgil Dupras
+
+# This software is licensed under the "BSD" License as described in the "LICENSE" file,
+# which should be included with this package. The terms are also available at
+# http://www.hardcoded.net/licenses/bsd_license
+
+from __future__ import print_function
+
+import sys
+
+from argparse import ArgumentParser
+from send2trash import send2trash
+
+
+def main(args=None):
+    parser = ArgumentParser(description='Tool to send files to trash')
+    parser.add_argument('files', nargs='+')
+    parser.add_argument('-v', '--verbose', action='store_true', help='Print deleted files')
+    args = parser.parse_args(args)
+
+    for filename in args.files:
+        try:
+            send2trash(filename)
+            if args.verbose:
+                print('Trashed «' + filename + '»')
+        except OSError as e:
+            print(str(e), file=sys.stderr)
+            sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

send2trash/compat.py

@@ -0,0 +1,20 @@
+# Copyright 2017 Virgil Dupras
+
+# This software is licensed under the "BSD" License as described in the "LICENSE" file,
+# which should be included with this package. The terms are also available at
+# http://www.hardcoded.net/licenses/bsd_license
+
+import sys
+import os
+
+PY3 = sys.version_info[0] >= 3
+if PY3:
+    text_type = str
+    binary_type = bytes
+    if os.supports_bytes_environ:
+        # environb will be unset under Windows, but then again we're not supposed to use it.
+        environb = os.environb
+else:
+    text_type = unicode  # noqa: F821
+    binary_type = str
+    environb = os.environ

send2trash/exceptions.py

@@ -0,0 +1,26 @@
+import errno
+from .compat import PY3
+
+if PY3:
+    _permission_error = PermissionError  # noqa: F821
+else:
+    _permission_error = OSError
+
+
+class TrashPermissionError(_permission_error):
+    """A permission error specific to a trash directory.
+
+    Raising this error indicates that permissions prevent us efficiently
+    trashing a file, although we might still have permission to delete it.
+    This is *not* used when permissions prevent removing the file itself:
+    that will be raised as a regular PermissionError (OSError on Python 2).
+
+    Application code that catches this may try to simply delete the file,
+    or prompt the user to decide, or (on Freedesktop platforms), move it to
+    'home trash' as a fallback. This last option probably involves copying the
+    data between partitions, devices, or network drives, so we don't do it as
+    a fallback.
+    """
+
+    def __init__(self, filename):
+        _permission_error.__init__(self, errno.EACCES, "Permission denied", filename)

send2trash/plat_gio.py

@@ -0,0 +1,23 @@
+# Copyright 2017 Virgil Dupras
+
+# This software is licensed under the "BSD" License as described in the "LICENSE" file,
+# which should be included with this package. The terms are also available at
+# http://www.hardcoded.net/licenses/bsd_license
+
+from gi.repository import GObject, Gio
+from .exceptions import TrashPermissionError
+
+
+def send2trash(paths):
+    if not isinstance(paths, list):
+        paths = [paths]
+    for path in paths:
+        try:
+            f = Gio.File.new_for_path(path)
+            f.trash(cancellable=None)
+        except GObject.GError as e:
+            if e.code == Gio.IOErrorEnum.NOT_SUPPORTED:
+                # We get here if we can't create a trash directory on the same
+                # device. I don't know if other errors can result in NOT_SUPPORTED.
+                raise TrashPermissionError("")
+            raise OSError(e.message)

send2trash/plat_osx.py

@@ -1,12 +1,20 @@
-# Copyright 2010 Hardcoded Software (http://www.hardcoded.net)
+# Copyright 2017 Virgil Dupras
 
-# This software is licensed under the "BSD" License as described in the "LICENSE" file, 
-# which should be included with this package. The terms are also available at 
+# This software is licensed under the "BSD" License as described in the "LICENSE" file,
+# which should be included with this package. The terms are also available at
 # http://www.hardcoded.net/licenses/bsd_license
 
-import _send2trash_osx
+from platform import mac_ver
+from sys import version_info
 
-def send2trash(path):
-    if not isinstance(path, unicode):
-        path = unicode(path, 'utf-8')
-    _send2trash_osx.send(path)
+# NOTE: version of pyobjc only supports python >= 3.6 and 10.9+
+macos_ver = tuple(int(part) for part in mac_ver()[0].split("."))
+if version_info >= (3, 6) and macos_ver >= (10, 9):
+    try:
+        from .plat_osx_pyobjc import send2trash
+    except ImportError:
+        # Try to fall back to ctypes version, although likely problematic still
+        from .plat_osx_ctypes import send2trash
+else:
+    # Just use the old version otherwise
+    from .plat_osx_ctypes import send2trash  # noqa: F401

send2trash/plat_osx_ctypes.py

@@ -0,0 +1,56 @@
+# Copyright 2017 Virgil Dupras
+
+# This software is licensed under the "BSD" License as described in the "LICENSE" file,
+# which should be included with this package. The terms are also available at
+# http://www.hardcoded.net/licenses/bsd_license
+
+from __future__ import unicode_literals
+
+from ctypes import cdll, byref, Structure, c_char, c_char_p
+from ctypes.util import find_library
+
+from .compat import binary_type
+
+Foundation = cdll.LoadLibrary(find_library("Foundation"))
+CoreServices = cdll.LoadLibrary(find_library("CoreServices"))
+
+GetMacOSStatusCommentString = Foundation.GetMacOSStatusCommentString
+GetMacOSStatusCommentString.restype = c_char_p
+FSPathMakeRefWithOptions = CoreServices.FSPathMakeRefWithOptions
+FSMoveObjectToTrashSync = CoreServices.FSMoveObjectToTrashSync
+
+kFSPathMakeRefDefaultOptions = 0
+kFSPathMakeRefDoNotFollowLeafSymlink = 0x01
+
+kFSFileOperationDefaultOptions = 0
+kFSFileOperationOverwrite = 0x01
+kFSFileOperationSkipSourcePermissionErrors = 0x02
+kFSFileOperationDoNotMoveAcrossVolumes = 0x04
+kFSFileOperationSkipPreflight = 0x08
+
+
+class FSRef(Structure):
+    _fields_ = [("hidden", c_char * 80)]
+
+
+def check_op_result(op_result):
+    if op_result:
+        msg = GetMacOSStatusCommentString(op_result).decode("utf-8")
+        raise OSError(msg)
+
+
+def send2trash(paths):
+    if not isinstance(paths, list):
+        paths = [paths]
+    paths = [
+        path.encode("utf-8") if not isinstance(path, binary_type) else path
+        for path in paths
+    ]
+    for path in paths:
+        fp = FSRef()
+        opts = kFSPathMakeRefDoNotFollowLeafSymlink
+        op_result = FSPathMakeRefWithOptions(path, opts, byref(fp), None)
+        check_op_result(op_result)
+        opts = kFSFileOperationDefaultOptions
+        op_result = FSMoveObjectToTrashSync(byref(fp), None, opts)
+        check_op_result(op_result)

send2trash/plat_osx_pyobjc.py

@@ -0,0 +1,29 @@
+# Copyright 2017 Virgil Dupras
+
+# This software is licensed under the "BSD" License as described in the "LICENSE" file,
+# which should be included with this package. The terms are also available at
+# http://www.hardcoded.net/licenses/bsd_license
+
+from Foundation import NSFileManager, NSURL
+from .compat import text_type
+
+
+def check_op_result(op_result):
+    # First value will be false on failure
+    if not op_result[0]:
+        # Error is in third value, localized failure reason matchs ctypes version
+        raise OSError(op_result[2].localizedFailureReason())
+
+
+def send2trash(paths):
+    if not isinstance(paths, list):
+        paths = [paths]
+    paths = [
+        path.decode("utf-8") if not isinstance(path, text_type) else path
+        for path in paths
+    ]
+    for path in paths:
+        file_url = NSURL.fileURLWithPath_(path)
+        fm = NSFileManager.defaultManager()
+        op_result = fm.trashItemAtURL_resultingItemURL_error_(file_url, None, None)
+        check_op_result(op_result)

send2trash/plat_other.py

@@ -1,71 +1,211 @@
+# Copyright 2017 Virgil Dupras
+
+# This software is licensed under the "BSD" License as described in the "LICENSE" file,
+# which should be included with this package. The terms are also available at
+# http://www.hardcoded.net/licenses/bsd_license
+
+# This is a reimplementation of plat_other.py with reference to the
+# freedesktop.org trash specification:
+#   [1] http://www.freedesktop.org/wiki/Specifications/trash-spec
+#   [2] http://www.ramendik.ru/docs/trashspec.html
+# See also:
+#   [3] http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
+#
+# For external volumes this implementation will raise an exception if it can't
+# find or create the user's trash directory.
+
 from __future__ import unicode_literals
+
+import errno
 import sys
 import os
 import os.path as op
-# Copyright 2010 Hardcoded Software (http://www.hardcoded.net)
+from datetime import datetime
+import stat
 
-# This software is licensed under the "BSD" License as described in the "LICENSE" file, 
-# which should be included with this package. The terms are also available at 
-# http://www.hardcoded.net/licenses/bsd_license
+try:
+    from urllib.parse import quote
+except ImportError:
+    # Python 2
+    from urllib import quote
 
-import logging
+from .compat import text_type, environb
+from .exceptions import TrashPermissionError
 
-CANDIDATES = [
-    '~/.local/share/Trash/files',
-    '~/.Trash',
-]
+try:
+    fsencode = os.fsencode  # Python 3
+    fsdecode = os.fsdecode
+except AttributeError:
 
-for candidate in CANDIDATES:
-    candidate_path = op.expanduser(candidate)
-    if op.exists(candidate_path):
-        TRASH_PATH = candidate_path
-        break
-else:
-    logging.warning("Can't find path for Trash")
-    TRASH_PATH = op.expanduser('~/.Trash')
+    def fsencode(u):  # Python 2
+        return u.encode(sys.getfilesystemencoding())
+
+    def fsdecode(b):
+        return b.decode(sys.getfilesystemencoding())
+
+    # The Python 3 versions are a bit smarter, handling surrogate escapes,
+    # but these should work in most cases.
+
+FILES_DIR = b"files"
+INFO_DIR = b"info"
+INFO_SUFFIX = b".trashinfo"
+
+# Default of ~/.local/share [3]
+XDG_DATA_HOME = op.expanduser(environb.get(b"XDG_DATA_HOME", b"~/.local/share"))
+HOMETRASH_B = op.join(XDG_DATA_HOME, b"Trash")
+HOMETRASH = fsdecode(HOMETRASH_B)
+
+uid = os.getuid()
+TOPDIR_TRASH = b".Trash"
+TOPDIR_FALLBACK = b".Trash-" + text_type(uid).encode("ascii")
+
+
+def is_parent(parent, path):
+    path = op.realpath(path)  # In case it's a symlink
+    if isinstance(path, text_type):
+        path = fsencode(path)
+    parent = op.realpath(parent)
+    if isinstance(parent, text_type):
+        parent = fsencode(parent)
+    return path.startswith(parent)
+
+
+def format_date(date):
+    return date.strftime("%Y-%m-%dT%H:%M:%S")
+
+
+def info_for(src, topdir):
+    # ...it MUST not include a ".." directory, and for files not "under" that
+    # directory, absolute pathnames must be used. [2]
+    if topdir is None or not is_parent(topdir, src):
+        src = op.abspath(src)
+    else:
+        src = op.relpath(src, topdir)
+
+    info = "[Trash Info]\n"
+    info += "Path=" + quote(src) + "\n"
+    info += "DeletionDate=" + format_date(datetime.now()) + "\n"
+    return info
+
+
+def check_create(dir):
+    # use 0700 for paths [3]
+    if not op.exists(dir):
+        os.makedirs(dir, 0o700)
+
+
+def trash_move(src, dst, topdir=None):
+    filename = op.basename(src)
+    filespath = op.join(dst, FILES_DIR)
+    infopath = op.join(dst, INFO_DIR)
+    base_name, ext = op.splitext(filename)
+
+    counter = 0
+    destname = filename
+    while op.exists(op.join(filespath, destname)) or op.exists(
+        op.join(infopath, destname + INFO_SUFFIX)
+    ):
+        counter += 1
+        destname = base_name + b" " + text_type(counter).encode("ascii") + ext
+
+    check_create(filespath)
+    check_create(infopath)
+
+    with open(op.join(infopath, destname + INFO_SUFFIX), "w") as f:
+        f.write(info_for(src, topdir))
+    os.rename(src, op.join(filespath, destname))
 
-EXTERNAL_CANDIDATES = [
-    '.Trash-1000/files',
-    '.Trash/files',
-    '.Trash-1000',
-    '.Trash',
-]
 
 def find_mount_point(path):
     # Even if something's wrong, "/" is a mount point, so the loop will exit.
+    # Use realpath in case it's a symlink
+    path = op.realpath(path)  # Required to avoid infinite loop
     while not op.ismount(path):
-        path = op.join(*op.split(path)[:-1])
+        path = op.split(path)[0]
     return path
 
-def find_ext_volume_trash(volume_root):
-    for candidate in EXTERNAL_CANDIDATES:
-        candidate_path = op.join(volume_root, candidate)
-        if op.exists(candidate_path):
-            return candidate_path
-    else:
-        # Something's wrong here. Screw that, just create a .Trash folder
-        trash_path = op.join(volume_root, '.Trash')
-        os.mkdir(trash_path)
-        return trash_path
 
-def move_without_conflict(src, dst):
-    filename = op.basename(src)
-    destpath = op.join(dst, filename)
-    counter = 0
-    while op.exists(destpath):
-        counter += 1
-        base_name, ext = op.splitext(filename)
-        new_filename = '{0} {1}{2}'.format(base_name, counter, ext)
-        destpath = op.join(TRASH_PATH, new_filename)
-    os.rename(src, destpath)
+def find_ext_volume_global_trash(volume_root):
+    # from [2] Trash directories (1) check for a .Trash dir with the right
+    # permissions set.
+    trash_dir = op.join(volume_root, TOPDIR_TRASH)
+    if not op.exists(trash_dir):
+        return None
 
-def send2trash(path):
-    if not isinstance(path, unicode):
-        path = unicode(path, sys.getfilesystemencoding())
+    mode = os.lstat(trash_dir).st_mode
+    # vol/.Trash must be a directory, cannot be a symlink, and must have the
+    # sticky bit set.
+    if not op.isdir(trash_dir) or op.islink(trash_dir) or not (mode & stat.S_ISVTX):
+        return None
+
+    trash_dir = op.join(trash_dir, text_type(uid).encode("ascii"))
     try:
-        move_without_conflict(path, TRASH_PATH)
+        check_create(trash_dir)
     except OSError:
-        # We're probably on an external volume
-        mount_point = find_mount_point(path)
-        dest_trash = find_ext_volume_trash(mount_point)
-        move_without_conflict(path, dest_trash)
+        return None
+    return trash_dir
+
+
+def find_ext_volume_fallback_trash(volume_root):
+    # from [2] Trash directories (1) create a .Trash-$uid dir.
+    trash_dir = op.join(volume_root, TOPDIR_FALLBACK)
+    # Try to make the directory, if we lack permission, raise TrashPermissionError
+    try:
+        check_create(trash_dir)
+    except OSError as e:
+        if e.errno == errno.EACCES:
+            raise TrashPermissionError(e.filename)
+        raise
+    return trash_dir
+
+
+def find_ext_volume_trash(volume_root):
+    trash_dir = find_ext_volume_global_trash(volume_root)
+    if trash_dir is None:
+        trash_dir = find_ext_volume_fallback_trash(volume_root)
+    return trash_dir
+
+
+# Pull this out so it's easy to stub (to avoid stubbing lstat itself)
+def get_dev(path):
+    return os.lstat(path).st_dev
+
+
+def send2trash(paths):
+    if not isinstance(paths, list):
+        paths = [paths]
+    for path in paths:
+        if isinstance(path, text_type):
+            path_b = fsencode(path)
+        elif isinstance(path, bytes):
+            path_b = path
+        elif hasattr(path, "__fspath__"):
+            # Python 3.6 PathLike protocol
+            return send2trash(path.__fspath__())
+        else:
+            raise TypeError("str, bytes or PathLike expected, not %r" % type(path))
+
+        if not op.exists(path_b):
+            raise OSError("File not found: %s" % path)
+        # ...should check whether the user has the necessary permissions to delete
+        # it, before starting the trashing operation itself. [2]
+        if not os.access(path_b, os.W_OK):
+            raise OSError("Permission denied: %s" % path)
+        # if the file to be trashed is on the same device as HOMETRASH we
+        # want to move it there.
+        path_dev = get_dev(path_b)
+
+        # If XDG_DATA_HOME or HOMETRASH do not yet exist we need to stat the
+        # home directory, and these paths will be created further on if needed.
+        trash_dev = get_dev(op.expanduser(b"~"))
+
+        if path_dev == trash_dev:
+            topdir = XDG_DATA_HOME
+            dest_trash = HOMETRASH_B
+        else:
+            topdir = find_mount_point(path_b)
+            trash_dev = get_dev(topdir)
+            if trash_dev != path_dev:
+                raise OSError("Couldn't find mount point for %s" % path)
+            dest_trash = find_ext_volume_trash(topdir)
+        trash_move(path_b, dest_trash, topdir)

send2trash/plat_win.py

@@ -1,15 +1,20 @@
-# Copyright 2010 Hardcoded Software (http://www.hardcoded.net)
+# Copyright 2017 Virgil Dupras
 
-# This software is licensed under the "BSD" License as described in the "LICENSE" file, 
-# which should be included with this package. The terms are also available at 
+# This software is licensed under the "BSD" License as described in the "LICENSE" file,
+# which should be included with this package. The terms are also available at
 # http://www.hardcoded.net/licenses/bsd_license
 
-import os.path as op
-import _send2trash_win
+from __future__ import unicode_literals
+from platform import version
 
-def send2trash(path):
-    if not isinstance(path, unicode):
-        path = unicode(path, 'mbcs')
-    if not op.isabs(path):
-        path = op.abspath(path)
-    _send2trash_win.send(path)
+# if windows is vista or newer and pywin32 is available use IFileOperation
+if int(version().split(".", 1)[0]) >= 6:
+    try:
+        # Attempt to use pywin32 to use IFileOperation
+        from .plat_win_modern import send2trash
+    except ImportError:
+        # use SHFileOperation as fallback
+        from .plat_win_legacy import send2trash
+else:
+    # use SHFileOperation as fallback
+    from .plat_win_legacy import send2trash  # noqa: F401

send2trash/plat_win_legacy.py

@@ -0,0 +1,111 @@
+# Copyright 2017 Virgil Dupras
+
+# This software is licensed under the "BSD" License as described in the "LICENSE" file,
+# which should be included with this package. The terms are also available at
+# http://www.hardcoded.net/licenses/bsd_license
+
+from __future__ import unicode_literals
+import os.path as op
+from .compat import text_type
+from ctypes import (
+    windll,
+    Structure,
+    byref,
+    c_uint,
+    create_unicode_buffer,
+    addressof,
+    GetLastError,
+    FormatError,
+)
+from ctypes.wintypes import HWND, UINT, LPCWSTR, BOOL
+
+kernel32 = windll.kernel32
+GetShortPathNameW = kernel32.GetShortPathNameW
+
+shell32 = windll.shell32
+SHFileOperationW = shell32.SHFileOperationW
+
+
+class SHFILEOPSTRUCTW(Structure):
+    _fields_ = [
+        ("hwnd", HWND),
+        ("wFunc", UINT),
+        ("pFrom", LPCWSTR),
+        ("pTo", LPCWSTR),
+        ("fFlags", c_uint),
+        ("fAnyOperationsAborted", BOOL),
+        ("hNameMappings", c_uint),
+        ("lpszProgressTitle", LPCWSTR),
+    ]
+
+
+FO_MOVE = 1
+FO_COPY = 2
+FO_DELETE = 3
+FO_RENAME = 4
+
+FOF_MULTIDESTFILES = 1
+FOF_SILENT = 4
+FOF_NOCONFIRMATION = 16
+FOF_ALLOWUNDO = 64
+FOF_NOERRORUI = 1024
+
+
+def get_short_path_name(long_name):
+    if not long_name.startswith("\\\\?\\"):
+        long_name = "\\\\?\\" + long_name
+    buf_size = GetShortPathNameW(long_name, None, 0)
+    # FIX: https://github.com/hsoft/send2trash/issues/31
+    # If buffer size is zero, an error has occurred.
+    if not buf_size:
+        err_no = GetLastError()
+        raise WindowsError(err_no, FormatError(err_no), long_name[4:])
+    output = create_unicode_buffer(buf_size)
+    GetShortPathNameW(long_name, output, buf_size)
+    return output.value[4:]  # Remove '\\?\' for SHFileOperationW
+
+
+def send2trash(paths):
+    if not isinstance(paths, list):
+        paths = [paths]
+    # convert data type
+    paths = [
+        text_type(path, "mbcs") if not isinstance(path, text_type) else path
+        for path in paths
+    ]
+    # convert to full paths
+    paths = [op.abspath(path) if not op.isabs(path) else path for path in paths]
+    # get short path to handle path length issues
+    paths = [get_short_path_name(path) for path in paths]
+    fileop = SHFILEOPSTRUCTW()
+    fileop.hwnd = 0
+    fileop.wFunc = FO_DELETE
+    # FIX: https://github.com/hsoft/send2trash/issues/17
+    # Starting in python 3.6.3 it is no longer possible to use:
+    # LPCWSTR(path + '\0') directly as embedded null characters are no longer
+    # allowed in strings
+    # Workaround
+    #  - create buffer of c_wchar[] (LPCWSTR is based on this type)
+    #  - buffer is two c_wchar characters longer (double null terminator)
+    #  - cast the address of the buffer to a LPCWSTR
+    # NOTE: based on how python allocates memory for these types they should
+    # always be zero, if this is ever not true we can go back to explicitly
+    # setting the last two characters to null using buffer[index] = '\0'.
+    # Additional note on another issue here, unicode_buffer expects length in
+    # bytes essentially, so having multi-byte characters causes issues if just
+    # passing pythons string length.  Instead of dealing with this difference we
+    # just create a buffer then a new one with an extra null.  Since the non-length
+    # specified version apparently stops after the first null, join with a space first.
+    buffer = create_unicode_buffer(" ".join(paths))
+    # convert to a single string of null terminated paths
+    path_string = "\0".join(paths)
+    buffer = create_unicode_buffer(path_string, len(buffer) + 1)
+    fileop.pFrom = LPCWSTR(addressof(buffer))
+    fileop.pTo = None
+    fileop.fFlags = FOF_ALLOWUNDO | FOF_NOCONFIRMATION | FOF_NOERRORUI | FOF_SILENT
+    fileop.fAnyOperationsAborted = 0
+    fileop.hNameMappings = 0
+    fileop.lpszProgressTitle = None
+    result = SHFileOperationW(byref(fileop))
+    if result:
+        raise WindowsError(result, FormatError(result), paths)

send2trash/plat_win_modern.py

@@ -0,0 +1,67 @@
+# Copyright 2017 Virgil Dupras
+
+# This software is licensed under the "BSD" License as described in the "LICENSE" file,
+# which should be included with this package. The terms are also available at
+# http://www.hardcoded.net/licenses/bsd_license
+
+from __future__ import unicode_literals
+import os.path as op
+from .compat import text_type
+from platform import version
+import pythoncom
+import pywintypes
+from win32com.shell import shell, shellcon
+from .IFileOperationProgressSink import CreateSink
+
+
+def send2trash(paths):
+    if not isinstance(paths, list):
+        paths = [paths]
+    # convert data type
+    paths = [
+        text_type(path, "mbcs") if not isinstance(path, text_type) else path
+        for path in paths
+    ]
+    # convert to full paths
+    paths = [op.abspath(path) if not op.isabs(path) else path for path in paths]
+    # remove the leading \\?\ if present
+    paths = [path[4:] if path.startswith("\\\\?\\") else path for path in paths]
+    # create instance of file operation object
+    fileop = pythoncom.CoCreateInstance(
+        shell.CLSID_FileOperation, None, pythoncom.CLSCTX_ALL, shell.IID_IFileOperation,
+    )
+    # default flags to use
+    flags = (
+        shellcon.FOF_NOCONFIRMATION
+        | shellcon.FOF_NOERRORUI
+        | shellcon.FOF_SILENT
+        | shellcon.FOFX_EARLYFAILURE
+    )
+    # determine rest of the flags based on OS version
+    # use newer recommended flags if available
+    if int(version().split(".", 1)[0]) >= 8:
+        flags |= (
+            0x20000000  # FOFX_ADDUNDORECORD win 8+
+            | 0x00080000  # FOFX_RECYCLEONDELETE win 8+
+        )
+    else:
+        flags |= shellcon.FOF_ALLOWUNDO
+    # set the flags
+    fileop.SetOperationFlags(flags)
+    # actually try to perform the operation, this section may throw a
+    # pywintypes.com_error which does not seem to create as nice of an
+    # error as OSError so wrapping with try to convert
+    sink = CreateSink()
+    try:
+        for path in paths:
+            item = shell.SHCreateItemFromParsingName(path, None, shell.IID_IShellItem)
+            fileop.DeleteItem(item, sink)
+        result = fileop.PerformOperations()
+        aborted = fileop.GetAnyOperationsAborted()
+        # if non-zero result or aborted throw an exception
+        if result or aborted:
+            raise OSError(None, None, paths, result)
+    except pywintypes.com_error as error:
+        # convert to standard OS error, allows other code to get a
+        # normal errno
+        raise OSError(None, error.strerror, path, error.hresult)

setup.py

@@ -1,33 +1,41 @@
-import sys
-import os.path as op
-
 from setuptools import setup
-from distutils.extension import Extension
 
-exts = []
+CLASSIFIERS = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: BSD License",
+    "Operating System :: MacOS :: MacOS X",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX",
+    "Programming Language :: Python :: 2.7",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.4",
+    "Programming Language :: Python :: 3.5",
+    "Programming Language :: Python :: 3.6",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Topic :: Desktop Environment :: File Managers",
+]
 
-if sys.platform == 'darwin':
-    exts.append(Extension(
-        '_send2trash_osx',
-        [op.join('modules', 'send2trash_osx.c')],
-        extra_link_args=['-framework', 'CoreServices'],
-    ))
-if sys.platform == 'win32':
-    exts.append(Extension(
-        '_send2trash_win',
-        [op.join('modules', 'send2trash_win.c')],
-        extra_link_args = ['shell32.lib'],
-    ))
+with open("README.rst", "rt") as f1, open("CHANGES.rst", "rt") as f2:
+    LONG_DESCRIPTION = f1.read() + "\n\n" + f2.read()
 
 setup(
-    name='Send2Trash',
-    version='1.0.0',
-    author='Hardcoded Software',
-    author_email='hsoft@hardcoded.net',
-    packages=['send2trash'],
+    name="Send2Trash",
+    version="1.7.0a1",
+    author="Andrew Senetar",
+    author_email="arsenetar@voltaicideas.net",
+    packages=["send2trash"],
     scripts=[],
-    ext_modules = exts,
-    url='http://hg.hardcoded.net/send2trash/',
-    license='LICENSE',
-    description='Send file to trash natively under Mac OS X, Windows and Linux.',
-)
+    test_suite="tests",
+    url="https://github.com/arsenetar/send2trash",
+    license="BSD License",
+    description="Send file to trash natively under Mac OS X, Windows and Linux.",
+    long_description=LONG_DESCRIPTION,
+    classifiers=CLASSIFIERS,
+    extras_require={"win32": ["pywin32"]},
+    project_urls={"Bug Reports": "https://github.com/arsenetar/send2trash/issues"},
+    entry_points={"console_scripts": ["send2trash=send2trash.__main__:main"]},
+)

tests/test_plat_other.py

@@ -0,0 +1,235 @@
+# encoding: utf-8
+import pytest
+import codecs
+import os
+import sys
+from os import path as op
+from send2trash.compat import PY3
+from send2trash import TrashPermissionError
+
+try:
+    from configparser import ConfigParser
+except ImportError:
+    # py2
+    from ConfigParser import ConfigParser  # noqa: F401
+
+from tempfile import mkdtemp, NamedTemporaryFile, mktemp
+import shutil
+import stat
+
+if sys.platform != "win32":
+    import send2trash.plat_other
+    from send2trash.plat_other import send2trash as s2t
+
+    HOMETRASH = send2trash.plat_other.HOMETRASH
+else:
+    pytest.skip("Skipping non-windows tests", allow_module_level=True)
+
+
+@pytest.fixture
+def testfile():
+    file = NamedTemporaryFile(
+        dir=op.expanduser("~"), prefix="send2trash_test", delete=False
+    )
+    file.close()
+    assert op.exists(file.name) is True
+    yield file
+    # Cleanup trash files on supported platforms
+    if sys.platform != "win32":
+        name = op.basename(file.name)
+        # Remove trash files if they exist
+        if op.exists(op.join(HOMETRASH, "files", name)):
+            os.remove(op.join(HOMETRASH, "files", name))
+            os.remove(op.join(HOMETRASH, "info", name + ".trashinfo"))
+    if op.exists(file.name):
+        os.remove(file.name)
+
+
+@pytest.fixture
+def testfiles():
+    files = list(
+        map(
+            lambda index: NamedTemporaryFile(
+                dir=op.expanduser("~"),
+                prefix="send2trash_test{}".format(index),
+                delete=False,
+            ),
+            range(10),
+        )
+    )
+    [file.close() for file in files]
+    assert all([op.exists(file.name) for file in files]) is True
+    yield files
+    filenames = [op.basename(file.name) for file in files]
+    [os.remove(op.join(HOMETRASH, "files", filename)) for filename in filenames]
+    [
+        os.remove(op.join(HOMETRASH, "info", filename + ".trashinfo"))
+        for filename in filenames
+    ]
+
+
+def test_trash(testfile):
+    s2t(testfile.name)
+    assert op.exists(testfile.name) is False
+
+
+def test_multitrash(testfiles):
+    filenames = [file.name for file in testfiles]
+    s2t(filenames)
+    assert any([op.exists(filename) for filename in filenames]) is False
+
+
+def touch(path):
+    with open(path, "a"):
+        os.utime(path, None)
+
+
+def _filesys_enc():
+    enc = sys.getfilesystemencoding()
+    # Get canonical name of codec
+    return codecs.lookup(enc).name
+
+
+@pytest.fixture
+def testUnicodefile():
+    name = u"send2trash_tést1"
+    file = op.join(op.expanduser(b"~"), name.encode("utf-8"))
+    touch(file)
+    assert op.exists(file) is True
+    yield file
+    # Cleanup trash files on supported platforms
+    if sys.platform != "win32":
+        # Remove trash files if they exist
+        if op.exists(op.join(HOMETRASH, "files", name)):
+            os.remove(op.join(HOMETRASH, "files", name))
+            os.remove(op.join(HOMETRASH, "info", name + ".trashinfo"))
+    if op.exists(file):
+        os.remove(file)
+
+
+@pytest.mark.skipif(_filesys_enc() == "ascii", reason="Requires Unicode filesystem")
+def test_trash_bytes(testUnicodefile):
+    s2t(testUnicodefile)
+    assert not op.exists(testUnicodefile)
+
+
+@pytest.mark.skipif(_filesys_enc() == "ascii", reason="Requires Unicode filesystem")
+def test_trash_unicode(testUnicodefile):
+    s2t(testUnicodefile.decode(sys.getfilesystemencoding()))
+    assert not op.exists(testUnicodefile)
+
+
+class ExtVol:
+    def __init__(self, path):
+        self.trashTopdir = path
+        if PY3:
+            self.trashTopdir_b = os.fsencode(self.trashTopdir)
+        else:
+            self.trashTopdir_b = self.trashTopdir
+
+        def s_getdev(path):
+            from send2trash.plat_other import is_parent
+
+            st = os.lstat(path)
+            if is_parent(self.trashTopdir, path):
+                return "dev"
+            return st.st_dev
+
+        def s_ismount(path):
+            if op.realpath(path) in (
+                op.realpath(self.trashTopdir),
+                op.realpath(self.trashTopdir_b),
+            ):
+                return True
+            return old_ismount(path)
+
+        self.old_ismount = old_ismount = op.ismount
+        self.old_getdev = send2trash.plat_other.get_dev
+        send2trash.plat_other.os.path.ismount = s_ismount
+        send2trash.plat_other.get_dev = s_getdev
+
+    def cleanup(self):
+        send2trash.plat_other.get_dev = self.old_getdev
+        send2trash.plat_other.os.path.ismount = self.old_ismount
+        shutil.rmtree(self.trashTopdir)
+
+
+@pytest.fixture
+def testExtVol():
+    trashTopdir = mkdtemp(prefix="s2t")
+    volume = ExtVol(trashTopdir)
+    fileName = "test.txt"
+    filePath = op.join(volume.trashTopdir, fileName)
+    touch(filePath)
+    assert op.exists(filePath) is True
+    yield volume, fileName, filePath
+    volume.cleanup()
+
+
+def test_trash_topdir(testExtVol):
+    trashDir = op.join(testExtVol[0].trashTopdir, ".Trash")
+    os.mkdir(trashDir, 0o777 | stat.S_ISVTX)
+
+    s2t(testExtVol[2])
+    assert op.exists(testExtVol[2]) is False
+    assert (
+        op.exists(op.join(trashDir, str(os.getuid()), "files", testExtVol[1])) is True
+    )
+    assert (
+        op.exists(
+            op.join(trashDir, str(os.getuid()), "info", testExtVol[1] + ".trashinfo",)
+        )
+        is True
+    )
+    # info relative path (if another test is added, with the same fileName/Path,
+    # then it gets renamed etc.)
+    cfg = ConfigParser()
+    cfg.read(op.join(trashDir, str(os.getuid()), "info", testExtVol[1] + ".trashinfo"))
+    assert (testExtVol[1] == cfg.get("Trash Info", "Path", raw=True)) is True
+
+
+def test_trash_topdir_fallback(testExtVol):
+    s2t(testExtVol[2])
+    assert op.exists(testExtVol[2]) is False
+    assert (
+        op.exists(
+            op.join(
+                testExtVol[0].trashTopdir,
+                ".Trash-" + str(os.getuid()),
+                "files",
+                testExtVol[1],
+            )
+        )
+        is True
+    )
+
+
+def test_trash_topdir_failure(testExtVol):
+    os.chmod(testExtVol[0].trashTopdir, 0o500)  # not writable to induce the exception
+    pytest.raises(TrashPermissionError, s2t, [testExtVol[2]])
+    os.chmod(testExtVol[0].trashTopdir, 0o700)  # writable to allow deletion
+
+
+def test_trash_symlink(testExtVol):
+    # Use mktemp (race conditioney but no symlink equivalent)
+    # Since is_parent uses realpath(), and our getdev uses is_parent,
+    # this should work
+    slDir = mktemp(prefix="s2t", dir=op.expanduser("~"))
+    os.mkdir(op.join(testExtVol[0].trashTopdir, "subdir"), 0o700)
+    filePath = op.join(testExtVol[0].trashTopdir, "subdir", testExtVol[1])
+    touch(filePath)
+    os.symlink(op.join(testExtVol[0].trashTopdir, "subdir"), slDir)
+    s2t(op.join(slDir, testExtVol[1]))
+    assert op.exists(filePath) is False
+    assert (
+        op.exists(
+            op.join(
+                testExtVol[0].trashTopdir,
+                ".Trash-" + str(os.getuid()),
+                "files",
+                testExtVol[1],
+            )
+        )
+        is True
+    )
+    os.remove(slDir)

tests/test_plat_win.py

@@ -0,0 +1,203 @@
+# encoding: utf-8
+import os
+import shutil
+import sys
+import pytest
+from os import path as op
+
+from send2trash import send2trash as s2t
+
+# import the two versions as well as the "automatic" version
+if sys.platform == "win32":
+    from send2trash.plat_win_modern import send2trash as s2t_modern
+    from send2trash.plat_win_legacy import send2trash as s2t_legacy
+else:
+    pytest.skip("Skipping windows-only tests", allow_module_level=True)
+
+
+def _create_tree(path):
+    dirname = op.dirname(path)
+    if not op.isdir(dirname):
+        os.makedirs(dirname)
+    with open(path, "w") as writer:
+        writer.write("send2trash test")
+
+
+@pytest.fixture
+def testdir(tmp_path):
+    dirname = "\\\\?\\" + str(tmp_path)
+    assert op.exists(dirname) is True
+    yield dirname
+    shutil.rmtree(dirname, ignore_errors=True)
+
+
+@pytest.fixture
+def testfile(testdir):
+    file = op.join(testdir, "testfile.txt")
+    _create_tree(file)
+    assert op.exists(file) is True
+    yield file
+    # Note dir will cleanup the file
+
+
+@pytest.fixture
+def testfiles(testdir):
+    files = [op.join(testdir, "testfile{}.txt".format(index)) for index in range(10)]
+    [_create_tree(file) for file in files]
+    assert all([op.exists(file) for file in files]) is True
+    yield files
+    # Note dir will cleanup the files
+
+
+def _trash_folder(dir, fcn):
+    fcn(dir)
+    assert op.exists(dir) is False
+
+
+def _trash_file(file, fcn):
+    fcn(file)
+    assert op.exists(file) is False
+
+
+def _trash_multifile(files, fcn):
+    fcn(files)
+    assert any([op.exists(file) for file in files]) is False
+
+
+def _file_not_found(dir, fcn):
+    file = op.join(dir, "otherfile.txt")
+    pytest.raises(OSError, fcn, file)
+
+
+def _multi_byte_unicode(dir, fcn):
+    single_file = op.join(dir, "😇.txt")
+    _create_tree(single_file)
+    assert op.exists(single_file) is True
+    fcn(single_file)
+    assert op.exists(single_file) is False
+    files = [op.join(dir, "😇{}.txt".format(index)) for index in range(10)]
+    [_create_tree(file) for file in files]
+    assert all([op.exists(file) for file in files]) is True
+    fcn(files)
+    assert any([op.exists(file) for file in files]) is False
+
+
+def test_trash_folder(testdir):
+    _trash_folder(testdir, s2t)
+
+
+def test_trash_file(testfile):
+    _trash_file(testfile, s2t)
+
+
+def test_trash_multifile(testfiles):
+    _trash_multifile(testfiles, s2t)
+
+
+def test_file_not_found(testdir):
+    _file_not_found(testdir, s2t)
+
+
+def test_trash_folder_modern(testdir):
+    _trash_folder(testdir, s2t_modern)
+
+
+def test_trash_file_modern(testfile):
+    _trash_file(testfile, s2t_modern)
+
+
+def test_trash_multifile_modern(testfiles):
+    _trash_multifile(testfiles, s2t_modern)
+
+
+def test_file_not_found_modern(testdir):
+    _file_not_found(testdir, s2t_modern)
+
+
+def test_multi_byte_unicode_modern(testdir):
+    _multi_byte_unicode(testdir, s2t_modern)
+
+
+def test_trash_folder_legacy(testdir):
+    _trash_folder(testdir, s2t_legacy)
+
+
+def test_trash_file_legacy(testfile):
+    _trash_file(testfile, s2t_legacy)
+
+
+def test_trash_multifile_legacy(testfiles):
+    _trash_multifile(testfiles, s2t_legacy)
+
+
+def test_file_not_found_legacy(testdir):
+    _file_not_found(testdir, s2t_legacy)
+
+
+def test_multi_byte_unicode_legacy(testdir):
+    _multi_byte_unicode(testdir, s2t_legacy)
+
+
+# Long path tests
+@pytest.fixture
+def longdir(tmp_path):
+    dirname = "\\\\?\\" + str(tmp_path)
+    name = "A" * 100
+    yield op.join(dirname, name, name, name)
+    shutil.rmtree(dirname, ignore_errors=True)
+
+
+@pytest.fixture
+def longfile(longdir):
+    name = "A" * 100
+    path = op.join(longdir, name + "{}.txt")
+    file = path.format("")
+    _create_tree(file)
+    assert op.exists(file) is True
+    yield file
+
+
+@pytest.fixture
+def longfiles(longdir):
+    name = "A" * 100
+    path = op.join(longdir, name + "{}.txt")
+    files = [path.format(index) for index in range(10)]
+    [_create_tree(file) for file in files]
+    assert all([op.exists(file) for file in files]) is True
+    yield files
+
+
+# NOTE: both legacy and modern test "pass" on windows, however sometimes with the same path
+# they do not actually recycle files but delete them.  Noticed this when testing with the
+# recycle bin open, noticed later tests actually worked, modern version can actually detect
+# when this happens but not stop it at this moment, and we need a way to verify it when testing.
+def test_trash_long_file_modern(longfile):
+    _trash_file(longfile, s2t_modern)
+
+
+def test_trash_long_multifile_modern(longfiles):
+    _trash_multifile(longfiles, s2t_modern)
+
+
+#     @pytest.skipif(
+#         op.splitdrive(os.getcwd())[0] != op.splitdrive(gettempdir())[0],
+#         "Cannot trash long path from other drive",
+#     )
+#     def test_trash_long_folder_modern(self):
+#         self._trash_folder(s2t_modern)
+
+
+def test_trash_long_file_legacy(longfile):
+    _trash_file(longfile, s2t_legacy)
+
+
+def test_trash_long_multifile_legacy(longfiles):
+    _trash_multifile(longfiles, s2t_legacy)
+
+
+#     @pytest.skipif(
+#         op.splitdrive(os.getcwd())[0] != op.splitdrive(gettempdir())[0],
+#         "Cannot trash long path from other drive",
+#     )
+#     def test_trash_long_folder_legacy(self):
+#         self._trash_folder(s2t_legacy)

tests/test_script_main.py

@@ -0,0 +1,43 @@
+# encoding: utf-8
+import os
+import sys
+import pytest
+from tempfile import NamedTemporaryFile
+from os import path as op
+
+from send2trash.__main__ import main as trash_main
+
+# Only import HOMETRASH on supported platforms
+if sys.platform != "win32":
+    from send2trash.plat_other import HOMETRASH
+
+
+@pytest.fixture
+def file():
+    file = NamedTemporaryFile(
+        dir=op.expanduser("~"), prefix="send2trash_test", delete=False
+    )
+    file.close()
+    # Verify file was actually created
+    assert op.exists(file.name) is True
+    yield file.name
+    # Cleanup trash files on supported platforms
+    if sys.platform != "win32":
+        name = op.basename(file.name)
+        # Remove trash files if they exist
+        if op.exists(op.join(HOMETRASH, "files", name)):
+            os.remove(op.join(HOMETRASH, "files", name))
+            os.remove(op.join(HOMETRASH, "info", name + ".trashinfo"))
+    if op.exists(file.name):
+        os.remove(file.name)
+
+
+def test_trash(file):
+    trash_main(["-v", file])
+    assert op.exists(file) is False
+
+
+def test_no_args(file):
+    pytest.raises(SystemExit, trash_main, [])
+    pytest.raises(SystemExit, trash_main, ["-v"])
+    assert op.exists(file) is True

tox.ini

@@ -0,0 +1,23 @@
+[tox]
+envlist = py{27,34,35,36,37,38,39,310}
+skip_missing_interpreters = True
+
+[testenv]
+deps =
+    flake8
+    pytest
+    pywin32; sys_platform == 'win32'
+    pyobjc-framework-Cocoa; sys_platform == 'darwin'
+commands =
+    flake8
+    pytest
+
+[testenv:py27]
+deps =
+    configparser
+    {[testenv]deps}
+
+[flake8]
+exclude = .tox,env,build
+max-line-length = 120
+ignore = E731,E203,E501,W503