diff --git a/CHANGES.md b/CHANGES.md
index 932612e5..6ea69be9 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -8,7 +8,9 @@
* Update profilehooks module 1.10.0 (0ce1e29) to 1.10.1 (fdbf19d)
* Update PySocks 1.6.8 (524ceb4) to 1.6.8 (b687a34)
* Update Requests library 2.15.1 (282b01a) to 2.19.1 (33b41c7)
+* Update scandir module 1.6 (c3592ee) to 1.9.0 (9ab3d1f)
* Add urllib3 release 1.23 (7c216f4)
+* Change if old scandir binary module is installed, fallback to slow Python module and inform user to upgrade binary
[develop changelog]
diff --git a/HACKS.txt b/HACKS.txt
index c8727b41..0dd835eb 100644
--- a/HACKS.txt
+++ b/HACKS.txt
@@ -10,6 +10,7 @@ Libs with customisations...
/lib/hachoir_parser/guess.py
/lib/hachoir_parser/misc/torrent.py
/lib/lockfile/mkdirlockfile.py
+/lib/scandir/scandir.py
/lib/tmdb_api/tmdb_api.py
/lib/tornado
/lib/tvdb_api/tvdb_api.py
diff --git a/gui/slick/interfaces/default/inc_top.tmpl b/gui/slick/interfaces/default/inc_top.tmpl
index 5928bafa..a6695957 100644
--- a/gui/slick/interfaces/default/inc_top.tmpl
+++ b/gui/slick/interfaces/default/inc_top.tmpl
@@ -265,6 +265,11 @@
$sg_str('NEWEST_VERSION_STRING')
#end if
+#if $sg_str('MODULE_UPDATE_STRING')
+
+ $sg_str('MODULE_UPDATE_STRING')
+
+#end if
##
#set $items = []
#try
diff --git a/lib/scandir/scandir.py b/lib/scandir/scandir.py
index 3594d9dc..a01379ad 100644
--- a/lib/scandir/scandir.py
+++ b/lib/scandir/scandir.py
@@ -1,671 +1,697 @@
-"""scandir, a better directory iterator and faster os.walk(), now in the Python 3.5 stdlib
-
-scandir() is a generator version of os.listdir() that returns an
-iterator over files in a directory, and also exposes the extra
-information most OSes provide while iterating files in a directory
-(such as type and stat information).
-
-This module also includes a version of os.walk() that uses scandir()
-to speed it up significantly.
-
-See README.md or https://github.com/benhoyt/scandir for rationale and
-docs, or read PEP 471 (https://www.python.org/dev/peps/pep-0471/) for
-more details on its inclusion into Python 3.5
-
-scandir is released under the new BSD 3-clause license. See
-LICENSE.txt for the full license text.
-"""
-
-from __future__ import division
-
-from errno import ENOENT
-from os import listdir, lstat, stat, strerror
-from os.path import join, islink
-from stat import S_IFDIR, S_IFLNK, S_IFREG
-import collections
-import os
-import sys
-
-try:
- import _scandir
-except ImportError:
- _scandir = None
-
-try:
- import ctypes
-except ImportError:
- ctypes = None
-
-if _scandir is None and ctypes is None:
- import warnings
- warnings.warn("scandir can't find the compiled _scandir C module "
- "or ctypes, using slow generic fallback")
-
-__version__ = '1.6'
-__all__ = ['scandir', 'walk']
-
-# Windows FILE_ATTRIBUTE constants for interpreting the
-# FIND_DATA.dwFileAttributes member
-FILE_ATTRIBUTE_ARCHIVE = 32
-FILE_ATTRIBUTE_COMPRESSED = 2048
-FILE_ATTRIBUTE_DEVICE = 64
-FILE_ATTRIBUTE_DIRECTORY = 16
-FILE_ATTRIBUTE_ENCRYPTED = 16384
-FILE_ATTRIBUTE_HIDDEN = 2
-FILE_ATTRIBUTE_INTEGRITY_STREAM = 32768
-FILE_ATTRIBUTE_NORMAL = 128
-FILE_ATTRIBUTE_NOT_CONTENT_INDEXED = 8192
-FILE_ATTRIBUTE_NO_SCRUB_DATA = 131072
-FILE_ATTRIBUTE_OFFLINE = 4096
-FILE_ATTRIBUTE_READONLY = 1
-FILE_ATTRIBUTE_REPARSE_POINT = 1024
-FILE_ATTRIBUTE_SPARSE_FILE = 512
-FILE_ATTRIBUTE_SYSTEM = 4
-FILE_ATTRIBUTE_TEMPORARY = 256
-FILE_ATTRIBUTE_VIRTUAL = 65536
-
-IS_PY3 = sys.version_info >= (3, 0)
-
-if IS_PY3:
- unicode = str # Because Python <= 3.2 doesn't have u'unicode' syntax
-
-
-class GenericDirEntry(object):
- __slots__ = ('name', '_stat', '_lstat', '_scandir_path', '_path')
-
- def __init__(self, scandir_path, name):
- self._scandir_path = scandir_path
- self.name = name
- self._stat = None
- self._lstat = None
- self._path = None
-
- @property
- def path(self):
- if self._path is None:
- self._path = join(self._scandir_path, self.name)
- return self._path
-
- def stat(self, follow_symlinks=True):
- if follow_symlinks:
- if self._stat is None:
- self._stat = stat(self.path)
- return self._stat
- else:
- if self._lstat is None:
- self._lstat = lstat(self.path)
- return self._lstat
-
- def is_dir(self, follow_symlinks=True):
- try:
- st = self.stat(follow_symlinks=follow_symlinks)
- except OSError as e:
- if e.errno != ENOENT:
- raise
- return False # Path doesn't exist or is a broken symlink
- return st.st_mode & 0o170000 == S_IFDIR
-
- def is_file(self, follow_symlinks=True):
- try:
- st = self.stat(follow_symlinks=follow_symlinks)
- except OSError as e:
- if e.errno != ENOENT:
- raise
- return False # Path doesn't exist or is a broken symlink
- return st.st_mode & 0o170000 == S_IFREG
-
- def is_symlink(self):
- try:
- st = self.stat(follow_symlinks=False)
- except OSError as e:
- if e.errno != ENOENT:
- raise
- return False # Path doesn't exist or is a broken symlink
- return st.st_mode & 0o170000 == S_IFLNK
-
- def inode(self):
- st = self.stat(follow_symlinks=False)
- return st.st_ino
-
- def __str__(self):
- return '<{0}: {1!r}>'.format(self.__class__.__name__, self.name)
-
- __repr__ = __str__
-
-
-def _scandir_generic(path=unicode('.')):
- """Like os.listdir(), but yield DirEntry objects instead of returning
- a list of names.
- """
- for name in listdir(path):
- yield GenericDirEntry(path, name)
-
-
-if IS_PY3 and sys.platform == 'win32':
- def scandir_generic(path=unicode('.')):
- if isinstance(path, bytes):
- raise TypeError("os.scandir() doesn't support bytes path on Windows, use Unicode instead")
- return _scandir_generic(path)
- scandir_generic.__doc__ = _scandir_generic.__doc__
-else:
- scandir_generic = _scandir_generic
-
-
-scandir_c = None
-scandir_python = None
-
-
-if sys.platform == 'win32':
- if ctypes is not None:
- from ctypes import wintypes
-
- # Various constants from windows.h
- INVALID_HANDLE_VALUE = ctypes.c_void_p(-1).value
- ERROR_FILE_NOT_FOUND = 2
- ERROR_NO_MORE_FILES = 18
- IO_REPARSE_TAG_SYMLINK = 0xA000000C
-
- # Numer of seconds between 1601-01-01 and 1970-01-01
- SECONDS_BETWEEN_EPOCHS = 11644473600
-
- kernel32 = ctypes.windll.kernel32
-
- # ctypes wrappers for (wide string versions of) FindFirstFile,
- # FindNextFile, and FindClose
- FindFirstFile = kernel32.FindFirstFileW
- FindFirstFile.argtypes = [
- wintypes.LPCWSTR,
- ctypes.POINTER(wintypes.WIN32_FIND_DATAW),
- ]
- FindFirstFile.restype = wintypes.HANDLE
-
- FindNextFile = kernel32.FindNextFileW
- FindNextFile.argtypes = [
- wintypes.HANDLE,
- ctypes.POINTER(wintypes.WIN32_FIND_DATAW),
- ]
- FindNextFile.restype = wintypes.BOOL
-
- FindClose = kernel32.FindClose
- FindClose.argtypes = [wintypes.HANDLE]
- FindClose.restype = wintypes.BOOL
-
- Win32StatResult = collections.namedtuple('Win32StatResult', [
- 'st_mode',
- 'st_ino',
- 'st_dev',
- 'st_nlink',
- 'st_uid',
- 'st_gid',
- 'st_size',
- 'st_atime',
- 'st_mtime',
- 'st_ctime',
- 'st_atime_ns',
- 'st_mtime_ns',
- 'st_ctime_ns',
- 'st_file_attributes',
- ])
-
- def filetime_to_time(filetime):
- """Convert Win32 FILETIME to time since Unix epoch in seconds."""
- total = filetime.dwHighDateTime << 32 | filetime.dwLowDateTime
- return total / 10000000 - SECONDS_BETWEEN_EPOCHS
-
- def find_data_to_stat(data):
- """Convert Win32 FIND_DATA struct to stat_result."""
- # First convert Win32 dwFileAttributes to st_mode
- attributes = data.dwFileAttributes
- st_mode = 0
- if attributes & FILE_ATTRIBUTE_DIRECTORY:
- st_mode |= S_IFDIR | 0o111
- else:
- st_mode |= S_IFREG
- if attributes & FILE_ATTRIBUTE_READONLY:
- st_mode |= 0o444
- else:
- st_mode |= 0o666
- if (attributes & FILE_ATTRIBUTE_REPARSE_POINT and
- data.dwReserved0 == IO_REPARSE_TAG_SYMLINK):
- st_mode ^= st_mode & 0o170000
- st_mode |= S_IFLNK
-
- st_size = data.nFileSizeHigh << 32 | data.nFileSizeLow
- st_atime = filetime_to_time(data.ftLastAccessTime)
- st_mtime = filetime_to_time(data.ftLastWriteTime)
- st_ctime = filetime_to_time(data.ftCreationTime)
-
- # Some fields set to zero per CPython's posixmodule.c: st_ino, st_dev,
- # st_nlink, st_uid, st_gid
- return Win32StatResult(st_mode, 0, 0, 0, 0, 0, st_size,
- st_atime, st_mtime, st_ctime,
- int(st_atime * 1000000000),
- int(st_mtime * 1000000000),
- int(st_ctime * 1000000000),
- attributes)
-
- class Win32DirEntryPython(object):
- __slots__ = ('name', '_stat', '_lstat', '_find_data', '_scandir_path', '_path', '_inode')
-
- def __init__(self, scandir_path, name, find_data):
- self._scandir_path = scandir_path
- self.name = name
- self._stat = None
- self._lstat = None
- self._find_data = find_data
- self._path = None
- self._inode = None
-
- @property
- def path(self):
- if self._path is None:
- self._path = join(self._scandir_path, self.name)
- return self._path
-
- def stat(self, follow_symlinks=True):
- if follow_symlinks:
- if self._stat is None:
- if self.is_symlink():
- # It's a symlink, call link-following stat()
- self._stat = stat(self.path)
- else:
- # Not a symlink, stat is same as lstat value
- if self._lstat is None:
- self._lstat = find_data_to_stat(self._find_data)
- self._stat = self._lstat
- return self._stat
- else:
- if self._lstat is None:
- # Lazily convert to stat object, because it's slow
- # in Python, and often we only need is_dir() etc
- self._lstat = find_data_to_stat(self._find_data)
- return self._lstat
-
- def is_dir(self, follow_symlinks=True):
- is_symlink = self.is_symlink()
- if follow_symlinks and is_symlink:
- try:
- return self.stat().st_mode & 0o170000 == S_IFDIR
- except OSError as e:
- if e.errno != ENOENT:
- raise
- return False
- elif is_symlink:
- return False
- else:
- return (self._find_data.dwFileAttributes &
- FILE_ATTRIBUTE_DIRECTORY != 0)
-
- def is_file(self, follow_symlinks=True):
- is_symlink = self.is_symlink()
- if follow_symlinks and is_symlink:
- try:
- return self.stat().st_mode & 0o170000 == S_IFREG
- except OSError as e:
- if e.errno != ENOENT:
- raise
- return False
- elif is_symlink:
- return False
- else:
- return (self._find_data.dwFileAttributes &
- FILE_ATTRIBUTE_DIRECTORY == 0)
-
- def is_symlink(self):
- return (self._find_data.dwFileAttributes &
- FILE_ATTRIBUTE_REPARSE_POINT != 0 and
- self._find_data.dwReserved0 == IO_REPARSE_TAG_SYMLINK)
-
- def inode(self):
- if self._inode is None:
- self._inode = lstat(self.path).st_ino
- return self._inode
-
- def __str__(self):
- return '<{0}: {1!r}>'.format(self.__class__.__name__, self.name)
-
- __repr__ = __str__
-
- def win_error(error, filename):
- exc = WindowsError(error, ctypes.FormatError(error))
- exc.filename = filename
- return exc
-
- def _scandir_python(path=unicode('.')):
- """Like os.listdir(), but yield DirEntry objects instead of returning
- a list of names.
- """
- # Call FindFirstFile and handle errors
- if isinstance(path, bytes):
- is_bytes = True
- filename = join(path.decode('mbcs', 'strict'), '*.*')
- else:
- is_bytes = False
- filename = join(path, '*.*')
- data = wintypes.WIN32_FIND_DATAW()
- data_p = ctypes.byref(data)
- handle = FindFirstFile(filename, data_p)
- if handle == INVALID_HANDLE_VALUE:
- error = ctypes.GetLastError()
- if error == ERROR_FILE_NOT_FOUND:
- # No files, don't yield anything
- return
- raise win_error(error, path)
-
- # Call FindNextFile in a loop, stopping when no more files
- try:
- while True:
- # Skip '.' and '..' (current and parent directory), but
- # otherwise yield (filename, stat_result) tuple
- name = data.cFileName
- if name not in ('.', '..'):
- if is_bytes:
- name = name.encode('mbcs', 'replace')
- yield Win32DirEntryPython(path, name, data)
-
- data = wintypes.WIN32_FIND_DATAW()
- data_p = ctypes.byref(data)
- success = FindNextFile(handle, data_p)
- if not success:
- error = ctypes.GetLastError()
- if error == ERROR_NO_MORE_FILES:
- break
- raise win_error(error, path)
- finally:
- if not FindClose(handle):
- raise win_error(ctypes.GetLastError(), path)
-
- if IS_PY3:
- def scandir_python(path=unicode('.')):
- if isinstance(path, bytes):
- raise TypeError("os.scandir() doesn't support bytes path on Windows, use Unicode instead")
- return _scandir_python(path)
- scandir_python.__doc__ = _scandir_python.__doc__
- else:
- scandir_python = _scandir_python
-
- if _scandir is not None:
- scandir_c = _scandir.scandir
-
- if _scandir is not None:
- scandir = scandir_c
- elif ctypes is not None:
- scandir = scandir_python
- else:
- scandir = scandir_generic
-
-
-# Linux, OS X, and BSD implementation
-elif sys.platform.startswith(('linux', 'darwin', 'sunos5')) or 'bsd' in sys.platform:
- have_dirent_d_type = (sys.platform != 'sunos5')
-
- if ctypes is not None and have_dirent_d_type:
- import ctypes.util
-
- DIR_p = ctypes.c_void_p
-
- # Rather annoying how the dirent struct is slightly different on each
- # platform. The only fields we care about are d_name and d_type.
- class Dirent(ctypes.Structure):
- if sys.platform.startswith('linux'):
- _fields_ = (
- ('d_ino', ctypes.c_ulong),
- ('d_off', ctypes.c_long),
- ('d_reclen', ctypes.c_ushort),
- ('d_type', ctypes.c_byte),
- ('d_name', ctypes.c_char * 256),
- )
- else:
- _fields_ = (
- ('d_ino', ctypes.c_uint32), # must be uint32, not ulong
- ('d_reclen', ctypes.c_ushort),
- ('d_type', ctypes.c_byte),
- ('d_namlen', ctypes.c_byte),
- ('d_name', ctypes.c_char * 256),
- )
-
- DT_UNKNOWN = 0
- DT_DIR = 4
- DT_REG = 8
- DT_LNK = 10
-
- Dirent_p = ctypes.POINTER(Dirent)
- Dirent_pp = ctypes.POINTER(Dirent_p)
-
- libc = ctypes.CDLL(ctypes.util.find_library('c'), use_errno=True)
- opendir = libc.opendir
- opendir.argtypes = [ctypes.c_char_p]
- opendir.restype = DIR_p
-
- readdir_r = libc.readdir_r
- readdir_r.argtypes = [DIR_p, Dirent_p, Dirent_pp]
- readdir_r.restype = ctypes.c_int
-
- closedir = libc.closedir
- closedir.argtypes = [DIR_p]
- closedir.restype = ctypes.c_int
-
- file_system_encoding = sys.getfilesystemencoding()
-
- class PosixDirEntry(object):
- __slots__ = ('name', '_d_type', '_stat', '_lstat', '_scandir_path', '_path', '_inode')
-
- def __init__(self, scandir_path, name, d_type, inode):
- self._scandir_path = scandir_path
- self.name = name
- self._d_type = d_type
- self._inode = inode
- self._stat = None
- self._lstat = None
- self._path = None
-
- @property
- def path(self):
- if self._path is None:
- self._path = join(self._scandir_path, self.name)
- return self._path
-
- def stat(self, follow_symlinks=True):
- if follow_symlinks:
- if self._stat is None:
- if self.is_symlink():
- self._stat = stat(self.path)
- else:
- if self._lstat is None:
- self._lstat = lstat(self.path)
- self._stat = self._lstat
- return self._stat
- else:
- if self._lstat is None:
- self._lstat = lstat(self.path)
- return self._lstat
-
- def is_dir(self, follow_symlinks=True):
- if (self._d_type == DT_UNKNOWN or
- (follow_symlinks and self.is_symlink())):
- try:
- st = self.stat(follow_symlinks=follow_symlinks)
- except OSError as e:
- if e.errno != ENOENT:
- raise
- return False
- return st.st_mode & 0o170000 == S_IFDIR
- else:
- return self._d_type == DT_DIR
-
- def is_file(self, follow_symlinks=True):
- if (self._d_type == DT_UNKNOWN or
- (follow_symlinks and self.is_symlink())):
- try:
- st = self.stat(follow_symlinks=follow_symlinks)
- except OSError as e:
- if e.errno != ENOENT:
- raise
- return False
- return st.st_mode & 0o170000 == S_IFREG
- else:
- return self._d_type == DT_REG
-
- def is_symlink(self):
- if self._d_type == DT_UNKNOWN:
- try:
- st = self.stat(follow_symlinks=False)
- except OSError as e:
- if e.errno != ENOENT:
- raise
- return False
- return st.st_mode & 0o170000 == S_IFLNK
- else:
- return self._d_type == DT_LNK
-
- def inode(self):
- return self._inode
-
- def __str__(self):
- return '<{0}: {1!r}>'.format(self.__class__.__name__, self.name)
-
- __repr__ = __str__
-
- def posix_error(filename):
- errno = ctypes.get_errno()
- exc = OSError(errno, strerror(errno))
- exc.filename = filename
- return exc
-
- def scandir_python(path=unicode('.')):
- """Like os.listdir(), but yield DirEntry objects instead of returning
- a list of names.
- """
- if isinstance(path, bytes):
- opendir_path = path
- is_bytes = True
- else:
- opendir_path = path.encode(file_system_encoding)
- is_bytes = False
- dir_p = opendir(opendir_path)
- if not dir_p:
- raise posix_error(path)
- try:
- result = Dirent_p()
- while True:
- entry = Dirent()
- if readdir_r(dir_p, entry, result):
- raise posix_error(path)
- if not result:
- break
- name = entry.d_name
- if name not in (b'.', b'..'):
- if not is_bytes:
- name = name.decode(file_system_encoding)
- yield PosixDirEntry(path, name, entry.d_type, entry.d_ino)
- finally:
- if closedir(dir_p):
- raise posix_error(path)
-
- if _scandir is not None:
- scandir_c = _scandir.scandir
-
- if _scandir is not None:
- scandir = scandir_c
- elif ctypes is not None:
- scandir = scandir_python
- else:
- scandir = scandir_generic
-
-
-# Some other system -- no d_type or stat information
-else:
- scandir = scandir_generic
-
-
-def _walk(top, topdown=True, onerror=None, followlinks=False):
- """Like Python 3.5's implementation of os.walk() -- faster than
- the pre-Python 3.5 version as it uses scandir() internally.
- """
- dirs = []
- nondirs = []
-
- # We may not have read permission for top, in which case we can't
- # get a list of the files the directory contains. os.walk
- # always suppressed the exception then, rather than blow up for a
- # minor reason when (say) a thousand readable directories are still
- # left to visit. That logic is copied here.
- try:
- scandir_it = scandir(top)
- except OSError as error:
- if onerror is not None:
- onerror(error)
- return
-
- while True:
- try:
- try:
- entry = next(scandir_it)
- except StopIteration:
- break
- except OSError as error:
- if onerror is not None:
- onerror(error)
- return
-
- try:
- is_dir = entry.is_dir()
- except OSError:
- # If is_dir() raises an OSError, consider that the entry is not
- # a directory, same behaviour than os.path.isdir().
- is_dir = False
-
- if is_dir:
- dirs.append(entry.name)
- else:
- nondirs.append(entry.name)
-
- if not topdown and is_dir:
- # Bottom-up: recurse into sub-directory, but exclude symlinks to
- # directories if followlinks is False
- if followlinks:
- walk_into = True
- else:
- try:
- is_symlink = entry.is_symlink()
- except OSError:
- # If is_symlink() raises an OSError, consider that the
- # entry is not a symbolic link, same behaviour than
- # os.path.islink().
- is_symlink = False
- walk_into = not is_symlink
-
- if walk_into:
- for entry in walk(entry.path, topdown, onerror, followlinks):
- yield entry
-
- # Yield before recursion if going top down
- if topdown:
- yield top, dirs, nondirs
-
- # Recurse into sub-directories
- for name in dirs:
- new_path = join(top, name)
- # Issue #23605: os.path.islink() is used instead of caching
- # entry.is_symlink() result during the loop on os.scandir() because
- # the caller can replace the directory entry during the "yield"
- # above.
- if followlinks or not islink(new_path):
- for entry in walk(new_path, topdown, onerror, followlinks):
- yield entry
- else:
- # Yield after recursion if going bottom up
- yield top, dirs, nondirs
-
-
-if IS_PY3 or sys.platform != 'win32':
- walk = _walk
-else:
- # Fix for broken unicode handling on Windows on Python 2.x, see:
- # https://github.com/benhoyt/scandir/issues/54
- file_system_encoding = sys.getfilesystemencoding()
-
- def walk(top, topdown=True, onerror=None, followlinks=False):
- if isinstance(top, bytes):
- top = top.decode(file_system_encoding)
- return _walk(top, topdown, onerror, followlinks)
+"""scandir, a better directory iterator and faster os.walk(), now in the Python 3.5 stdlib
+
+scandir() is a generator version of os.listdir() that returns an
+iterator over files in a directory, and also exposes the extra
+information most OSes provide while iterating files in a directory
+(such as type and stat information).
+
+This module also includes a version of os.walk() that uses scandir()
+to speed it up significantly.
+
+See README.md or https://github.com/benhoyt/scandir for rationale and
+docs, or read PEP 471 (https://www.python.org/dev/peps/pep-0471/) for
+more details on its inclusion into Python 3.5
+
+scandir is released under the new BSD 3-clause license. See
+LICENSE.txt for the full license text.
+"""
+
+from __future__ import division
+
+from errno import ENOENT
+from os import listdir, lstat, stat, strerror
+from os.path import join, islink
+from stat import S_IFDIR, S_IFLNK, S_IFREG
+import collections
+import sys
+
+try:
+ import _scandir
+except ImportError:
+ _scandir = None
+
+try:
+ import ctypes
+except ImportError:
+ ctypes = None
+
+
+if None is not _scandir and None is not ctypes and not getattr(_scandir, 'DirEntry', None):
+ import warnings
+ warnings.warn("scandir compiled _scandir C module is too old, using slow generic fallback")
+ _scandir = None
+elif _scandir is None and ctypes is None:
+ import warnings
+ warnings.warn("scandir can't find the compiled _scandir C module or ctypes, using slow generic fallback")
+
+__version__ = '1.9.0'
+__all__ = ['scandir', 'walk']
+
+# Windows FILE_ATTRIBUTE constants for interpreting the
+# FIND_DATA.dwFileAttributes member
+FILE_ATTRIBUTE_ARCHIVE = 32
+FILE_ATTRIBUTE_COMPRESSED = 2048
+FILE_ATTRIBUTE_DEVICE = 64
+FILE_ATTRIBUTE_DIRECTORY = 16
+FILE_ATTRIBUTE_ENCRYPTED = 16384
+FILE_ATTRIBUTE_HIDDEN = 2
+FILE_ATTRIBUTE_INTEGRITY_STREAM = 32768
+FILE_ATTRIBUTE_NORMAL = 128
+FILE_ATTRIBUTE_NOT_CONTENT_INDEXED = 8192
+FILE_ATTRIBUTE_NO_SCRUB_DATA = 131072
+FILE_ATTRIBUTE_OFFLINE = 4096
+FILE_ATTRIBUTE_READONLY = 1
+FILE_ATTRIBUTE_REPARSE_POINT = 1024
+FILE_ATTRIBUTE_SPARSE_FILE = 512
+FILE_ATTRIBUTE_SYSTEM = 4
+FILE_ATTRIBUTE_TEMPORARY = 256
+FILE_ATTRIBUTE_VIRTUAL = 65536
+
+IS_PY3 = sys.version_info >= (3, 0)
+
+if IS_PY3:
+ unicode = str # Because Python <= 3.2 doesn't have u'unicode' syntax
+
+
+class GenericDirEntry(object):
+ __slots__ = ('name', '_stat', '_lstat', '_scandir_path', '_path')
+
+ def __init__(self, scandir_path, name):
+ self._scandir_path = scandir_path
+ self.name = name
+ self._stat = None
+ self._lstat = None
+ self._path = None
+
+ @property
+ def path(self):
+ if self._path is None:
+ self._path = join(self._scandir_path, self.name)
+ return self._path
+
+ def stat(self, follow_symlinks=True):
+ if follow_symlinks:
+ if self._stat is None:
+ self._stat = stat(self.path)
+ return self._stat
+ else:
+ if self._lstat is None:
+ self._lstat = lstat(self.path)
+ return self._lstat
+
+ # The code duplication below is intentional: this is for slightly
+ # better performance on systems that fall back to GenericDirEntry.
+ # It avoids an additional attribute lookup and method call, which
+ # are relatively slow on CPython.
+ def is_dir(self, follow_symlinks=True):
+ try:
+ st = self.stat(follow_symlinks=follow_symlinks)
+ except OSError as e:
+ if e.errno != ENOENT:
+ raise
+ return False # Path doesn't exist or is a broken symlink
+ return st.st_mode & 0o170000 == S_IFDIR
+
+ def is_file(self, follow_symlinks=True):
+ try:
+ st = self.stat(follow_symlinks=follow_symlinks)
+ except OSError as e:
+ if e.errno != ENOENT:
+ raise
+ return False # Path doesn't exist or is a broken symlink
+ return st.st_mode & 0o170000 == S_IFREG
+
+ def is_symlink(self):
+ try:
+ st = self.stat(follow_symlinks=False)
+ except OSError as e:
+ if e.errno != ENOENT:
+ raise
+ return False # Path doesn't exist or is a broken symlink
+ return st.st_mode & 0o170000 == S_IFLNK
+
+ def inode(self):
+ st = self.stat(follow_symlinks=False)
+ return st.st_ino
+
+ def __str__(self):
+ return '<{0}: {1!r}>'.format(self.__class__.__name__, self.name)
+
+ __repr__ = __str__
+
+
+def _scandir_generic(path=unicode('.')):
+ """Like os.listdir(), but yield DirEntry objects instead of returning
+ a list of names.
+ """
+ for name in listdir(path):
+ yield GenericDirEntry(path, name)
+
+
+if IS_PY3 and sys.platform == 'win32':
+ def scandir_generic(path=unicode('.')):
+ if isinstance(path, bytes):
+ raise TypeError("os.scandir() doesn't support bytes path on Windows, use Unicode instead")
+ return _scandir_generic(path)
+ scandir_generic.__doc__ = _scandir_generic.__doc__
+else:
+ scandir_generic = _scandir_generic
+
+
+scandir_c = None
+scandir_python = None
+
+
+if sys.platform == 'win32':
+ if ctypes is not None:
+ from ctypes import wintypes
+
+ # Various constants from windows.h
+ INVALID_HANDLE_VALUE = ctypes.c_void_p(-1).value
+ ERROR_FILE_NOT_FOUND = 2
+ ERROR_NO_MORE_FILES = 18
+ IO_REPARSE_TAG_SYMLINK = 0xA000000C
+
+ # Numer of seconds between 1601-01-01 and 1970-01-01
+ SECONDS_BETWEEN_EPOCHS = 11644473600
+
+ kernel32 = ctypes.windll.kernel32
+
+ # ctypes wrappers for (wide string versions of) FindFirstFile,
+ # FindNextFile, and FindClose
+ FindFirstFile = kernel32.FindFirstFileW
+ FindFirstFile.argtypes = [
+ wintypes.LPCWSTR,
+ ctypes.POINTER(wintypes.WIN32_FIND_DATAW),
+ ]
+ FindFirstFile.restype = wintypes.HANDLE
+
+ FindNextFile = kernel32.FindNextFileW
+ FindNextFile.argtypes = [
+ wintypes.HANDLE,
+ ctypes.POINTER(wintypes.WIN32_FIND_DATAW),
+ ]
+ FindNextFile.restype = wintypes.BOOL
+
+ FindClose = kernel32.FindClose
+ FindClose.argtypes = [wintypes.HANDLE]
+ FindClose.restype = wintypes.BOOL
+
+ Win32StatResult = collections.namedtuple('Win32StatResult', [
+ 'st_mode',
+ 'st_ino',
+ 'st_dev',
+ 'st_nlink',
+ 'st_uid',
+ 'st_gid',
+ 'st_size',
+ 'st_atime',
+ 'st_mtime',
+ 'st_ctime',
+ 'st_atime_ns',
+ 'st_mtime_ns',
+ 'st_ctime_ns',
+ 'st_file_attributes',
+ ])
+
+ def filetime_to_time(filetime):
+ """Convert Win32 FILETIME to time since Unix epoch in seconds."""
+ total = filetime.dwHighDateTime << 32 | filetime.dwLowDateTime
+ return total / 10000000 - SECONDS_BETWEEN_EPOCHS
+
+ def find_data_to_stat(data):
+ """Convert Win32 FIND_DATA struct to stat_result."""
+ # First convert Win32 dwFileAttributes to st_mode
+ attributes = data.dwFileAttributes
+ st_mode = 0
+ if attributes & FILE_ATTRIBUTE_DIRECTORY:
+ st_mode |= S_IFDIR | 0o111
+ else:
+ st_mode |= S_IFREG
+ if attributes & FILE_ATTRIBUTE_READONLY:
+ st_mode |= 0o444
+ else:
+ st_mode |= 0o666
+ if (attributes & FILE_ATTRIBUTE_REPARSE_POINT and
+ data.dwReserved0 == IO_REPARSE_TAG_SYMLINK):
+ st_mode ^= st_mode & 0o170000
+ st_mode |= S_IFLNK
+
+ st_size = data.nFileSizeHigh << 32 | data.nFileSizeLow
+ st_atime = filetime_to_time(data.ftLastAccessTime)
+ st_mtime = filetime_to_time(data.ftLastWriteTime)
+ st_ctime = filetime_to_time(data.ftCreationTime)
+
+ # Some fields set to zero per CPython's posixmodule.c: st_ino, st_dev,
+ # st_nlink, st_uid, st_gid
+ return Win32StatResult(st_mode, 0, 0, 0, 0, 0, st_size,
+ st_atime, st_mtime, st_ctime,
+ int(st_atime * 1000000000),
+ int(st_mtime * 1000000000),
+ int(st_ctime * 1000000000),
+ attributes)
+
+ class Win32DirEntryPython(object):
+ __slots__ = ('name', '_stat', '_lstat', '_find_data', '_scandir_path', '_path', '_inode')
+
+ def __init__(self, scandir_path, name, find_data):
+ self._scandir_path = scandir_path
+ self.name = name
+ self._stat = None
+ self._lstat = None
+ self._find_data = find_data
+ self._path = None
+ self._inode = None
+
+ @property
+ def path(self):
+ if self._path is None:
+ self._path = join(self._scandir_path, self.name)
+ return self._path
+
+ def stat(self, follow_symlinks=True):
+ if follow_symlinks:
+ if self._stat is None:
+ if self.is_symlink():
+ # It's a symlink, call link-following stat()
+ self._stat = stat(self.path)
+ else:
+ # Not a symlink, stat is same as lstat value
+ if self._lstat is None:
+ self._lstat = find_data_to_stat(self._find_data)
+ self._stat = self._lstat
+ return self._stat
+ else:
+ if self._lstat is None:
+ # Lazily convert to stat object, because it's slow
+ # in Python, and often we only need is_dir() etc
+ self._lstat = find_data_to_stat(self._find_data)
+ return self._lstat
+
+ def is_dir(self, follow_symlinks=True):
+ is_symlink = self.is_symlink()
+ if follow_symlinks and is_symlink:
+ try:
+ return self.stat().st_mode & 0o170000 == S_IFDIR
+ except OSError as e:
+ if e.errno != ENOENT:
+ raise
+ return False
+ elif is_symlink:
+ return False
+ else:
+ return (self._find_data.dwFileAttributes &
+ FILE_ATTRIBUTE_DIRECTORY != 0)
+
+ def is_file(self, follow_symlinks=True):
+ is_symlink = self.is_symlink()
+ if follow_symlinks and is_symlink:
+ try:
+ return self.stat().st_mode & 0o170000 == S_IFREG
+ except OSError as e:
+ if e.errno != ENOENT:
+ raise
+ return False
+ elif is_symlink:
+ return False
+ else:
+ return (self._find_data.dwFileAttributes &
+ FILE_ATTRIBUTE_DIRECTORY == 0)
+
+ def is_symlink(self):
+ return (self._find_data.dwFileAttributes &
+ FILE_ATTRIBUTE_REPARSE_POINT != 0 and
+ self._find_data.dwReserved0 == IO_REPARSE_TAG_SYMLINK)
+
+ def inode(self):
+ if self._inode is None:
+ self._inode = lstat(self.path).st_ino
+ return self._inode
+
+ def __str__(self):
+ return '<{0}: {1!r}>'.format(self.__class__.__name__, self.name)
+
+ __repr__ = __str__
+
+ def win_error(error, filename):
+ exc = WindowsError(error, ctypes.FormatError(error))
+ exc.filename = filename
+ return exc
+
+ def _scandir_python(path=unicode('.')):
+ """Like os.listdir(), but yield DirEntry objects instead of returning
+ a list of names.
+ """
+ # Call FindFirstFile and handle errors
+ if isinstance(path, bytes):
+ is_bytes = True
+ filename = join(path.decode('mbcs', 'strict'), '*.*')
+ else:
+ is_bytes = False
+ filename = join(path, '*.*')
+ data = wintypes.WIN32_FIND_DATAW()
+ data_p = ctypes.byref(data)
+ handle = FindFirstFile(filename, data_p)
+ if handle == INVALID_HANDLE_VALUE:
+ error = ctypes.GetLastError()
+ if error == ERROR_FILE_NOT_FOUND:
+ # No files, don't yield anything
+ return
+ raise win_error(error, path)
+
+ # Call FindNextFile in a loop, stopping when no more files
+ try:
+ while True:
+ # Skip '.' and '..' (current and parent directory), but
+ # otherwise yield (filename, stat_result) tuple
+ name = data.cFileName
+ if name not in ('.', '..'):
+ if is_bytes:
+ name = name.encode('mbcs', 'replace')
+ yield Win32DirEntryPython(path, name, data)
+
+ data = wintypes.WIN32_FIND_DATAW()
+ data_p = ctypes.byref(data)
+ success = FindNextFile(handle, data_p)
+ if not success:
+ error = ctypes.GetLastError()
+ if error == ERROR_NO_MORE_FILES:
+ break
+ raise win_error(error, path)
+ finally:
+ if not FindClose(handle):
+ raise win_error(ctypes.GetLastError(), path)
+
+ if IS_PY3:
+ def scandir_python(path=unicode('.')):
+ if isinstance(path, bytes):
+ raise TypeError("os.scandir() doesn't support bytes path on Windows, use Unicode instead")
+ return _scandir_python(path)
+ scandir_python.__doc__ = _scandir_python.__doc__
+ else:
+ scandir_python = _scandir_python
+
+ if _scandir is not None:
+ scandir_c = _scandir.scandir
+ DirEntry_c = _scandir.DirEntry
+
+ if _scandir is not None:
+ scandir = scandir_c
+ DirEntry = DirEntry_c
+ elif ctypes is not None:
+ scandir = scandir_python
+ DirEntry = Win32DirEntryPython
+ else:
+ scandir = scandir_generic
+ DirEntry = GenericDirEntry
+
+
+# Linux, OS X, and BSD implementation
+elif sys.platform.startswith(('linux', 'darwin', 'sunos5')) or 'bsd' in sys.platform:
+ have_dirent_d_type = (sys.platform != 'sunos5')
+
+ if ctypes is not None and have_dirent_d_type:
+ import ctypes.util
+
+ DIR_p = ctypes.c_void_p
+
+ # Rather annoying how the dirent struct is slightly different on each
+ # platform. The only fields we care about are d_name and d_type.
+ class Dirent(ctypes.Structure):
+ if sys.platform.startswith('linux'):
+ _fields_ = (
+ ('d_ino', ctypes.c_ulong),
+ ('d_off', ctypes.c_long),
+ ('d_reclen', ctypes.c_ushort),
+ ('d_type', ctypes.c_byte),
+ ('d_name', ctypes.c_char * 256),
+ )
+ elif 'openbsd' in sys.platform:
+ _fields_ = (
+ ('d_ino', ctypes.c_uint64),
+ ('d_off', ctypes.c_uint64),
+ ('d_reclen', ctypes.c_uint16),
+ ('d_type', ctypes.c_uint8),
+ ('d_namlen', ctypes.c_uint8),
+ ('__d_padding', ctypes.c_uint8 * 4),
+ ('d_name', ctypes.c_char * 256),
+ )
+ else:
+ _fields_ = (
+ ('d_ino', ctypes.c_uint32), # must be uint32, not ulong
+ ('d_reclen', ctypes.c_ushort),
+ ('d_type', ctypes.c_byte),
+ ('d_namlen', ctypes.c_byte),
+ ('d_name', ctypes.c_char * 256),
+ )
+
+ DT_UNKNOWN = 0
+ DT_DIR = 4
+ DT_REG = 8
+ DT_LNK = 10
+
+ Dirent_p = ctypes.POINTER(Dirent)
+ Dirent_pp = ctypes.POINTER(Dirent_p)
+
+ libc = ctypes.CDLL(ctypes.util.find_library('c'), use_errno=True)
+ opendir = libc.opendir
+ opendir.argtypes = [ctypes.c_char_p]
+ opendir.restype = DIR_p
+
+ readdir_r = libc.readdir_r
+ readdir_r.argtypes = [DIR_p, Dirent_p, Dirent_pp]
+ readdir_r.restype = ctypes.c_int
+
+ closedir = libc.closedir
+ closedir.argtypes = [DIR_p]
+ closedir.restype = ctypes.c_int
+
+ file_system_encoding = sys.getfilesystemencoding()
+
+ class PosixDirEntry(object):
+ __slots__ = ('name', '_d_type', '_stat', '_lstat', '_scandir_path', '_path', '_inode')
+
+ def __init__(self, scandir_path, name, d_type, inode):
+ self._scandir_path = scandir_path
+ self.name = name
+ self._d_type = d_type
+ self._inode = inode
+ self._stat = None
+ self._lstat = None
+ self._path = None
+
+ @property
+ def path(self):
+ if self._path is None:
+ self._path = join(self._scandir_path, self.name)
+ return self._path
+
+ def stat(self, follow_symlinks=True):
+ if follow_symlinks:
+ if self._stat is None:
+ if self.is_symlink():
+ self._stat = stat(self.path)
+ else:
+ if self._lstat is None:
+ self._lstat = lstat(self.path)
+ self._stat = self._lstat
+ return self._stat
+ else:
+ if self._lstat is None:
+ self._lstat = lstat(self.path)
+ return self._lstat
+
+ def is_dir(self, follow_symlinks=True):
+ if (self._d_type == DT_UNKNOWN or
+ (follow_symlinks and self.is_symlink())):
+ try:
+ st = self.stat(follow_symlinks=follow_symlinks)
+ except OSError as e:
+ if e.errno != ENOENT:
+ raise
+ return False
+ return st.st_mode & 0o170000 == S_IFDIR
+ else:
+ return self._d_type == DT_DIR
+
+ def is_file(self, follow_symlinks=True):
+ if (self._d_type == DT_UNKNOWN or
+ (follow_symlinks and self.is_symlink())):
+ try:
+ st = self.stat(follow_symlinks=follow_symlinks)
+ except OSError as e:
+ if e.errno != ENOENT:
+ raise
+ return False
+ return st.st_mode & 0o170000 == S_IFREG
+ else:
+ return self._d_type == DT_REG
+
+ def is_symlink(self):
+ if self._d_type == DT_UNKNOWN:
+ try:
+ st = self.stat(follow_symlinks=False)
+ except OSError as e:
+ if e.errno != ENOENT:
+ raise
+ return False
+ return st.st_mode & 0o170000 == S_IFLNK
+ else:
+ return self._d_type == DT_LNK
+
+ def inode(self):
+ return self._inode
+
+ def __str__(self):
+ return '<{0}: {1!r}>'.format(self.__class__.__name__, self.name)
+
+ __repr__ = __str__
+
+ def posix_error(filename):
+ errno = ctypes.get_errno()
+ exc = OSError(errno, strerror(errno))
+ exc.filename = filename
+ return exc
+
+ def scandir_python(path=unicode('.')):
+ """Like os.listdir(), but yield DirEntry objects instead of returning
+ a list of names.
+ """
+ if isinstance(path, bytes):
+ opendir_path = path
+ is_bytes = True
+ else:
+ opendir_path = path.encode(file_system_encoding)
+ is_bytes = False
+ dir_p = opendir(opendir_path)
+ if not dir_p:
+ raise posix_error(path)
+ try:
+ result = Dirent_p()
+ while True:
+ entry = Dirent()
+ if readdir_r(dir_p, entry, result):
+ raise posix_error(path)
+ if not result:
+ break
+ name = entry.d_name
+ if name not in (b'.', b'..'):
+ if not is_bytes:
+ name = name.decode(file_system_encoding)
+ yield PosixDirEntry(path, name, entry.d_type, entry.d_ino)
+ finally:
+ if closedir(dir_p):
+ raise posix_error(path)
+
+ if _scandir is not None:
+ scandir_c = _scandir.scandir
+ DirEntry_c = _scandir.DirEntry
+
+ if _scandir is not None:
+ scandir = scandir_c
+ DirEntry = DirEntry_c
+ elif ctypes is not None and have_dirent_d_type:
+ scandir = scandir_python
+ DirEntry = PosixDirEntry
+ else:
+ scandir = scandir_generic
+ DirEntry = GenericDirEntry
+
+
+# Some other system -- no d_type or stat information
+else:
+ scandir = scandir_generic
+ DirEntry = GenericDirEntry
+
+
+def _walk(top, topdown=True, onerror=None, followlinks=False):
+ """Like Python 3.5's implementation of os.walk() -- faster than
+ the pre-Python 3.5 version as it uses scandir() internally.
+ """
+ dirs = []
+ nondirs = []
+
+ # We may not have read permission for top, in which case we can't
+ # get a list of the files the directory contains. os.walk
+ # always suppressed the exception then, rather than blow up for a
+ # minor reason when (say) a thousand readable directories are still
+ # left to visit. That logic is copied here.
+ try:
+ scandir_it = scandir(top)
+ except OSError as error:
+ if onerror is not None:
+ onerror(error)
+ return
+
+ while True:
+ try:
+ try:
+ entry = next(scandir_it)
+ except StopIteration:
+ break
+ except OSError as error:
+ if onerror is not None:
+ onerror(error)
+ return
+
+ try:
+ is_dir = entry.is_dir()
+ except OSError:
+ # If is_dir() raises an OSError, consider that the entry is not
+ # a directory, same behaviour than os.path.isdir().
+ is_dir = False
+
+ if is_dir:
+ dirs.append(entry.name)
+ else:
+ nondirs.append(entry.name)
+
+ if not topdown and is_dir:
+ # Bottom-up: recurse into sub-directory, but exclude symlinks to
+ # directories if followlinks is False
+ if followlinks:
+ walk_into = True
+ else:
+ try:
+ is_symlink = entry.is_symlink()
+ except OSError:
+ # If is_symlink() raises an OSError, consider that the
+ # entry is not a symbolic link, same behaviour than
+ # os.path.islink().
+ is_symlink = False
+ walk_into = not is_symlink
+
+ if walk_into:
+ for entry in walk(entry.path, topdown, onerror, followlinks):
+ yield entry
+
+ # Yield before recursion if going top down
+ if topdown:
+ yield top, dirs, nondirs
+
+ # Recurse into sub-directories
+ for name in dirs:
+ new_path = join(top, name)
+ # Issue #23605: os.path.islink() is used instead of caching
+ # entry.is_symlink() result during the loop on os.scandir() because
+ # the caller can replace the directory entry during the "yield"
+ # above.
+ if followlinks or not islink(new_path):
+ for entry in walk(new_path, topdown, onerror, followlinks):
+ yield entry
+ else:
+ # Yield after recursion if going bottom up
+ yield top, dirs, nondirs
+
+
+if IS_PY3 or sys.platform != 'win32':
+ walk = _walk
+else:
+ # Fix for broken unicode handling on Windows on Python 2.x, see:
+ # https://github.com/benhoyt/scandir/issues/54
+ file_system_encoding = sys.getfilesystemencoding()
+
+ def walk(top, topdown=True, onerror=None, followlinks=False):
+ if isinstance(top, bytes):
+ top = top.decode(file_system_encoding)
+ return _walk(top, topdown, onerror, followlinks)
diff --git a/sickbeard/__init__.py b/sickbeard/__init__.py
index 8f88cb35..08622f4b 100755
--- a/sickbeard/__init__.py
+++ b/sickbeard/__init__.py
@@ -108,6 +108,7 @@ newznabProviderList = []
torrentRssProviderList = []
metadata_provider_dict = {}
+MODULE_UPDATE_STRING = None
NEWEST_VERSION_STRING = None
VERSION_NOTIFY = False
AUTO_UPDATE = False
@@ -572,7 +573,7 @@ def initialize(console_logging=True):
global __INITIALIZED__, showList, providerList, newznabProviderList, torrentRssProviderList, \
WEB_HOST, WEB_ROOT, ACTUAL_CACHE_DIR, CACHE_DIR, ZONEINFO_DIR, ADD_SHOWS_WO_DIR, CREATE_MISSING_SHOW_DIRS, \
RECENTSEARCH_STARTUP, NAMING_FORCE_FOLDERS, SOCKET_TIMEOUT, DEBUG, INDEXER_DEFAULT, CONFIG_FILE, \
- REMOVE_FILENAME_CHARS, IMPORT_DEFAULT_CHECKED_SHOWS, WANTEDLIST_CACHE
+ REMOVE_FILENAME_CHARS, IMPORT_DEFAULT_CHECKED_SHOWS, WANTEDLIST_CACHE, MODULE_UPDATE_STRING
# Schedulers
# global traktCheckerScheduler
global recentSearchScheduler, backlogSearchScheduler, showUpdateScheduler, \
@@ -1460,6 +1461,23 @@ def initialize(console_logging=True):
run_delay=datetime.timedelta(minutes=5),
threadName='PLEXWATCHEDSTATE')
+ try:
+ import _scandir
+ except ImportError:
+ _scandir = None
+
+ try:
+ import ctypes
+ except ImportError:
+ ctypes = None
+
+ if None is not _scandir and None is not ctypes and not getattr(_scandir, 'DirEntry', None):
+ MODULE_UPDATE_STRING = \
+ 'Your scandir binary module is outdated, using the slow but newer Python module.' \
+ '
Upgrade the binary at a command prompt with' \
+ ' # python -m pip install -U scandir' \
+ '
Important: You must Shutdown SickGear before upgrading'
+
__INITIALIZED__ = True
return True