Merge pull request #103 from arsenetar/as/ci-lang-updates

feat: CI, Lanugage, lint, and misc cleanups

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,35 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [master]
+  schedule:
+    - cron: "25 5 * * 4"
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: ["python"]
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@5d4e8d1aca955e8d8589aabd499c5cae939e33c7 # v4.31.9
+        with:
+          languages: ${{ matrix.language }}
+      - name: Autobuild
+        uses: github/codeql-action/autobuild@5d4e8d1aca955e8d8589aabd499c5cae939e33c7 # v4.31.9
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@5d4e8d1aca955e8d8589aabd499c5cae939e33c7 # v4.31.9

.github/workflows/default.yml

@@ -0,0 +1,72 @@
+# Workflow lints, and checks format in parallel then runs tests on all platforms
+
+name: Default CI/CD
+
+on: push
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+      - name: Set up Python 3.x
+        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        with:
+          python-version: 3.x
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install flake8
+      - name: Lint with flake8
+        run: |
+          flake8 .
+  test:
+    needs: lint
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            python-version: 3.14
+          - os: ubuntu-latest
+            python-version: 3.13
+          - os: ubuntu-latest
+            python-version: 3.12
+          - os: ubuntu-latest
+            python-version: 3.11
+          - os: ubuntu-latest
+            python-version: "3.10"
+          - os: ubuntu-latest
+            python-version: 3.9
+          - os: ubuntu-latest
+            python-version: 3.8
+          - os: macos-latest
+            python-version: 3.14
+          - os: macos-latest
+            python-version: 3.9
+          - os: windows-latest
+            python-version: 3.14
+          - os: windows-latest
+            python-version: 3.8
+
+    steps:
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install pytest
+      - name: Install windows dependencies
+        if: ${{ matrix.os == 'windows-latest' }}
+        run: |
+          pip install pywin32
+      - name: Install macOS dependencies
+        if: ${{ matrix.os == 'macos-latest' }}
+        run: |
+          pip install pyobjc-framework-Cocoa
+      - name: Run tests
+        run: |
+          pytest

.travis.yml

@@ -1,33 +0,0 @@
-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.rst

@@ -1,5 +1,34 @@
 Changes
 =======
+Version 2.0.0 -- 2025/12/30
+---------------------------
+* Drop suport for Python 2
+* Fix `test_trash_topdir` failing on macOS by @denini08 in https://github.com/arsenetar/send2trash/pull/100
+* Update source installation instructions by @gunSlaveUnit in https://github.com/arsenetar/send2trash/pull/102
+* Update gio implemenation, should fix #5 by no longer using deprecated GObject.GError
+
+Version 1.8.3 -- 2024/04/06
+---------------------------
+* Add support for any iterable type as input by @PalmtopTiger in https://github.com/arsenetar/send2trash/pull/88
+* fix: Use os.fsdecode() for arguments to shutil.move() by @yogeshiitm in https://github.com/arsenetar/send2trash/pull/90
+
+Version 1.8.2 -- 2023/04/27
+---------------------------
+* win/legacy: tiny logic simplification by @BoboTiG in https://github.com/arsenetar/send2trash/pull/77
+* TravisCI is not used anymore by @sobolevn in https://github.com/arsenetar/send2trash/pull/73
+* fix(ci): Update to latest actions, fix python versions by @arsenetar in https://github.com/arsenetar/send2trash/pull/78
+
+Version 1.8.1b0 -- 2021/09/20
+-----------------------------
+* Add fallback to HOMETRASH when cross device errors happen in plat_other (#26, #41, #63)
+
+Version 1.8.0 -- 2021/08/08
+---------------------------
+
+* Add compatibility with pathlib paths (#49)
+* Fix thread compatibility of modern windows implementation (#59)
+* Fix handling of UNC names in legacy windows implementation  (#57)
+
 Version 1.7.1 -- 2021/06/21
 ---------------------------
 

README.rst

@@ -3,15 +3,15 @@ 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
+*all platforms*. On OS X, it uses native ``FSMoveObjectToTrashSync`` Cocoa calls or can use pyobjc 
-uses native ``IFileOperation`` call if on Vista or newer and pywin32 is installed or falls back 
+with NSFileManager. On Windows, it uses native ``IFileOperation`` call if on Vista or newer and 
-to ``SHFileOperation`` calls. On other platforms, if `PyGObject`_ and `GIO`_ are available, it 
+pywin32 is installed or falls back to ``SHFileOperation`` calls. On other platforms, if `PyGObject`_ 
-will use this.  Otherwise, it will fallback to its own implementation of the `trash specifications 
+and `GIO`_ are available, it will use this.  Otherwise, it will fallback to its own implementation of 
-from freedesktop.org`_.
+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).
+Send2Trash supports Python 3 (versions before 2.x support Python 2).
 
 Status: Additional Help Welcome
 -------------------------------
@@ -22,13 +22,31 @@ issues and fixes would be most appreciated.
 Installation
 ------------
 
-You can download it with pip::
+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::
+To install with pywin32 or pyobjc required specify the extra `nativeLib`:
 
-    >>> python setup.py install
+    python -m pip install -U send2trash[nativeLib]
+
+or download the source from https://github.com/arsenetar/send2trash and install it with:
+
+    python -m pip install -e .
+
+On systems where Python enforces PEP 668 (e.g., recent Linux distributions),
+installing packages into the system Python may be restricted.
+Use a virtual environment:
+
+    python -m venv .venv
+
+    GNU/Linux / macOS:
+
+        source .venv/bin/activate
+
+    Windows:
+
+        .venv\Scripts\activate
 
 Usage
 -----
@@ -40,7 +58,7 @@ Usage
 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
+``PermissionError``. 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.

pyproject.toml

@@ -0,0 +1,6 @@
+[build-system]
+requires = ["setuptools >= 75.3.1"]
+build-backend = "setuptools.build_meta"
+
+[tool.black]
+line-length = 120

send2trash/IFileOperationProgressSink.py

@@ -1,105 +0,0 @@
-# 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

@@ -6,16 +6,19 @@
 
 import sys
 
-from .exceptions import TrashPermissionError  # noqa: F401
+from send2trash.exceptions import TrashPermissionError  # noqa: F401
+
+if sys.version_info[0] < 3:
+    raise RuntimeError("send2trash is only compatible with Python 3 and above (use versions <= 1.8.3 for python 2).")
 
 if sys.platform == "darwin":
-    from .plat_osx import send2trash
+    from send2trash.mac import send2trash
 elif sys.platform == "win32":
-    from .plat_win import send2trash
+    from send2trash.win import send2trash
 else:
     try:
         # If we can use gio, let's use it
-        from .plat_gio import send2trash
+        from send2trash.plat_gio import send2trash
     except ImportError:
         # Oh well, let's fallback to our own Freedesktop trash implementation
-        from .plat_other import send2trash  # noqa: F401
+        from send2trash.plat_other import send2trash  # noqa: F401

send2trash/__main__.py

@@ -12,22 +12,25 @@ import sys
 from argparse import ArgumentParser
 from send2trash import send2trash
 
+if sys.version_info[0] < 3:
+    raise RuntimeError("send2trash is only compatible with Python 3 and above (use versions <= 1.8.3 for python 2).")
+
 
 def main(args=None):
-    parser = ArgumentParser(description='Tool to send files to trash')
+    parser = ArgumentParser(description="Tool to send files to trash")
-    parser.add_argument('files', nargs='+')
+    parser.add_argument("files", nargs="+")
-    parser.add_argument('-v', '--verbose', action='store_true', help='Print deleted files')
+    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 + '»')
+                print("Trashed «" + filename + "»")
         except OSError as e:
             print(str(e), file=sys.stderr)
             sys.exit(1)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

send2trash/compat.py

@@ -1,20 +0,0 @@
-# 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

@@ -1,13 +1,7 @@
 import errno
-from .compat import PY3
-
-if PY3:
-    _permission_error = PermissionError  # noqa: F821
-else:
-    _permission_error = OSError
 
 
-class TrashPermissionError(_permission_error):
+class TrashPermissionError(PermissionError):
     """A permission error specific to a trash directory.
 
     Raising this error indicates that permissions prevent us efficiently
@@ -23,4 +17,4 @@ class TrashPermissionError(_permission_error):
     """
 
     def __init__(self, filename):
-        _permission_error.__init__(self, errno.EACCES, "Permission denied", filename)
+        PermissionError.__init__(self, errno.EACCES, "Permission denied", filename)

send2trash/mac/__init__.py

@@ -11,10 +11,10 @@ from sys import version_info
 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
+        from send2trash.mac.modern import send2trash
     except ImportError:
         # Try to fall back to ctypes version, although likely problematic still
-        from .plat_osx_ctypes import send2trash
+        from send2trash.mac.legacy import send2trash
 else:
     # Just use the old version otherwise
-    from .plat_osx_ctypes import send2trash  # noqa: F401
+    from send2trash.mac.legacy import send2trash  # noqa: F401

send2trash/mac/legacy.py

@@ -9,7 +9,7 @@ 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
+from send2trash.util import preprocess_paths
 
 Foundation = cdll.LoadLibrary(find_library("Foundation"))
 CoreServices = cdll.LoadLibrary(find_library("CoreServices"))
@@ -40,12 +40,8 @@ def check_op_result(op_result):
 
 
 def send2trash(paths):
-    if not isinstance(paths, list):
+    paths = preprocess_paths(paths)
-        paths = [paths]
+    paths = [path.encode("utf-8") if not isinstance(path, bytes) else path for path in 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

send2trash/mac/modern.py

@@ -5,7 +5,7 @@
 # http://www.hardcoded.net/licenses/bsd_license
 
 from Foundation import NSFileManager, NSURL
-from .compat import text_type
+from send2trash.util import preprocess_paths
 
 
 def check_op_result(op_result):
@@ -16,12 +16,8 @@ def check_op_result(op_result):
 
 
 def send2trash(paths):
-    if not isinstance(paths, list):
+    paths = preprocess_paths(paths)
-        paths = [paths]
+    paths = [path.decode("utf-8") if not isinstance(path, str) else path for path in 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()

send2trash/plat_gio.py

@@ -4,20 +4,20 @@
 # 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 gi.repository import Gio, GLib
-from .exceptions import TrashPermissionError
+from send2trash.exceptions import TrashPermissionError
+from send2trash.util import preprocess_paths
 
 
 def send2trash(paths):
-    if not isinstance(paths, list):
+    paths = preprocess_paths(paths)
-        paths = [paths]
     for path in paths:
         try:
             f = Gio.File.new_for_path(path)
             f.trash(cancellable=None)
-        except GObject.GError as e:
+        except GLib.Error 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 TrashPermissionError("") from e
-            raise OSError(e.message)
+            raise OSError(e.message) from e

send2trash/plat_other.py

@@ -17,56 +17,36 @@
 from __future__ import unicode_literals
 
 import errno
-import sys
+import shutil
 import os
 import os.path as op
 from datetime import datetime
 import stat
-
+from urllib.parse import quote
-try:
+from send2trash.util import preprocess_paths
-    from urllib.parse import quote
+from send2trash.exceptions import TrashPermissionError
-except ImportError:
-    # Python 2
-    from urllib import quote
-
-from .compat import text_type, environb
-from .exceptions import TrashPermissionError
-
-try:
-    fsencode = os.fsencode  # Python 3
-    fsdecode = os.fsdecode
-except AttributeError:
-
-    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"))
+XDG_DATA_HOME = op.expanduser(os.environb.get(b"XDG_DATA_HOME", b"~/.local/share"))
 HOMETRASH_B = op.join(XDG_DATA_HOME, b"Trash")
-HOMETRASH = fsdecode(HOMETRASH_B)
+HOMETRASH = os.fsdecode(HOMETRASH_B)
 
 uid = os.getuid()
 TOPDIR_TRASH = b".Trash"
-TOPDIR_FALLBACK = b".Trash-" + text_type(uid).encode("ascii")
+TOPDIR_FALLBACK = b".Trash-" + str(uid).encode("ascii")
 
 
 def is_parent(parent, path):
     path = op.realpath(path)  # In case it's a symlink
-    if isinstance(path, text_type):
+    if isinstance(path, str):
-        path = fsencode(path)
+        path = os.fsencode(path)
     parent = op.realpath(parent)
-    if isinstance(parent, text_type):
+    if isinstance(parent, str):
-        parent = fsencode(parent)
+        parent = os.fsencode(parent)
     return path.startswith(parent)
 
 
@@ -88,39 +68,41 @@ def info_for(src, topdir):
     return info
 
 
-def check_create(dir):
+def check_create(folder):
     # use 0700 for paths [3]
-    if not op.exists(dir):
+    if not op.exists(folder):
-        os.makedirs(dir, 0o700)
+        os.makedirs(folder, 0o700)
 
 
-def trash_move(src, dst, topdir=None):
+def trash_move(src, dst, topdir=None, cross_dev=False):
-    filename = op.basename(src)
+    file_name = op.basename(src)
-    filespath = op.join(dst, FILES_DIR)
+    files_path = op.join(dst, FILES_DIR)
-    infopath = op.join(dst, INFO_DIR)
+    info_path = op.join(dst, INFO_DIR)
-    base_name, ext = op.splitext(filename)
+    base_name, ext = op.splitext(file_name)
 
     counter = 0
-    destname = filename
+    dest_name = file_name
-    while op.exists(op.join(filespath, destname)) or op.exists(
+    while op.exists(op.join(files_path, dest_name)) or op.exists(op.join(info_path, dest_name + INFO_SUFFIX)):
-        op.join(infopath, destname + INFO_SUFFIX)
-    ):
         counter += 1
-        destname = base_name + b" " + text_type(counter).encode("ascii") + ext
+        dest_name = base_name + b" " + str(counter).encode("ascii") + ext
 
-    check_create(filespath)
+    check_create(files_path)
-    check_create(infopath)
+    check_create(info_path)
 
-    with open(op.join(infopath, destname + INFO_SUFFIX), "w") as f:
+    with open(op.join(info_path, dest_name + INFO_SUFFIX), "w") as f:
         f.write(info_for(src, topdir))
-    os.rename(src, op.join(filespath, destname))
+    dest_path = op.join(files_path, dest_name)
+    if cross_dev:
+        shutil.move(os.fsdecode(src), os.fsdecode(dest_path))
+    else:
+        os.rename(src, dest_path)
 
 
 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):
+    while not op.ismount(path):  # Note ismount() does not always detect mounts
         path = op.split(path)[0]
     return path
 
@@ -135,10 +117,10 @@ def find_ext_volume_global_trash(volume_root):
     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):
+    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"))
+    trash_dir = op.join(trash_dir, str(uid).encode("ascii"))
     try:
         check_create(trash_dir)
     except OSError:
@@ -154,7 +136,7 @@ def find_ext_volume_fallback_trash(volume_root):
         check_create(trash_dir)
     except OSError as e:
         if e.errno == errno.EACCES:
-            raise TrashPermissionError(e.filename)
+            raise TrashPermissionError(e.filename) from e
         raise
     return trash_dir
 
@@ -172,33 +154,29 @@ def get_dev(path):
 
 
 def send2trash(paths):
-    if not isinstance(paths, list):
+    paths = preprocess_paths(paths)
-        paths = [paths]
     for path in paths:
-        if isinstance(path, text_type):
+        if isinstance(path, str):
-            path_b = fsencode(path)
+            path_b = os.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))
+            raise TypeError(f"str, bytes or PathLike expected, not {type(path)}")
 
         if not op.exists(path_b):
-            raise OSError("File not found: %s" % path)
+            raise OSError(errno.ENOENT, f"File not found: {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)
+            raise OSError(errno.EACCES, f"Permission denied: {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)
 
+        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 the file to be trashed is on the same device as HOMETRASH we
+        # want to move it there.
         if path_dev == trash_dev:
             topdir = XDG_DATA_HOME
             dest_trash = HOMETRASH_B
@@ -206,6 +184,13 @@ def send2trash(paths):
             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)
+                raise OSError(f"Couldn't find mount point for {path}")
             dest_trash = find_ext_volume_trash(topdir)
-        trash_move(path_b, dest_trash, topdir)
+        try:
+            trash_move(path_b, dest_trash, topdir)
+        except OSError as error:
+            # Cross link errors default back to HOMETRASH
+            if error.errno == errno.EXDEV:
+                trash_move(path_b, HOMETRASH_B, XDG_DATA_HOME, cross_dev=True)
+            else:
+                raise

send2trash/util.py

@@ -0,0 +1,18 @@
+# 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
+
+import os
+import collections.abc
+
+
+def preprocess_paths(paths):
+    if isinstance(paths, collections.abc.Iterable) and not isinstance(paths, (str, bytes)):
+        paths = list(paths)
+    elif not isinstance(paths, list):
+        paths = [paths]
+    # Convert items such as pathlib paths to strings
+    return [os.fspath(path) for path in paths]

send2trash/win/IFileOperationProgressSink.py

@@ -0,0 +1,46 @@
+# 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, hr_delete, newly_created):
+        if newly_created:
+            self.newItem = newly_created.GetDisplayName(shellcon.SHGDN_FORPARSING)
+
+
+def create_sink():
+    return pythoncom.WrapObject(FileOperationProgressSink(), shell.IID_IFileOperationProgressSink)

send2trash/win/__init__.py

@@ -11,10 +11,10 @@ from platform import version
 if int(version().split(".", 1)[0]) >= 6:
     try:
         # Attempt to use pywin32 to use IFileOperation
-        from .plat_win_modern import send2trash
+        from send2trash.win.modern import send2trash
     except ImportError:
         # use SHFileOperation as fallback
-        from .plat_win_legacy import send2trash
+        from send2trash.win.legacy import send2trash
 else:
     # use SHFileOperation as fallback
-    from .plat_win_legacy import send2trash  # noqa: F401
+    from send2trash.win.legacy import send2trash  # noqa: F401

send2trash/win/legacy.py

@@ -6,7 +6,6 @@
 
 from __future__ import unicode_literals
 import os.path as op
-from .compat import text_type
 from ctypes import (
     windll,
     Structure,
@@ -19,6 +18,8 @@ from ctypes import (
 )
 from ctypes.wintypes import HWND, UINT, LPCWSTR, BOOL
 
+from send2trash.util import preprocess_paths
+
 kernel32 = windll.kernel32
 GetShortPathNameW = kernel32.GetShortPathNameW
 
@@ -51,6 +52,41 @@ FOF_ALLOWUNDO = 64
 FOF_NOERRORUI = 1024
 
 
+def convert_sh_file_opt_result(result):
+    # map overlapping values from SHFileOpterationW to approximate standard windows errors
+    # ref https://docs.microsoft.com/en-us/windows/win32/api/shellapi/nf-shellapi-shfileoperationw#return-value
+    # ref https://docs.microsoft.com/en-us/windows/win32/debug/system-error-codes--0-499-
+    results = {
+        0x71: 0x50,  # DE_SAMEFILE -> ERROR_FILE_EXISTS
+        0x72: 0x57,  # DE_MANYSRC1DEST -> ERROR_INVALID_PARAMETER
+        0x73: 0x57,  # DE_DIFFDIR -> ERROR_INVALID_PARAMETER
+        0x74: 0x57,  # DE_ROOTDIR -> ERROR_INVALID_PARAMETER
+        0x75: 0x4C7,  # DE_OPCANCELLED -> ERROR_CANCELLED
+        0x76: 0x57,  # DE_DESTSUBTREE -> ERROR_INVALID_PARAMETER
+        0x78: 0x05,  # DE_ACCESSDENIEDSRC -> ERROR_ACCESS_DENIED
+        0x79: 0x6F,  # DE_PATHTOODEEP -> ERROR_BUFFER_OVERFLOW
+        0x7A: 0x57,  # DE_MANYDEST -> ERROR_INVALID_PARAMETER
+        0x7C: 0xA1,  # DE_INVALIDFILES -> ERROR_BAD_PATHNAME
+        0x7D: 0x57,  # DE_DESTSAMETREE -> ERROR_INVALID_PARAMETER
+        0x7E: 0xB7,  # DE_FLDDESTISFILE -> ERROR_ALREADY_EXISTS
+        0x80: 0xB7,  # DE_FILEDESTISFLD -> ERROR_ALREADY_EXISTS
+        0x81: 0x6F,  # DE_FILENAMETOOLONG -> ERROR_BUFFER_OVERFLOW
+        0x82: 0x13,  # DE_DEST_IS_CDROM -> ERROR_WRITE_PROTECT
+        0x83: 0x13,  # DE_DEST_IS_DVD -> ERROR_WRITE_PROTECT
+        0x84: 0x6F9,  # DE_DEST_IS_CDRECORD -> ERROR_UNRECOGNIZED_MEDIA
+        0x85: 0xDF,  # DE_FILE_TOO_LARGE -> ERROR_FILE_TOO_LARGE
+        0x86: 0x13,  # DE_SRC_IS_CDROM -> ERROR_WRITE_PROTECT
+        0x87: 0x13,  # DE_SRC_IS_DVD -> ERROR_WRITE_PROTECT
+        0x88: 0x6F9,  # DE_SRC_IS_CDRECORD -> ERROR_UNRECOGNIZED_MEDIA
+        0xB7: 0x6F,  # DE_ERROR_MAX -> ERROR_BUFFER_OVERFLOW
+        0x402: 0xA1,  # UNKNOWN -> ERROR_BAD_PATHNAME
+        0x10000: 0x1D,  # ERRORONDEST -> ERROR_WRITE_FAULT
+        0x10074: 0x57,  # DE_ROOTDIR | ERRORONDEST -> ERROR_INVALID_PARAMETER
+    }
+
+    return results.get(result, result)
+
+
 def prefix_and_path(path):
     r"""Guess the long-path prefix based on the kind of *path*.
     Local paths (C:\folder\file.ext) and UNC names (\\server\folder\file.ext)
@@ -101,13 +137,11 @@ def get_short_path_name(long_name):
 
 
 def send2trash(paths):
-    if not isinstance(paths, list):
+    paths = preprocess_paths(paths)
-        paths = [paths]
+    if not paths:
+        return
     # convert data type
-    paths = [
+    paths = [str(path, "mbcs") if not isinstance(path, str) else path for path in 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
@@ -143,4 +177,5 @@ def send2trash(paths):
     fileop.lpszProgressTitle = None
     result = SHFileOperationW(byref(fileop))
     if result:
-        raise WindowsError(result, FormatError(result), paths)
+        error = convert_sh_file_opt_result(result)
+        raise WindowsError(None, FormatError(error), paths, error)

send2trash/win/modern.py

@@ -6,44 +6,39 @@
 
 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
+from send2trash.util import preprocess_paths
+from send2trash.win.IFileOperationProgressSink import create_sink
 
 
 def send2trash(paths):
-    if not isinstance(paths, list):
+    paths = preprocess_paths(paths)
-        paths = [paths]
+    if not paths:
+        return
     # convert data type
-    paths = [
+    paths = [str(path, "mbcs") if not isinstance(path, str) else path for path in 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]
+    # Need to initialize the com before using
+    pythoncom.CoInitialize()
     # create instance of file operation object
     fileop = pythoncom.CoCreateInstance(
-        shell.CLSID_FileOperation, None, pythoncom.CLSCTX_ALL, shell.IID_IFileOperation,
+        shell.CLSID_FileOperation,
+        None,
+        pythoncom.CLSCTX_ALL,
+        shell.IID_IFileOperation,
     )
     # default flags to use
-    flags = (
+    flags = shellcon.FOF_NOCONFIRMATION | shellcon.FOF_NOERRORUI | shellcon.FOF_SILENT | shellcon.FOFX_EARLYFAILURE
-        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 |= (
+        flags |= 0x20000000 | 0x00080000  # FOFX_ADDUNDORECORD win 8+  # FOFX_RECYCLEONDELETE win 8+
-            0x20000000  # FOFX_ADDUNDORECORD win 8+
-            | 0x00080000  # FOFX_RECYCLEONDELETE win 8+
-        )
     else:
         flags |= shellcon.FOF_ALLOWUNDO
     # set the flags
@@ -51,7 +46,7 @@ def send2trash(paths):
     # 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()
+    sink = create_sink()
     try:
         for path in paths:
             item = shell.SHCreateItemFromParsingName(path, None, shell.IID_IShellItem)
@@ -64,4 +59,7 @@ def send2trash(paths):
     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)
+        raise OSError(None, error.strerror, path, error.hresult) from error
+    finally:
+        # Need to make sure we call this once fore every init
+        pythoncom.CoUninitialize()

setup.cfg

@@ -0,0 +1,51 @@
+[metadata]
+name = Send2Trash
+version = 2.0.0
+url = https://github.com/arsenetar/send2trash
+project_urls = 
+    Bug Reports = https://github.com/arsenetar/send2trash/issues
+author = Andrew Senetar
+author_email = arsenetar@voltaicideas.net
+license = BSD License
+license_files = LICENSE
+description = Send file to trash natively under Mac OS X, Windows and Linux
+long_description = file:README.rst
+long_description_content_type = text/x-rst
+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 :: 3
+    Programming Language :: Python :: 3.8
+    Programming Language :: Python :: 3.9
+    Programming Language :: Python :: 3.10
+    Programming Language :: Python :: 3.11
+    Programming Language :: Python :: 3.12
+    Programming Language :: Python :: 3.13
+    Programming Language :: Python :: 3.14
+    Topic :: Desktop Environment :: File Managers
+
+[options]
+packages = find:
+tests_require = pytest
+python_requires = !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*, !=3.7.*
+
+[options.packages.find]
+include=
+    send2trash*
+
+[options.extras_require]
+win32 = 
+    pywin32; sys_platform == "win32"
+objc = 
+    pyobjc-framework-Cocoa; sys_platform == "darwin"
+nativeLib = 
+    pywin32; sys_platform == "win32"
+    pyobjc-framework-Cocoa; sys_platform == "darwin"
+
+[options.entry_points]
+console_scripts =
+    send2trash = send2trash.__main__:main

setup.py

@@ -1,41 +0,0 @@
-from setuptools import setup
-
-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",
-]
-
-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.7.1",
-    author="Andrew Senetar",
-    author_email="arsenetar@voltaicideas.net",
-    packages=["send2trash"],
-    scripts=[],
-    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/conftest.py

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

tests/test_plat_other.py

@@ -1,86 +1,62 @@
 # encoding: utf-8
-import pytest
 import codecs
 import os
 import sys
 from os import path as op
-from send2trash.compat import PY3
+from tempfile import mkdtemp, NamedTemporaryFile
-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
+import uuid
+from configparser import ConfigParser
+import pytest
+from send2trash import TrashPermissionError
 
-if sys.platform != "win32":
+if sys.platform == "win32":
+    pytest.skip("Skipping non-windows tests", allow_module_level=True)
+else:
     import send2trash.plat_other
     from send2trash.plat_other import send2trash as s2t
+    from send2trash.plat_other import is_parent
 
-    HOMETRASH = send2trash.plat_other.HOMETRASH
+INFO_SUFFIX = send2trash.plat_other.INFO_SUFFIX.decode()
-else:
+HOMETRASH = send2trash.plat_other.HOMETRASH
-    pytest.skip("Skipping non-windows tests", allow_module_level=True)
 
 
-@pytest.fixture
+@pytest.fixture(name="test_files")
-def testfile():
+def fixture_test_files():
-    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),
+                prefix=f"send2trash_test{index}",
                 delete=False,
             ),
             range(10),
         )
     )
-    [file.close() for file in files]
+    for file in files:
-    assert all([op.exists(file.name) for file in files]) is True
+        file.close()
+    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]
+    for filename in filenames:
-    [
+        os.remove(op.join(HOMETRASH, "files", filename))
-        os.remove(op.join(HOMETRASH, "info", filename + ".trashinfo"))
+        os.remove(op.join(HOMETRASH, "info", filename + INFO_SUFFIX))
-        for filename in filenames
-    ]
 
 
-def test_trash(testfile):
+def test_trash(test_file):
-    s2t(testfile.name)
+    s2t(test_file)
-    assert op.exists(testfile.name) is False
+    assert op.exists(test_file) is False
 
 
-def test_multitrash(testfiles):
+def test_multitrash(test_files):
-    filenames = [file.name for file in testfiles]
+    file_names = [file.name for file in test_files]
-    s2t(filenames)
+    s2t(file_names)
-    assert any([op.exists(filename) for filename in filenames]) is False
+    assert any(op.exists(filename) for filename in file_names) is False
 
 
 def touch(path):
-    with open(path, "a"):
+    with open(path, "a", encoding="utf-8"):
         os.utime(path, None)
 
 
@@ -90,55 +66,48 @@ def _filesys_enc():
     return codecs.lookup(enc).name
 
 
-@pytest.fixture
+@pytest.fixture(name="gen_unicode_file")
-def testUnicodefile():
+def fixture_gen_unicode_file():
-    name = u"send2trash_tést1"
+    name = "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":
+    if sys.platform != "win32" and op.exists(op.join(HOMETRASH, "files", name)):
-        # Remove trash files if they exist
+        os.remove(op.join(HOMETRASH, "files", name))
-        if op.exists(op.join(HOMETRASH, "files", name)):
+        os.remove(op.join(HOMETRASH, "info", name + INFO_SUFFIX))
-            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):
+def test_trash_bytes(gen_unicode_file):
-    s2t(testUnicodefile)
+    s2t(gen_unicode_file)
-    assert not op.exists(testUnicodefile)
+    assert not op.exists(gen_unicode_file)
 
 
 @pytest.mark.skipif(_filesys_enc() == "ascii", reason="Requires Unicode filesystem")
-def test_trash_unicode(testUnicodefile):
+def test_trash_unicode(gen_unicode_file):
-    s2t(testUnicodefile.decode(sys.getfilesystemencoding()))
+    s2t(gen_unicode_file.decode(sys.getfilesystemencoding()))
-    assert not op.exists(testUnicodefile)
+    assert not op.exists(gen_unicode_file)
 
 
 class ExtVol:
     def __init__(self, path):
-        self.trashTopdir = path
+        self.trash_topdir = path
-        if PY3:
+        self.trash_topdir_b = os.fsencode(self.trash_topdir)
-            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):
+            if is_parent(self.trash_topdir, path):
                 return "dev"
             return st.st_dev
 
         def s_ismount(path):
             if op.realpath(path) in (
-                op.realpath(self.trashTopdir),
+                op.realpath(self.trash_topdir),
-                op.realpath(self.trashTopdir_b),
+                op.realpath(self.trash_topdir_b),
             ):
                 return True
             return old_ismount(path)
@@ -151,85 +120,91 @@ class ExtVol:
     def cleanup(self):
         send2trash.plat_other.get_dev = self.old_getdev
         send2trash.plat_other.os.path.ismount = self.old_ismount
-        shutil.rmtree(self.trashTopdir)
+        shutil.rmtree(self.trash_topdir)
 
 
-@pytest.fixture
+@pytest.fixture(name="gen_ext_vol")
-def testExtVol():
+def fixture_gen_ext_vol():
-    trashTopdir = mkdtemp(prefix="s2t")
+    trash_topdir = mkdtemp(prefix="s2t")
-    volume = ExtVol(trashTopdir)
+    volume = ExtVol(trash_topdir)
-    fileName = "test.txt"
+    file_name = "test.txt"
-    filePath = op.join(volume.trashTopdir, fileName)
+    file_path = op.join(volume.trash_topdir, file_name)
-    touch(filePath)
+    touch(file_path)
-    assert op.exists(filePath) is True
+    assert op.exists(file_path) is True
-    yield volume, fileName, filePath
+    yield volume, file_name, file_path
     volume.cleanup()
 
 
-def test_trash_topdir(testExtVol):
+def test_trash_topdir(gen_ext_vol):
-    trashDir = op.join(testExtVol[0].trashTopdir, ".Trash")
+    trash_dir = op.join(gen_ext_vol[0].trash_topdir, ".Trash")
-    os.mkdir(trashDir, 0o777 | stat.S_ISVTX)
+    os.mkdir(trash_dir, 0o777 | stat.S_ISVTX)
 
-    s2t(testExtVol[2])
+    s2t(gen_ext_vol[2])
-    assert op.exists(testExtVol[2]) is False
+    assert op.exists(gen_ext_vol[2]) is False
-    assert (
+
-        op.exists(op.join(trashDir, str(os.getuid()), "files", testExtVol[1])) is True
+    if sys.platform == "darwin":
-    )
+        # On macOS, we can only verify the file was removed from original location
-    assert (
+        pass
-        op.exists(
+    else:
-            op.join(trashDir, str(os.getuid()), "info", testExtVol[1] + ".trashinfo",)
+        # Others platforms we can test
+        assert op.exists(op.join(trash_dir, str(os.getuid()), "files", gen_ext_vol[1])) is True
+        assert (
+            op.exists(
+                op.join(
+                    trash_dir,
+                    str(os.getuid()),
+                    "info",
+                    gen_ext_vol[1] + INFO_SUFFIX,
+                )
+            )
+            is True
         )
-        is True
+
-    )
+        cfg = ConfigParser()
-    # info relative path (if another test is added, with the same fileName/Path,
+        cfg.read(op.join(trash_dir, str(os.getuid()), "info", gen_ext_vol[1] + INFO_SUFFIX))
-    # then it gets renamed etc.)
+        assert (gen_ext_vol[1] == cfg.get("Trash Info", "Path", raw=True)) is True
-    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):
+def test_trash_topdir_fallback(gen_ext_vol):
-    s2t(testExtVol[2])
+    s2t(gen_ext_vol[2])
-    assert op.exists(testExtVol[2]) is False
+    assert op.exists(gen_ext_vol[2]) is False
     assert (
         op.exists(
             op.join(
-                testExtVol[0].trashTopdir,
+                gen_ext_vol[0].trash_topdir,
                 ".Trash-" + str(os.getuid()),
                 "files",
-                testExtVol[1],
+                gen_ext_vol[1],
             )
         )
         is True
     )
 
 
-def test_trash_topdir_failure(testExtVol):
+def test_trash_topdir_failure(gen_ext_vol):
-    os.chmod(testExtVol[0].trashTopdir, 0o500)  # not writable to induce the exception
+    os.chmod(gen_ext_vol[0].trash_topdir, 0o500)  # not writable to induce the exception
-    pytest.raises(TrashPermissionError, s2t, [testExtVol[2]])
+    pytest.raises(TrashPermissionError, s2t, [gen_ext_vol[2]])
-    os.chmod(testExtVol[0].trashTopdir, 0o700)  # writable to allow deletion
+    os.chmod(gen_ext_vol[0].trash_topdir, 0o700)  # writable to allow deletion
 
 
-def test_trash_symlink(testExtVol):
+def test_trash_symlink(gen_ext_vol):
-    # Use mktemp (race conditioney but no symlink equivalent)
+    # Generating a random uuid named path for symlink
-    # Since is_parent uses realpath(), and our getdev uses is_parent,
+    sl_dir = op.join(op.expanduser("~"), "s2t_" + str(uuid.uuid4()))
-    # this should work
+    os.mkdir(op.join(gen_ext_vol[0].trash_topdir, "subdir"), 0o700)
-    slDir = mktemp(prefix="s2t", dir=op.expanduser("~"))
+    file_path = op.join(gen_ext_vol[0].trash_topdir, "subdir", gen_ext_vol[1])
-    os.mkdir(op.join(testExtVol[0].trashTopdir, "subdir"), 0o700)
+    touch(file_path)
-    filePath = op.join(testExtVol[0].trashTopdir, "subdir", testExtVol[1])
+    os.symlink(op.join(gen_ext_vol[0].trash_topdir, "subdir"), sl_dir)
-    touch(filePath)
+    s2t(op.join(sl_dir, gen_ext_vol[1]))
-    os.symlink(op.join(testExtVol[0].trashTopdir, "subdir"), slDir)
+    assert op.exists(file_path) is False
-    s2t(op.join(slDir, testExtVol[1]))
-    assert op.exists(filePath) is False
     assert (
         op.exists(
             op.join(
-                testExtVol[0].trashTopdir,
+                gen_ext_vol[0].trash_topdir,
                 ".Trash-" + str(os.getuid()),
                 "files",
-                testExtVol[1],
+                gen_ext_vol[1],
             )
         )
         is True
     )
-    os.remove(slDir)
+    os.remove(sl_dir)

tests/test_plat_win.py

@@ -2,56 +2,98 @@
 import os
 import shutil
 import sys
-import pytest
 from os import path as op
-
+import pytest
 from send2trash import send2trash as s2t
 
-# import the two versions as well as the "automatic" version
+s2t_modern = None
-if sys.platform == "win32":
+s2t_legacy = None
-    from send2trash.plat_win_modern import send2trash as s2t_modern
+
-    from send2trash.plat_win_legacy import send2trash as s2t_legacy
+if sys.platform != "win32":
-else:
     pytest.skip("Skipping windows-only tests", allow_module_level=True)
+else:
+    # import the two versions as well as the "automatic" version
+    from send2trash.win.modern import send2trash as s2t_modern
+    from send2trash.win.legacy import send2trash as s2t_legacy
+
+if s2t_modern is None:
+    pytest.fail("Modern send2trash not available")
+
+if s2t_legacy is None:
+    pytest.fail("Legacy send2trash not available")
 
 
 def _create_tree(path):
-    dirname = op.dirname(path)
+    dir_name = op.dirname(path)
-    if not op.isdir(dirname):
+    if not op.isdir(dir_name):
-        os.makedirs(dirname)
+        os.makedirs(dir_name)
-    with open(path, "w") as writer:
+    with open(path, "w", encoding="utf-8") as writer:
         writer.write("send2trash test")
 
 
-@pytest.fixture
+@pytest.fixture(name="test_dir")
-def testdir(tmp_path):
+def fixture_test_dir(tmp_path):
-    dirname = "\\\\?\\" + str(tmp_path)
+    dir_name = "\\\\?\\" + str(tmp_path)
-    assert op.exists(dirname) is True
+    assert op.exists(dir_name) is True
-    yield dirname
+    yield dir_name
-    shutil.rmtree(dirname, ignore_errors=True)
+    shutil.rmtree(dir_name, ignore_errors=True)
 
 
-@pytest.fixture
+@pytest.fixture(name="test_file")
-def testfile(testdir):
+def fixture_test_file(test_dir):
-    file = op.join(testdir, "testfile.txt")
+    file = op.join(test_dir, "testfile.txt")
     _create_tree(file)
     assert op.exists(file) is True
     yield file
     # Note dir will cleanup the file
 
 
-@pytest.fixture
+@pytest.fixture(name="test_files")
-def testfiles(testdir):
+def fixture_test_files(test_dir):
-    files = [op.join(testdir, "testfile{}.txt".format(index)) for index in range(10)]
+    files = [op.join(test_dir, f"testfile{index}.txt") for index in range(10)]
-    [_create_tree(file) for file in files]
+    for file in files:
-    assert all([op.exists(file) for file in files]) is True
+        _create_tree(file)
+    assert all(op.exists(file) for file in files) is True
     yield files
     # Note dir will cleanup the files
 
 
-def _trash_folder(dir, fcn):
+# Long path tests
-    fcn(dir)
+@pytest.fixture(name="long_dir")
-    assert op.exists(dir) is False
+def fixture_long_dir(tmp_path):
+    dir_name = "\\\\?\\" + str(tmp_path)
+    name = "A" * 100
+    yield op.join(dir_name, name, name, name)
+    try:
+        shutil.rmtree(dir_name, ignore_errors=True)
+    except TypeError:
+        pass
+
+
+@pytest.fixture(name="long_file")
+def fixture_long_file(long_dir):
+    name = "A" * 100
+    path = op.join(long_dir, name + "{}.txt")
+    file = path.format("")
+    _create_tree(file)
+    assert op.exists(file) is True
+    yield file
+
+
+@pytest.fixture(name="long_files")
+def fixture_long_files(long_dir):
+    name = "A" * 100
+    path = op.join(long_dir, name + "{}.txt")
+    files = [path.format(index) for index in range(10)]
+    for file in files:
+        _create_tree(file)
+    assert all(op.exists(file) for file in files) is True
+    yield files
+
+
+def _trash_folder(folder, fcn):
+    fcn(folder)
+    assert op.exists(folder) is False
 
 
 def _trash_file(file, fcn):
@@ -61,143 +103,113 @@ def _trash_file(file, fcn):
 
 def _trash_multifile(files, fcn):
     fcn(files)
-    assert any([op.exists(file) for file in files]) is False
+    assert any(op.exists(file) for file in files) is False
 
 
-def _file_not_found(dir, fcn):
+def _file_not_found(folder, fcn):
-    file = op.join(dir, "otherfile.txt")
+    file = op.join(folder, "otherfile.txt")
     pytest.raises(OSError, fcn, file)
 
 
-def _multi_byte_unicode(dir, fcn):
+def _multi_byte_unicode(folder, fcn):
-    single_file = op.join(dir, "😇.txt")
+    single_file = op.join(folder, "😇.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)]
+    files = [op.join(folder, f"😇{index}.txt") for index in range(10)]
-    [_create_tree(file) for file in files]
+    for file in files:
-    assert all([op.exists(file) for file in files]) is True
+        _create_tree(file)
+    assert all(op.exists(file) for file in files) is True
     fcn(files)
-    assert any([op.exists(file) for file in files]) is False
+    assert any(op.exists(file) for file in files) is False
 
 
-def test_trash_folder(testdir):
+def test_trash_folder(test_dir):
-    _trash_folder(testdir, s2t)
+    _trash_folder(test_dir, s2t)
 
 
-def test_trash_file(testfile):
+def test_trash_file(test_file):
-    _trash_file(testfile, s2t)
+    _trash_file(test_file, s2t)
 
 
-def test_trash_multifile(testfiles):
+def test_trash_multifile(test_files):
-    _trash_multifile(testfiles, s2t)
+    _trash_multifile(test_files, s2t)
 
 
-def test_file_not_found(testdir):
+def test_file_not_found(test_dir):
-    _file_not_found(testdir, s2t)
+    _file_not_found(test_dir, s2t)
 
 
-def test_trash_folder_modern(testdir):
+def test_trash_folder_modern(test_dir):
-    _trash_folder(testdir, s2t_modern)
+    _trash_folder(test_dir, s2t_modern)
 
 
-def test_trash_file_modern(testfile):
+def test_trash_file_modern(test_file):
-    _trash_file(testfile, s2t_modern)
+    _trash_file(test_file, s2t_modern)
 
 
-def test_trash_multifile_modern(testfiles):
+def test_trash_multifile_modern(test_files):
-    _trash_multifile(testfiles, s2t_modern)
+    _trash_multifile(test_files, s2t_modern)
 
 
-def test_file_not_found_modern(testdir):
+def test_file_not_found_modern(test_dir):
-    _file_not_found(testdir, s2t_modern)
+    _file_not_found(test_dir, s2t_modern)
 
 
-def test_multi_byte_unicode_modern(testdir):
+def test_multi_byte_unicode_modern(test_dir):
-    _multi_byte_unicode(testdir, s2t_modern)
+    _multi_byte_unicode(test_dir, 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):
+def test_trash_long_file_modern(long_file):
-    _trash_file(longfile, s2t_modern)
+    _trash_file(long_file, s2t_modern)
 
 
-def test_trash_long_multifile_modern(longfiles):
+def test_trash_long_multifile_modern(long_files):
-    _trash_multifile(longfiles, s2t_modern)
+    _trash_multifile(long_files, s2t_modern)
 
 
-#     @pytest.skipif(
+def test_trash_nothing_modern():
-#         op.splitdrive(os.getcwd())[0] != op.splitdrive(gettempdir())[0],
+    try:
-#         "Cannot trash long path from other drive",
+        s2t_modern([])
-#     )
+    except Exception as ex:
-#     def test_trash_long_folder_modern(self):
+        assert False, f"Exception thrown when trashing nothing: {ex}"
-#         self._trash_folder(s2t_modern)
 
 
-def test_trash_long_file_legacy(longfile):
+def test_trash_folder_legacy(test_dir):
-    _trash_file(longfile, s2t_legacy)
+    _trash_folder(test_dir, s2t_legacy)
 
 
-def test_trash_long_multifile_legacy(longfiles):
+def test_trash_file_legacy(test_file):
-    _trash_multifile(longfiles, s2t_legacy)
+    _trash_file(test_file, s2t_legacy)
 
 
-#     @pytest.skipif(
+def test_trash_multifile_legacy(test_files):
-#         op.splitdrive(os.getcwd())[0] != op.splitdrive(gettempdir())[0],
+    _trash_multifile(test_files, s2t_legacy)
-#         "Cannot trash long path from other drive",
+
-#     )
+
-#     def test_trash_long_folder_legacy(self):
+def test_file_not_found_legacy(test_dir):
-#         self._trash_folder(s2t_legacy)
+    _file_not_found(test_dir, s2t_legacy)
+
+
+def test_multi_byte_unicode_legacy(test_dir):
+    _multi_byte_unicode(test_dir, s2t_legacy)
+
+
+def test_trash_long_file_legacy(long_file):
+    _trash_file(long_file, s2t_legacy)
+
+
+def test_trash_long_multifile_legacy(long_files):
+    _trash_multifile(long_files, s2t_legacy)
+
+
+def test_trash_nothing_legacy():
+    try:
+        s2t_legacy([])
+    except Exception as ex:
+        assert False, f"Exception thrown when trashing nothing: {ex}"

tests/test_script_main.py

@@ -1,43 +1,16 @@
 # encoding: utf-8
-import os
-import sys
-import pytest
-from tempfile import NamedTemporaryFile
 from os import path as op
+import pytest
 
 from send2trash.__main__ import main as trash_main
 
-# Only import HOMETRASH on supported platforms
+
-if sys.platform != "win32":
+def test_trash(test_file):
-    from send2trash.plat_other import HOMETRASH
+    trash_main(["-v", test_file])
+    assert op.exists(test_file) is False
 
 
-@pytest.fixture
+def test_no_args(test_file):
-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
+    assert op.exists(test_file) is True

tox.ini

@@ -1,6 +1,7 @@
 [tox]
-envlist = py{27,34,35,36,37,38,39,310}
+envlist = py{38,39,310,311,312,313,314}
 skip_missing_interpreters = True
+isolated_build = True
 
 [testenv]
 deps =
@@ -20,4 +21,5 @@ deps =
 [flake8]
 exclude = .tox,env,build
 max-line-length = 120
-ignore = E731,E203,E501,W503
+select = C,E,F,W,B,B950
+extend-ignore = E203, E501