pax_global_header00006660000000000000000000000064141100730140014501gustar00rootroot0000000000000052 comment=2aa834be94448fb3b63618aad9c7c4e1ffba4bdf send2trash-1.8.1b0/000077500000000000000000000000001411007301400140075ustar00rootroot00000000000000send2trash-1.8.1b0/.github/000077500000000000000000000000001411007301400153475ustar00rootroot00000000000000send2trash-1.8.1b0/.github/workflows/000077500000000000000000000000001411007301400174045ustar00rootroot00000000000000send2trash-1.8.1b0/.github/workflows/codeql-analysis.yml000066400000000000000000000046171411007301400232270ustar00rootroot00000000000000# For most projects, this workflow file will not need changing; you simply need # to commit it to your repository. # # You may wish to alter this file to override the set of languages analyzed, # or to provide custom queries or build logic. # # ******** NOTE ******** # We have attempted to detect the languages in your repository. Please check # the `language` matrix defined below to confirm you have the correct set of # supported CodeQL languages. # 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' ] # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ] # Learn more: # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed steps: - name: Checkout repository uses: actions/checkout@v2 # Initializes the CodeQL tools for scanning. - name: Initialize CodeQL uses: github/codeql-action/init@v1 with: languages: ${{ matrix.language }} # If you wish to specify custom queries, you can do so here or in a config file. # By default, queries listed here will override any specified in a config file. # Prefix the list here with "+" to use these queries and those in the config file. # queries: ./path/to/local/query, your-org/your-repo/queries@main # Autobuild attempts to build any compiled languages (C/C++, C#, or Java). # If this step fails, then you should remove it and run the build manually (see below) - name: Autobuild uses: github/codeql-action/autobuild@v1 # ℹ️ Command-line programs to run using the OS shell. # 📚 https://git.io/JvXDl # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines # and modify them (or add more) to build your code if your project # uses a compiled language #- run: | # make bootstrap # make release - name: Perform CodeQL Analysis uses: github/codeql-action/analyze@v1 send2trash-1.8.1b0/.github/workflows/default.yml000066400000000000000000000041111411007301400215500ustar00rootroot00000000000000# Workflow lints, and checks format in parallel then runs tests on all platforms name: Default CI/CD on: push: branches: [ master ] pull_request: branches: [ master ] jobs: lint: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Set up Python 3.x uses: actions/setup-python@v2 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.10.0-alpha - 3.10.0 - os: ubuntu-latest python-version: 3.9 - os: ubuntu-latest python-version: 3.8 - os: ubuntu-latest python-version: 3.7 - os: ubuntu-latest python-version: 3.6 - os: ubuntu-latest python-version: 3.5 - os: ubuntu-latest python-version: 2.7 # - os: macos-latest # python-version: 3.9 # - os: macos-latest # python-version: 3.8 # - os: macos-latest # python-version: 2.7 - os: windows-latest python-version: 3.9 - os: windows-latest python-version: 3.8 - os: windows-latest python-version: 2.7 steps: - uses: actions/checkout@v2 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v2 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 send2trash-1.8.1b0/.gitignore000066400000000000000000000000761411007301400160020ustar00rootroot00000000000000*.pyc *.egg-info /build /dist .DS_Store /.tox __pycache__ /envsend2trash-1.8.1b0/.travis.yml000066400000000000000000000005711411007301400161230ustar00rootroot00000000000000language: python matrix: include: - python: "2.7" arch: ppc64le - python: "3.6" arch: ppc64le - python: "3.7" arch: ppc64le - python: "3.8" arch: ppc64le - python: "3.9" arch: ppc64le install: - python -m pip install tox before_script: - export TOXENV=$(echo py$TRAVIS_PYTHON_VERSION | tr -d .) script: - python -m tox send2trash-1.8.1b0/CHANGES.rst000066400000000000000000000057441411007301400156230ustar00rootroot00000000000000Changes ======= 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 --------------------------- * Release stable version with changes from last 3 releases * Fix handling of UNC names (#57) Version 1.7.0a1 -- 2021/05/14 ----------------------------- * Changed conditional for when to try to use pyobjc version (#51) Version 1.7.0a0 -- 2021/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 send2trash-1.8.1b0/LICENSE000066400000000000000000000027261411007301400150230ustar00rootroot00000000000000Copyright (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: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * 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. send2trash-1.8.1b0/MANIFEST.in000066400000000000000000000000341411007301400155420ustar00rootroot00000000000000include CHANGES.rst LICENSE send2trash-1.8.1b0/README.rst000066400000000000000000000043531411007301400155030ustar00rootroot00000000000000================================================== 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 or can use pyobjc with NSFileManager. 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 To install with pywin32 or pyobjc required specify the extra `nativeLib`: python -m pip install -U send2trash[nativeLib] 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/ send2trash-1.8.1b0/pyproject.toml000066400000000000000000000002041411007301400167170ustar00rootroot00000000000000[build-system] requires = ["setuptools >= 40.6.0", "wheel"] build-backend = "setuptools.build_meta" [tool.black] line-length = 120 send2trash-1.8.1b0/send2trash/000077500000000000000000000000001411007301400160645ustar00rootroot00000000000000send2trash-1.8.1b0/send2trash/IFileOperationProgressSink.py000066400000000000000000000050001411007301400236540ustar00rootroot00000000000000# 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-1.8.1b0/send2trash/__init__.py000066400000000000000000000013451411007301400202000ustar00rootroot00000000000000# 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 # http://www.hardcoded.net/licenses/bsd_license import sys 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: 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-1.8.1b0/send2trash/__main__.py000066400000000000000000000016651411007301400201660ustar00rootroot00000000000000# 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-1.8.1b0/send2trash/compat.py000066400000000000000000000011321411007301400177160ustar00rootroot00000000000000# 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-1.8.1b0/send2trash/exceptions.py000066400000000000000000000017441411007301400206250ustar00rootroot00000000000000import 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-1.8.1b0/send2trash/plat_gio.py000066400000000000000000000015641411007301400202420ustar00rootroot00000000000000# 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 from .util import preprocess_paths def send2trash(paths): paths = preprocess_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-1.8.1b0/send2trash/plat_osx.py000066400000000000000000000014411411007301400202670ustar00rootroot00000000000000# 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 platform import mac_ver from sys import version_info # 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-1.8.1b0/send2trash/plat_osx_ctypes.py000066400000000000000000000034441411007301400216630ustar00rootroot00000000000000# 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 from .util import preprocess_paths 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): paths = preprocess_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-1.8.1b0/send2trash/plat_osx_pyobjc.py000066400000000000000000000017421411007301400216410ustar00rootroot00000000000000# 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 from .util import preprocess_paths 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): paths = preprocess_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-1.8.1b0/send2trash/plat_other.py000066400000000000000000000157061411007301400206100ustar00rootroot00000000000000# 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 shutil import os.path as op from datetime import datetime import stat try: from urllib.parse import quote except ImportError: # Python 2 from urllib import quote from .compat import text_type, environb from .util import preprocess_paths 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")) 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, cross_dev=False): 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)) destpath = op.join(filespath, destname) if cross_dev: shutil.move(src, destpath) else: os.rename(src, destpath) 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): # Note ismount() does not always detect mounts path = op.split(path)[0] return path 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 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: check_create(trash_dir) except OSError: 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): paths = preprocess_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) 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-1.8.1b0/send2trash/plat_win.py000066400000000000000000000013711411007301400202550ustar00rootroot00000000000000# 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 platform import version # 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-1.8.1b0/send2trash/plat_win_legacy.py000066400000000000000000000116261411007301400216050ustar00rootroot00000000000000# 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 .util import preprocess_paths 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 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) are handled. Return a tuple of the long-path prefix and the prefixed path. """ prefix, long_path = "\\\\?\\", path if not path.startswith(prefix): if path.startswith("\\\\"): # Likely a UNC name prefix = "\\\\?\\UNC" long_path = prefix + path[1:] else: # Likely a local path long_path = prefix + path elif path.startswith(prefix + "UNC\\"): # UNC name with long-path prefix prefix = "\\\\?\\UNC" return prefix, long_path def get_awaited_path_from_prefix(prefix, path): """Guess the correct path to pass to the SHFileOperationW() call. The long-path prefix must be removed, so we should take care of different long-path prefixes. """ if prefix == "\\\\?\\UNC": # We need to prepend a backslash for UNC names, as it was removed # in prefix_and_path(). return "\\" + path[len(prefix) :] return path[len(prefix) :] def get_short_path_name(long_name): prefix, long_path = prefix_and_path(long_name) buf_size = GetShortPathNameW(long_path, 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_path) output = create_unicode_buffer(buf_size) GetShortPathNameW(long_path, output, buf_size) return get_awaited_path_from_prefix(prefix, output.value) def send2trash(paths): paths = preprocess_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-1.8.1b0/send2trash/plat_win_modern.py000066400000000000000000000051071411007301400216220ustar00rootroot00000000000000# 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 .util import preprocess_paths from platform import version import pythoncom import pywintypes from win32com.shell import shell, shellcon from .IFileOperationProgressSink import CreateSink def send2trash(paths): paths = preprocess_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] # 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, ) # 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 | 0x00080000 # FOFX_ADDUNDORECORD win 8+ # 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) finally: # Need to make sure we call this once fore every init pythoncom.CoUninitialize() send2trash-1.8.1b0/send2trash/util.py000066400000000000000000000010041411007301400174060ustar00rootroot00000000000000# 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 def preprocess_paths(paths): if not isinstance(paths, list): paths = [paths] # Convert items such as pathlib paths to strings paths = [path.__fspath__() if hasattr(path, "__fspath__") else path for path in paths] return paths send2trash-1.8.1b0/setup.cfg000066400000000000000000000027551411007301400156410ustar00rootroot00000000000000[metadata] name = Send2Trash version = 1.8.1b0 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 :: 2.7 Programming Language :: Python :: 3 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 [options] packages = send2trash tests_require = pytest python_requires = >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.* [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__:mainsend2trash-1.8.1b0/tests/000077500000000000000000000000001411007301400151515ustar00rootroot00000000000000send2trash-1.8.1b0/tests/__init__.py000066400000000000000000000000001411007301400172500ustar00rootroot00000000000000send2trash-1.8.1b0/tests/test_plat_other.py000066400000000000000000000146601411007301400207320ustar00rootroot00000000000000# 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) send2trash-1.8.1b0/tests/test_plat_win.py000066400000000000000000000122001411007301400203720ustar00rootroot00000000000000# 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) try: shutil.rmtree(dirname, ignore_errors=True) except TypeError: pass @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) send2trash-1.8.1b0/tests/test_script_main.py000066400000000000000000000022421411007301400210720ustar00rootroot00000000000000# 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 send2trash-1.8.1b0/tox.ini000066400000000000000000000006571411007301400153320ustar00rootroot00000000000000[tox] envlist = py{27,34,35,36,37,38,39,310} skip_missing_interpreters = True isolated_build = 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 select = C,E,F,W,B,B950 extend-ignore = E203, E501