Uploaded Test files

venv/Lib/site-packages/send2trash/__init__.py

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

venv/Lib/site-packages/send2trash/compat.py

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

venv/Lib/site-packages/send2trash/exceptions.py

@@ -0,0 +1,25 @@
+import errno
+from .compat import PY3
+
+if PY3:
+    _permission_error = PermissionError
+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)

venv/Lib/site-packages/send2trash/plat_gio.py

@@ -0,0 +1,19 @@
+# Copyright 2017 Virgil Dupras
+
+# This software is licensed under the "BSD" License as described in the "LICENSE" file,
+# which should be included with this package. The terms are also available at
+# http://www.hardcoded.net/licenses/bsd_license
+
+from gi.repository import GObject, Gio
+from .exceptions import TrashPermissionError
+
+def send2trash(path):
+    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)

venv/Lib/site-packages/send2trash/plat_osx.py

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

venv/Lib/site-packages/send2trash/plat_other.py

@@ -0,0 +1,192 @@
+# Copyright 2017 Virgil Dupras
+
+# This software is licensed under the "BSD" License as described in the "LICENSE" file,
+# which should be included with this package. The terms are also available at
+# http://www.hardcoded.net/licenses/bsd_license
+
+# This is a reimplementation of plat_other.py with reference to the
+# freedesktop.org trash specification:
+#   [1] http://www.freedesktop.org/wiki/Specifications/trash-spec
+#   [2] http://www.ramendik.ru/docs/trashspec.html
+# See also:
+#   [3] http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
+#
+# For external volumes this implementation will raise an exception if it can't
+# find or create the user's trash directory.
+
+from __future__ import unicode_literals
+
+import errno
+import sys
+import os
+import os.path as op
+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 .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):
+    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)
+
+    os.rename(src, op.join(filespath, destname))
+    f = open(op.join(infopath, destname + INFO_SUFFIX), 'w')
+    f.write(info_for(src, topdir))
+    f.close()
+
+def find_mount_point(path):
+    # Even if something's wrong, "/" is a mount point, so the loop will exit.
+    # Use realpath in case it's a symlink
+    path = op.realpath(path) # Required to avoid infinite loop
+    while not op.ismount(path):
+        path = op.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(path):
+    if isinstance(path, text_type):
+        path_b = fsencode(path)
+    elif isinstance(path, bytes):
+        path_b = path
+    elif hasattr(path, '__fspath__'):
+        # Python 3.6 PathLike protocol
+        return send2trash(path.__fspath__())
+    else:
+        raise TypeError('str, bytes or PathLike expected, not %r' % type(path))
+
+    if not op.exists(path_b):
+        raise OSError("File not found: %s" % path)
+    # ...should check whether the user has the necessary permissions to delete
+    # it, before starting the trashing operation itself. [2]
+    if not os.access(path_b, os.W_OK):
+        raise OSError("Permission denied: %s" % path)
+    # if the file to be trashed is on the same device as HOMETRASH we
+    # want to move it there.
+    path_dev = get_dev(path_b)
+
+    # If XDG_DATA_HOME or HOMETRASH do not yet exist we need to stat the
+    # home directory, and these paths will be created further on if needed.
+    trash_dev = get_dev(op.expanduser(b'~'))
+
+    if path_dev == trash_dev:
+        topdir = XDG_DATA_HOME
+        dest_trash = HOMETRASH_B
+    else:
+        topdir = find_mount_point(path_b)
+        trash_dev = get_dev(topdir)
+        if trash_dev != path_dev:
+            raise OSError("Couldn't find mount point for %s" % path)
+        dest_trash = find_ext_volume_trash(topdir)
+    trash_move(path_b, dest_trash, topdir)

venv/Lib/site-packages/send2trash/plat_win.py

@@ -0,0 +1,86 @@
+# 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 (windll, Structure, byref, c_uint,
+                    create_unicode_buffer, addressof)
+from ctypes.wintypes import HWND, UINT, LPCWSTR, BOOL
+import os.path as op
+
+from .compat import text_type
+
+kernel32 = windll.kernel32
+GetShortPathNameW = kernel32.GetShortPathNameW
+
+shell32 = windll.shell32
+SHFileOperationW = shell32.SHFileOperationW
+
+
+class SHFILEOPSTRUCTW(Structure):
+    _fields_ = [
+        ("hwnd", HWND),
+        ("wFunc", UINT),
+        ("pFrom", LPCWSTR),
+        ("pTo", LPCWSTR),
+        ("fFlags", c_uint),
+        ("fAnyOperationsAborted", BOOL),
+        ("hNameMappings", c_uint),
+        ("lpszProgressTitle", LPCWSTR),
+        ]
+
+
+FO_MOVE = 1
+FO_COPY = 2
+FO_DELETE = 3
+FO_RENAME = 4
+
+FOF_MULTIDESTFILES = 1
+FOF_SILENT = 4
+FOF_NOCONFIRMATION = 16
+FOF_ALLOWUNDO = 64
+FOF_NOERRORUI = 1024
+
+
+def get_short_path_name(long_name):
+    if not long_name.startswith('\\\\?\\'):
+        long_name = '\\\\?\\' + long_name
+    buf_size = GetShortPathNameW(long_name, None, 0)
+    output = create_unicode_buffer(buf_size)
+    GetShortPathNameW(long_name, output, buf_size)
+    return output.value[4:]  # Remove '\\?\' for SHFileOperationW
+
+
+def send2trash(path):
+    if not isinstance(path, text_type):
+        path = text_type(path, 'mbcs')
+    if not op.isabs(path):
+        path = op.abspath(path)
+    path = get_short_path_name(path)
+    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'.
+    buffer = create_unicode_buffer(path, len(path)+2)
+    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(None, None, path, result)