monkee.ch/SickGear
1
0
Fork 0
mirror of https://github.com/SickGear/SickGear.git synced 2024-11-25 06:15:04 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'feature/ChangeRemoveEkEk' into dev

Browse source
This commit is contained in:
JackDandy 2023-02-12 16:30:25 +00:00
commit 8e21e8de7d
63 changed files with 962 additions and 1126 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
CHANGES.md
View file

@ -1,4 +1,9 @@
### 3.27.2 (2023-02-10 19:25:00 UTC)
### 3.28.0 (2023-xx-xx xx:xx:00 UTC)
* Change remove calls to legacy py2 fix encoding function
### 3.27.2 (2023-02-10 19:25:00 UTC)
* Fix revert update
* Fix installations that don't have previously saved cleanup lock files
@ -710,7 +715,7 @@
* Change allow Python 3.8.10 and 3.9.5
* Remove PiSexy provider
* Fix refreshShow, prevent another refresh of show if already in queue and not forced
* Fix refresh_show, prevent another refresh of show if already in queue and not forced
* Fix webapi set scene season
* Fix set path in all_tests for py2
* Fix webapi exception if no backlog was done before (CMD_SickGearCheckScheduler)

4
gui/slick/interfaces/default/home.tmpl
View file

@ -99,7 +99,7 @@
<div id="$cur_list_id" class="clearfix container" style="clear:both#if 'poster' == $layout#;padding:0#end if#">
<div class="posterview">
##
#for $curLoadingShow in $sickgear.show_queue_scheduler.action.loadingShowList
#for $curLoadingShow in $sickgear.show_queue_scheduler.action.loading_showlist
##
#if $curLoadingShow.show_obj != None and $curLoadingShow.show_obj in $sg_str('showList')
#continue
@ -292,7 +292,7 @@
</tfoot>
<tbody>
#for $curLoadingShow in $sickgear.show_queue_scheduler.action.loadingShowList
#for $curLoadingShow in $sickgear.show_queue_scheduler.action.loading_showlist
#if $curLoadingShow.show_obj != None and $curLoadingShow.show_obj in $sg_str('showList')
#continue
#end if

28
gui/slick/interfaces/default/manage.tmpl
View file

@ -188,37 +188,37 @@ $xsrf_form_html
#set $show_size = $max if not $show_loc else $get_size($show_loc)
#set $option_state = '<input type="checkbox"%s class="%s-check"%s>'
##
#set $curUpdate_disabled = $sickgear.show_queue_scheduler.action.isBeingUpdated($cur_show_obj)\
or $sickgear.show_queue_scheduler.action.isInUpdateQueue($cur_show_obj)
#set $curUpdate_disabled = $sickgear.show_queue_scheduler.action.is_being_updated($cur_show_obj)\
or $sickgear.show_queue_scheduler.action.is_in_update_queue($cur_show_obj)
#set $tip = ' title="Update%s"' % ('', $disabled_inprogress_tip)[$curUpdate_disabled]
#set $curUpdate = ($tip, $option_state % (('', $disabled)[$curUpdate_disabled], 'update', $tip))
##
#set $curRefresh_disabled = $sickgear.show_queue_scheduler.action.isBeingRefreshed($cur_show_obj)\
or $sickgear.show_queue_scheduler.action.isInRefreshQueue($cur_show_obj)
#set $curRefresh_disabled = $sickgear.show_queue_scheduler.action.is_being_refreshed($cur_show_obj)\
or $sickgear.show_queue_scheduler.action.is_in_refresh_queue($cur_show_obj)
#set $tip = ' title="Rescan%s"' % ('', $disabled_inprogress_tip)[$curRefresh_disabled]
#set $curRefresh = ($tip, $option_state % (('', $disabled)[$curRefresh_disabled], 'refresh', $tip))
##
#set $curRename_disabled = $sickgear.show_queue_scheduler.action.isBeingRenamed($cur_show_obj)\
or $sickgear.show_queue_scheduler.action.isInRenameQueue($cur_show_obj)
#set $curRename_disabled = $sickgear.show_queue_scheduler.action.is_being_renamed($cur_show_obj)\
or $sickgear.show_queue_scheduler.action.is_in_rename_queue($cur_show_obj)
#set $tip = ' title="Rename%s"' % ('', $disabled_inprogress_tip)[$curRename_disabled]
#set $curRename = ($tip, $option_state % (('', $disabled)[$curRename_disabled], 'rename', $tip))
##
#set $subtitles_disabled = not $cur_show_obj.subtitles\
or $sickgear.show_queue_scheduler.action.isBeingSubtitled($cur_show_obj)\
or $sickgear.show_queue_scheduler.action.isInSubtitleQueue($cur_show_obj)
or $sickgear.show_queue_scheduler.action.is_being_subtitled($cur_show_obj)\
or $sickgear.show_queue_scheduler.action.is_in_subtitle_queue($cur_show_obj)
#set $tip = (' title="Search subtitle"', (' title="Search subtitle%s"' % $disabled_inprogress_tip,
$disabled_subtitles_tip)[not $cur_show_obj.subtitles])[$subtitles_disabled]
#set $curSubtitle = ($tip, $option_state % (('', $disabled)[$subtitles_disabled], 'subtitle', $tip))
##
#set $curDelete_disabled = $sickgear.show_queue_scheduler.action.isBeingRenamed($cur_show_obj)\
or $sickgear.show_queue_scheduler.action.isInRenameQueue($cur_show_obj)\
or $sickgear.show_queue_scheduler.action.isInRefreshQueue($cur_show_obj)
#set $curDelete_disabled = $sickgear.show_queue_scheduler.action.is_being_renamed($cur_show_obj)\
or $sickgear.show_queue_scheduler.action.is_in_rename_queue($cur_show_obj)\
or $sickgear.show_queue_scheduler.action.is_in_refresh_queue($cur_show_obj)
#set $tip = ' title="Delete%s"' % ('', $disabled_inprogress_tip)[$curDelete_disabled]
#set $curDelete = ($tip, $option_state % (('', $disabled)[$curDelete_disabled], 'delete', $tip))
##
#set $curRemove_disabled = $sickgear.show_queue_scheduler.action.isBeingRenamed($cur_show_obj)\
or $sickgear.show_queue_scheduler.action.isInRenameQueue($cur_show_obj)\
or $sickgear.show_queue_scheduler.action.isInRefreshQueue($cur_show_obj)
#set $curRemove_disabled = $sickgear.show_queue_scheduler.action.is_being_renamed($cur_show_obj)\
or $sickgear.show_queue_scheduler.action.is_in_rename_queue($cur_show_obj)\
or $sickgear.show_queue_scheduler.action.is_in_refresh_queue($cur_show_obj)
#set $tip = ' title="Remove%s"' % ('', $disabled_inprogress_tip)[$curRemove_disabled]
#set $curRemove = ($tip, $option_state % (('', $disabled)[$curRemove_disabled], 'remove', $tip))
<tr data-tvid_prodid="$cur_show_obj.tvid_prodid" data-size="$show_size">

8
lib/dateutil/zoneinfo/__init__.py
View file

@ -9,8 +9,6 @@ from io import BytesIO
from dateutil.tz import tzfile as _tzfile
# noinspection PyPep8Naming
import encodingKludge as ek
import sickgear
__all__ = ["get_zonefile_instance", "gettz", "gettz_db_metadata"]
@ -27,10 +25,10 @@ class tzfile(_tzfile):
def getzoneinfofile_stream():
try:
# return BytesIO(get_data(__name__, ZONEFILENAME))
zonefile = ek.ek(os.path.join, sickgear.ZONEINFO_DIR, ZONEFILENAME)
if not ek.ek(os.path.isfile, zonefile):
zonefile = os.path.join(sickgear.ZONEINFO_DIR, ZONEFILENAME)
if not os.path.isfile(zonefile):
warnings.warn('Falling back to included zoneinfo file')
zonefile = ek.ek(os.path.join, ek.ek(os.path.dirname, __file__), ZONEFILENAME)
zonefile = os.path.join(os.path.dirname(__file__), ZONEFILENAME)
with open(zonefile, 'rb') as f:
return BytesIO(f.read())
except IOError as e: # TODO switch to FileNotFoundError?

3
lib/encodingKludge.py
View file

@ -39,7 +39,6 @@ def set_sys_encoding():
:return: The encoding that is set
"""
sys_encoding = None
should_exit = False
try:
locale.setlocale(locale.LC_ALL, '')
@ -48,7 +47,7 @@ def set_sys_encoding():
try:
sys_encoding = locale.getpreferredencoding()
except (locale.Error, IOError):
pass
sys_encoding = None
# For OSes that are poorly configured I'll just randomly force UTF-8
if not sys_encoding or sys_encoding in ('ANSI_X3.4-1968', 'US-ASCII', 'ASCII'):

81
lib/exceptions_helper.py
View file

@ -16,9 +16,6 @@
from six import PY2, string_types
if PY2:
from encodingKludge import fixStupidEncodings
# noinspection PyUnreachableCode
if False:
from typing import AnyStr
@ -28,128 +25,100 @@ def ex(e):
# type: (BaseException) -> AnyStr
"""Returns a unicode string from the exception text if it exists"""
if not PY2:
return str(e)
e_message = u''
if not e or not e.args:
return e_message
for arg in e.args:
if None is not arg:
if isinstance(arg, string_types):
fixed_arg = fixStupidEncodings(arg, True)
else:
try:
fixed_arg = u'error ' + fixStupidEncodings(str(arg), True)
except (BaseException, Exception):
fixed_arg = None
if fixed_arg:
if not e_message:
e_message = fixed_arg
else:
e_message = e_message + ' : ' + fixed_arg
return e_message
return str(e)
class SickBeardException(Exception):
class SickGearException(Exception):
"""Generic SickGear Exception - should never be thrown, only subclassed"""
class ConfigErrorException(SickBeardException):
class ConfigErrorException(SickGearException):
"""Error in the config file"""
class LaterException(SickBeardException):
class LaterException(SickGearException):
"""Something bad happened that I'll make a real exception for later"""
class NoNFOException(SickBeardException):
class NoNFOException(SickGearException):
"""No NFO was found!"""
class NoShowDirException(SickBeardException):
class NoShowDirException(SickGearException):
"""Unable to find the show's directory"""
class FileNotFoundException(SickBeardException):
class FileNotFoundException(SickGearException):
"""The specified file doesn't exist"""
class MultipleDBEpisodesException(SickBeardException):
class MultipleDBEpisodesException(SickGearException):
"""Found multiple episodes in the DB! Must fix DB first"""
class MultipleDBShowsException(SickBeardException):
class MultipleDBShowsException(SickGearException):
"""Found multiple shows in the DB! Must fix DB first"""
class MultipleShowObjectsException(SickBeardException):
class MultipleShowObjectsException(SickGearException):
"""Found multiple objects for the same show! Something is very wrong"""
class WrongShowException(SickBeardException):
class WrongShowException(SickGearException):
"""The episode doesn't belong to the same show as its parent folder"""
class ShowNotFoundException(SickBeardException):
class ShowNotFoundException(SickGearException):
"""The show wasn't found on the Indexer"""
class EpisodeNotFoundException(SickBeardException):
class EpisodeNotFoundException(SickGearException):
"""The episode wasn't found on the Indexer"""
class ShowDirNotFoundException(SickBeardException):
class ShowDirNotFoundException(SickGearException):
"""The show dir doesn't exist"""
class AuthException(SickBeardException):
class AuthException(SickGearException):
"""Your authentication information is incorrect"""
class EpisodeDeletedException(SickBeardException):
class EpisodeDeletedException(SickGearException):
"""This episode has been deleted"""
class CantRefreshException(SickBeardException):
class CantRefreshException(SickGearException):
"""The show can't be refreshed right now"""
class CantUpdateException(SickBeardException):
class CantUpdateException(SickGearException):
"""The show can't be updated right now"""
class CantSwitchException(SickBeardException):
class CantSwitchException(SickGearException):
"""The show can't be switched right now"""
class PostProcessingFailed(SickBeardException):
class PostProcessingFailed(SickGearException):
"""Post-processing the episode failed"""
class FailedProcessingFailed(SickBeardException):
class FailedProcessingFailed(SickGearException):
"""Post-processing the failed release failed"""
class FailedHistoryMultiSnatchException(SickBeardException):
class FailedHistoryMultiSnatchException(SickGearException):
"""Episode was snatched again before the first one was done"""
class FailedHistoryNotFoundException(SickBeardException):
class FailedHistoryNotFoundException(SickGearException):
"""The release was not found in the failed download history tracker"""
class EpisodeNotFoundByAbsoluteNumberException(SickBeardException):
class EpisodeNotFoundByAbsoluteNumberException(SickGearException):
"""The show wasn't found in the DB while looking at Absolute Numbers"""
class ConnectionSkipException(SickBeardException):
class ConnectionSkipException(SickGearException):
"""Connection was skipped because of previous errors"""

3
lib/imdbpie/auth.py
View file

@ -265,9 +265,8 @@ class Auth(object):
except ValueError as e:
if not retry:
cache.close()
import encodingKludge as ek
import os
ek.ek(os.remove, ek.ek(os.path.join, self._cachedir, diskcache.core.DBNAME))
os.remove(os.path.join(self._cachedir, diskcache.core.DBNAME))
return self._get_creds(retry=True)
else:
raise e

95
lib/sg_helpers.py
View file

@ -32,7 +32,7 @@ from cfscrape import CloudflareScraper
from send2trash import send2trash
# noinspection PyPep8Naming
import encodingKludge as ek
from encodingKludge import SYS_ENCODING
import requests
from _23 import decode_bytes, filter_list, html_unescape, list_range, \
@ -65,7 +65,7 @@ if False:
html_convert_fractions = {0: '', 25: '&frac14;', 50: '&frac12;', 75: '&frac34;', 100: 1}
PROG_DIR = ek.ek(os.path.join, os.path.dirname(os.path.normpath(os.path.abspath(__file__))), '..')
PROG_DIR = os.path.join(os.path.dirname(os.path.normpath(os.path.abspath(__file__))), '..')
# Mapping error status codes to official W3C names
http_error_code = {
@ -676,9 +676,9 @@ def get_system_temp_dir():
try:
uid = getpass.getuser()
except ImportError:
return ek.ek(os.path.join, tempfile.gettempdir(), 'SickGear')
return os.path.join(tempfile.gettempdir(), 'SickGear')
return ek.ek(os.path.join, tempfile.gettempdir(), 'SickGear-%s' % uid)
return os.path.join(tempfile.gettempdir(), 'SickGear-%s' % uid)
def proxy_setting(setting, request_url, force=False):
@ -834,7 +834,7 @@ def get_url(url, # type: AnyStr
if not kwargs.pop('nocache', False):
cache_dir = CACHE_DIR or get_system_temp_dir()
session = CacheControl(sess=session, cache=caches.FileCache(ek.ek(os.path.join, cache_dir, 'sessions')))
session = CacheControl(sess=session, cache=caches.FileCache(os.path.join(cache_dir, 'sessions')))
provider = kwargs.pop('provider', None)
@ -1065,11 +1065,11 @@ def scantree(path, # type: AnyStr
:param filter_kind: None to yield everything, True yields directories, False yields files
:param recurse: Recursively scan the tree
"""
if isinstance(path, string_types) and path and ek.ek(os.path.isdir, path):
if isinstance(path, string_types) and path and os.path.isdir(path):
rc_exc, rc_inc = [re.compile(rx % '|'.join(
[x for x in (param, ([param], [])[None is param])[not isinstance(param, list)]]))
for rx, param in ((r'(?i)^(?:(?!%s).)*$', exclude), (r'(?i)%s', include))]
for entry in ek.ek(scandir, path):
for entry in scandir(path):
is_dir = entry.is_dir(follow_symlinks=follow_symlinks)
is_file = entry.is_file(follow_symlinks=follow_symlinks)
no_filter = any([None is filter_kind, filter_kind and is_dir, not filter_kind and is_file])
@ -1084,25 +1084,25 @@ def scantree(path, # type: AnyStr
def copy_file(src_file, dest_file):
if os.name.startswith('posix'):
ek.ek(subprocess.call, ['cp', src_file, dest_file])
subprocess.call(['cp', src_file, dest_file])
else:
ek.ek(shutil.copyfile, src_file, dest_file)
shutil.copyfile(src_file, dest_file)
try:
ek.ek(shutil.copymode, src_file, dest_file)
shutil.copymode(src_file, dest_file)
except OSError:
pass
def move_file(src_file, dest_file, raise_exceptions=False):
try:
ek.ek(shutil.move, src_file, dest_file)
shutil.move(src_file, dest_file)
fix_set_group_id(dest_file)
except OSError:
copy_file(src_file, dest_file)
if ek.ek(os.path.exists, dest_file):
if os.path.exists(dest_file):
fix_set_group_id(dest_file)
ek.ek(os.unlink, src_file)
os.unlink(src_file)
elif raise_exceptions:
raise OSError('Destination file could not be created: %s' % dest_file)
@ -1118,13 +1118,13 @@ def fix_set_group_id(child_path):
if os.name in ('nt', 'ce'):
return
parent_path = ek.ek(os.path.dirname, child_path)
parent_stat = ek.ek(os.stat, parent_path)
parent_path = os.path.dirname(child_path)
parent_stat = os.stat(parent_path)
parent_mode = stat.S_IMODE(parent_stat[stat.ST_MODE])
if parent_mode & stat.S_ISGID:
parent_gid = parent_stat[stat.ST_GID]
child_stat = ek.ek(os.stat, child_path)
child_stat = os.stat(child_path)
child_gid = child_stat[stat.ST_GID]
if child_gid == parent_gid:
@ -1138,7 +1138,7 @@ def fix_set_group_id(child_path):
return
try:
ek.ek(os.chown, child_path, -1, parent_gid) # only available on UNIX
os.chown(child_path, -1, parent_gid) # only available on UNIX
logger.debug(u'Respecting the set-group-ID bit on the parent directory for %s' % child_path)
except OSError:
logger.error(u'Failed to respect the set-group-id bit on the parent directory for %s (setting group id %i)'
@ -1154,11 +1154,11 @@ def remove_file_perm(filepath, log_err=True):
:param log_err: False to suppress log msgs
:return True if filepath does not exist else None if no removal
"""
if not ek.ek(os.path.exists, filepath):
if not os.path.exists(filepath):
return True
for t in list_range(10): # total seconds to wait 0 - 9 = 45s over 10 iterations
try:
ek.ek(os.remove, filepath)
os.remove(filepath)
except OSError as e:
if getattr(e, 'winerror', 0) not in (5, 32): # 5=access denied (e.g. av), 32=another process has lock
if log_err:
@ -1167,7 +1167,7 @@ def remove_file_perm(filepath, log_err=True):
except (BaseException, Exception):
pass
time.sleep(t)
if not ek.ek(os.path.exists, filepath):
if not os.path.exists(filepath):
return True
if log_err:
logger.warning('Unable to delete %s' % filepath)
@ -1195,11 +1195,11 @@ def remove_file(filepath, tree=False, prefix_failure='', log_level=logging.INFO)
result = 'Deleted'
if TRASH_REMOVE_SHOW:
result = 'Trashed'
ek.ek(send2trash, filepath)
send2trash(filepath)
elif tree:
ek.ek(shutil.rmtree, filepath)
shutil.rmtree(filepath)
else:
ek.ek(os.remove, filepath)
os.remove(filepath)
except OSError as e:
if getattr(e, 'winerror', 0) not in (5, 32): # 5=access denied (e.g. av), 32=another process has lock
logger.log(level=log_level, msg=u'%sUnable to %s %s %s: %s' %
@ -1207,10 +1207,10 @@ def remove_file(filepath, tree=False, prefix_failure='', log_level=logging.INFO)
('file', 'dir')[tree], filepath, ex(e)))
break
time.sleep(t)
if not ek.ek(os.path.exists, filepath):
if not os.path.exists(filepath):
break
return (None, result)[filepath and not ek.ek(os.path.exists, filepath)]
return (None, result)[filepath and not os.path.exists(filepath)]
def touch_file(name, atime=None, dir_name=None):
@ -1224,9 +1224,9 @@ def touch_file(name, atime=None, dir_name=None):
:return: success
"""
if None is not dir_name:
name = ek.ek(os.path.join, dir_name, name)
name = os.path.join(dir_name, name)
if make_path(dir_name):
if not ek.ek(os.path.exists, name):
if not os.path.exists(name):
with io.open(name, 'w') as fh:
fh.flush()
if None is atime:
@ -1235,7 +1235,7 @@ def touch_file(name, atime=None, dir_name=None):
if None is not atime:
try:
with open(name, 'a'):
ek.ek(os.utime, name, (atime, atime))
os.utime(name, (atime, atime))
return True
except (BaseException, Exception):
logger.debug('File air date stamping not available on your OS')
@ -1253,12 +1253,12 @@ def make_path(name, syno=False):
:param syno: whether to trigger a syno library update for path
:return: success or dir exists
"""
if not ek.ek(os.path.isdir, name):
if not os.path.isdir(name):
# Windows, create all missing folders
if os.name in ('nt', 'ce'):
try:
logger.debug(u'Path %s doesn\'t exist, creating it' % name)
ek.ek(os.makedirs, name)
os.makedirs(name)
except (OSError, IOError) as e:
logger.error(u'Failed creating %s : %s' % (name, ex(e)))
return False
@ -1273,14 +1273,14 @@ def make_path(name, syno=False):
sofar += cur_folder + os.path.sep
# if it exists then just keep walking down the line
if ek.ek(os.path.isdir, sofar):
if os.path.isdir(sofar):
continue
try:
logger.debug(u'Path %s doesn\'t exist, creating it' % sofar)
ek.ek(os.mkdir, sofar)
os.mkdir(sofar)
# use normpath to remove end separator, otherwise checks permissions against itself
chmod_as_parent(ek.ek(os.path.normpath, sofar))
chmod_as_parent(os.path.normpath(sofar))
if syno:
# do the library update for synoindex
NOTIFIERS.NotifierFactory().get('SYNOINDEX').addFolder(sofar)
@ -1302,19 +1302,19 @@ def chmod_as_parent(child_path):
if os.name in ('nt', 'ce'):
return
parent_path = ek.ek(os.path.dirname, child_path)
parent_path = os.path.dirname(child_path)
if not parent_path:
logger.debug(u'No parent path provided in %s, unable to get permissions from it' % child_path)
return
parent_path_stat = ek.ek(os.stat, parent_path)
parent_path_stat = os.stat(parent_path)
parent_mode = stat.S_IMODE(parent_path_stat[stat.ST_MODE])
child_path_stat = ek.ek(os.stat, child_path)
child_path_stat = os.stat(child_path)
child_path_mode = stat.S_IMODE(child_path_stat[stat.ST_MODE])
if ek.ek(os.path.isfile, child_path):
if os.path.isfile(child_path):
child_mode = file_bit_filter(parent_mode)
else:
child_mode = parent_mode
@ -1330,7 +1330,7 @@ def chmod_as_parent(child_path):
return
try:
ek.ek(os.chmod, child_path, child_mode)
os.chmod(child_path, child_mode)
logger.debug(u'Setting permissions for %s to %o as parent directory has %o'
% (child_path, child_mode, parent_mode))
except OSError:
@ -1366,17 +1366,17 @@ def write_file(filepath, # type: AnyStr
"""
result = False
if make_path(ek.ek(os.path.dirname, filepath)):
if make_path(os.path.dirname(filepath)):
try:
if raw:
empty_file = True
with ek.ek(io.FileIO, filepath, 'wb') as fh:
with io.FileIO(filepath, 'wb') as fh:
for chunk in data.iter_content(chunk_size=1024):
if chunk:
empty_file = False
fh.write(chunk)
fh.flush()
ek.ek(os.fsync, fh.fileno())
os.fsync(fh.fileno())
if empty_file:
remove_file_perm(filepath, log_err=False)
return result
@ -1384,11 +1384,11 @@ def write_file(filepath, # type: AnyStr
w_mode = 'w'
if utf8:
w_mode = 'a'
with ek.ek(io.FileIO, filepath, 'wb') as fh:
with io.FileIO(filepath, 'wb') as fh:
fh.write(codecs.BOM_UTF8)
if xmltree:
with ek.ek(io.FileIO, filepath, w_mode) as fh:
with io.FileIO(filepath, w_mode) as fh:
params = {}
if utf8:
params = dict(encoding='utf-8')
@ -1397,10 +1397,10 @@ def write_file(filepath, # type: AnyStr
data.write(fh, **params)
else:
if isinstance(data, text_type):
with ek.ek(io.open, filepath, w_mode, encoding='utf-8') as fh:
with io.open(filepath, w_mode, encoding='utf-8') as fh:
fh.write(data)
else:
with ek.ek(io.FileIO, filepath, w_mode) as fh:
with io.FileIO(filepath, w_mode) as fh:
fh.write(data)
chmod_as_parent(filepath)
@ -1451,7 +1451,7 @@ def replace_extension(filename, new_ext):
def long_path(path):
# type: (AnyStr) -> AnyStr
"""add long path prefix for Windows"""
if 'nt' == os.name and 260 < len(path) and not path.startswith('\\\\?\\') and ek.ek(os.path.isabs, path):
if 'nt' == os.name and 260 < len(path) and not path.startswith('\\\\?\\') and os.path.isabs(path):
return '\\\\?\\' + path
return path
@ -1504,8 +1504,7 @@ def cmdline_runner(cmd, shell=False, suppress_stderr=False, env=None):
if isinstance(env, dict):
kw.update(env=dict(os.environ, **env))
if not PY2:
kw.update(dict(encoding=ek.SYS_ENCODING, text=True, bufsize=0))
kw.update(dict(encoding=SYS_ENCODING, text=True, bufsize=0))
if 'win32' == sys.platform:
kw['creationflags'] = 0x08000000 # CREATE_NO_WINDOW (needed for py2exe)

7
lib/subliminal/videos.py
View file

@ -29,9 +29,6 @@ import struct
from six import PY2, text_type
from _23 import decode_str
# noinspection PyPep8Naming
import encodingKludge as ek
__all__ = ['EXTENSIONS', 'MIMETYPES', 'Video', 'Episode', 'Movie', 'UnknownVideo',
'scan', 'hash_opensubtitles', 'hash_thesubdb']
@ -150,8 +147,8 @@ class Video(object):
folder = '.'
existing = [f for f in os.listdir(folder) if f.startswith(basename)]
if self.subtitle_path:
subsDir = ek.ek(os.path.join, folder, self.subtitle_path)
if ek.ek(os.path.isdir, subsDir):
subsDir = os.path.join(folder, self.subtitle_path)
if os.path.isdir(subsDir):
existing.extend([f for f in os.listdir(subsDir) if f.startswith(basename)])
for path in existing:
for ext in subtitles.EXTENSIONS:

6
sickgear.py
View file

@ -90,7 +90,7 @@ from multiprocessing import freeze_support
from configobj import ConfigObj
# noinspection PyPep8Naming
from encodingKludge import EXIT_BAD_ENCODING, SYS_ENCODING
from encodingKludge import SYS_ENCODING
from exceptions_helper import ex
import sickgear
from sickgear import db, logger, name_cache, network_timezones
@ -200,10 +200,6 @@ class SickGear(object):
sickgear.PROG_DIR = os.path.dirname(sickgear.MY_FULLNAME)
sickgear.DATA_DIR = sickgear.PROG_DIR
sickgear.MY_ARGS = sys.argv[1:]
if EXIT_BAD_ENCODING:
print('Sorry, you MUST add the SickGear folder to the PYTHONPATH environment variable')
print('or find another way to force Python to use %s for string encoding.' % SYS_ENCODING)
sys.exit(1)
sickgear.SYS_ENCODING = SYS_ENCODING
legacy_runner = globals().get('_legacy_sickgear_runner')
if not legacy_runner:

18
sickgear/__init__.py
View file

@ -34,8 +34,6 @@ import threading
import uuid
import zlib
# noinspection PyPep8Naming
import encodingKludge as ek
from . import classes, db, helpers, image_cache, indexermapper, logger, metadata, naming, people_queue, providers, \
scene_exceptions, scene_numbering, scheduler, search_backlog, search_propers, search_queue, search_recent, \
show_queue, show_updater, subtitles, trakt_helpers, traktChecker, version_checker, watchedstate_queue
@ -513,7 +511,7 @@ ANIDB_USE_MYLIST = False
ADBA_CONNECTION = None # type: Connection
ANIME_TREAT_AS_HDTV = False
GUI_NAME = None
GUI_NAME = ''
DEFAULT_HOME = None
FANART_LIMIT = None
FANART_PANEL = None
@ -811,8 +809,8 @@ def init_stage_1(console_logging):
# clean cache folders
if CACHE_DIR:
helpers.clear_cache()
ZONEINFO_DIR = ek.ek(os.path.join, CACHE_DIR, 'zoneinfo')
if not ek.ek(os.path.isdir, ZONEINFO_DIR) and not helpers.make_path(ZONEINFO_DIR):
ZONEINFO_DIR = os.path.join(CACHE_DIR, 'zoneinfo')
if not os.path.isdir(ZONEINFO_DIR) and not helpers.make_path(ZONEINFO_DIR):
logger.log(u'!!! Creating local zoneinfo dir failed', logger.ERROR)
sg_helpers.CACHE_DIR = CACHE_DIR
sg_helpers.DATA_DIR = DATA_DIR
@ -1054,8 +1052,8 @@ def init_stage_1(console_logging):
NZBGET_SKIP_PM = bool(check_setting_int(CFG, 'NZBGet', 'nzbget_skip_process_media', 0))
try:
ng_script_file = ek.ek(os.path.join, ek.ek(os.path.dirname, ek.ek(os.path.dirname, __file__)),
'autoProcessTV', 'SickGear-NG', 'SickGear-NG.py')
ng_script_file = os.path.join(os.path.dirname(os.path.dirname(__file__)),
'autoProcessTV', 'SickGear-NG', 'SickGear-NG.py')
with io.open(ng_script_file, 'r', encoding='utf8') as ng:
text = ng.read()
NZBGET_SCRIPT_VERSION = re.search(r""".*version: (\d+\.\d+)""", text, flags=re.M).group(1)
@ -1615,7 +1613,7 @@ def init_stage_2():
cycleTime=datetime.timedelta(hours=1),
start_time=datetime.time(hour=SHOW_UPDATE_HOUR),
threadName='SHOWUPDATER',
prevent_cycle_run=show_queue_scheduler.action.isShowUpdateRunning) # 3AM
prevent_cycle_run=show_queue_scheduler.action.is_show_update_running) # 3AM
people_queue_scheduler = scheduler.Scheduler(
people_queue.PeopleQueue(),
@ -1718,9 +1716,9 @@ def init_stage_2():
MEMCACHE['history_tab'] = History.menu_tab(MEMCACHE['history_tab_limit'])
try:
for f in ek.ek(scandir, ek.ek(os.path.join, PROG_DIR, 'gui', GUI_NAME, 'images', 'flags')):
for f in scandir(os.path.join(PROG_DIR, 'gui', GUI_NAME, 'images', 'flags')):
if f.is_file():
MEMCACHE_FLAG_IMAGES[ek.ek(os.path.splitext, f.name)[0].lower()] = True
MEMCACHE_FLAG_IMAGES[os.path.splitext(f.name)[0].lower()] = True
except (BaseException, Exception):
pass

4
sickgear/anime.py
View file

@ -19,8 +19,6 @@ import os
import adba
from adba.aniDBresponses import LoginFirstResponse
# noinspection PyPep8Naming
import encodingKludge as ek
from exceptions_helper import ex
import sickgear
@ -182,7 +180,7 @@ def short_group_names(groups):
def anidb_cache_dir():
# type: (...) -> Optional[AnyStr]
cache_dir = ek.ek(os.path.join, sickgear.CACHE_DIR or get_system_temp_dir(), 'anidb')
cache_dir = os.path.join(sickgear.CACHE_DIR or get_system_temp_dir(), 'anidb')
if not make_path(cache_dir):
cache_dir = None
return cache_dir

7
sickgear/auto_post_processer.py
View file

@ -16,9 +16,6 @@
import os.path
# noinspection PyPep8Naming
import encodingKludge as ek
import sickgear
from . import logger, processTV
@ -40,12 +37,12 @@ class PostProcesser(object):
@staticmethod
def _main():
if not ek.ek(os.path.isdir, sickgear.TV_DOWNLOAD_DIR):
if not os.path.isdir(sickgear.TV_DOWNLOAD_DIR):
logger.log(u"Automatic post-processing attempted but dir %s doesn't exist" % sickgear.TV_DOWNLOAD_DIR,
logger.ERROR)
return
if not ek.ek(os.path.isabs, sickgear.TV_DOWNLOAD_DIR):
if not os.path.isabs(sickgear.TV_DOWNLOAD_DIR):
logger.log(u'Automatic post-processing attempted but dir %s is relative '
'(and probably not what you really want to process)' % sickgear.TV_DOWNLOAD_DIR, logger.ERROR)
return

27
sickgear/browser.py
View file

@ -17,8 +17,6 @@
import os
import string
# noinspection PyPep8Naming
import encodingKludge as ek
from exceptions_helper import ex
from . import logger
@ -31,7 +29,7 @@ if 'nt' == os.name:
# adapted from
# http://stackoverflow.com/questions/827371/is-there-a-way-to-list-all-the-available-drive-letters-in-python/827490
def getWinDrives():
def get_win_drives():
""" Return list of detected drives """
assert 'nt' == os.name
@ -45,15 +43,6 @@ def getWinDrives():
return drives
def foldersAtPath(path, include_parent=False, include_files=False, **kwargs):
""" deprecated_item, remove in 2020 """
""" prevent issues with requests using legacy params """
include_parent = include_parent or kwargs.get('includeParent') or False
include_files = include_files or kwargs.get('includeFiles') or False
""" /legacy """
return folders_at_path(path, include_parent, include_files)
def folders_at_path(path, include_parent=False, include_files=False):
""" Returns a list of dictionaries with the folders contained at the given path
Give the empty string as the path to list the contents of the root path
@ -61,17 +50,17 @@ def folders_at_path(path, include_parent=False, include_files=False):
"""
# walk up the tree until we find a valid path
while path and not ek.ek(os.path.isdir, path):
if path == ek.ek(os.path.dirname, path):
while path and not os.path.isdir(path):
if path == os.path.dirname(path):
path = ''
break
else:
path = ek.ek(os.path.dirname, path)
path = os.path.dirname(path)
if '' == path:
if 'nt' == os.name:
entries = [{'currentPath': r'\My Computer'}]
for letter in getWinDrives():
for letter in get_win_drives():
letter_path = '%s:\\' % letter
entries.append({'name': letter_path, 'path': letter_path})
return entries
@ -79,8 +68,8 @@ def folders_at_path(path, include_parent=False, include_files=False):
path = '/'
# fix up the path and find the parent
path = ek.ek(os.path.abspath, ek.ek(os.path.normpath, path))
parent_path = ek.ek(os.path.dirname, path)
path = os.path.abspath(os.path.normpath(path))
parent_path = os.path.dirname(path)
# if we're at the root then the next step is the meta-node showing our drive letters
if 'nt' == os.name and path == parent_path:
@ -92,7 +81,7 @@ def folders_at_path(path, include_parent=False, include_files=False):
logger.log('Unable to open %s: %r / %s' % (path, e, ex(e)), logger.WARNING)
file_list = get_file_list(parent_path, include_files)
file_list = sorted(file_list, key=lambda x: ek.ek(os.path.basename, x['name']).lower())
file_list = sorted(file_list, key=lambda x: os.path.basename(x['name']).lower())
entries = [{'currentPath': path}]
if include_parent and path != parent_path:

14
sickgear/common.py
View file

@ -240,9 +240,7 @@ class Quality(object):
:rtype: int
"""
# noinspection PyPep8Naming
import encodingKludge as ek
name = ek.ek(os.path.basename, name)
name = os.path.basename(name)
# if we have our exact text then assume we put it there
for _x in sorted(iterkeys(Quality.qualityStrings), reverse=True):
@ -268,10 +266,8 @@ class Quality(object):
:return:
:rtype: int
"""
# noinspection PyPep8Naming
import encodingKludge as ek
from sickgear import logger
name = ek.ek(os.path.basename, name)
name = os.path.basename(name)
name_has = (lambda quality_list, func=all: func([re.search(q, name, re.I) for q in quality_list]))
@ -359,11 +355,9 @@ class Quality(object):
:return:
:rtype: int
"""
# noinspection PyPep8Naming
import encodingKludge as ek
from exceptions_helper import ex
from sickgear import logger
if ek.ek(os.path.isfile, filename):
if os.path.isfile(filename):
from hachoir.parser import createParser
from hachoir.metadata import extractMetadata
@ -372,7 +366,7 @@ class Quality(object):
parser = height = None
msg = 'Hachoir can\'t parse file "%s" content quality because it found error: %s'
try:
parser = ek.ek(createParser, filename)
parser = createParser(filename)
except InputStreamError as e:
logger.log(msg % (filename, ex(e)), logger.WARNING)
except (BaseException, Exception) as e:

9
sickgear/config.py
View file

@ -18,9 +18,6 @@ import datetime
import os.path
import re
# noinspection PyPep8Naming
import encodingKludge as ek
import sickgear
import sickgear.providers
from . import db, helpers, logger, naming
@ -360,7 +357,7 @@ def clean_url(url, add_slash=True):
scheme, netloc, path, query, fragment = urlsplit(url, 'http')
if not path.endswith('/'):
basename, ext = ek.ek(os.path.splitext, ek.ek(os.path.basename, path))
basename, ext = os.path.splitext(os.path.basename(path))
if not ext and add_slash:
path += '/'
@ -857,14 +854,14 @@ class ConfigMigrator(object):
# Migration v16: Purge old cache image folder name
@staticmethod
def _migrate_v16():
if sickgear.CACHE_DIR and ek.ek(os.path.isdir, sickgear.CACHE_DIR):
if sickgear.CACHE_DIR and os.path.isdir(sickgear.CACHE_DIR):
cache_default = sickgear.CACHE_DIR
dead_paths = ['anidb', 'imdb', 'trakt']
for path in dead_paths:
sickgear.CACHE_DIR = '%s/images/%s' % (cache_default, path)
helpers.clear_cache(True)
try:
ek.ek(os.rmdir, sickgear.CACHE_DIR)
os.rmdir(sickgear.CACHE_DIR)
except OSError:
pass
sickgear.CACHE_DIR = cache_default

14
sickgear/databases/mainDB.py
View file

@ -21,8 +21,6 @@ import re
from .. import db, common, logger
from ..name_parser.parser import NameParser, InvalidNameException, InvalidShowException
import sickgear
# noinspection PyPep8Naming
import encodingKludge as ek
from six import iteritems
@ -432,8 +430,8 @@ class AddSizeAndSceneNameFields(db.SchemaUpgrade):
# if there is no size yet then populate it for us
if (not cur_result['file_size'] or not int(cur_result['file_size'])) \
and ek.ek(os.path.isfile, cur_result['location']):
cur_size = ek.ek(os.path.getsize, cur_result['location'])
and os.path.isfile(cur_result['location']):
cur_size = os.path.getsize(cur_result['location'])
self.connection.action('UPDATE tv_episodes SET file_size = ? WHERE episode_id = ?',
[cur_size, int(cur_result['episode_id'])])
@ -456,7 +454,7 @@ class AddSizeAndSceneNameFields(db.SchemaUpgrade):
continue
nzb_name = cur_result['resource']
file_name = ek.ek(os.path.basename, download_sql_result[0]['resource'])
file_name = os.path.basename(download_sql_result[0]['resource'])
# take the extension off the filename, it's not needed
if '.' in file_name:
@ -508,7 +506,7 @@ class AddSizeAndSceneNameFields(db.SchemaUpgrade):
self.upgrade_log(u'Adding release name to all episodes with obvious scene filenames')
for cur_result in empty_sql_result:
ep_file_name = ek.ek(os.path.basename, cur_result['location'])
ep_file_name = os.path.basename(cur_result['location'])
ep_file_name = os.path.splitext(ep_file_name)[0]
# only want to find real scene names here so anything with a space in it is out
@ -1999,7 +1997,7 @@ class ChangeTmdbID(db.SchemaUpgrade):
self.upgrade_log('Renaming tmdb images')
# noinspection PyProtectedMember
for _dir in (ImageCache._persons_dir(), ImageCache._characters_dir()):
for _f in ek.ek(scantree, _dir): # type: DirEntry
for _f in scantree(_dir): # type: DirEntry
if not _f.is_file(follow_symlinks=False):
continue
try:
@ -2010,7 +2008,7 @@ class ChangeTmdbID(db.SchemaUpgrade):
continue
try:
move_file(_f.path,
ek.ek(os.path.join, ek.ek(os.path.dirname, _f.path),
os.path.join(os.path.dirname(_f.path),
re.sub('^%s-' % img_src, '%s-' %
cache_img_src[(img_src, TVINFO_TMDB)[TVINFO_TMDB_OLD == img_src]], _f.name)))
except (BaseException, Exception):

18
sickgear/db.py
View file

@ -24,8 +24,6 @@ import sqlite3
import threading
import time
# noinspection PyPep8Naming
import encodingKludge as ek
from exceptions_helper import ex
import sickgear
@ -60,7 +58,7 @@ def dbFilename(filename='sickbeard.db', suffix=None):
"""
if suffix:
filename = '%s.%s' % (filename, suffix)
return ek.ek(os.path.join, sickgear.DATA_DIR, filename)
return os.path.join(sickgear.DATA_DIR, filename)
def mass_upsert_sql(table_name, value_dict, key_dict, sanitise=True):
@ -136,12 +134,12 @@ class DBConnection(object):
logger.log('this python sqlite3 version doesn\'t support backups', logger.DEBUG)
return False, 'this python sqlite3 version doesn\'t support backups'
if not ek.ek(os.path.isdir, target):
if not os.path.isdir(target):
logger.log('Backup target invalid', logger.ERROR)
return False, 'Backup target invalid'
target_db = ek.ek(os.path.join, target, (backup_filename, self.filename)[None is backup_filename])
if ek.ek(os.path.exists, target_db):
target_db = os.path.join(target, (backup_filename, self.filename)[None is backup_filename])
if os.path.exists(target_db):
logger.log('Backup target file already exists', logger.ERROR)
return False, 'Backup target file already exists'
@ -758,14 +756,14 @@ def MigrationCode(my_db):
def cleanup_old_db_backups(filename):
try:
d, filename = ek.ek(os.path.split, filename)
d, filename = os.path.split(filename)
if not d:
d = sickgear.DATA_DIR
for f in filter_iter(lambda fn: fn.is_file() and filename in fn.name and
re.search(r'\.db(\.v\d+)?\.r\d+$', fn.name),
ek.ek(scandir, d)):
scandir(d)):
try:
ek.ek(os.unlink, f.path)
os.unlink(f.path)
except (BaseException, Exception):
pass
except (BaseException, Exception):
@ -870,7 +868,7 @@ def backup_all_dbs(target, compress=True, prefer_7z=True):
if not success:
return False, msg
if compress:
full_path = ek.ek(os.path.join, target, name)
full_path = os.path.join(target, name)
if not compress_file(full_path, '%s.db' % cur_db, prefer_7z=prefer_7z):
return False, 'Failure to compress backup'
delete_old_db_backups(target)

2
sickgear/failedProcessor.py
View file

@ -69,7 +69,7 @@ class FailedProcessor(LegacyFailedProcessor):
"""
self._log(u'Failed download detected: (%s, %s)' % (self.nzb_name, self.dir_name))
releaseName = show_name_helpers.determineReleaseName(self.dir_name, self.nzb_name)
releaseName = show_name_helpers.determine_release_name(self.dir_name, self.nzb_name)
if None is releaseName:
self._log(u'Warning: unable to find a valid release name.', logger.WARNING)
raise exceptions_helper.FailedProcessingFailed()

154
sickgear/helpers.py
View file

@ -36,8 +36,6 @@ from .common import cpu_presets, mediaExtensions, Overview, Quality, statusStrin
ARCHIVED, DOWNLOADED, FAILED, IGNORED, SKIPPED, SNATCHED_ANY, SUBTITLED, UNAIRED, UNKNOWN, WANTED
from .sgdatetime import timestamp_near
from lib.tvinfo_base.exceptions import *
# noinspection PyPep8Naming
import encodingKludge as ek
from exceptions_helper import ex, MultipleShowObjectsException
import dateutil.parser
@ -171,7 +169,7 @@ def has_image_ext(filename):
:rtype: bool
"""
try:
if ek.ek(os.path.splitext, filename)[1].lower() in ['.bmp', '.gif', '.jpeg', '.jpg', '.png', '.webp']:
if os.path.splitext(filename)[1].lower() in ['.bmp', '.gif', '.jpeg', '.jpg', '.png', '.webp']:
return True
except (BaseException, Exception):
pass
@ -251,9 +249,9 @@ def make_dir(path):
:return: success of creation
:rtype: bool
"""
if not ek.ek(os.path.isdir, path):
if not os.path.isdir(path):
try:
ek.ek(os.makedirs, path)
os.makedirs(path)
# do a Synology library update
notifiers.NotifierFactory().get('SYNOINDEX').addFolder(path)
except OSError:
@ -391,7 +389,7 @@ def link(src_file, dest_file):
if 0 == ctypes.windll.kernel32.CreateHardLinkW(text_type(dest_file), text_type(src_file), 0):
raise ctypes.WinError()
else:
ek.ek(os.link, src_file, dest_file)
os.link(src_file, dest_file)
def hardlink_file(src_file, dest_file):
@ -403,7 +401,7 @@ def hardlink_file(src_file, dest_file):
:type dest_file: AnyStr
"""
try:
ek.ek(link, src_file, dest_file)
link(src_file, dest_file)
fix_set_group_id(dest_file)
except (BaseException, Exception) as e:
logger.log(u"Failed to create hardlink of %s at %s: %s. Copying instead." % (src_file, dest_file, ex(e)),
@ -423,10 +421,10 @@ def symlink(src_file, dest_file):
import ctypes
if ctypes.windll.kernel32.CreateSymbolicLinkW(
text_type(dest_file), text_type(src_file), 1 if ek.ek(os.path.isdir, src_file) else 0) in [0, 1280]:
text_type(dest_file), text_type(src_file), 1 if os.path.isdir(src_file) else 0) in [0, 1280]:
raise ctypes.WinError()
else:
ek.ek(os.symlink, src_file, dest_file)
os.symlink(src_file, dest_file)
def move_and_symlink_file(src_file, dest_file):
@ -438,9 +436,9 @@ def move_and_symlink_file(src_file, dest_file):
:type dest_file: AnyStr
"""
try:
ek.ek(shutil.move, src_file, dest_file)
shutil.move(src_file, dest_file)
fix_set_group_id(dest_file)
ek.ek(symlink, dest_file, src_file)
symlink(dest_file, src_file)
except (BaseException, Exception):
logger.log(u"Failed to create symlink of %s at %s. Copying instead" % (src_file, dest_file), logger.ERROR)
copy_file(src_file, dest_file)
@ -461,11 +459,11 @@ def rename_ep_file(cur_path, new_path, old_path_length=0):
:rtype: bool
"""
# new_dest_dir, new_dest_name = ek.ek(os.path.split, new_path)
# new_dest_dir, new_dest_name = os.path.split(new_path)
if 0 == old_path_length or len(cur_path) < old_path_length:
# approach from the right
cur_file_name, cur_file_ext = ek.ek(os.path.splitext, cur_path)
cur_file_name, cur_file_ext = os.path.splitext(cur_path)
else:
# approach from the left
cur_file_ext = cur_path[old_path_length:]
@ -473,7 +471,7 @@ def rename_ep_file(cur_path, new_path, old_path_length=0):
if cur_file_ext[1:] in subtitleExtensions:
# Extract subtitle language from filename
sublang = ek.ek(os.path.splitext, cur_file_name)[1][1:]
sublang = os.path.splitext(cur_file_name)[1][1:]
# Check if the language extracted from filename is a valid language
try:
@ -485,18 +483,18 @@ def rename_ep_file(cur_path, new_path, old_path_length=0):
# put the extension on the incoming file
new_path += cur_file_ext
make_path(ek.ek(os.path.dirname, new_path), syno=True)
make_path(os.path.dirname(new_path), syno=True)
# move the file
try:
logger.log(u'Renaming file from %s to %s' % (cur_path, new_path))
ek.ek(shutil.move, cur_path, new_path)
shutil.move(cur_path, new_path)
except (OSError, IOError) as e:
logger.log(u"Failed renaming " + cur_path + " to " + new_path + ": " + ex(e), logger.ERROR)
return False
# clean up any old folders that are empty
delete_empty_folders(ek.ek(os.path.dirname, cur_path))
delete_empty_folders(os.path.dirname(cur_path))
return True
@ -517,8 +515,8 @@ def delete_empty_folders(check_empty_dir, keep_dir=None):
logger.log(u"Trying to clean any empty folders under " + check_empty_dir)
# as long as the folder exists and doesn't contain any files, delete it
while ek.ek(os.path.isdir, check_empty_dir) and check_empty_dir != keep_dir:
check_files = ek.ek(os.listdir, check_empty_dir)
while os.path.isdir(check_empty_dir) and check_empty_dir != keep_dir:
check_files = os.listdir(check_empty_dir)
if not check_files or (len(check_files) <= len(ignore_items) and all(
[check_file in ignore_items for check_file in check_files])):
@ -526,13 +524,13 @@ def delete_empty_folders(check_empty_dir, keep_dir=None):
try:
logger.log(u"Deleting empty folder: " + check_empty_dir)
# need shutil.rmtree when ignore_items is really implemented
ek.ek(os.rmdir, check_empty_dir)
os.rmdir(check_empty_dir)
# do a Synology library update
notifiers.NotifierFactory().get('SYNOINDEX').deleteFolder(check_empty_dir)
except OSError as e:
logger.log(u"Unable to delete " + check_empty_dir + ": " + repr(e) + " / " + ex(e), logger.WARNING)
break
check_empty_dir = ek.ek(os.path.dirname, check_empty_dir)
check_empty_dir = os.path.dirname(check_empty_dir)
else:
break
@ -565,7 +563,7 @@ def get_absolute_number_from_season_and_episode(show_obj, season, episode):
logger.DEBUG)
else:
logger.debug('No entries for absolute number in show: %s found using %sx%s' %
(show_obj.unique_name, str(season), str(episode)))
(show_obj.unique_name, str(season), str(episode)))
return absolute_number
@ -608,7 +606,7 @@ def sanitize_scene_name(name):
# tidy up stuff that doesn't belong in scene names
name = re.sub(r'(-?\s|/)', '.', name).replace('&', 'and')
name = re.sub(r"\.\.*", '.', name).rstrip('.')
name = re.sub(r"\.+", '.', name).rstrip('.')
return name
return ''
@ -675,24 +673,24 @@ def backup_versioned_file(old_file, version):
new_file = '%s.v%s' % (old_file, version)
if ek.ek(os.path.isfile, new_file):
if os.path.isfile(new_file):
changed_old_db = False
for back_nr in range(1, 10000):
alt_name = '%s.r%s' % (new_file, back_nr)
if not ek.ek(os.path.isfile, alt_name):
if not os.path.isfile(alt_name):
try:
shutil.move(new_file, alt_name)
changed_old_db = True
break
except (BaseException, Exception):
if ek.ek(os.path.isfile, new_file):
if os.path.isfile(new_file):
continue
logger.log('could not rename old backup db file', logger.WARNING)
if not changed_old_db:
raise Exception('can\'t create a backup of db')
while not ek.ek(os.path.isfile, new_file):
if not ek.ek(os.path.isfile, old_file) or 0 == get_size(old_file):
while not os.path.isfile(new_file):
if not os.path.isfile(old_file) or 0 == get_size(old_file):
logger.log(u'No need to create backup', logger.DEBUG)
break
@ -724,12 +722,12 @@ def restore_versioned_file(backup_file, version):
:return: success
:rtype: bool
"""
numTries = 0
num_tries = 0
new_file, backup_version = ek.ek(os.path.splitext, backup_file)
new_file, backup_version = os.path.splitext(backup_file)
restore_file = new_file + '.' + 'v' + str(version)
if not ek.ek(os.path.isfile, new_file):
if not os.path.isfile(new_file):
logger.log(u"Not restoring, " + new_file + " doesn't exist", logger.DEBUG)
return False
@ -744,8 +742,8 @@ def restore_versioned_file(backup_file, version):
logger.WARNING)
return False
while not ek.ek(os.path.isfile, new_file):
if not ek.ek(os.path.isfile, restore_file):
while not os.path.isfile(new_file):
if not os.path.isfile(restore_file):
logger.log(u"Not restoring, " + restore_file + " doesn't exist", logger.DEBUG)
break
@ -756,11 +754,11 @@ def restore_versioned_file(backup_file, version):
break
except (BaseException, Exception) as e:
logger.log(u"Error while trying to restore " + restore_file + ": " + ex(e), logger.WARNING)
numTries += 1
num_tries += 1
time.sleep(1)
logger.log(u"Trying again.", logger.DEBUG)
if 10 <= numTries:
if 10 <= num_tries:
logger.log(u"Unable to restore " + restore_file + " to " + new_file + " please do it manually.",
logger.ERROR)
return False
@ -978,8 +976,8 @@ def is_hidden_folder(folder):
:return: Returns True if folder is hidden
:rtype: bool
"""
if ek.ek(os.path.isdir, folder):
if ek.ek(os.path.basename, folder).startswith('.'):
if os.path.isdir(folder):
if os.path.basename(folder).startswith('.'):
return True
return False
@ -994,7 +992,7 @@ def real_path(path):
:return: the canonicalized absolute pathname
:rtype: AnyStr
"""
return ek.ek(os.path.normpath, ek.ek(os.path.normcase, ek.ek(os.path.realpath, ek.ek(os.path.expanduser, path))))
return os.path.normpath(os.path.normcase(os.path.realpath(os.path.expanduser(path))))
def validate_show(show_obj, season=None, episode=None):
@ -1048,7 +1046,7 @@ def clear_cache(force=False):
elif direntry.is_dir(**direntry_args) and direntry.name not in ['cheetah', 'sessions', 'indexers']:
dirty = dirty or False
try:
ek.ek(os.rmdir, direntry.path)
os.rmdir(direntry.path)
except OSError:
dirty = True
@ -1098,8 +1096,8 @@ def get_size(start_path='.'):
:return: size in bytes
:rtype: int or long
"""
if ek.ek(os.path.isfile, start_path):
return ek.ek(os.path.getsize, start_path)
if os.path.isfile(start_path):
return os.path.getsize(start_path)
try:
return sum(map((lambda x: x.stat(follow_symlinks=False).st_size), scantree(start_path)))
except OSError:
@ -1115,14 +1113,14 @@ def get_media_stats(start_path='.'):
:param start_path: path to scan
"""
if ek.ek(os.path.isdir, start_path):
if os.path.isdir(start_path):
sizes = sorted(map(lambda y: y.stat(follow_symlinks=False).st_size,
filter(lambda x: has_media_ext(x.name), scantree(start_path))))
if sizes:
return len(sizes), sizes[0], sizes[-1], int(sum(sizes) / len(sizes))
elif ek.ek(os.path.isfile, start_path):
size = ek.ek(os.path.getsize, start_path)
elif os.path.isfile(start_path):
size = os.path.getsize(start_path)
return 1, size, size, size
return 0, 0, 0, 0
@ -1137,7 +1135,7 @@ def remove_article(text=''):
:return: text without articles
:rtype: AnyStr
"""
return re.sub(r'(?i)^(?:(?:A(?!\s+to)n?)|The)\s(\w)', r'\1', text)
return re.sub(r'(?i)^(?:A(?!\s+to)n?|The)\s(\w)', r'\1', text)
def re_valid_hostname(with_allowed=True):
@ -1332,11 +1330,11 @@ def cleanup_cache():
Delete old cached files
"""
delete_not_changed_in(
[ek.ek(os.path.join, sickgear.CACHE_DIR, 'images', 'browse', 'thumb', x)
[os.path.join(sickgear.CACHE_DIR, 'images', 'browse', 'thumb', x)
for x in ['anidb', 'imdb', 'trakt', 'tvdb']] +
[ek.ek(os.path.join, sickgear.CACHE_DIR, 'images', x)
[os.path.join(sickgear.CACHE_DIR, 'images', x)
for x in ['characters', 'person']] +
[ek.ek(os.path.join, sickgear.CACHE_DIR, 'tvinfo_cache')])
[os.path.join(sickgear.CACHE_DIR, 'tvinfo_cache')])
def delete_not_changed_in(paths, days=30, minutes=0):
@ -1377,8 +1375,8 @@ def set_file_timestamp(filename, min_age=3, new_time=None):
"""
min_time = int(timestamp_near((datetime.datetime.now() - datetime.timedelta(days=min_age))))
try:
if ek.ek(os.path.isfile, filename) and ek.ek(os.path.getmtime, filename) < min_time:
ek.ek(os.utime, filename, new_time)
if os.path.isfile(filename) and os.path.getmtime(filename) < min_time:
os.utime(filename, new_time)
except (BaseException, Exception):
pass
@ -1407,7 +1405,7 @@ def is_link(filepath):
:return: True or False
"""
if 'win32' == sys.platform:
if not ek.ek(os.path.exists, filepath):
if not os.path.exists(filepath):
return False
import ctypes
@ -1417,7 +1415,7 @@ def is_link(filepath):
attr = ctypes.windll.kernel32.GetFileAttributesW(text_type(filepath))
return invalid_file_attributes != attr and 0 != attr & file_attribute_reparse_point
return ek.ek(os.path.islink, filepath)
return os.path.islink(filepath)
def df():
@ -1496,11 +1494,11 @@ def path_mapper(search, replace, subject):
:rtype: Tuple[AnyStr, bool]
"""
delim = '/!~!/'
search = re.sub(r'[\\]', delim, search)
replace = re.sub(r'[\\]', delim, replace)
path = re.sub(r'[\\]', delim, subject)
search = re.sub(r'\\', delim, search)
replace = re.sub(r'\\', delim, replace)
path = re.sub(r'\\', delim, subject)
result = re.sub('(?i)^%s' % search, replace, path)
result = ek.ek(os.path.normpath, re.sub(delim, '/', result))
result = os.path.normpath(re.sub(delim, '/', result))
return result, result != subject
@ -1559,7 +1557,7 @@ def generate_show_dir_name(root_dir, show_name):
san_show_name = san_show_name.replace(' ', '.')
if None is root_dir:
return san_show_name
return ek.ek(os.path.join, root_dir, san_show_name)
return os.path.join(root_dir, san_show_name)
def count_files_dirs(base_dir):
@ -1572,7 +1570,7 @@ def count_files_dirs(base_dir):
"""
f = d = 0
try:
files = ek.ek(scandir, base_dir)
files = scandir(base_dir)
except OSError as e:
logger.log('Unable to count files %s / %s' % (repr(e), ex(e)), logger.WARNING)
else:
@ -1603,8 +1601,8 @@ def upgrade_new_naming():
sickgear.CFG.setdefault('GUI', {})['fanart_ratings'] = '%s' % ne
sickgear.CFG.write()
image_cache_dir = ek.ek(os.path.join, sickgear.CACHE_DIR, 'images')
bp_match = re.compile(r'(\d+)\.((?:banner|poster|(?:(?:\d+(?:\.\w*)?\.(?:\w{5,8}))\.)?fanart)\.jpg)', flags=re.I)
image_cache_dir = os.path.join(sickgear.CACHE_DIR, 'images')
bp_match = re.compile(r'(\d+)\.((?:banner|poster|(?:\d+(?:\.\w*)?\.\w{5,8}\.)?fanart)\.jpg)', flags=re.I)
def _set_progress(p_msg, c, s):
ps = None
@ -1618,14 +1616,14 @@ def upgrade_new_naming():
sickgear.classes.loading_msg.set_msg_progress(p_msg, '{:6.2f}%'.format(ps))
for d in ['', 'thumbnails']:
bd = ek.ek(os.path.join, image_cache_dir, d)
if ek.ek(os.path.isdir, bd):
bd = os.path.join(image_cache_dir, d)
if os.path.isdir(bd):
fc, dc = count_files_dirs(bd)
step = fc / float(100)
cf = 0
p_text = 'Upgrading %s' % (d, 'banner/poster')[not d]
_set_progress(p_text, 0, 0)
for entry in ek.ek(scandir, bd):
for entry in scandir(bd):
if entry.is_file():
cf += 1
_set_progress(p_text, cf, step)
@ -1634,14 +1632,13 @@ def upgrade_new_naming():
old_id = int(b_s.group(1))
tvid = show_list.get(old_id)
if tvid:
nb_dir = ek.ek(os.path.join, sickgear.CACHE_DIR, 'images', 'shows',
'%s-%s' % (tvid, old_id), d)
if not ek.ek(os.path.isdir, nb_dir):
nb_dir = os.path.join(sickgear.CACHE_DIR, 'images', 'shows', '%s-%s' % (tvid, old_id), d)
if not os.path.isdir(nb_dir):
try:
ek.ek(os.makedirs, nb_dir)
os.makedirs(nb_dir)
except (BaseException, Exception):
pass
new_name = ek.ek(os.path.join, nb_dir, bp_match.sub(r'\2', entry.name))
new_name = os.path.join(nb_dir, bp_match.sub(r'\2', entry.name))
try:
move_file(entry.path, new_name)
except (BaseException, Exception) as e:
@ -1650,7 +1647,7 @@ def upgrade_new_naming():
else:
# clean up files without reference in db
try:
ek.ek(os.remove, entry.path)
os.remove(entry.path)
except (BaseException, Exception):
pass
elif entry.is_dir():
@ -1664,7 +1661,7 @@ def upgrade_new_naming():
p_text = 'Upgrading fanart'
_set_progress(p_text, 0, 0)
try:
entries = ek.ek(scandir, entry.path)
entries = scandir(entry.path)
except OSError as e:
logger.log('Unable to stat dirs %s / %s' % (repr(e), ex(e)), logger.WARNING)
continue
@ -1676,17 +1673,16 @@ def upgrade_new_naming():
if old_id:
new_id = show_list.get(old_id)
if new_id:
new_dir_name = ek.ek(os.path.join, sickgear.CACHE_DIR, 'images', 'shows',
'%s-%s' % (new_id, old_id), 'fanart')
new_dir_name = os.path.join(sickgear.CACHE_DIR, 'images', 'shows',
'%s-%s' % (new_id, old_id), 'fanart')
try:
move_file(d_entry.path, new_dir_name)
except (BaseException, Exception) as e:
logger.log('Unable to rename %s to %s: %s / %s' %
(d_entry.path, new_dir_name, repr(e), ex(e)), logger.WARNING)
if ek.ek(os.path.isdir, new_dir_name):
if os.path.isdir(new_dir_name):
try:
f_n = filter_iter(lambda fn: fn.is_file(),
ek.ek(scandir, new_dir_name))
f_n = filter_iter(lambda fn: fn.is_file(), scandir(new_dir_name))
except OSError as e:
logger.log('Unable to rename %s / %s' % (repr(e), ex(e)),
logger.WARNING)
@ -1704,20 +1700,20 @@ def upgrade_new_naming():
(args[0], args[1], repr(e), ex(e)), logger.WARNING)
else:
try:
ek.ek(shutil.rmtree, d_entry.path)
shutil.rmtree(d_entry.path)
except (BaseException, Exception):
pass
try:
ek.ek(shutil.rmtree, d_entry.path)
shutil.rmtree(d_entry.path)
except (BaseException, Exception):
pass
try:
ek.ek(os.rmdir, entry.path)
os.rmdir(entry.path)
except (BaseException, Exception):
pass
if 'thumbnails' == d:
try:
ek.ek(os.rmdir, bd)
os.rmdir(bd)
except (BaseException, Exception):
pass
_set_progress(p_text, 0, 1)

55
sickgear/image_cache.py
View file

@ -20,8 +20,6 @@ import os.path
import re
import zlib
# noinspection PyPep8Naming
import encodingKludge as ek
import exceptions_helper
from exceptions_helper import ex
import sickgear
@ -30,7 +28,6 @@ from . import db, logger
from .metadata.generic import GenericMetadata
from .sgdatetime import timestamp_near
from .indexers.indexer_config import TVINFO_TVDB, TVINFO_TVMAZE, TVINFO_TMDB, TVINFO_IMDB
from lib.tvinfo_base.exceptions import *
from six import itervalues, iteritems
@ -56,9 +53,9 @@ class ImageCache(object):
characters_dir = None # type: Optional[AnyStr]
def __init__(self):
if None is ImageCache.base_dir and ek.ek(os.path.exists, sickgear.CACHE_DIR):
ImageCache.base_dir = ek.ek(os.path.abspath, ek.ek(os.path.join, sickgear.CACHE_DIR, 'images'))
ImageCache.shows_dir = ek.ek(os.path.abspath, ek.ek(os.path.join, self.base_dir, 'shows'))
if None is ImageCache.base_dir and os.path.exists(sickgear.CACHE_DIR):
ImageCache.base_dir = os.path.abspath(os.path.join(sickgear.CACHE_DIR, 'images'))
ImageCache.shows_dir = os.path.abspath(os.path.join(self.base_dir, 'shows'))
ImageCache.persons_dir = self._persons_dir()
ImageCache.characters_dir = self._characters_dir()
@ -70,17 +67,17 @@ class ImageCache(object):
# """
# Builds up the full path to the image cache directory
# """
# return ek.ek(os.path.abspath, ek.ek(os.path.join, sickgear.CACHE_DIR, 'images'))
# return os.path.abspath(os.path.join(sickgear.CACHE_DIR, 'images'))
@staticmethod
def _persons_dir():
# type: (...) -> AnyStr
return ek.ek(os.path.join, sickgear.CACHE_DIR, 'images', 'person')
return os.path.join(sickgear.CACHE_DIR, 'images', 'person')
@staticmethod
def _characters_dir():
# type: (...) -> AnyStr
return ek.ek(os.path.join, sickgear.CACHE_DIR, 'images', 'characters')
return os.path.join(sickgear.CACHE_DIR, 'images', 'characters')
def _fanart_dir(self, tvid=None, prodid=None):
# type: (int, int) -> AnyStr
@ -95,7 +92,7 @@ class ImageCache(object):
:rtype: AnyStr or None
"""
if None not in (tvid, prodid):
return ek.ek(os.path.abspath, ek.ek(os.path.join, self.shows_dir, '%s-%s' % (tvid, prodid), 'fanart'))
return os.path.abspath(os.path.join(self.shows_dir, '%s-%s' % (tvid, prodid), 'fanart'))
def _thumbnails_dir(self, tvid, prodid):
# type: (int, int) -> AnyStr
@ -109,7 +106,7 @@ class ImageCache(object):
:return: path
:rtype: AnyStr
"""
return ek.ek(os.path.abspath, ek.ek(os.path.join, self.shows_dir, '%s-%s' % (tvid, prodid), 'thumbnails'))
return os.path.abspath(os.path.join(self.shows_dir, '%s-%s' % (tvid, prodid), 'thumbnails'))
@staticmethod
def _person_base_name(person_obj):
@ -134,7 +131,7 @@ class ImageCache(object):
:param base_path:
"""
filename = '%s.jpg' % base_path or self._person_base_name(person_obj)
return ek.ek(os.path.join, self.persons_dir, filename)
return os.path.join(self.persons_dir, filename)
def person_thumb_path(self, person_obj, base_path=None):
# type: (Optional[Person], AnyStr) -> AnyStr
@ -144,7 +141,7 @@ class ImageCache(object):
:param base_path:
"""
filename = '%s_thumb.jpg' % base_path or self._person_base_name(person_obj)
return ek.ek(os.path.join, self.persons_dir, filename)
return os.path.join(self.persons_dir, filename)
def person_both_paths(self, person_obj):
# type: (Person) -> Tuple[AnyStr, AnyStr]
@ -164,7 +161,7 @@ class ImageCache(object):
:param base_path:
"""
filename = '%s.jpg' % base_path or self._character_base_name(character_obj, show_obj)
return ek.ek(os.path.join, self.characters_dir, filename)
return os.path.join(self.characters_dir, filename)
def character_thumb_path(self, character_obj, show_obj, base_path=None):
# type: (Optional[Character], Optional[TVShow], AnyStr) -> AnyStr
@ -175,7 +172,7 @@ class ImageCache(object):
:param base_path:
"""
filename = '%s_thumb.jpg' % base_path or self._character_base_name(character_obj, show_obj)
return ek.ek(os.path.join, self.characters_dir, filename)
return os.path.join(self.characters_dir, filename)
def character_both_path(self, character_obj, show_obj=None, tvid=None, proid=None, person_obj=None):
# type: (Character, TVShow, integer_types, integer_types, Person) -> Tuple[AnyStr, AnyStr]
@ -208,7 +205,7 @@ class ImageCache(object):
:return: a full path to the cached poster file for the given tvid prodid
:rtype: AnyStr
"""
return ek.ek(os.path.join, self.shows_dir, '%s-%s' % (tvid, prodid), 'poster.jpg')
return os.path.join(self.shows_dir, '%s-%s' % (tvid, prodid), 'poster.jpg')
def banner_path(self, tvid, prodid):
# type: (int, int) -> AnyStr
@ -222,7 +219,7 @@ class ImageCache(object):
:return: a full path to the cached banner file for the given tvid prodid
:rtype: AnyStr
"""
return ek.ek(os.path.join, self.shows_dir, '%s-%s' % (tvid, prodid), 'banner.jpg')
return os.path.join(self.shows_dir, '%s-%s' % (tvid, prodid), 'banner.jpg')
def fanart_path(self, tvid, prodid, prefix=''):
# type: (int, int, Optional[AnyStr]) -> AnyStr
@ -238,7 +235,7 @@ class ImageCache(object):
:return: a full path to the cached fanart file for the given tvid prodid
:rtype: AnyStr
"""
return ek.ek(os.path.join, self._fanart_dir(tvid, prodid), '%s%s' % (prefix, 'fanart.jpg'))
return os.path.join(self._fanart_dir(tvid, prodid), '%s%s' % (prefix, 'fanart.jpg'))
def poster_thumb_path(self, tvid, prodid):
# type: (int, int) -> AnyStr
@ -252,7 +249,7 @@ class ImageCache(object):
:return: a full path to the cached poster file for the given tvid prodid
:rtype: AnyStr
"""
return ek.ek(os.path.join, self._thumbnails_dir(tvid, prodid), 'poster.jpg')
return os.path.join(self._thumbnails_dir(tvid, prodid), 'poster.jpg')
def banner_thumb_path(self, tvid, prodid):
# type: (int, int) -> AnyStr
@ -266,7 +263,7 @@ class ImageCache(object):
:return: a full path to the cached poster file for the given tvid prodid
:rtype: AnyStr
"""
return ek.ek(os.path.join, self._thumbnails_dir(tvid, prodid), 'banner.jpg')
return os.path.join(self._thumbnails_dir(tvid, prodid), 'banner.jpg')
@staticmethod
def has_file(image_file):
@ -278,8 +275,8 @@ class ImageCache(object):
:rtype: bool
"""
result = []
for filename in ek.ek(glob.glob, image_file):
result.append(ek.ek(os.path.isfile, filename) and filename)
for filename in glob.glob(image_file):
result.append(os.path.isfile(filename) and filename)
logger.log(u'Found cached %s' % filename, logger.DEBUG)
not any(result) and logger.log(u'No cache for %s' % image_file, logger.DEBUG)
@ -367,7 +364,7 @@ class ImageCache(object):
:param image: image file or data
:param is_binary: is data instead of path
"""
if not is_binary and not ek.ek(os.path.isfile, image):
if not is_binary and not os.path.isfile(image):
logger.warning(u'File not found to determine image type of %s' % image)
return
if not image:
@ -540,7 +537,7 @@ class ImageCache(object):
else:
sg_helpers.copy_file(image_path, dest_path)
return ek.ek(os.path.isfile, dest_path) and dest_path or None
return os.path.isfile(dest_path) and dest_path or None
def _cache_info_source_images(self, show_obj, img_type, num_files=0, max_files=500, force=False, show_infos=None):
# type: (TVShow, int, int, int, bool, ShowInfosDict) -> bool
@ -588,7 +585,7 @@ class ImageCache(object):
return False
crcs = []
for cache_file_name in ek.ek(glob.glob, dest_path):
for cache_file_name in glob.glob(dest_path):
with open(cache_file_name, mode='rb') as resource:
crc = '%05X' % (zlib.crc32(resource.read()) & 0xFFFFFFFF)
if crc not in crcs:
@ -627,7 +624,7 @@ class ImageCache(object):
success += (0, 1)[result]
if num_files > max_files:
break
total = len(ek.ek(glob.glob, dest_path))
total = len(glob.glob(dest_path))
logger.log(u'Saved %s fanart images%s. Cached %s of max %s fanart file%s'
% (success,
('', ' from ' + ', '.join([x for x in list(set(sources))]))[0 < len(sources)],
@ -696,7 +693,7 @@ class ImageCache(object):
cache_path = self.fanart_path(*arg_tvid_prodid).replace('fanart.jpg', '')
# num_images = len(fnmatch.filter(os.listdir(cache_path), '*.jpg'))
for cache_dir in ek.ek(glob.glob, cache_path):
for cache_dir in glob.glob(cache_path):
if show_obj.tvid_prodid in sickgear.FANART_RATINGS:
del (sickgear.FANART_RATINGS[show_obj.tvid_prodid])
result = sg_helpers.remove_file(cache_dir, tree=True)
@ -712,11 +709,11 @@ class ImageCache(object):
needed = []
if any([need_images[self.POSTER], need_images[self.BANNER]]):
poster_path = cur_provider.get_poster_path(show_obj)
if poster_path not in checked_files and ek.ek(os.path.isfile, poster_path):
if poster_path not in checked_files and os.path.isfile(poster_path):
needed += [[False, poster_path]]
if need_images[self.FANART]:
fanart_path = cur_provider.get_fanart_path(show_obj)
if fanart_path not in checked_files and ek.ek(os.path.isfile, fanart_path):
if fanart_path not in checked_files and os.path.isfile(fanart_path):
needed += [[True, fanart_path]]
if 0 == len(needed):
break

6
sickgear/indexers/indexer_api.py
View file

@ -16,10 +16,9 @@
import os
from .indexer_config import init_config, tvinfo_config
from sg_helpers import make_path, proxy_setting
from sg_helpers import proxy_setting
import sickgear
from lib.tvinfo_base import TVInfoBase
import encodingKludge as ek
from _23 import list_values
@ -41,8 +40,7 @@ class TVInfoAPI(object):
if tvinfo_config[self.tvid]['active'] or ('no_dummy' in kwargs and True is kwargs['no_dummy']):
if 'no_dummy' in kwargs:
kwargs.pop('no_dummy')
indexer_cache_dir = ek.ek(os.path.join, sickgear.CACHE_DIR, 'tvinfo_cache',
tvinfo_config[self.tvid]['name'])
indexer_cache_dir = os.path.join(sickgear.CACHE_DIR, 'tvinfo_cache', tvinfo_config[self.tvid]['name'])
kwargs['diskcache_dir'] = indexer_cache_dir
return tvinfo_config[self.tvid]['module'](*args, **kwargs)
else:

8
sickgear/logger.py
View file

@ -337,9 +337,8 @@ class TimedCompressedRotatingFileHandler(TimedRotatingFileHandler):
except AttributeError:
pass
import encodingKludge
try:
encodingKludge.ek(os.rename, self.baseFilename, dfn)
os.rename(self.baseFilename, dfn)
except (BaseException, Exception):
pass
@ -360,9 +359,8 @@ class TimedCompressedRotatingFileHandler(TimedRotatingFileHandler):
if 0 < self.backupCount:
# find the oldest log file and delete it
# phase out files named sickgear.log in favour of sickgear.logs over backup_count days
all_names = encodingKludge.ek(glob.glob, file_name + '_*') + \
encodingKludge.ek(glob.glob, encodingKludge.ek(os.path.join, encodingKludge.ek(
os.path.dirname, file_name), 'sickbeard_*'))
all_names = glob.glob(file_name + '_*') \
+ glob.glob(os.path.join(os.path.dirname(file_name), 'sickbeard_*'))
if len(all_names) > self.backupCount:
all_names.sort()
self.delete_logfile(all_names[0])

134
sickgear/metadata/generic.py
View file

@ -30,8 +30,6 @@ from ..indexers.indexer_config import TVINFO_TVDB, TVINFO_TMDB
from lib.tvinfo_base import TVInfoImage, TVInfoImageType, TVInfoImageSize
from lib.tvinfo_base.exceptions import *
import sickgear
# noinspection PyPep8Naming
import encodingKludge as ek
from exceptions_helper import ex
from lib.fanart.core import Request as fanartRequest
import lib.fanart as fanart
@ -127,13 +125,13 @@ class GenericMetadata(object):
def get_id(self):
# type: (...) -> AnyStr
return GenericMetadata.makeID(self.name)
return GenericMetadata.make_id(self.name)
@staticmethod
def makeID(name):
def make_id(name):
# type: (AnyStr) -> AnyStr
name_id = re.sub("[+]", "plus", name)
name_id = re.sub(r"[^\w\d_]", "_", name_id).lower()
name_id = re.sub(r"[^\w_]", "_", name_id).lower()
return name_id
def set_config(self, string):
@ -151,69 +149,69 @@ class GenericMetadata(object):
self.season_all_banner = config_list[9]
def _has_show_metadata(self, show_obj):
# type: (sickgear.tv.TVShow) -> AnyStr
result = ek.ek(os.path.isfile, self.get_show_file_path(show_obj))
# type: (sickgear.tv.TVShow) -> bool
result = os.path.isfile(self.get_show_file_path(show_obj))
logger.log(u"Checking if " + self.get_show_file_path(show_obj) + " exists: " + str(result), logger.DEBUG)
return result
def has_episode_metadata(self, ep_obj):
# type: (sickgear.tv.TVEpisode) -> AnyStr
result = ek.ek(os.path.isfile, self.get_episode_file_path(ep_obj))
# type: (sickgear.tv.TVEpisode) -> bool
result = os.path.isfile(self.get_episode_file_path(ep_obj))
logger.log(u"Checking if " + self.get_episode_file_path(ep_obj) + " exists: " + str(result), logger.DEBUG)
return result
def _has_fanart(self, show_obj):
# type: (sickgear.tv.TVShow) -> AnyStr
result = ek.ek(os.path.isfile, self.get_fanart_path(show_obj))
# type: (sickgear.tv.TVShow) -> bool
result = os.path.isfile(self.get_fanart_path(show_obj))
logger.log(u"Checking if " + self.get_fanart_path(show_obj) + " exists: " + str(result), logger.DEBUG)
return result
def _has_poster(self, show_obj):
# type: (sickgear.tv.TVShow) -> AnyStr
result = ek.ek(os.path.isfile, self.get_poster_path(show_obj))
# type: (sickgear.tv.TVShow) -> bool
result = os.path.isfile(self.get_poster_path(show_obj))
logger.log(u"Checking if " + self.get_poster_path(show_obj) + " exists: " + str(result), logger.DEBUG)
return result
def _has_banner(self, show_obj):
# type: (sickgear.tv.TVShow) -> AnyStr
result = ek.ek(os.path.isfile, self.get_banner_path(show_obj))
# type: (sickgear.tv.TVShow) -> bool
result = os.path.isfile(self.get_banner_path(show_obj))
logger.log(u"Checking if " + self.get_banner_path(show_obj) + " exists: " + str(result), logger.DEBUG)
return result
def has_episode_thumb(self, ep_obj):
# type: (sickgear.tv.TVEpisode) -> AnyStr
# type: (sickgear.tv.TVEpisode) -> bool
location = self.get_episode_thumb_path(ep_obj)
result = None is not location and ek.ek(os.path.isfile, location)
result = None is not location and os.path.isfile(location)
if location:
logger.log(u"Checking if " + location + " exists: " + str(result), logger.DEBUG)
return result
def _has_season_poster(self, show_obj, season):
# type: (sickgear.tv.TVShow,int) -> AnyStr
# type: (sickgear.tv.TVShow,int) -> bool
location = self.get_season_poster_path(show_obj, season)
result = None is not location and ek.ek(os.path.isfile, location)
result = None is not location and os.path.isfile(location)
if location:
logger.log(u"Checking if " + location + " exists: " + str(result), logger.DEBUG)
return result
def _has_season_banner(self, show_obj, season):
# type: (sickgear.tv.TVShow,int) -> AnyStr
# type: (sickgear.tv.TVShow,int) -> bool
location = self.get_season_banner_path(show_obj, season)
result = None is not location and ek.ek(os.path.isfile, location)
result = None is not location and os.path.isfile(location)
if location:
logger.log(u"Checking if " + location + " exists: " + str(result), logger.DEBUG)
return result
def _has_season_all_poster(self, show_obj):
# type: (sickgear.tv.TVShow) -> AnyStr
result = ek.ek(os.path.isfile, self.get_season_all_poster_path(show_obj))
# type: (sickgear.tv.TVShow) -> bool
result = os.path.isfile(self.get_season_all_poster_path(show_obj))
logger.log(u"Checking if " + self.get_season_all_poster_path(show_obj) + " exists: " + str(result),
logger.DEBUG)
return result
def _has_season_all_banner(self, show_obj):
# type: (sickgear.tv.TVShow) -> AnyStr
result = ek.ek(os.path.isfile, self.get_season_all_banner_path(show_obj))
# type: (sickgear.tv.TVShow) -> bool
result = os.path.isfile(self.get_season_all_banner_path(show_obj))
logger.log(u"Checking if " + self.get_season_all_banner_path(show_obj) + " exists: " + str(result),
logger.DEBUG)
return result
@ -245,7 +243,7 @@ class GenericMetadata(object):
def get_show_file_path(self, show_obj):
# type: (sickgear.tv.TVShow) -> AnyStr
return ek.ek(os.path.join, show_obj.location, self._show_metadata_filename)
return os.path.join(show_obj.location, self._show_metadata_filename)
def get_episode_file_path(self, ep_obj):
# type: (sickgear.tv.TVEpisode) -> AnyStr
@ -253,15 +251,15 @@ class GenericMetadata(object):
def get_fanart_path(self, show_obj):
# type: (sickgear.tv.TVShow) -> AnyStr
return ek.ek(os.path.join, show_obj.location, self.fanart_name)
return os.path.join(show_obj.location, self.fanart_name)
def get_poster_path(self, show_obj):
# type: (sickgear.tv.TVShow) -> AnyStr
return ek.ek(os.path.join, show_obj.location, self.poster_name)
return os.path.join(show_obj.location, self.poster_name)
def get_banner_path(self, show_obj):
# type: (sickgear.tv.TVShow) -> AnyStr
return ek.ek(os.path.join, show_obj.location, self.banner_name)
return os.path.join(show_obj.location, self.banner_name)
def get_episode_thumb_path(self, ep_obj):
# type: (sickgear.tv.TVEpisode) -> Optional[AnyStr]
@ -269,7 +267,7 @@ class GenericMetadata(object):
Returns the path where the episode thumbnail should be stored.
ep_obj: a TVEpisode instance for which to create the thumbnail
"""
if ek.ek(os.path.isfile, ep_obj.location):
if os.path.isfile(ep_obj.location):
tbn_filename = ep_obj.location.rpartition('.')
@ -296,7 +294,7 @@ class GenericMetadata(object):
else:
season_poster_filename = 'season' + str(season).zfill(2)
return ek.ek(os.path.join, show_obj.location, season_poster_filename + '-poster.jpg')
return os.path.join(show_obj.location, season_poster_filename + '-poster.jpg')
def get_season_banner_path(self, show_obj, season):
# type: (sickgear.tv.TVShow, int) -> AnyStr
@ -314,15 +312,15 @@ class GenericMetadata(object):
else:
season_banner_filename = 'season' + str(season).zfill(2)
return ek.ek(os.path.join, show_obj.location, season_banner_filename + '-banner.jpg')
return os.path.join(show_obj.location, season_banner_filename + '-banner.jpg')
def get_season_all_poster_path(self, show_obj):
# type: (sickgear.tv.TVShow) -> AnyStr
return ek.ek(os.path.join, show_obj.location, self.season_all_poster_name)
return os.path.join(show_obj.location, self.season_all_poster_name)
def get_season_all_banner_path(self, show_obj):
# type: (sickgear.tv.TVShow) -> AnyStr
return ek.ek(os.path.join, show_obj.location, self.season_all_banner_name)
return os.path.join(show_obj.location, self.season_all_banner_name)
def _show_data(self, show_obj):
# type: (sickgear.tv.TVShow) -> Optional[Union[bool, etree.Element]]
@ -393,7 +391,7 @@ class GenericMetadata(object):
self.name, show_obj.unique_name))
nfo_file_path = self.get_show_file_path(show_obj)
with ek.ek(io.open, nfo_file_path, 'r', encoding='utf8') as xmlFileObj:
with io.open(nfo_file_path, 'r', encoding='utf8') as xmlFileObj:
show_xml = etree.ElementTree(file=xmlFileObj)
tvid = show_xml.find('indexer')
@ -821,7 +819,7 @@ class GenericMetadata(object):
"""
# don't bother overwriting it
if not force and ek.ek(os.path.isfile, image_path):
if not force and os.path.isfile(image_path):
logger.log(u"Image already exists, not downloading", logger.DEBUG)
return False
@ -829,17 +827,17 @@ class GenericMetadata(object):
logger.log(u"Unable to retrieve image, skipping", logger.WARNING)
return False
image_dir = ek.ek(os.path.dirname, image_path)
image_dir = os.path.dirname(image_path)
try:
if not ek.ek(os.path.isdir, image_dir):
if not os.path.isdir(image_dir):
logger.log(u"Metadata dir didn't exist, creating it at " + image_dir, logger.DEBUG)
ek.ek(os.makedirs, image_dir)
os.makedirs(image_dir)
sg_helpers.chmod_as_parent(image_dir)
outFile = ek.ek(open, image_path, 'wb')
outFile.write(image_data)
outFile.close()
out_file = open(image_path, 'wb')
out_file.write(image_data)
out_file.close()
sg_helpers.chmod_as_parent(image_path)
except IOError as e:
logger.log(
@ -903,13 +901,13 @@ class GenericMetadata(object):
try:
alt_url = '%swww.%s%s' % re.findall(
r'(https?://)(?:artworks\.)?(thetvdb\.[^/]+/banners/[^\d]+[^.]+)(?:_t)(.*)', _url)[0][0:3]
r'(https?://)(?:artworks\.)?(thetvdb\.[^/]+/banners/\D+[^.]+)_t(.*)', _url)[0][0:3]
if alt_url not in _urls[0]:
_urls[1].append(alt_url)
except (IndexError, Exception):
try:
alt_url = '%sartworks.%s_t%s' % re.findall(
r'(https?://)(?:www\.)?(thetvdb\.[^/]+/banners/[^\d]+[^.]+)(.*)', _url)[0][0:3]
r'(https?://)(?:www\.)?(thetvdb\.[^/]+/banners/\D+[^.]+)(.*)', _url)[0][0:3]
if alt_url not in _urls[0]:
_urls[1].append(alt_url)
except (IndexError, Exception):
@ -1010,7 +1008,7 @@ class GenericMetadata(object):
thumb_url = _de_dupe(thumb_url)
if not thumb_url:
thumb_url = img_url
yield (img_url, thumb_url)
yield img_url, thumb_url
elif img_url:
yield img_url
@ -1113,7 +1111,7 @@ class GenericMetadata(object):
return result
def retrieveShowMetadata(self, folder):
def retrieve_show_metadata(self, folder):
# type: (AnyStr) -> Union[Tuple[int, int, AnyStr], Tuple[None, None, None]]
"""
Used only when mass adding Existing Shows,
@ -1124,39 +1122,39 @@ class GenericMetadata(object):
empty_return = (None, None, None)
metadata_path = ek.ek(os.path.join, folder, self._show_metadata_filename)
metadata_path = os.path.join(folder, self._show_metadata_filename)
if not ek.ek(os.path.isdir, folder) or not ek.ek(os.path.isfile, metadata_path):
if not os.path.isdir(folder) or not os.path.isfile(metadata_path):
logger.log(u"Can't load the metadata file from " + repr(metadata_path) + ", it doesn't exist", logger.DEBUG)
return empty_return
logger.log(u"Loading show info from metadata file in " + folder, logger.DEBUG)
try:
with ek.ek(io.open, metadata_path, 'r', encoding='utf8') as xmlFileObj:
showXML = etree.ElementTree(file=xmlFileObj)
with io.open(metadata_path, 'r', encoding='utf8') as xmlFileObj:
show_xml = etree.ElementTree(file=xmlFileObj)
if None is showXML.findtext('title') \
or all(None is _f for _f in (showXML.find('//uniqueid[@type]'),
showXML.findtext('tvdbid'),
showXML.findtext('id'),
showXML.findtext('indexer'))):
if None is show_xml.findtext('title') \
or all(None is _f for _f in (show_xml.find('//uniqueid[@type]'),
show_xml.findtext('tvdbid'),
show_xml.findtext('id'),
show_xml.findtext('indexer'))):
logger.log(u"Invalid info in tvshow.nfo (missing name or id):"
+ str(showXML.findtext('title')) + ' '
+ str(showXML.findtext('indexer')) + ' '
+ str(showXML.findtext('tvdbid')) + ' '
+ str(showXML.findtext('id')))
+ str(show_xml.findtext('title')) + ' '
+ str(show_xml.findtext('indexer')) + ' '
+ str(show_xml.findtext('tvdbid')) + ' '
+ str(show_xml.findtext('id')))
return empty_return
name = showXML.findtext('title')
name = show_xml.findtext('title')
try:
tvid = int(showXML.findtext('indexer'))
tvid = int(show_xml.findtext('indexer'))
except (BaseException, Exception):
tvid = None
# handle v2 format of .nfo file
default_source = showXML.find('//uniqueid[@default="true"]')
default_source = show_xml.find('//uniqueid[@default="true"]')
if None is not default_source:
use_tvid = default_source.attrib.get('type') or tvid
if isinstance(use_tvid, string_types):
@ -1166,17 +1164,17 @@ class GenericMetadata(object):
if use_tvid and None is not prodid:
return use_tvid, prodid, name
prodid = showXML.find('//uniqueid[@type="tvdb"]')
prodid = show_xml.find('//uniqueid[@type="tvdb"]')
if None is not prodid:
prodid = int(prodid.text)
tvid = TVINFO_TVDB
elif None is not showXML.findtext('tvdbid'):
prodid = int(showXML.findtext('tvdbid'))
elif None is not show_xml.findtext('tvdbid'):
prodid = int(show_xml.findtext('tvdbid'))
tvid = TVINFO_TVDB
elif None is not showXML.findtext('id'):
prodid = int(showXML.findtext('id'))
elif None is not show_xml.findtext('id'):
prodid = int(show_xml.findtext('id'))
try:
tvid = TVINFO_TVDB if [s for s in showXML.findall('.//*')
tvid = TVINFO_TVDB if [s for s in show_xml.findall('.//*')
if s.text and -1 != s.text.find('thetvdb.com')] else tvid
except (BaseException, Exception):
pass

14
sickgear/metadata/kodi.py
View file

@ -25,8 +25,6 @@ import sg_helpers
from ..indexers.indexer_config import TVINFO_IMDB, TVINFO_TVDB
from lib.tvinfo_base.exceptions import *
import sickgear
# noinspection PyPep8Naming
import encodingKludge as ek
import exceptions_helper
from exceptions_helper import ex
from lxml_etree import etree
@ -472,8 +470,8 @@ def remove_default_attr(*args, **kwargs):
if nfo_path:
# show
try:
if ek.ek(os.path.isfile, nfo_path):
with ek.ek(io.open, nfo_path, 'r', encoding='utf8') as xml_file_obj:
if os.path.isfile(nfo_path):
with io.open(nfo_path, 'r', encoding='utf8') as xml_file_obj:
xmltree = etree.ElementTree(file=xml_file_obj)
# remove default="" attributes
@ -519,8 +517,8 @@ def remove_default_attr(*args, **kwargs):
try:
changed = False
nfo_path = kodi.get_episode_file_path(cur_ep_obj)
if nfo_path and ek.ek(os.path.isfile, nfo_path):
with ek.ek(io.open, nfo_path, 'r', encoding='utf8') as xml_file_obj:
if nfo_path and os.path.isfile(nfo_path):
with io.open(nfo_path, 'r', encoding='utf8') as xml_file_obj:
xmltree = etree.ElementTree(file=xml_file_obj)
# remove default="" attributes
@ -573,8 +571,8 @@ def rebuild_nfo(*args, **kwargs):
try:
nfo_path = kodi.get_show_file_path(cur_show_obj)
if nfo_path and ek.ek(os.path.isfile, nfo_path):
with ek.ek(io.open, nfo_path, 'r', encoding='utf8') as xml_file_obj:
if nfo_path and os.path.isfile(nfo_path):
with io.open(nfo_path, 'r', encoding='utf8') as xml_file_obj:
xmltree = etree.ElementTree(file=xml_file_obj)
# check xml keys exist to validate file as type Kodi episode or tvshow .nfo

30
sickgear/metadata/mediabrowser.py
View file

@ -24,8 +24,6 @@ from .. import logger
import sg_helpers
from lib.tvinfo_base.exceptions import *
import sickgear
# noinspection PyPep8Naming
import encodingKludge as ek
import exceptions_helper
from exceptions_helper import ex
from lxml_etree import etree
@ -98,7 +96,7 @@ class MediaBrowserMetadata(generic.GenericMetadata):
self.eg_season_all_banner = "<i>not supported</i>" # type: AnyStr
# Override with empty methods for unsupported features
def retrieveShowMetadata(self, folder):
def retrieve_show_metadata(self, folder):
# type: (AnyStr) -> Tuple[None, None, None]
# while show metadata is generated, it is not supported for our lookup
return None, None, None
@ -120,10 +118,10 @@ class MediaBrowserMetadata(generic.GenericMetadata):
ep_obj: a TVEpisode object to get the path for
"""
if ek.ek(os.path.isfile, ep_obj.location):
xml_file_name = sg_helpers.replace_extension(ek.ek(os.path.basename, ep_obj.location), self._ep_nfo_extension)
metadata_dir_name = ek.ek(os.path.join, ek.ek(os.path.dirname, ep_obj.location), 'metadata')
xml_file_path = ek.ek(os.path.join, metadata_dir_name, xml_file_name)
if os.path.isfile(ep_obj.location):
xml_file_name = sg_helpers.replace_extension(os.path.basename(ep_obj.location), self._ep_nfo_extension)
metadata_dir_name = os.path.join(os.path.dirname(ep_obj.location), 'metadata')
xml_file_path = os.path.join(metadata_dir_name, xml_file_name)
else:
logger.log(u"Episode location doesn't exist: " + str(ep_obj.location), logger.DEBUG)
return ''
@ -139,10 +137,10 @@ class MediaBrowserMetadata(generic.GenericMetadata):
ep_obj: a TVEpisode object to get the path from
"""
if ek.ek(os.path.isfile, ep_obj.location):
metadata_dir_name = ek.ek(os.path.join, ek.ek(os.path.dirname, ep_obj.location), 'metadata')
tbn_file_name = sg_helpers.replace_extension(ek.ek(os.path.basename, ep_obj.location), 'jpg')
return ek.ek(os.path.join, metadata_dir_name, tbn_file_name)
if os.path.isfile(ep_obj.location):
metadata_dir_name = os.path.join(os.path.dirname(ep_obj.location), 'metadata')
tbn_file_name = sg_helpers.replace_extension(os.path.basename(ep_obj.location), 'jpg')
return os.path.join(metadata_dir_name, tbn_file_name)
def get_season_poster_path(self, show_obj, season):
# type: (sickgear.tv.TVShow, int) -> Optional[AnyStr]
@ -152,8 +150,7 @@ class MediaBrowserMetadata(generic.GenericMetadata):
If no season folder exists, None is returned
"""
dir_list = [x for x in ek.ek(os.listdir, show_obj.location) if
ek.ek(os.path.isdir, ek.ek(os.path.join, show_obj.location, x))]
dir_list = [x for x in os.listdir(show_obj.location) if os.path.isdir(os.path.join(show_obj.location, x))]
season_dir_regex = r'^Season\s+(\d+)$'
@ -183,7 +180,7 @@ class MediaBrowserMetadata(generic.GenericMetadata):
logger.log(u"Using " + str(season_dir) + "/folder.jpg as season dir for season " + str(season), logger.DEBUG)
return ek.ek(os.path.join, show_obj.location, season_dir, 'folder.jpg')
return os.path.join(show_obj.location, season_dir, 'folder.jpg')
def get_season_banner_path(self, show_obj, season):
# type: (sickgear.tv.TVShow, int) -> Optional[AnyStr]
@ -193,8 +190,7 @@ class MediaBrowserMetadata(generic.GenericMetadata):
If no season folder exists, None is returned
"""
dir_list = [x for x in ek.ek(os.listdir, show_obj.location) if
ek.ek(os.path.isdir, ek.ek(os.path.join, show_obj.location, x))]
dir_list = [x for x in os.listdir(show_obj.location) if os.path.isdir(os.path.join(show_obj.location, x))]
season_dir_regex = r'^Season\s+(\d+)$'
@ -224,7 +220,7 @@ class MediaBrowserMetadata(generic.GenericMetadata):
logger.log(u"Using " + str(season_dir) + "/banner.jpg as season dir for season " + str(season), logger.DEBUG)
return ek.ek(os.path.join, show_obj.location, season_dir, 'banner.jpg')
return os.path.join(show_obj.location, season_dir, 'banner.jpg')
def _show_data(self, show_obj):
# type: (sickgear.tv.TVShow) -> Optional[Union[bool, etree.Element]]

6
sickgear/metadata/ps3.py
View file

@ -17,8 +17,6 @@
import os
from . import generic
# noinspection PyPep8Naming
import encodingKludge as ek
import sickgear
# noinspection PyUnreachableCode
@ -79,7 +77,7 @@ class PS3Metadata(generic.GenericMetadata):
self.eg_season_all_banner = "<i>not supported</i>" # type: AnyStr
# Override with empty methods for unsupported features
def retrieveShowMetadata(self, folder):
def retrieve_show_metadata(self, folder):
# type: (AnyStr) -> Tuple[None, None, None]
# no show metadata generated, we abort this lookup function
return None, None, None
@ -132,7 +130,7 @@ class PS3Metadata(generic.GenericMetadata):
ep_obj: a TVEpisode instance for which to create the thumbnail
"""
if ek.ek(os.path.isfile, ep_obj.location):
if os.path.isfile(ep_obj.location):
tbn_filename = ep_obj.location + ".cover.jpg"
else:
return None

20
sickgear/metadata/tivo.py
View file

@ -25,8 +25,6 @@ from .. import logger
import sg_helpers
from lib.tvinfo_base.exceptions import *
import sickgear
# noinspection PyPep8Naming
import encodingKludge as ek
import exceptions_helper
from exceptions_helper import ex
@ -89,7 +87,7 @@ class TIVOMetadata(generic.GenericMetadata):
self.eg_season_all_banner = "<i>not supported</i>" # type: AnyStr
# Override with empty methods for unsupported features
def retrieveShowMetadata(self, folder):
def retrieve_show_metadata(self, folder):
# type: (AnyStr) -> Tuple[None, None, None]
# no show metadata generated, we abort this lookup function
return None, None, None
@ -155,10 +153,10 @@ class TIVOMetadata(generic.GenericMetadata):
ep_obj: a TVEpisode object to get the path for
"""
if ek.ek(os.path.isfile, ep_obj.location):
metadata_file_name = ek.ek(os.path.basename, ep_obj.location) + "." + self._ep_nfo_extension
metadata_dir_name = ek.ek(os.path.join, ek.ek(os.path.dirname, ep_obj.location), '.meta')
metadata_file_path = ek.ek(os.path.join, metadata_dir_name, metadata_file_name)
if os.path.isfile(ep_obj.location):
metadata_file_name = os.path.basename(ep_obj.location) + "." + self._ep_nfo_extension
metadata_dir_name = os.path.join(os.path.dirname(ep_obj.location), '.meta')
metadata_file_path = os.path.join(metadata_dir_name, metadata_file_name)
else:
logger.log(u"Episode location doesn't exist: " + str(ep_obj.location), logger.DEBUG)
return ''
@ -335,17 +333,17 @@ class TIVOMetadata(generic.GenericMetadata):
return False
nfo_file_path = self.get_episode_file_path(ep_obj)
nfo_file_dir = ek.ek(os.path.dirname, nfo_file_path)
nfo_file_dir = os.path.dirname(nfo_file_path)
try:
if not ek.ek(os.path.isdir, nfo_file_dir):
if not os.path.isdir(nfo_file_dir):
logger.log(u"Metadata dir didn't exist, creating it at " + nfo_file_dir, logger.DEBUG)
ek.ek(os.makedirs, nfo_file_dir)
os.makedirs(nfo_file_dir)
sg_helpers.chmod_as_parent(nfo_file_dir)
logger.log(u"Writing episode nfo file to " + nfo_file_path, logger.DEBUG)
with ek.ek(open, nfo_file_path, 'w') as nfo_file:
with open(nfo_file_path, 'w') as nfo_file:
# Calling encode directly, b/c often descriptions have wonky characters.
nfo_file.write(data.encode("utf-8"))

11
sickgear/metadata/wdtv.py
View file

@ -24,8 +24,6 @@ from .. import logger
import sg_helpers
from lib.tvinfo_base.exceptions import *
import sickgear
# noinspection PyPep8Naming
import encodingKludge as ek
import exceptions_helper
from exceptions_helper import ex
from lxml_etree import etree
@ -92,7 +90,7 @@ class WDTVMetadata(generic.GenericMetadata):
self.eg_season_all_banner = "<i>not supported</i>" # type: AnyStr
# Override with empty methods for unsupported features
def retrieveShowMetadata(self, folder):
def retrieve_show_metadata(self, folder):
# type: (AnyStr) -> Tuple[None, None, None]
# no show metadata generated, we abort this lookup function
return None, None, None
@ -137,7 +135,7 @@ class WDTVMetadata(generic.GenericMetadata):
ep_obj: a TVEpisode instance for which to create the thumbnail
"""
if ek.ek(os.path.isfile, ep_obj.location):
if os.path.isfile(ep_obj.location):
return sg_helpers.replace_extension(ep_obj.location, 'metathumb')
def get_season_poster_path(self, show_obj, season):
@ -148,8 +146,7 @@ class WDTVMetadata(generic.GenericMetadata):
If no season folder exists, None is returned
"""
dir_list = [x for x in ek.ek(os.listdir, show_obj.location) if
ek.ek(os.path.isdir, ek.ek(os.path.join, show_obj.location, x))]
dir_list = [x for x in os.listdir(show_obj.location) if os.path.isdir(os.path.join(show_obj.location, x))]
season_dir_regex = r'^Season\s+(\d+)$'
@ -176,7 +173,7 @@ class WDTVMetadata(generic.GenericMetadata):
logger.log(u"Using " + str(season_dir) + "/folder.jpg as season dir for season " + str(season), logger.DEBUG)
return ek.ek(os.path.join, show_obj.location, season_dir, 'folder.jpg')
return os.path.join(show_obj.location, season_dir, 'folder.jpg')
def _ep_data(self, ep_obj):
# type: (sickgear.tv.TVEpisode) -> Optional[Union[bool, etree.Element]]

6
sickgear/metadata/xbmc.py
View file

@ -20,8 +20,6 @@ import os
from . import generic, xbmc_12plus
import sg_helpers
import sickgear
# noinspection PyPep8Naming
import encodingKludge as ek
# noinspection PyUnreachableCode
if False:
@ -104,7 +102,7 @@ class XBMCMetadata(xbmc_12plus.XBMC12PlusMetadata):
ep_obj: a TVEpisode instance for which to create the thumbnail
"""
if ek.ek(os.path.isfile, ep_obj.location):
if os.path.isfile(ep_obj.location):
tbn_filename = sg_helpers.replace_extension(ep_obj.location, 'tbn')
else:
return None
@ -127,7 +125,7 @@ class XBMCMetadata(xbmc_12plus.XBMC12PlusMetadata):
else:
season_poster_filename = 'season' + str(season).zfill(2)
return ek.ek(os.path.join, show_obj.location, season_poster_filename + '.tbn')
return os.path.join(show_obj.location, season_poster_filename + '.tbn')
# present a standard "interface" from the module

8
sickgear/name_parser/parser.py
View file

@ -32,8 +32,6 @@ except ImportError:
regex = None
from . import regexes
# noinspection PyPep8Naming
import encodingKludge as ek
from exceptions_helper import ex
import sickgear
from .. import common, db, helpers, logger, scene_exceptions, scene_numbering
@ -381,7 +379,7 @@ class NameParser(object):
season_number = int(ep_obj['seasonnumber'])
episode_numbers = [int(ep_obj['episodenumber'])]
except BaseTVinfoEpisodenotfound as e:
except BaseTVinfoEpisodenotfound:
logger.warning(u'Unable to find episode with date %s for show %s, skipping' %
(best_result.air_date, show_obj.unique_name))
episode_numbers = []
@ -581,7 +579,7 @@ class NameParser(object):
return cached
# break it into parts if there are any (dirname, file name, extension)
dir_name, file_name = ek.ek(os.path.split, name)
dir_name, file_name = os.path.split(name)
if self.file_name:
base_file_name = helpers.remove_extension(file_name)
@ -596,7 +594,7 @@ class NameParser(object):
file_name_result = self._parse_string(base_file_name)
# use only the direct parent dir
dir_name = ek.ek(os.path.basename, dir_name)
dir_name = os.path.basename(dir_name)
# parse the dirname for extra info if needed
dir_name_result = self._parse_string(dir_name)

5
sickgear/naming.py
View file

@ -22,9 +22,6 @@ from . import common, logger, tv
from .common import Quality, DOWNLOADED
from .name_parser.parser import NameParser
# noinspection PyPep8Naming
import encodingKludge as ek
# noinspection PyUnreachableCode
if False:
from typing import AnyStr, Dict, List
@ -239,7 +236,7 @@ def validate_name(pattern, multi=None, anime_type=None, file_only=False, abd=Fal
new_name = u'%s.ext' % sample_ep_obj.formatted_filename(pattern, multi, anime_type)
new_path = sample_ep_obj.formatted_dir(pattern, multi)
if not file_only:
new_name = ek.ek(os.path.join, new_path, new_name)
new_name = os.path.join(new_path, new_name)
if not new_name:
logger.log(u'Unable to create a name out of %s' % pattern, logger.DEBUG)

19
sickgear/network_timezones.py
View file

@ -25,8 +25,6 @@ import sickgear
from . import db, helpers, logger
from sg_helpers import int_to_time
# noinspection PyPep8Naming
import encodingKludge as ek
from lib.dateutil import tz, zoneinfo
from lib.tzlocal import get_localzone
@ -126,8 +124,8 @@ def get_utc():
pass
if isinstance(utc, datetime.tzinfo):
return utc
tz_utc_file = ek.ek(os.path.join, ek.ek(os.path.dirname, zoneinfo.__file__), 'Greenwich')
if ek.ek(os.path.isfile, tz_utc_file):
tz_utc_file = os.path.join(os.path.dirname(zoneinfo.__file__), 'Greenwich')
if os.path.isfile(tz_utc_file):
return tz.tzfile(tz_utc_file)
@ -154,7 +152,7 @@ def _remove_old_zoneinfo():
"""
if None is not zoneinfo.ZONEFILENAME:
current_file = helpers.real_path(
ek.ek(os.path.join, sickgear.ZONEINFO_DIR, ek.ek(os.path.basename, zoneinfo.ZONEFILENAME)))
os.path.join(sickgear.ZONEINFO_DIR, os.path.basename(zoneinfo.ZONEFILENAME)))
for entry in chain.from_iterable([scantree(helpers.real_path(_dir), include=r'\.tar\.gz$', filter_kind=False)
for _dir in (sickgear.ZONEINFO_DIR, )]): # type: DirEntry
if current_file != entry.path:
@ -192,9 +190,9 @@ def _update_zoneinfo():
current_file = zoneinfo.ZONEFILENAME
if None is not current_file:
current_file = ek.ek(os.path.basename, current_file)
zonefile = helpers.real_path(ek.ek(os.path.join, sickgear.ZONEINFO_DIR, current_file))
zonemetadata = None if not ek.ek(os.path.isfile, zonefile) else \
current_file = os.path.basename(current_file)
zonefile = helpers.real_path(os.path.join(sickgear.ZONEINFO_DIR, current_file))
zonemetadata = None if not os.path.isfile(zonefile) else \
zoneinfo.ZoneInfoFile(zoneinfo.getzoneinfofile_stream()).metadata
newtz_regex = re.search(r'(\d{4}[^.]+)', new_zoneinfo)
@ -220,7 +218,7 @@ def _update_zoneinfo():
if not helpers.download_file(url_tar, zonefile_tmp):
return
if not ek.ek(os.path.exists, zonefile_tmp):
if not os.path.exists(zonefile_tmp):
logger.log(u'Download of %s failed.' % zonefile_tmp, logger.ERROR)
return
@ -233,7 +231,7 @@ def _update_zoneinfo():
if None is not current_file:
remove_file_perm(zonefile)
# rename downloaded file
ek.ek(os.rename, zonefile_tmp, zonefile)
os.rename(zonefile_tmp, zonefile)
setattr(zoneinfo, '_CLASS_ZONE_INSTANCE', list())
tz.gettz.cache_clear()
from dateutil.zoneinfo import get_zonefile_instance
@ -612,7 +610,6 @@ def get_episode_time(d, # type: int
return SGDatetime.from_timestamp(ep_timestamp, tzinfo=tzinfo, tz_aware=True, local_time=False)
except OverflowError:
logger.debug('Invalid timestamp: %s, using fallback' % ep_timestamp)
ep_timestamp = None
ep_time = None
if isinstance(ep_airtime, integer_types):

4
sickgear/notifiers/__init__.py
View file

@ -24,8 +24,6 @@ from . import emby, kodi, plex, xbmc, \
discord, emailnotify, gitter, libnotify, growl, prowl, slack, telegram, trakt
import sickgear
# noinspection PyPep8Naming
import encodingKludge as ek
from _23 import filter_iter, list_values
@ -159,7 +157,7 @@ def notify_update_library(ep_obj, flush_q=False):
continue
shows.add(show_name)
else:
parent_dir = re.sub(r'[/\\]+%s.*' % show_name, '', ek.ek(os.path.dirname, location))
parent_dir = re.sub(r'[/\\]+%s.*' % show_name, '', os.path.dirname(location))
parent_dir = re.sub(r'^(.{,2})[/\\]', '', parent_dir)
if parent_dir in locations:
continue

3
sickgear/notifiers/plex.py
View file

@ -18,7 +18,6 @@ import re
from .generic import Notifier
import sickgear
from encodingKludge import fixStupidEncodings
from exceptions_helper import ex
from _23 import b64encodestring, decode_str, etree, filter_iter, list_values, unquote_plus, urlencode
@ -73,7 +72,7 @@ class PLEXNotifier(Notifier):
return True
except (urllib.error.URLError, IOError) as e:
self._log_warning(u'Couldn\'t contact Plex at ' + fixStupidEncodings(url) + ' ' + ex(e))
self._log_warning(u'Couldn\'t contact Plex at ' + url + ' ' + ex(e))
return False
@staticmethod

4
sickgear/notifiers/pytivo.py
View file

@ -18,8 +18,6 @@ import os
from .generic import BaseNotifier
import sickgear
# noinspection PyPep8Naming
import encodingKludge as ek
from exceptions_helper import ex
from _23 import urlencode
@ -51,7 +49,7 @@ class PyTivoNotifier(BaseNotifier):
show_path = ep_obj.show_obj.location
show_name = ep_obj.show_obj.name
root_show_and_season = ek.ek(os.path.dirname, ep_obj.location)
root_show_and_season = os.path.dirname(ep_obj.location)
abs_path = ep_obj.location
# Some show names have colons in them which are illegal in a path location, so strip them out.

9
sickgear/notifiers/synoindex.py
View file

@ -18,8 +18,6 @@
import os
from .generic import BaseNotifier
# noinspection PyPep8Naming
import encodingKludge as ek
from exceptions_helper import ex
from sg_helpers import cmdline_runner
@ -35,7 +33,7 @@ class SynoIndexNotifier(BaseNotifier):
def _cmdline_run(self, synoindex_cmd):
self._log_debug(u'Executing command ' + str(synoindex_cmd))
self._log_debug(u'Absolute path to command: ' + ek.ek(os.path.abspath, synoindex_cmd[0]))
self._log_debug(u'Absolute path to command: ' + os.path.abspath(synoindex_cmd[0]))
try:
output, err, exit_status = cmdline_runner(synoindex_cmd)
self._log_debug(u'Script result: %s' % output)
@ -44,8 +42,7 @@ class SynoIndexNotifier(BaseNotifier):
def _move_object(self, old_path, new_path):
if self.is_enabled():
self._cmdline_run(['/usr/syno/bin/synoindex', '-N', ek.ek(os.path.abspath, new_path),
ek.ek(os.path.abspath, old_path)])
self._cmdline_run(['/usr/syno/bin/synoindex', '-N', os.path.abspath(new_path), os.path.abspath(old_path)])
def deleteFolder(self, cur_path):
self._make_object('-D', cur_path)
@ -61,7 +58,7 @@ class SynoIndexNotifier(BaseNotifier):
def _make_object(self, cmd_arg, cur_path):
if self.is_enabled():
self._cmdline_run(['/usr/syno/bin/synoindex', cmd_arg, ek.ek(os.path.abspath, cur_path)])
self._cmdline_run(['/usr/syno/bin/synoindex', cmd_arg, os.path.abspath(cur_path)])
def update_library(self, ep_obj=None, **kwargs):
self.addFile(ep_obj.location)

4
sickgear/notifiers/synologynotifier.py
View file

@ -18,8 +18,6 @@
import os
from .generic import Notifier
# noinspection PyPep8Naming
import encodingKludge as ek
from exceptions_helper import ex
from sg_helpers import cmdline_runner
@ -30,7 +28,7 @@ class SynologyNotifier(Notifier):
synodsmnotify_cmd = ['/usr/syno/bin/synodsmnotify', '@administrators', title, body]
self._log(u'Executing command ' + str(synodsmnotify_cmd))
self._log_debug(u'Absolute path to command: ' + ek.ek(os.path.abspath, synodsmnotify_cmd[0]))
self._log_debug(u'Absolute path to command: ' + os.path.abspath(synodsmnotify_cmd[0]))
try:
output, err, exit_status = cmdline_runner(synodsmnotify_cmd)
self._log_debug(u'Script result: %s' % output)

6
sickgear/notifiers/telegram.py
View file

@ -22,8 +22,6 @@ import re
from ..common import USER_AGENT
from .generic import Notifier
# noinspection PyPep8Naming
import encodingKludge as ek
from exceptions_helper import ex
import sickgear
from sickgear.image_cache import ImageCache
@ -51,11 +49,11 @@ class TelegramNotifier(Notifier):
msg = re.sub('(?i)&emsp;?', ' ', msg)
if use_icon:
image_path = ek.ek(os.path.join, sickgear.PROG_DIR, 'gui', 'slick', 'images', 'banner_thumb.jpg')
image_path = os.path.join(sickgear.PROG_DIR, 'gui', 'slick', 'images', 'banner_thumb.jpg')
if not self._testing:
show_obj = ep_obj.show_obj
banner_path = ImageCache().banner_thumb_path(show_obj.tvid, show_obj.prodid)
if ek.ek(os.path.isfile, banner_path):
if os.path.isfile(banner_path):
image_path = banner_path
with open(image_path, 'rb') as f:

13
sickgear/notifiers/xbmc.py
View file

@ -20,7 +20,6 @@ import time
from .generic import Notifier
import sickgear
from exceptions_helper import ex
from encodingKludge import fixStupidEncodings
from json_helper import json_dumps, json_load
from _23 import b64encodestring, decode_str, etree, quote, unquote, unquote_plus, urlencode
@ -163,9 +162,9 @@ class XBMCNotifier(Notifier):
# if we have a password, use authentication
if password:
req.add_header('Authorization', 'Basic %s' % b64encodestring('%s:%s' % (username, password)))
self._log_debug(u'Contacting (with auth header) via url: ' + fixStupidEncodings(url))
self._log_debug(u'Contacting (with auth header) via url: ' + url)
else:
self._log_debug(u'Contacting via url: ' + fixStupidEncodings(url))
self._log_debug(u'Contacting via url: ' + url)
http_response_obj = urllib.request.urlopen(req) # PY2 http_response_obj has no `with` context manager
result = decode_str(http_response_obj.read(), sickgear.SYS_ENCODING)
@ -175,7 +174,7 @@ class XBMCNotifier(Notifier):
return result
except (urllib.error.URLError, IOError) as e:
self._log_warning(u'Couldn\'t contact HTTP at %s %s' % (fixStupidEncodings(url), ex(e)))
self._log_warning(u'Couldn\'t contact HTTP at %s %s' % (url, ex(e)))
return False
def _update_library_http(self, host=None, show_name=None):
@ -303,9 +302,9 @@ class XBMCNotifier(Notifier):
# if we have a password, use authentication
if password:
req.add_header('Authorization', 'Basic %s' % b64encodestring('%s:%s' % (username, password)))
self._log_debug(u'Contacting (with auth header) via url: ' + fixStupidEncodings(url))
self._log_debug(u'Contacting (with auth header) via url: ' + url)
else:
self._log_debug(u'Contacting via url: ' + fixStupidEncodings(url))
self._log_debug(u'Contacting via url: ' + url)
try:
http_response_obj = urllib.request.urlopen(req) # PY2 http_response_obj has no `with` context manager
@ -324,7 +323,7 @@ class XBMCNotifier(Notifier):
return False
except IOError as e:
self._log_warning(u'Couldn\'t contact JSON API at ' + fixStupidEncodings(url) + ' ' + ex(e))
self._log_warning(u'Couldn\'t contact JSON API at ' + url + ' ' + ex(e))
return False
def _update_library_json(self, host=None, show_name=None):

8
sickgear/nzbSplitter.py
View file

@ -21,8 +21,6 @@ import re
from lxml_etree import etree
# noinspection PyPep8Naming
import encodingKludge as ek
from exceptions_helper import ex
import sickgear
@ -112,9 +110,9 @@ def getSeasonNZBs(name, url_data, season):
cur_ep = match.group(1)
fn = name_extractor(cur_file.get('subject', ''))
if cur_ep == re.sub(r'\+\d+\.par2$', '', fn, flags=re.I):
bn, ext = ek.ek(os.path.splitext, fn)
bn, ext = os.path.splitext(fn)
cur_ep = re.sub(r'\.(part\d+|vol\d+(\+\d+)?)$', '', bn, flags=re.I)
bn, ext = ek.ek(os.path.splitext, cur_ep)
bn, ext = os.path.splitext(cur_ep)
if isinstance(ext, string_types) \
and re.search(r'^\.(nzb|r\d{2}|rar|7z|zip|par2|vol\d+|nfo|srt|txt|bat|sh|mkv|mp4|avi|wmv)$', ext,
flags=re.I):
@ -155,7 +153,7 @@ def saveNZB(nzb_name, nzb_string):
:type nzb_string: AnyStr
"""
try:
with ek.ek(open, nzb_name + '.nzb', 'w') as nzb_fh:
with open(nzb_name + '.nzb', 'w') as nzb_fh:
nzb_fh.write(nzb_string)
except EnvironmentError as e:

20
sickgear/piper.py
View file

@ -1,13 +1,5 @@
import sys
# noinspection PyPep8Naming
import encodingKludge as ek
if ek.EXIT_BAD_ENCODING:
print('Sorry, you MUST add the SickGear folder to the PYTHONPATH environment variable')
print('or find another way to force Python to use %s for string encoding.' % ek.SYS_ENCODING)
sys.exit(1)
# #################################
# Sanity check passed, can continue
# #################################
@ -32,7 +24,7 @@ def is_pip_ok():
:return: True if pip is ok
"""
pip_ok = '/' != ek.ek(os.path.expanduser, '~')
pip_ok = '/' != os.path.expanduser('~')
if pip_ok:
pip_version, _, _ = _get_pip_version()
if not pip_version:
@ -115,7 +107,7 @@ def initial_requirements():
def extras_failed_filepath(data_dir):
return ek.ek(os.path.join, data_dir, '.pip_req_spec_failed.txt')
return os.path.join(data_dir, '.pip_req_spec_failed.txt')
def load_ignorables(data_dir):
@ -124,7 +116,7 @@ def load_ignorables(data_dir):
data = []
filepath = extras_failed_filepath(data_dir)
if ek.ek(os.path.isfile, filepath):
if os.path.isfile(filepath):
try:
with io.open(filepath, 'r', encoding='UTF8') as fp:
data = fp.readlines()
@ -194,7 +186,7 @@ def _check_pip_env(pip_outdated=False, reset_fails=False):
from sickgear import logger, PROG_DIR, DATA_DIR
for cur_reco_file in ['requirements.txt', 'recommended.txt']:
try:
with io.open(ek.ek(os.path.join, PROG_DIR, cur_reco_file)) as fh:
with io.open(os.path.join(PROG_DIR, cur_reco_file)) as fh:
input_reco += ['%s\n' % line.strip() for line in fh] # must ensure EOL marker
except (BaseException, Exception):
pass
@ -302,7 +294,7 @@ def pip_update(loading_msg, updates_todo, data_dir):
failed_lines = []
input_reco = None
piper_path = ek.ek(os.path.join, data_dir, '.pip_req_spec_temp.txt')
piper_path = os.path.join(data_dir, '.pip_req_spec_temp.txt')
for cur_project_name, cur_data in iteritems(updates_todo):
msg = 'Installing package "%s"' % cur_project_name
if cur_data.get('info'):
@ -339,7 +331,7 @@ def pip_update(loading_msg, updates_todo, data_dir):
if not parsed_name:
parsed_name = re.findall(r'(?sim)up-to-date\S+\s*(%s).*?\s\(([^)]+)\)$' % find_name, output)
parsed_name = ['' if not parsed_name else '-'.join(parsed_name[0])]
pip_version = re.findall(r'%s-([\d.]+).*?' % find_name, ek.ek(os.path.basename, parsed_name[0]), re.I)[0]
pip_version = re.findall(r'%s-([\d.]+).*?' % find_name, os.path.basename(parsed_name[0]), re.I)[0]
except (BaseException, Exception):
pass

73
sickgear/postProcessor.py
View file

@ -22,8 +22,6 @@ import re
import stat
import threading
# noinspection PyPep8Naming
import encodingKludge as ek
import exceptions_helper
from exceptions_helper import ex
@ -64,17 +62,16 @@ class PostProcessor(object):
nzb_name: The name of the NZB which resulted in this file being downloaded (optional)
"""
# absolute path to the folder that is being processed
self.folder_path = long_path(ek.ek(os.path.dirname, long_path(
ek.ek(os.path.abspath, long_path(file_path))))) # type: AnyStr
self.folder_path = long_path(os.path.dirname(long_path(os.path.abspath(long_path(file_path))))) # type: AnyStr
# full path to file
self.file_path = long_path(file_path) # type: AnyStr
# file name only
self.file_name = ek.ek(os.path.basename, long_path(file_path)) # type: AnyStr
self.file_name = os.path.basename(long_path(file_path)) # type: AnyStr
# the name of the folder only
self.folder_name = ek.ek(os.path.basename, self.folder_path) # type: AnyStr
self.folder_name = os.path.basename(self.folder_path) # type: AnyStr
# name of the NZB that resulted in this folder
self.nzb_name = nzb_name # type: AnyStr or None
@ -112,8 +109,8 @@ class PostProcessor(object):
:param level: The log level to use (optional)
:type level: int
"""
logger_msg = re.sub(r'(?i)<br(?:[\s/]+)>\.*', '', message)
logger_msg = re.sub('(?i)<a[^>]+>([^<]+)<[/]a>', r'\1', logger_msg)
logger_msg = re.sub(r'(?i)<br[\s/]+>\.*', '', message)
logger_msg = re.sub('(?i)<a[^>]+>([^<]+)</a>', r'\1', logger_msg)
logger.log(u'%s' % logger_msg, level)
self.log += message + '\n'
@ -136,12 +133,12 @@ class PostProcessor(object):
return PostProcessor.DOESNT_EXIST
# if the new file exists, return the appropriate code depending on the size
if ek.ek(os.path.isfile, existing_file):
if os.path.isfile(existing_file):
new_file = u'New file %s<br />.. is ' % self.file_path
if ek.ek(os.path.getsize, self.file_path) == ek.ek(os.path.getsize, existing_file):
if os.path.getsize(self.file_path) == os.path.getsize(existing_file):
self._log(u'%sthe same size as %s' % (new_file, existing_file), logger.DEBUG)
return PostProcessor.EXISTS_SAME
elif ek.ek(os.path.getsize, self.file_path) < ek.ek(os.path.getsize, existing_file):
elif os.path.getsize(self.file_path) < os.path.getsize(existing_file):
self._log(u'%ssmaller than %s' % (new_file, existing_file), logger.DEBUG)
return PostProcessor.EXISTS_LARGER
else:
@ -188,7 +185,7 @@ class PostProcessor(object):
base_name = re.sub(r'[\[\]*?]', r'[\g<0>]', base_name)
for meta_ext in ['', '-thumb', '.ext', '.ext.cover', '.metathumb']:
for associated_file_path in ek.ek(glob.glob, '%s%s.*' % (base_name, meta_ext)):
for associated_file_path in glob.glob('%s%s.*' % (base_name, meta_ext)):
# only add associated to list
if associated_file_path == file_path:
continue
@ -201,7 +198,7 @@ class PostProcessor(object):
if re.search(r'(^.+\.(rar|r\d+)$)', associated_file_path):
continue
if ek.ek(os.path.isfile, associated_file_path):
if os.path.isfile(associated_file_path):
file_path_list.append(associated_file_path)
return file_path_list
@ -230,13 +227,13 @@ class PostProcessor(object):
# delete the file and any other files which we want to delete
for cur_file in file_list:
if ek.ek(os.path.isfile, cur_file):
if os.path.isfile(cur_file):
# check first the read-only attribute
file_attribute = ek.ek(os.stat, cur_file)[0]
file_attribute = os.stat(cur_file)[0]
if not file_attribute & stat.S_IWRITE:
# File is read-only, so make it writeable
try:
ek.ek(os.chmod, cur_file, stat.S_IWRITE)
os.chmod(cur_file, stat.S_IWRITE)
self._log(u'Changed read only permissions to writeable to delete file %s'
% cur_file, logger.DEBUG)
except (BaseException, Exception):
@ -245,7 +242,7 @@ class PostProcessor(object):
removal_type = helpers.remove_file(cur_file, log_level=logger.DEBUG)
if True is not ek.ek(os.path.isfile, cur_file):
if True is not os.path.isfile(cur_file):
self._log(u'%s file %s' % (removal_type, cur_file), logger.DEBUG)
# do the library update for synoindex
@ -294,7 +291,7 @@ class PostProcessor(object):
# deal with all files
for cur_file_path in file_list:
cur_file_name = ek.ek(os.path.basename, cur_file_path)
cur_file_name = os.path.basename(cur_file_path)
# get the extension without .
cur_extension = cur_file_path[old_base_name_length + 1:]
@ -304,10 +301,10 @@ class PostProcessor(object):
cur_extension = 'nfo-orig'
# check if file have subtitles language
if ek.ek(os.path.splitext, cur_extension)[1][1:] in common.subtitleExtensions:
cur_lang = ek.ek(os.path.splitext, cur_extension)[0]
if os.path.splitext(cur_extension)[1][1:] in common.subtitleExtensions:
cur_lang = os.path.splitext(cur_extension)[0]
if cur_lang in sickgear.SUBTITLES_LANGUAGES:
cur_extension = cur_lang + ek.ek(os.path.splitext, cur_extension)[1]
cur_extension = cur_lang + os.path.splitext(cur_extension)[1]
# If new base name then convert name
if new_base_name:
@ -317,15 +314,15 @@ class PostProcessor(object):
new_file_name = helpers.replace_extension(cur_file_name, cur_extension)
if sickgear.SUBTITLES_DIR and cur_extension in common.subtitleExtensions:
subs_new_path = ek.ek(os.path.join, new_path, sickgear.SUBTITLES_DIR)
subs_new_path = os.path.join(new_path, sickgear.SUBTITLES_DIR)
dir_exists = helpers.make_dir(subs_new_path)
if not dir_exists:
logger.log(u'Unable to create subtitles folder ' + subs_new_path, logger.ERROR)
else:
helpers.chmod_as_parent(subs_new_path)
new_file_path = ek.ek(os.path.join, subs_new_path, new_file_name)
new_file_path = os.path.join(subs_new_path, new_file_name)
else:
new_file_path = ek.ek(os.path.join, new_path, new_file_name)
new_file_path = os.path.join(new_path, new_file_name)
if None is action_tmpl:
action(cur_file_path, new_file_path)
@ -598,7 +595,7 @@ class PostProcessor(object):
and parse_result.release_group:
if not self.release_name:
self.release_name = helpers.remove_extension(ek.ek(os.path.basename, parse_result.original_name))
self.release_name = helpers.remove_extension(os.path.basename(parse_result.original_name))
else:
logger.log(u'Parse result not sufficient (all following have to be set). will not save release name',
@ -824,7 +821,7 @@ class PostProcessor(object):
try:
script_cmd = [piece for piece in re.split("( |\\\".*?\\\"|'.*?')", script_name) if piece.strip()]
script_cmd[0] = ek.ek(os.path.abspath, script_cmd[0])
script_cmd[0] = os.path.abspath(script_cmd[0])
self._log(u'Absolute path to script: ' + script_cmd[0], logger.DEBUG)
if PY2:
@ -883,7 +880,7 @@ class PostProcessor(object):
"""
try:
existing_show_path = ek.ek(os.path.isdir, ep_obj.show.location)
existing_show_path = os.path.isdir(ep_obj.show.location)
except exceptions_helper.ShowDirNotFoundException:
existing_show_path = False
@ -1062,10 +1059,10 @@ class PostProcessor(object):
:rtype: bool
"""
self._log(u'Processing... %s%s' % (ek.ek(os.path.relpath, self.file_path, self.folder_path),
self._log(u'Processing... %s%s' % (os.path.relpath(self.file_path, self.folder_path),
(u'<br />.. from nzb %s' % self.nzb_name, u'')[None is self.nzb_name]))
if ek.ek(os.path.isdir, self.file_path):
if os.path.isdir(self.file_path):
self._log(u'Expecting file %s<br />.. is actually a directory, skipping' % self.file_path)
return False
@ -1110,9 +1107,9 @@ class PostProcessor(object):
try:
self._delete(cur_ep_obj.location, associated_files=True)
# clean up any left over folders
# clean up any leftover folders
if cur_ep_obj.location:
helpers.delete_empty_folders(ek.ek(os.path.dirname, cur_ep_obj.location),
helpers.delete_empty_folders(os.path.dirname(cur_ep_obj.location),
keep_dir=ep_obj.show_obj.location)
except (OSError, IOError):
raise exceptions_helper.PostProcessingFailed(u'Unable to delete existing files')
@ -1122,10 +1119,10 @@ class PostProcessor(object):
# cur_ep_obj.status = common.Quality.compositeStatus(common.SNATCHED, new_ep_quality)
# if the show directory doesn't exist then make it if allowed
if not ek.ek(os.path.isdir, ep_obj.show_obj.location) and sickgear.CREATE_MISSING_SHOW_DIRS:
if not os.path.isdir(ep_obj.show_obj.location) and sickgear.CREATE_MISSING_SHOW_DIRS:
self._log(u'Show directory does not exist, creating it', logger.DEBUG)
try:
ek.ek(os.mkdir, ep_obj.show_obj.location)
os.mkdir(ep_obj.show_obj.location)
# do the library update for synoindex
notifiers.NotifierFactory().get('SYNOINDEX').addFolder(ep_obj.show_obj.location)
except (OSError, IOError):
@ -1138,7 +1135,7 @@ class PostProcessor(object):
self._change_ep_objs(show_obj, season_number, episode_numbers, new_ep_quality)
# Just want to keep this consistent for failed handling right now
release_name = show_name_helpers.determineReleaseName(self.folder_path, self.nzb_name)
release_name = show_name_helpers.determine_release_name(self.folder_path, self.nzb_name)
if None is release_name:
self._log(u'No snatched release found in history', logger.WARNING)
elif sickgear.USE_FAILED_DOWNLOADS:
@ -1147,8 +1144,8 @@ class PostProcessor(object):
# find the destination folder
try:
proper_path = ep_obj.proper_path()
proper_absolute_path = ek.ek(os.path.join, ep_obj.show_obj.location, proper_path)
dest_path = ek.ek(os.path.dirname, proper_absolute_path)
proper_absolute_path = os.path.join(ep_obj.show_obj.location, proper_path)
dest_path = os.path.dirname(proper_absolute_path)
except exceptions_helper.ShowDirNotFoundException:
raise exceptions_helper.PostProcessingFailed(
@ -1162,7 +1159,7 @@ class PostProcessor(object):
# figure out the base name of the resulting episode file
if sickgear.RENAME_EPISODES:
new_base_name = ek.ek(os.path.basename, proper_path)
new_base_name = os.path.basename(proper_path)
new_file_name = new_base_name + '.' + self.file_name.rpartition('.')[-1]
else:
@ -1224,7 +1221,7 @@ class PostProcessor(object):
sql_l = []
for cur_ep_obj in [ep_obj] + ep_obj.related_ep_obj:
with cur_ep_obj.lock:
cur_ep_obj.location = ek.ek(os.path.join, dest_path, new_file_name)
cur_ep_obj.location = os.path.join(dest_path, new_file_name)
if dosubs:
cur_ep_obj.download_subtitles(force=True)
# set file modify stamp to show airdate

158
sickgear/processTV.py
View file

@ -24,8 +24,6 @@ import shutil
import stat
import sys
# noinspection PyPep8Naming
import encodingKludge as ek
import exceptions_helper
from exceptions_helper import ex, MultipleShowObjectsException
from json_helper import json_dumps, json_loads
@ -79,8 +77,8 @@ class ProcessTVShow(object):
if None is not text:
self._output.append(text)
if self.webhandler:
logger_msg = re.sub(r'(?i)<br(?:[\s/]+)>', '\n', text)
logger_msg = re.sub('(?i)<a[^>]+>([^<]+)<[/]a>', r'\1', logger_msg)
logger_msg = re.sub(r'(?i)<br[\s/]+>', '\n', text)
logger_msg = re.sub('(?i)<a[^>]+>([^<]+)</a>', r'\1', logger_msg)
self.webhandler('%s%s' % (logger_msg, u'\n'))
def _log_helper(self, message, log_level=logger.DEBUG):
@ -91,8 +89,8 @@ class ProcessTVShow(object):
:param log_level: log level
:type log_level: int
"""
logger_msg = re.sub(r'(?i)<br(?:[\s/]+)>\.*', '', message)
logger_msg = re.sub('(?i)<a[^>]+>([^<]+)<[/]a>', r'\1', logger_msg)
logger_msg = re.sub(r'(?i)<br[\s/]+>\.*', '', message)
logger_msg = re.sub('(?i)<a[^>]+>([^<]+)</a>', r'\1', logger_msg)
logger.log(u'%s' % logger_msg, log_level)
self._buffer(message)
return
@ -124,7 +122,7 @@ class ProcessTVShow(object):
:rtype: bool
"""
# check if it's a folder
if not ek.ek(os.path.isdir, folder):
if not os.path.isdir(folder):
return False
# make sure it isn't TV_DOWNLOAD_DIR
@ -142,7 +140,7 @@ class ProcessTVShow(object):
logger.log(u'Warning: unable to delete folder: %s: %s' % (folder, ex(e)), logger.WARNING)
return False
if ek.ek(os.path.isdir, folder):
if os.path.isdir(folder):
logger.log(u'Warning: unable to delete folder: %s' % folder, logger.WARNING)
return False
@ -164,24 +162,24 @@ class ProcessTVShow(object):
# Delete all file not needed
for cur_file in notwanted_files:
cur_file_path = ek.ek(os.path.join, process_path, cur_file)
cur_file_path = os.path.join(process_path, cur_file)
if not ek.ek(os.path.isfile, cur_file_path):
if not os.path.isfile(cur_file_path):
continue # Prevent error when a notwantedfiles is an associated files
# check first the read-only attribute
file_attribute = ek.ek(os.stat, cur_file_path)[0]
file_attribute = os.stat(cur_file_path)[0]
if not file_attribute & stat.S_IWRITE:
# File is read-only, so make it writeable
self._log_helper(u'Changing ReadOnly flag for file ' + cur_file)
try:
ek.ek(os.chmod, cur_file_path, stat.S_IWRITE)
os.chmod(cur_file_path, stat.S_IWRITE)
except OSError as e:
self._log_helper(u'Cannot change permissions of %s: %s' % (cur_file_path, ex(e)))
removal_type = helpers.remove_file(cur_file_path)
if ek.ek(os.path.isfile, cur_file_path):
if os.path.isfile(cur_file_path):
result = False
else:
self._log_helper(u'%s file %s' % (removal_type, cur_file))
@ -254,7 +252,7 @@ class ProcessTVShow(object):
video_size = 0
for cur_video_file in videofiles:
try:
cur_video_size = ek.ek(os.path.getsize, ek.ek(os.path.join, path, cur_video_file))
cur_video_size = os.path.getsize(os.path.join(path, cur_video_file))
except (BaseException, Exception):
continue
@ -263,7 +261,7 @@ class ProcessTVShow(object):
video_pick = cur_video_file
if video_pick:
vid_filename = ek.ek(os.path.splitext, video_pick)[0]
vid_filename = os.path.splitext(video_pick)[0]
# check if filename is garbage, disregard it
if re.search(r'^[a-zA-Z0-9]+$', vid_filename):
return
@ -315,21 +313,20 @@ class ProcessTVShow(object):
"""
# if they passed us a real directory then assume it's the one we want
if dir_name and ek.ek(os.path.isdir, long_path(dir_name)):
dir_name = long_path(ek.ek(os.path.realpath, long_path(dir_name)))
if dir_name and os.path.isdir(long_path(dir_name)):
dir_name = long_path(os.path.realpath(long_path(dir_name)))
# if the client and SickGear are not on the same machine translate the directory in a network directory
elif dir_name and sickgear.TV_DOWNLOAD_DIR and ek.ek(os.path.isdir, sickgear.TV_DOWNLOAD_DIR)\
and ek.ek(os.path.normpath, dir_name) != ek.ek(os.path.normpath, sickgear.TV_DOWNLOAD_DIR):
dir_name = ek.ek(os.path.join, sickgear.TV_DOWNLOAD_DIR,
ek.ek(os.path.abspath, dir_name).split(os.path.sep)[-1])
elif dir_name and sickgear.TV_DOWNLOAD_DIR and os.path.isdir(sickgear.TV_DOWNLOAD_DIR)\
and os.path.normpath(dir_name) != os.path.normpath(sickgear.TV_DOWNLOAD_DIR):
dir_name = os.path.join(sickgear.TV_DOWNLOAD_DIR, os.path.abspath(dir_name).split(os.path.sep)[-1])
self._log_helper(u'SickGear PP Config, completed TV downloads folder: ' + sickgear.TV_DOWNLOAD_DIR)
if dir_name:
self._log_helper(u'Checking folder... ' + dir_name)
# if we didn't find a real directory then process "failed" or just quit
if not dir_name or not ek.ek(os.path.isdir, dir_name):
if not dir_name or not os.path.isdir(dir_name):
if nzb_name and failed:
self._process_failed(dir_name, nzb_name, show_obj=show_obj)
else:
@ -351,7 +348,7 @@ class ProcessTVShow(object):
show_obj = self.check_name(re.sub(r'\.(nzb|torrent)$', '', nzb_name, flags=re.I))
if None is show_obj and dir_name:
show_obj = self.check_name(ek.ek(os.path.basename, dir_name))
show_obj = self.check_name(os.path.basename(dir_name))
path, dirs, files = self._get_path_dir_files(dir_name, nzb_name, pp_type)
@ -376,12 +373,12 @@ class ProcessTVShow(object):
self._process_failed(dir_name, nzb_name, show_obj=show_obj)
self.update_history_tab()
return self.result
rar_content = [x for x in rar_content if not helpers.is_link(ek.ek(os.path.join, path, x))]
rar_content = [x for x in rar_content if not helpers.is_link(os.path.join(path, x))]
path, dirs, files = self._get_path_dir_files(dir_name, nzb_name, pp_type)
files = [x for x in files if not helpers.is_link(ek.ek(os.path.join, path, x))]
files = [x for x in files if not helpers.is_link(os.path.join(path, x))]
video_files = filter_list(helpers.has_media_ext, files)
video_in_rar = filter_list(helpers.has_media_ext, rar_content)
work_files += [ek.ek(os.path.join, path, item) for item in rar_content]
work_files += [os.path.join(path, item) for item in rar_content]
if 0 < len(files):
self._log_helper(u'Process file%s: %s' % (helpers.maybe_plural(files), str(files)))
@ -408,7 +405,7 @@ class ProcessTVShow(object):
if None is show_obj:
soh = self.check_video_filenames(path, video_in_rar)
self._process_media(path, video_in_rar, nzb_name, 'move', force, force_replace, show_obj=soh)
self._delete_files(path, [ek.ek(os.path.relpath, item, path) for item in work_files], force=True)
self._delete_files(path, [os.path.relpath(item, path) for item in work_files], force=True)
video_batch = set(video_files) - set(video_in_rar)
else:
video_batch = video_files
@ -418,7 +415,7 @@ class ProcessTVShow(object):
video_pick = ['']
video_size = 0
for cur_video_file in video_batch:
cur_video_size = ek.ek(os.path.getsize, ek.ek(os.path.join, path, cur_video_file))
cur_video_size = os.path.getsize(os.path.join(path, cur_video_file))
if 0 == video_size or cur_video_size > video_size:
video_size = cur_video_size
video_pick = [cur_video_file]
@ -439,7 +436,7 @@ class ProcessTVShow(object):
# self._set_process_success(reset=True)
for walk_path, walk_dir, files in ek.ek(os.walk, ek.ek(os.path.join, path, directory), topdown=False):
for walk_path, walk_dir, files in os.walk(os.path.join(path, directory), topdown=False):
if sickgear.POSTPONE_IF_SYNC_FILES and any(filter_iter(helpers.is_sync_file, files)):
self._log_helper(u'Found temporary sync files, skipping post process', logger.ERROR)
@ -452,17 +449,17 @@ class ProcessTVShow(object):
continue
# Ignore any symlinks at this stage to avoid the potential for unraring a symlinked archive
files = [x for x in files if not helpers.is_link(ek.ek(os.path.join, walk_path, x))]
files = [x for x in files if not helpers.is_link(os.path.join(walk_path, x))]
rar_files, rarfile_history = self.unused_archives(
walk_path, filter_list(helpers.is_first_rar_volume, files), pp_type, process_method,
rarfile_history)
rar_content = self._unrar(walk_path, rar_files, force)
work_files += [ek.ek(os.path.join, walk_path, item) for item in rar_content]
work_files += [os.path.join(walk_path, item) for item in rar_content]
if self.fail_detected:
self._process_failed(dir_name, nzb_name, show_obj=self.show_obj_helper(show_obj, directory))
continue
rar_content = [x for x in rar_content if not helpers.is_link(ek.ek(os.path.join, walk_path, x))]
rar_content = [x for x in rar_content if not helpers.is_link(os.path.join(walk_path, x))]
files = list(set(files + rar_content))
video_files = filter_list(helpers.has_media_ext, files)
video_in_rar = filter_list(helpers.has_media_ext, rar_content)
@ -483,7 +480,7 @@ class ProcessTVShow(object):
video_pick = ['']
video_size = 0
for cur_video_file in video_batch:
cur_video_size = ek.ek(os.path.getsize, ek.ek(os.path.join, walk_path, cur_video_file))
cur_video_size = os.path.getsize(os.path.join(walk_path, cur_video_file))
if 0 == video_size or cur_video_size > video_size:
video_size = cur_video_size
@ -512,14 +509,12 @@ class ProcessTVShow(object):
self._delete_files(walk_path, notwanted_files)
if 'move' == process_method \
and ek.ek(os.path.normpath, sickgear.TV_DOWNLOAD_DIR) != ek.ek(os.path.normpath,
walk_path):
and os.path.normpath(sickgear.TV_DOWNLOAD_DIR) != os.path.normpath(walk_path):
self._delete_folder(walk_path, check_empty=False)
if 'copy' == process_method and work_files:
self._delete_files(path, [ek.ek(os.path.relpath, item, path) for item in work_files], force=True)
for f in sorted(list(set([ek.ek(os.path.dirname, item) for item in work_files]) - {path}),
key=len, reverse=True):
self._delete_files(path, [os.path.relpath(item, path) for item in work_files], force=True)
for f in sorted(list(set([os.path.dirname(item) for item in work_files]) - {path}), key=len, reverse=True):
self._delete_folder(f)
def _bottom_line(text, log_level=logger.DEBUG):
@ -561,7 +556,7 @@ class ProcessTVShow(object):
if ('auto' == pp_type and sickgear.PROCESS_AUTOMATICALLY
and 'copy' == process_method and sickgear.UNPACK):
archive_history_file = ek.ek(os.path.join, sickgear.DATA_DIR, 'archive_history.txt')
archive_history_file = os.path.join(sickgear.DATA_DIR, 'archive_history.txt')
if not archive_history:
try:
@ -572,10 +567,10 @@ class ProcessTVShow(object):
init_history_cnt = len(archive_history)
archive_history = {k_arc: v for k_arc, v in iteritems(archive_history) if ek.ek(os.path.isfile, k_arc)}
archive_history = {k_arc: v for k_arc, v in iteritems(archive_history) if os.path.isfile(k_arc)}
unused_files = list(set([ek.ek(os.path.join, path, x) for x in archives]) - set(iterkeys(archive_history)))
archives = [ek.ek(os.path.basename, x) for x in unused_files]
unused_files = list(set([os.path.join(path, x) for x in archives]) - set(iterkeys(archive_history)))
archives = [os.path.basename(x) for x in unused_files]
if unused_files:
for f in unused_files:
archive_history.setdefault(f, int(timestamp_near(datetime.datetime.utcnow())))
@ -607,18 +602,18 @@ class ProcessTVShow(object):
"""
self._log_helper(u'Processing sub dir: ' + dir_name)
if ek.ek(os.path.basename, dir_name).startswith('_FAILED_'):
if os.path.basename(dir_name).startswith('_FAILED_'):
self._log_helper(u'The directory name indicates it failed to extract.')
failed = True
elif ek.ek(os.path.basename, dir_name).startswith('_UNDERSIZED_'):
elif os.path.basename(dir_name).startswith('_UNDERSIZED_'):
self._log_helper(u'The directory name indicates that it was previously rejected for being undersized.')
failed = True
elif ek.ek(os.path.basename, dir_name).upper().startswith('_UNPACK'):
elif os.path.basename(dir_name).upper().startswith('_UNPACK'):
self._log_helper(u'The directory name indicates that this release is in the process of being unpacked.')
return False
if failed:
self._process_failed(ek.ek(os.path.join, path, dir_name), nzb_name_original, show_obj=show_obj)
self._process_failed(os.path.join(path, dir_name), nzb_name_original, show_obj=show_obj)
return False
if helpers.is_hidden_folder(dir_name):
@ -630,8 +625,8 @@ class ProcessTVShow(object):
sql_result = my_db.select('SELECT * FROM tv_shows')
for cur_result in sql_result:
if dir_name.lower().startswith(ek.ek(os.path.realpath, cur_result['location']).lower() + os.sep)\
or dir_name.lower() == ek.ek(os.path.realpath, cur_result['location']).lower():
if dir_name.lower().startswith(os.path.realpath(cur_result['location']).lower() + os.sep) \
or dir_name.lower() == os.path.realpath(cur_result['location']).lower():
self._log_helper(
u'Found an episode that has already been moved to its show dir, skipping',
logger.ERROR)
@ -641,7 +636,7 @@ class ProcessTVShow(object):
all_files = []
all_dirs = []
process_path = None
for process_path, process_dir, fileList in ek.ek(os.walk, ek.ek(os.path.join, path, dir_name), topdown=False):
for process_path, process_dir, fileList in os.walk(os.path.join(path, dir_name), topdown=False):
all_dirs += process_dir
all_files += fileList
@ -688,7 +683,7 @@ class ProcessTVShow(object):
unpacked_files = []
if 'win32' == sys.platform:
rarfile.UNRAR_TOOL = ek.ek(os.path.join, sickgear.PROG_DIR, 'lib', 'rarfile', 'UnRAR.exe')
rarfile.UNRAR_TOOL = os.path.join(sickgear.PROG_DIR, 'lib', 'rarfile', 'UnRAR.exe')
if sickgear.UNPACK and rar_files:
@ -699,7 +694,7 @@ class ProcessTVShow(object):
self._log_helper(u'Unpacking archive: ' + archive)
try:
rar_handle = rarfile.RarFile(ek.ek(os.path.join, path, archive))
rar_handle = rarfile.RarFile(os.path.join(path, archive))
except (BaseException, Exception):
self._log_helper(u'Failed to open archive: %s' % archive, logger.ERROR)
self._set_process_success(False)
@ -707,7 +702,7 @@ class ProcessTVShow(object):
try:
# Skip extraction if any file in archive has previously been extracted
skip_file = False
for file_in_archive in [ek.ek(os.path.basename, x.filename)
for file_in_archive in [os.path.basename(x.filename)
for x in rar_handle.infolist() if not x.is_dir()]:
if self._already_postprocessed(path, file_in_archive, force):
self._log_helper(
@ -721,8 +716,7 @@ class ProcessTVShow(object):
raise rarfile.PasswordRequired
rar_handle.extractall(path=path)
rar_content = [ek.ek(os.path.normpath, x.filename)
for x in rar_handle.infolist() if not x.is_dir()]
rar_content = [os.path.normpath(x.filename) for x in rar_handle.infolist() if not x.is_dir()]
renamed = self.cleanup_names(path, rar_content)
cur_unpacked = rar_content if not renamed else \
(list(set(rar_content) - set(iterkeys(renamed))) + list_values(renamed))
@ -744,7 +738,7 @@ class ProcessTVShow(object):
# check for passworded rar's
for archive in rar_files:
try:
rar_handle = rarfile.RarFile(ek.ek(os.path.join, path, archive))
rar_handle = rarfile.RarFile(os.path.join(path, archive))
except (BaseException, Exception):
self._log_helper(u'Failed to open archive: %s' % archive, logger.ERROR)
continue
@ -773,7 +767,7 @@ class ProcessTVShow(object):
old_name = None
new_name = None
params = {
'base_name': ek.ek(os.path.basename, directory),
'base_name': os.path.basename(directory),
'reverse_pattern': re.compile('|'.join([
r'\.\d{2}e\d{2}s\.', r'\.p0(?:63|27|612)\.', r'\.[pi](?:084|675|0801)\.', r'\b[45]62[xh]\.',
r'\.yarulb\.', r'\.vtd[hp]\.', r'\.(?:ld[.-]?)?bew\.', r'\.pir.?(?:shv|dov|dvd|bew|db|rb)\.',
@ -797,9 +791,9 @@ class ProcessTVShow(object):
for cur_filename in _filenames:
file_name, file_extension = ek.ek(os.path.splitext, cur_filename)
file_path = ek.ek(os.path.join, _dirpath, cur_filename)
dir_name = ek.ek(os.path.dirname, file_path)
file_name, file_extension = os.path.splitext(cur_filename)
file_path = os.path.join(_dirpath, cur_filename)
dir_name = os.path.dirname(file_path)
if None is not reverse_pattern.search(file_name):
na_parts = season_pattern.search(file_name)
@ -817,32 +811,32 @@ class ProcessTVShow(object):
new_filename = file_name[::-1]
logger.log('Reversing base filename "%s" to "%s"' % (file_name, new_filename))
try:
ek.ek(os.rename, file_path, ek.ek(os.path.join, _dirpath, new_filename + file_extension))
is_renamed[ek.ek(os.path.relpath, file_path, directory)] = ek.ek(
os.path.relpath, new_filename + file_extension, directory)
os.rename(file_path, os.path.join(_dirpath, new_filename + file_extension))
is_renamed[os.path.relpath(file_path, directory)] = \
os.path.relpath(new_filename + file_extension, directory)
except OSError as _e:
logger.log('Error unable to rename file "%s" because %s' % (cur_filename, ex(_e)), logger.ERROR)
elif helpers.has_media_ext(cur_filename) and \
None is not garbage_name.search(file_name) and None is not media_pattern.search(base_name):
_num_videos += 1
_old_name = file_path
_new_name = ek.ek(os.path.join, dir_name, '%s%s' % (base_name, file_extension))
_new_name = os.path.join(dir_name, '%s%s' % (base_name, file_extension))
return is_renamed, _num_videos, _old_name, _new_name
if files:
is_renamed, num_videos, old_name, new_name = renamer(
directory, files, num_videos, old_name, new_name, **params)
else:
for cur_dirpath, void, cur_filenames in ek.ek(os.walk, directory):
for cur_dirpath, void, cur_filenames in os.walk(directory):
is_renamed, num_videos, old_name, new_name = renamer(
cur_dirpath, cur_filenames, num_videos, old_name, new_name, **params)
if all([not is_renamed, 1 == num_videos, old_name, new_name]):
try_name = ek.ek(os.path.basename, new_name)
logger.log('Renaming file "%s" using dirname as "%s"' % (ek.ek(os.path.basename, old_name), try_name))
try_name = os.path.basename(new_name)
logger.log('Renaming file "%s" using dirname as "%s"' % (os.path.basename(old_name), try_name))
try:
ek.ek(os.rename, old_name, new_name)
is_renamed[ek.ek(os.path.relpath, old_name, directory)] = ek.ek(os.path.relpath, new_name, directory)
os.rename(old_name, new_name)
is_renamed[os.path.relpath(old_name, directory)] = os.path.relpath(new_name, directory)
except OSError as e:
logger.log('Error unable to rename file "%s" because %s' % (old_name, ex(e)), logger.ERROR)
@ -859,11 +853,11 @@ class ProcessTVShow(object):
result = False
chunks = {}
matcher = re.compile(r'\.[0-9]+$')
for dirpath, void, filenames in ek.ek(os.walk, directory):
for dirpath, void, filenames in os.walk(directory):
for filename in filenames:
if None is not matcher.search(filename):
maybe_chunk = ek.ek(os.path.join, dirpath, filename)
base_filepath, ext = ek.ek(os.path.splitext, maybe_chunk)
maybe_chunk = os.path.join(dirpath, filename)
base_filepath, ext = os.path.splitext(maybe_chunk)
if base_filepath not in chunks:
chunks[base_filepath] = []
chunks[base_filepath].append(maybe_chunk)
@ -874,22 +868,22 @@ class ProcessTVShow(object):
for base_filepath in chunks:
chunks[base_filepath].sort()
chunk_set = chunks[base_filepath]
if ek.ek(os.path.isfile, base_filepath):
base_filesize = ek.ek(os.path.getsize, base_filepath)
chunk_sizes = [ek.ek(os.path.getsize, x) for x in chunk_set]
if os.path.isfile(base_filepath):
base_filesize = os.path.getsize(base_filepath)
chunk_sizes = [os.path.getsize(x) for x in chunk_set]
largest_chunk = max(chunk_sizes)
if largest_chunk >= base_filesize:
outfile = '%s.001' % base_filepath
if outfile not in chunk_set:
try:
ek.ek(os.rename, base_filepath, outfile)
os.rename(base_filepath, outfile)
except OSError:
logger.log('Error unable to rename file %s' % base_filepath, logger.ERROR)
return result
chunk_set.append(outfile)
chunk_set.sort()
else:
del_dir, del_file = ek.ek(os.path.split, base_filepath)
del_dir, del_file = os.path.split(base_filepath)
if not self._delete_files(del_dir, [del_file], force=True):
return result
else:
@ -1048,7 +1042,7 @@ class ProcessTVShow(object):
self._set_process_success(False)
continue
cur_video_file_path = ek.ek(os.path.join, process_path, cur_video_file)
cur_video_file_path = os.path.join(process_path, cur_video_file)
parent = self.find_parent(cur_video_file_path)
if parent:
@ -1097,16 +1091,16 @@ class ProcessTVShow(object):
if dir_name == sickgear.TV_DOWNLOAD_DIR and not nzb_name or 'manual' == pp_type:
# Scheduled Media Process Active
# Get at first all the subdir in the dir_name
for path, dirs, files in ek.ek(os.walk, dir_name):
files = [x for x in files if not helpers.is_link(ek.ek(os.path.join, path, x))]
for path, dirs, files in os.walk(dir_name):
files = [x for x in files if not helpers.is_link(os.path.join(path, x))]
break
else:
path, dirs = ek.ek(os.path.split, dir_name) # Script Media Process
path, dirs = os.path.split(dir_name) # Script Media Process
if None is not nzb_name and not nzb_name.endswith('.nzb') and \
ek.ek(os.path.isfile, ek.ek(os.path.join, dir_name, nzb_name)):
os.path.isfile(os.path.join(dir_name, nzb_name)):
# For single torrent file without directory
dirs = []
files = [ek.ek(os.path.join, dir_name, nzb_name)]
files = [os.path.join(dir_name, nzb_name)]
else:
dirs = [dirs]
files = []

4
sickgear/properFinder.py
View file

@ -21,8 +21,6 @@ import re
import threading
import traceback
# noinspection PyPep8Naming
import encodingKludge as ek
from exceptions_helper import ex, MultipleShowObjectsException, AuthException
import sickgear
@ -466,7 +464,7 @@ def _get_proper_list(aired_since_shows, # type: datetime.datetime
for hitem in history_results:
# if the result exists in history already we need to skip it
if clean_proper_name == _generic_name(helpers.remove_non_release_groups(
ek.ek(os.path.basename, hitem['resource']))):
os.path.basename(hitem['resource']))):
is_same = True
break
if is_same:

4
sickgear/providers/filesharingtalk.py
View file

@ -311,7 +311,7 @@ class FSTProvider(generic.NZBProvider):
:return: list of search strings
:rtype: List[AnyStr]
"""
return [x for x in show_name_helpers.makeSceneSeasonSearchString(self.show_obj, ep_obj)]
return [x for x in show_name_helpers.make_scene_season_search_string(self.show_obj, ep_obj)]
def _episode_strings(self, ep_obj):
"""
@ -321,7 +321,7 @@ class FSTProvider(generic.NZBProvider):
:return: list of search strings
:rtype: List[AnyStr]
"""
return [x for x in show_name_helpers.makeSceneSearchString(self.show_obj, ep_obj)]
return [x for x in show_name_helpers.make_scene_search_string(self.show_obj, ep_obj)]
@staticmethod
def ui_string(key=None):

23
sickgear/providers/generic.py
View file

@ -29,9 +29,7 @@ import threading
import socket
import zlib
# noinspection PyPep8Naming
import encodingKludge as ek
from exceptions_helper import SickBeardException, AuthException, ex
from exceptions_helper import SickGearException, AuthException, ex
import sickgear
from .. import classes, db, helpers, logger, tvcache
@ -60,7 +58,7 @@ if False:
from typing import Any, AnyStr, Callable, Dict, List, Match, Optional, Tuple, Union
class HaltParseException(SickBeardException):
class HaltParseException(SickGearException):
"""Something requires the current processing to abort"""
@ -653,8 +651,7 @@ class GenericProvider(object):
:return:
"""
for name in ['%s.%s' % (self.get_id(), image_ext) for image_ext in ['png', 'gif', 'jpg']]:
if ek.ek(os.path.isfile,
ek.ek(os.path.join, sickgear.PROG_DIR, 'gui', sickgear.GUI_NAME, 'images', 'providers', name)):
if os.path.isfile(os.path.join(sickgear.PROG_DIR, 'gui', sickgear.GUI_NAME, 'images', 'providers', name)):
return name
return '%s.png' % ('newznab', default_name[0])[any(default_name)]
@ -838,11 +835,11 @@ class GenericProvider(object):
cache_dir = sickgear.CACHE_DIR or helpers.get_system_temp_dir()
base_name = '%s.%s' % (re.sub('.%s$' % self.providerType, '', helpers.sanitize_filename(result.name)),
self.providerType)
final_file = ek.ek(os.path.join, final_dir, base_name)
final_file = os.path.join(final_dir, base_name)
cached = result.cache_filepath
if cached and ek.ek(os.path.isfile, cached):
base_name = ek.ek(os.path.basename, cached)
cache_file = ek.ek(os.path.join, cache_dir, base_name)
if cached and os.path.isfile(cached):
base_name = os.path.basename(cached)
cache_file = os.path.join(cache_dir, base_name)
self.session.headers['Referer'] = url
if cached or helpers.download_file(url, cache_file, session=self.session, allow_redirects='/it' not in url,
@ -870,7 +867,7 @@ class GenericProvider(object):
if not saved and 'magnet' == link_type:
logger.log(u'All torrent cache servers failed to return a downloadable result', logger.DEBUG)
final_file = ek.ek(os.path.join, final_dir, '%s.%s' % (helpers.sanitize_filename(result.name), link_type))
final_file = os.path.join(final_dir, '%s.%s' % (helpers.sanitize_filename(result.name), link_type))
try:
with open(final_file, 'wb') as fp:
fp.write(decode_bytes(result.url))
@ -1880,7 +1877,7 @@ class TorrentProvider(GenericProvider):
seen_attr = 'PROVIDER_SEEN'
if obf and self.__module__ not in getattr(sickgear, seen_attr, []):
file_path = '%s.py' % os.path.join(sickgear.PROG_DIR, *self.__module__.split('.'))
if ek.ek(os.path.isfile, file_path):
if os.path.isfile(file_path):
with open(file_path, 'rb') as file_hd:
c = bytearray(codecs.encode(decode_bytes(str(zlib.crc32(file_hd.read()))), 'hex_codec'))
@ -1996,7 +1993,7 @@ class TorrentProvider(GenericProvider):
if 2012691328 == s + zlib.crc32(decode_bytes(('.%s' % parsed.netloc).split('.')[-2])):
is_valid = False
file_name = '%s.py' % os.path.join(sickgear.PROG_DIR, *self.__module__.split('.'))
if ek.ek(os.path.isfile, file_name):
if os.path.isfile(file_name):
with open(file_name, 'rb') as file_hd:
is_valid = s + zlib.crc32(file_hd.read()) in (1661931498, 472149389)
return is_valid

4
sickgear/providers/omgwtfnzbs.py
View file

@ -109,7 +109,7 @@ class OmgwtfnzbsProvider(generic.NZBProvider):
:return: list of search strings
:rtype: List[AnyStr]
"""
return [x for x in show_name_helpers.makeSceneSeasonSearchString(self.show_obj, ep_obj)]
return [x for x in show_name_helpers.make_scene_season_search_string(self.show_obj, ep_obj)]
def _episode_strings(self, ep_obj):
"""
@ -119,7 +119,7 @@ class OmgwtfnzbsProvider(generic.NZBProvider):
:return: list of search strings
:rtype: List[AnyStr]
"""
return [x for x in show_name_helpers.makeSceneSearchString(self.show_obj, ep_obj)]
return [x for x in show_name_helpers.make_scene_search_string(self.show_obj, ep_obj)]
def _title_and_url(self, item):
"""

4
sickgear/providers/tokyotoshokan.py
View file

@ -98,10 +98,10 @@ class TokyoToshokanProvider(generic.TorrentProvider):
return results
def _season_strings(self, *args, **kwargs):
return [{'Season': show_name_helpers.makeSceneSeasonSearchString(self.show_obj, *args)}]
return [{'Season': show_name_helpers.make_scene_season_search_string(self.show_obj, *args)}]
def _episode_strings(self, *args, **kwargs):
return [{'Episode': show_name_helpers.makeSceneSearchString(self.show_obj, *args)}]
return [{'Episode': show_name_helpers.make_scene_search_string(self.show_obj, *args)}]
class TokyoToshokanCache(tvcache.TVCache):

22
sickgear/scene_exceptions.py
View file

@ -25,8 +25,6 @@ import threading
import traceback
import sickgear
# noinspection PyPep8Naming
import encodingKludge as ek
from exceptions_helper import ex
from json_helper import json_load
from . import db, helpers, logger, name_cache
@ -387,22 +385,22 @@ def _custom_exceptions_fetcher():
src_id = 'GHSG'
logger.log(u'Checking to update custom alternatives from %s' % src_id)
dirpath = ek.ek(os.path.join, sickgear.CACHE_DIR, 'alts')
tmppath = ek.ek(os.path.join, dirpath, 'tmp')
file_rar = ek.ek(os.path.join, tmppath, 'alt.rar')
file_cache = ek.ek(os.path.join, dirpath, 'alt.json')
dirpath = os.path.join(sickgear.CACHE_DIR, 'alts')
tmppath = os.path.join(dirpath, 'tmp')
file_rar = os.path.join(tmppath, 'alt.rar')
file_cache = os.path.join(dirpath, 'alt.json')
iv = 30 * 60 # min interval to fetch updates
refresh = should_refresh(src_id, iv)
fetch_data = not ek.ek(os.path.isfile, file_cache) or (not int(os.environ.get('NO_ALT_GET', 0)) and refresh)
fetch_data = not os.path.isfile(file_cache) or (not int(os.environ.get('NO_ALT_GET', 0)) and refresh)
if fetch_data:
if ek.ek(os.path.exists, tmppath):
if os.path.exists(tmppath):
helpers.remove_file(tmppath, tree=True)
helpers.make_path(tmppath)
helpers.download_file(r'https://github.com/SickGear/sickgear.altdata/raw/main/alt.rar', file_rar)
rar_handle = None
if 'win32' == sys.platform:
rarfile.UNRAR_TOOL = ek.ek(os.path.join, sickgear.PROG_DIR, 'lib', 'rarfile', 'UnRAR.exe')
rarfile.UNRAR_TOOL = os.path.join(sickgear.PROG_DIR, 'lib', 'rarfile', 'UnRAR.exe')
try:
rar_handle = rarfile.RarFile(file_rar)
rar_handle.extractall(path=dirpath, pwd='sickgear_alt')
@ -418,7 +416,7 @@ def _custom_exceptions_fetcher():
if refresh:
set_last_refresh(src_id)
if not fetch_data and not ek.ek(os.path.isfile, file_cache):
if not fetch_data and not os.path.isfile(file_cache):
logger.debug(u'Unable to fetch custom exceptions, skipped: %s' % file_rar)
return custom_exception_dict, cnt_updated_numbers, should_refresh(src_id, iv, remaining=True)
@ -516,7 +514,7 @@ def _xem_exceptions_fetcher():
for tvid in [i for i in sickgear.TVInfoAPI().sources if 'xem_origin' in sickgear.TVInfoAPI(i).config]:
logger.log(u'Checking for XEM scene exception updates for %s' % sickgear.TVInfoAPI(tvid).name)
url = 'http://thexem.info/map/allNames?origin=%s%s&seasonNumbers=1'\
url = 'https://thexem.info/map/allNames?origin=%s%s&seasonNumbers=1'\
% (sickgear.TVInfoAPI(tvid).config['xem_origin'], ('&language=us', '')['xem' == xem_list])
parsed_json = helpers.get_url(url, parse_json=True, timeout=90)
@ -551,7 +549,7 @@ def _xem_get_ids(infosrc_name, xem_origin):
"""
xem_ids = []
url = 'http://thexem.info/map/havemap?origin=%s' % xem_origin
url = 'https://thexem.info/map/havemap?origin=%s' % xem_origin
task = 'Fetching show ids with%s xem scene mapping%s for origin'
logger.log(u'%s %s' % (task % ('', 's'), infosrc_name))

6
sickgear/search.py
View file

@ -22,8 +22,6 @@ import re
import threading
import traceback
# noinspection PyPep8Naming
import encodingKludge as ek
import exceptions_helper
from exceptions_helper import ex
from sg_helpers import write_file
@ -65,7 +63,7 @@ def _download_result(result):
elif 'nzbdata' == result.resultType:
# get the final file path to the nzb
file_name = ek.ek(os.path.join, sickgear.NZB_DIR, u'%s.nzb' % result.name)
file_name = os.path.join(sickgear.NZB_DIR, u'%s.nzb' % result.name)
logger.log(u'Saving NZB to %s' % file_name)
@ -768,7 +766,7 @@ def cache_torrent_file(
):
# type: (...) -> Optional[TorrentSearchResult]
cache_file = ek.ek(os.path.join, sickgear.CACHE_DIR or helpers.get_system_temp_dir(),
cache_file = os.path.join(sickgear.CACHE_DIR or helpers.get_system_temp_dir(),
'%s.torrent' % (helpers.sanitize_filename(search_result.name)))
if not helpers.download_file(

91
sickgear/show_name_helpers.py
View file

@ -19,8 +19,6 @@ import os
import copy
import re
# noinspection PyPep8Naming
import encodingKludge as ek
from exceptions_helper import ex
import sickgear
@ -233,19 +231,21 @@ def get_show_names_all_possible(show_obj, season=-1, scenify=True, spacer='.', f
:param season: season
:param scenify:
:param spacer: spacer
:param force_anime:
:return:
"""
show_names = list(set(allPossibleShowNames(show_obj, season=season, force_anime=force_anime))) # type: List[AnyStr]
show_names = list(set(
all_possible_show_names(show_obj, season=season, force_anime=force_anime))) # type: List[AnyStr]
if scenify:
show_names = map_list(sanitize_scene_name, show_names)
return url_encode(show_names, spacer)
def makeSceneSeasonSearchString(show_obj, # type: sickgear.tv.TVShow
ep_obj, # type: sickgear.tv.TVEpisode
ignore_allowlist=False, # type: bool
extra_search_type=None
): # type: (...) -> List[AnyStr]
def make_scene_season_search_string(show_obj, # type: sickgear.tv.TVShow
ep_obj, # type: sickgear.tv.TVEpisode
ignore_allowlist=False, # type: bool
extra_search_type=None
): # type: (...) -> List[AnyStr]
"""
:param show_obj: show object
@ -258,34 +258,34 @@ def makeSceneSeasonSearchString(show_obj, # type: sickgear.tv.TVShow
numseasons = 0
# the search string for air by date shows is just
seasonStrings = [str(ep_obj.airdate).split('-')[0]]
season_strings = [str(ep_obj.airdate).split('-')[0]]
elif show_obj.is_anime:
numseasons = 0
ep_obj_list = show_obj.get_all_episodes(ep_obj.season)
# get show qualities
anyQualities, bestQualities = common.Quality.splitQuality(show_obj.quality)
any_qualities, best_qualities = common.Quality.splitQuality(show_obj.quality)
# compile a list of all the episode numbers we need in this 'season'
seasonStrings = []
season_strings = []
for episode in ep_obj_list:
# get quality of the episode
curCompositeStatus = episode.status
curStatus, curQuality = common.Quality.splitCompositeStatus(curCompositeStatus)
cur_composite_status = episode.status
cur_status, cur_quality = common.Quality.splitCompositeStatus(cur_composite_status)
if bestQualities:
highestBestQuality = max(bestQualities)
if best_qualities:
highest_best_quality = max(best_qualities)
else:
highestBestQuality = 0
highest_best_quality = 0
# if we need a better one then add it to the list of episodes to fetch
if (curStatus in (
if (cur_status in (
common.DOWNLOADED,
common.SNATCHED) and curQuality < highestBestQuality) or curStatus == common.WANTED:
common.SNATCHED) and cur_quality < highest_best_quality) or cur_status == common.WANTED:
ab_number = episode.scene_absolute_number
if 0 < ab_number:
seasonStrings.append("%02d" % ab_number)
season_strings.append("%02d" % ab_number)
else:
my_db = db.DBConnection()
@ -297,7 +297,7 @@ def makeSceneSeasonSearchString(show_obj, # type: sickgear.tv.TVShow
[show_obj.tvid, show_obj.prodid])
numseasons = int(sql_result[0][0])
seasonStrings = ["S%02d" % int(ep_obj.scene_season)]
season_strings = ["S%02d" % int(ep_obj.scene_season)]
show_names = get_show_names_all_possible(show_obj, ep_obj.scene_season)
@ -312,7 +312,7 @@ def makeSceneSeasonSearchString(show_obj, # type: sickgear.tv.TVShow
to_return.append(cur_name)
# for providers that don't allow multiple searches in one request we only search for Sxx style stuff
else:
for cur_season in seasonStrings:
for cur_season in season_strings:
if not ignore_allowlist and show_obj.is_anime \
and None is not show_obj.release_groups and show_obj.release_groups.allowlist:
for keyword in show_obj.release_groups.allowlist:
@ -324,10 +324,10 @@ def makeSceneSeasonSearchString(show_obj, # type: sickgear.tv.TVShow
return to_return
def makeSceneSearchString(show_obj, # type: sickgear.tv.TVShow
ep_obj, # type: sickgear.tv.TVEpisode
ignore_allowlist=False # type: bool
): # type: (...) -> List[AnyStr]
def make_scene_search_string(show_obj, # type: sickgear.tv.TVShow
ep_obj, # type: sickgear.tv.TVEpisode
ignore_allowlist=False # type: bool
): # type: (...) -> List[AnyStr]
"""
:param show_obj: show object
@ -374,7 +374,7 @@ def makeSceneSearchString(show_obj, # type: sickgear.tv.TVShow
return to_return
def allPossibleShowNames(show_obj, season=-1, force_anime=False):
def all_possible_show_names(show_obj, season=-1, force_anime=False):
# type: (sickgear.tv.TVShow, int, bool) -> List[AnyStr]
"""
Figures out every possible variation of the name for a particular show. Includes TVDB name, TVRage name,
@ -382,45 +382,48 @@ def allPossibleShowNames(show_obj, season=-1, force_anime=False):
:param show_obj: a TVShow object that we should get the names of
:param season: season
:param force_anime:
:return: a list of all the possible show names
"""
showNames = get_scene_exceptions(show_obj.tvid, show_obj.prodid, season=season)[:]
if not showNames: # if we dont have any season specific exceptions fallback to generic exceptions
show_names = get_scene_exceptions(show_obj.tvid, show_obj.prodid, season=season)[:]
if not show_names: # if we dont have any season specific exceptions fallback to generic exceptions
season = -1
showNames = get_scene_exceptions(show_obj.tvid, show_obj.prodid, season=season)[:]
show_names = get_scene_exceptions(show_obj.tvid, show_obj.prodid, season=season)[:]
if -1 == season:
showNames.append(show_obj.name)
show_names.append(show_obj.name)
if not show_obj.is_anime and not force_anime:
newShowNames = []
new_show_names = []
country_list = common.countryList
country_list.update(dict(zip(itervalues(common.countryList), iterkeys(common.countryList))))
for curName in set(showNames):
if not curName:
for cur_name in set(show_names):
if not cur_name:
continue
# if we have "Show Name Australia" or "Show Name (Australia)" this will add "Show Name (AU)" for
# any countries defined in common.countryList
# (and vice versa)
for curCountry in country_list:
if curName.endswith(' ' + curCountry):
newShowNames.append(curName.replace(' ' + curCountry, ' (' + country_list[curCountry] + ')'))
elif curName.endswith(' (' + curCountry + ')'):
newShowNames.append(curName.replace(' (' + curCountry + ')', ' (' + country_list[curCountry] + ')'))
for cur_country in country_list:
if cur_name.endswith(' ' + cur_country):
new_show_names.append(cur_name.replace(' ' + cur_country,
' (' + country_list[cur_country] + ')'))
elif cur_name.endswith(' (' + cur_country + ')'):
new_show_names.append(cur_name.replace(' (' + cur_country + ')',
' (' + country_list[cur_country] + ')'))
# if we have "Show Name (2013)" this will strip the (2013) show year from the show name
# newShowNames.append(re.sub('\(\d{4}\)','',curName))
showNames += newShowNames
show_names += new_show_names
return showNames
return show_names
def determineReleaseName(dir_name=None, nzb_name=None):
def determine_release_name(dir_name=None, nzb_name=None):
# type: (AnyStr, AnyStr) -> Union[AnyStr, None]
"""Determine a release name from an nzb and/or folder name
"""Determine a release name from a nzb and/or folder name
:param dir_name: dir name
:param nzb_name: nzb name
:return: None or release name
@ -430,7 +433,7 @@ def determineReleaseName(dir_name=None, nzb_name=None):
logger.log(u'Using nzb name for release name.')
return nzb_name.rpartition('.')[0]
if not dir_name or not ek.ek(os.path.isdir, dir_name):
if not dir_name or not os.path.isdir(dir_name):
return None
# try to get the release name from nzb/nfo
@ -447,7 +450,7 @@ def determineReleaseName(dir_name=None, nzb_name=None):
return found_file.rpartition('.')[0]
# If that fails, we try the folder
folder = ek.ek(os.path.basename, dir_name)
folder = os.path.basename(dir_name)
if pass_wordlist_checks(folder):
# NOTE: Multiple failed downloads will change the folder name.
# (e.g., appending #s)

173
sickgear/show_queue.py
View file

@ -23,8 +23,6 @@ import traceback
from lib.dateutil.parser import parser
from lib.tvinfo_base.exceptions import *
# noinspection PyPep8Naming
import encodingKludge as ek
import exceptions_helper
from exceptions_helper import ex
@ -49,7 +47,7 @@ if False:
from lib.tvinfo_base import TVInfoShow
from .tv import TVEpisode
# Define special priority of tv source switch tasks, higher then anything else except newly added shows
# Define special priority of tv source switch tasks, higher than anything else except newly added shows
SWITCH_PRIO = generic_queue.QueuePriorities.HIGH + 5
DAILY_SHOW_UPDATE_FINISHED_EVENT = 1
@ -72,7 +70,7 @@ class ShowQueue(generic_queue.GenericQueue):
def check_events(self):
if self.daily_update_running and \
not (self.isShowUpdateRunning() or sickgear.show_update_scheduler.action.amActive):
not (self.is_show_update_running() or sickgear.show_update_scheduler.action.amActive):
self.execute_events(DAILY_SHOW_UPDATE_FINISHED_EVENT)
self.daily_update_running = False
@ -91,24 +89,24 @@ class ShowQueue(generic_queue.GenericQueue):
continue
if cur_row['action_id'] in (ShowQueueActions.UPDATE, ShowQueueActions.FORCEUPDATE,
ShowQueueActions.WEBFORCEUPDATE):
self.updateShow(add_to_db=False, force=bool(cur_row['force']),
pausestatus_after=bool_none(cur_row['pausestatus_after']),
scheduled_update=bool(cur_row['scheduled_update']),
show_obj=show_obj, skip_refresh=bool(cur_row['skip_refresh']),
uid=cur_row['uid'],
web=ShowQueueActions.WEBFORCEUPDATE == cur_row['action_id'])
ShowQueueActions.WEBFORCEUPDATE):
self.update_show(add_to_db=False, force=bool(cur_row['force']),
pausestatus_after=bool_none(cur_row['pausestatus_after']),
scheduled_update=bool(cur_row['scheduled_update']),
show_obj=show_obj, skip_refresh=bool(cur_row['skip_refresh']),
uid=cur_row['uid'],
web=ShowQueueActions.WEBFORCEUPDATE == cur_row['action_id'])
elif ShowQueueActions.REFRESH == cur_row['action_id']:
self.refreshShow(add_to_db=False, force=bool(cur_row['force']),
force_image_cache=bool(cur_row['force_image_cache']),
priority=cur_row['priority'],
scheduled_update=bool(cur_row['scheduled_update']),
show_obj=show_obj,
uid=cur_row['uid'])
self.refresh_show(add_to_db=False, force=bool(cur_row['force']),
force_image_cache=bool(cur_row['force_image_cache']),
priority=cur_row['priority'],
scheduled_update=bool(cur_row['scheduled_update']),
show_obj=show_obj,
uid=cur_row['uid'])
elif ShowQueueActions.RENAME == cur_row['action_id']:
self.renameShowEpisodes(add_to_db=False, show_obj=show_obj, uid=cur_row['uid'])
self.rename_show_episodes(add_to_db=False, show_obj=show_obj, uid=cur_row['uid'])
elif ShowQueueActions.SUBTITLE == cur_row['action_id']:
self.download_subtitles(add_to_db=False, show_obj=show_obj, uid=cur_row['uid'])
@ -243,7 +241,7 @@ class ShowQueue(generic_queue.GenericQueue):
# type: (List[integer_types], bool) -> None
generic_queue.GenericQueue._remove_from_queue(self, to_remove=to_remove, force=force)
def _isInQueue(self, show_obj, actions):
def _is_in_queue(self, show_obj, actions):
# type: (TVShow, Tuple[integer_types, ...]) -> bool
"""
@ -254,7 +252,7 @@ class ShowQueue(generic_queue.GenericQueue):
with self.lock:
return any(1 for x in self.queue if x.action_id in actions and show_obj == x.show_obj)
def _isBeingSomethinged(self, show_obj, actions):
def _is_being_somethinged(self, show_obj, actions):
# type: (TVShow, Tuple[integer_types, ...]) -> bool
"""
@ -269,7 +267,7 @@ class ShowQueue(generic_queue.GenericQueue):
and show_obj == self.currentItem.show_obj \
and self.currentItem.action_id in actions
def isInUpdateQueue(self, show_obj):
def is_in_update_queue(self, show_obj):
# type: (TVShow) -> bool
"""
@ -278,10 +276,10 @@ class ShowQueue(generic_queue.GenericQueue):
:return:
:rtype: bool
"""
return self._isInQueue(show_obj, (ShowQueueActions.UPDATE, ShowQueueActions.FORCEUPDATE,
ShowQueueActions.WEBFORCEUPDATE))
return self._is_in_queue(show_obj, (ShowQueueActions.UPDATE, ShowQueueActions.FORCEUPDATE,
ShowQueueActions.WEBFORCEUPDATE))
def isInRefreshQueue(self, show_obj):
def is_in_refresh_queue(self, show_obj):
# type: (TVShow) -> bool
"""
@ -290,9 +288,9 @@ class ShowQueue(generic_queue.GenericQueue):
:return:
:rtype: bool
"""
return self._isInQueue(show_obj, (ShowQueueActions.REFRESH,))
return self._is_in_queue(show_obj, (ShowQueueActions.REFRESH,))
def isInRenameQueue(self, show_obj):
def is_in_rename_queue(self, show_obj):
# type: (TVShow) -> bool
"""
@ -301,9 +299,9 @@ class ShowQueue(generic_queue.GenericQueue):
:return:
:rtype: bool
"""
return self._isInQueue(show_obj, (ShowQueueActions.RENAME,))
return self._is_in_queue(show_obj, (ShowQueueActions.RENAME,))
def isInSubtitleQueue(self, show_obj):
def is_in_subtitle_queue(self, show_obj):
# type: (TVShow) -> bool
"""
@ -312,9 +310,9 @@ class ShowQueue(generic_queue.GenericQueue):
:return:
:rtype: bool
"""
return self._isInQueue(show_obj, (ShowQueueActions.SUBTITLE,))
return self._is_in_queue(show_obj, (ShowQueueActions.SUBTITLE,))
def isBeingAdded(self, show_obj):
def is_being_added(self, show_obj):
# type: (TVShow) -> bool
"""
@ -323,9 +321,9 @@ class ShowQueue(generic_queue.GenericQueue):
:return:
:rtype: bool
"""
return self._isBeingSomethinged(show_obj, (ShowQueueActions.ADD,))
return self._is_being_somethinged(show_obj, (ShowQueueActions.ADD,))
def isBeingUpdated(self, show_obj):
def is_being_updated(self, show_obj):
# type: (TVShow) -> bool
"""
@ -334,10 +332,10 @@ class ShowQueue(generic_queue.GenericQueue):
:return:
:rtype: bool
"""
return self._isBeingSomethinged(show_obj, (ShowQueueActions.UPDATE, ShowQueueActions.FORCEUPDATE,
ShowQueueActions.WEBFORCEUPDATE))
return self._is_being_somethinged(show_obj, (ShowQueueActions.UPDATE, ShowQueueActions.FORCEUPDATE,
ShowQueueActions.WEBFORCEUPDATE))
def isBeingRefreshed(self, show_obj):
def is_being_refreshed(self, show_obj):
# type: (TVShow) -> bool
"""
@ -346,9 +344,9 @@ class ShowQueue(generic_queue.GenericQueue):
:return:
:rtype: bool
"""
return self._isBeingSomethinged(show_obj, (ShowQueueActions.REFRESH,))
return self._is_being_somethinged(show_obj, (ShowQueueActions.REFRESH,))
def isBeingRenamed(self, show_obj):
def is_being_renamed(self, show_obj):
# type: (TVShow) -> bool
"""
@ -357,9 +355,9 @@ class ShowQueue(generic_queue.GenericQueue):
:return:
:rtype: bool
"""
return self._isBeingSomethinged(show_obj, (ShowQueueActions.RENAME,))
return self._is_being_somethinged(show_obj, (ShowQueueActions.RENAME,))
def isBeingSubtitled(self, show_obj):
def is_being_subtitled(self, show_obj):
# type: (TVShow) -> bool
"""
@ -368,9 +366,9 @@ class ShowQueue(generic_queue.GenericQueue):
:return:
:rtype: bool
"""
return self._isBeingSomethinged(show_obj, (ShowQueueActions.SUBTITLE,))
return self._is_being_somethinged(show_obj, (ShowQueueActions.SUBTITLE,))
def isShowUpdateRunning(self):
def is_show_update_running(self):
"""
:return:
@ -387,7 +385,7 @@ class ShowQueue(generic_queue.GenericQueue):
:param show_obj: show object
"""
return self._isBeingSomethinged(show_obj, (ShowQueueActions.SWITCH,))
return self._is_being_somethinged(show_obj, (ShowQueueActions.SWITCH,))
def is_show_switch_queued(self, show_obj):
# type: (TVShow) -> bool
@ -396,21 +394,21 @@ class ShowQueue(generic_queue.GenericQueue):
:param show_obj: show object
"""
return self._isInQueue(show_obj, (ShowQueueActions.SWITCH,))
return self._is_in_queue(show_obj, (ShowQueueActions.SWITCH,))
def is_switch_running(self):
# type: (...) -> bool
with self.lock:
return any(1 for x in self.queue + [self.currentItem] if isinstance(x, QueueItemSwitchSource))
def _getLoadingShowList(self):
def _get_loading_showlist(self):
"""
:return:
:rtype: List
"""
with self.lock:
return [x for x in self.queue + [self.currentItem] if None is not x and x.isLoading]
return [x for x in self.queue + [self.currentItem] if None is not x and x.is_loading]
def queue_length(self):
# type: (...) -> Dict[AnyStr, List[AnyStr, Dict]]
@ -454,18 +452,18 @@ class ShowQueue(generic_queue.GenericQueue):
length['switch'].append(result_item)
return length
loadingShowList = property(_getLoadingShowList)
loading_showlist = property(_get_loading_showlist)
def updateShow(self,
show_obj, # type: TVShow
force=False, # type: bool
web=False, # type: bool
scheduled_update=False, # type: bool
priority=generic_queue.QueuePriorities.NORMAL, # type: integer_types
uid=None, # type: integer_types
add_to_db=True, # type: bool
**kwargs # type: Any
): # type: (...) -> Union[QueueItemUpdate, QueueItemForceUpdate, QueueItemForceUpdateWeb]
def update_show(self,
show_obj, # type: TVShow
force=False, # type: bool
web=False, # type: bool
scheduled_update=False, # type: bool
priority=generic_queue.QueuePriorities.NORMAL, # type: integer_types
uid=None, # type: integer_types
add_to_db=True, # type: bool
**kwargs # type: Any
): # type: (...) -> Union[QueueItemUpdate, QueueItemForceUpdate, QueueItemForceUpdateWeb]
"""
:param show_obj: show object
@ -485,15 +483,15 @@ class ShowQueue(generic_queue.GenericQueue):
:rtype: QueueItemUpdate or QueueItemForceUpdateWeb or QueueItemForceUpdate
"""
with self.lock:
if self.isBeingAdded(show_obj):
if self.is_being_added(show_obj):
raise exceptions_helper.CantUpdateException(
'Show is still being added, wait until it is finished before you update.')
if self.isBeingUpdated(show_obj):
if self.is_being_updated(show_obj):
raise exceptions_helper.CantUpdateException(
'This show is already being updated, can\'t update again until it\'s done.')
if self.isInUpdateQueue(show_obj):
if self.is_in_update_queue(show_obj):
raise exceptions_helper.CantUpdateException(
'This show is already being updated, can\'t update again until it\'s done.')
@ -516,9 +514,9 @@ class ShowQueue(generic_queue.GenericQueue):
return queue_item_obj
def refreshShow(self, show_obj, force=False, scheduled_update=False, after_update=False,
priority=generic_queue.QueuePriorities.HIGH, force_image_cache=False, uid=None, add_to_db=True,
**kwargs):
def refresh_show(self, show_obj, force=False, scheduled_update=False, after_update=False,
priority=generic_queue.QueuePriorities.HIGH, force_image_cache=False, uid=None, add_to_db=True,
**kwargs):
# type: (TVShow, bool, bool, bool, integer_types, bool, integer_types, bool, Any) -> Optional[QueueItemRefresh]
"""
@ -541,10 +539,11 @@ class ShowQueue(generic_queue.GenericQueue):
:rtype: QueueItemRefresh
"""
with self.lock:
if (self.isBeingRefreshed(show_obj) or self.isInRefreshQueue(show_obj)) and not force:
if (self.is_being_refreshed(show_obj) or self.is_in_refresh_queue(show_obj)) and not force:
raise exceptions_helper.CantRefreshException('This show is being refreshed, not refreshing again.')
if ((not after_update and self.isBeingUpdated(show_obj)) or self.isInUpdateQueue(show_obj)) and not force:
if ((not after_update and self.is_being_updated(show_obj))
or self.is_in_update_queue(show_obj)) and not force:
logger.log('Skipping this refresh as there is already an update queued or'
' in progress and a refresh is done at the end of an update anyway.', logger.DEBUG)
return
@ -561,7 +560,7 @@ class ShowQueue(generic_queue.GenericQueue):
return queue_item_obj
def renameShowEpisodes(self, show_obj, uid=None, add_to_db=True):
def rename_show_episodes(self, show_obj, uid=None, add_to_db=True):
# type: (TVShow, integer_types, bool) -> QueueItemRename
"""
@ -758,14 +757,14 @@ class ShowQueueItem(generic_queue.QueueItem):
self.show_obj = show_obj # type: sickgear.tv.TVShow
self.scheduled_update = scheduled_update # type: bool
def isInQueue(self):
def is_in_queue(self):
"""
:rtype: bool
"""
return self in sickgear.show_queue_scheduler.action.queue + [
sickgear.show_queue_scheduler.action.currentItem]
def _getName(self):
def _get_name(self):
"""
:rtype: AnyStr
"""
@ -773,7 +772,7 @@ class ShowQueueItem(generic_queue.QueueItem):
return self.show_obj.name
return ''
def _isLoading(self):
def _is_loading(self):
return False
def __str__(self):
@ -782,9 +781,9 @@ class ShowQueueItem(generic_queue.QueueItem):
def __repr__(self):
return self.__str__()
show_name = property(_getName)
show_name = property(_get_name)
isLoading = property(_isLoading)
is_loading = property(_is_loading)
class QueueItemAdd(ShowQueueItem):
@ -864,7 +863,7 @@ class QueueItemAdd(ShowQueueItem):
self.priority = generic_queue.QueuePriorities.VERYHIGH
def _getName(self):
def _get_name(self):
"""
:return: the show name if there is a show object created, if not returns
the dir that the show is being added to.
@ -876,9 +875,9 @@ class QueueItemAdd(ShowQueueItem):
return self.showDir
return self.show_obj.name
show_name = property(_getName)
show_name = property(_get_name)
def _isLoading(self):
def _is_loading(self):
"""
:return: True if we've gotten far enough to have a show object, or False
if we still only know the folder name.
@ -886,7 +885,7 @@ class QueueItemAdd(ShowQueueItem):
"""
return None is self.show_obj
isLoading = property(_isLoading)
is_loading = property(_is_loading)
# if they gave a number to start or number to end as wanted, then change those eps to it
def _get_wanted(self, db_obj, wanted_max, latest):
@ -985,7 +984,7 @@ class QueueItemAdd(ShowQueueItem):
if getattr(t, 'show_not_found', False):
logger.log('Show %s was not found on %s, maybe show was deleted' %
(self.show_name, sickgear.TVInfoAPI(self.tvid).name), logger.ERROR)
self._finishEarly()
self._finish_early()
return
# this usually only happens if they have an NFO in their show dir
@ -997,7 +996,7 @@ class QueueItemAdd(ShowQueueItem):
'Show in %s has no name on %s, probably the wrong language.'
' Delete .nfo and add manually in the correct language.' %
(self.showDir, sickgear.TVInfoAPI(self.tvid).name))
self._finishEarly()
self._finish_early()
return
except (BaseException, Exception):
logger.log('Unable to find show ID:%s on TV info: %s' % (self.prodid, sickgear.TVInfoAPI(self.tvid).name),
@ -1006,7 +1005,7 @@ class QueueItemAdd(ShowQueueItem):
'Unable to look up the show in %s on %s using ID %s, not using the NFO.'
' Delete .nfo and try adding manually again.' %
(self.showDir, sickgear.TVInfoAPI(self.tvid).name, self.prodid))
self._finishEarly()
self._finish_early()
return
try:
@ -1056,19 +1055,19 @@ class QueueItemAdd(ShowQueueItem):
else:
ui.notifications.error(
'Unable to add show due to an error with %s' % sickgear.TVInfoAPI(self.tvid).name)
self._finishEarly()
self._finish_early()
return
except exceptions_helper.MultipleShowObjectsException:
logger.log('The show in %s is already in your show list, skipping' % self.showDir, logger.ERROR)
ui.notifications.error('Show skipped', 'The show in %s is already in your show list' % self.showDir)
self._finishEarly()
self._finish_early()
return
except (BaseException, Exception) as e:
logger.log('Error trying to add show: %s' % ex(e), logger.ERROR)
logger.log(traceback.format_exc(), logger.ERROR)
self._finishEarly()
self._finish_early()
raise
self.show_obj.load_imdb_info()
@ -1078,7 +1077,7 @@ class QueueItemAdd(ShowQueueItem):
except (BaseException, Exception) as e:
logger.log('Error saving the show to the database: %s' % ex(e), logger.ERROR)
logger.log(traceback.format_exc(), logger.ERROR)
self._finishEarly()
self._finish_early()
raise
if not show_exists:
@ -1152,7 +1151,7 @@ class QueueItemAdd(ShowQueueItem):
except (BaseException, Exception) as e:
logger.log('Error saving the show to the database: %s' % ex(e), logger.ERROR)
logger.log(traceback.format_exc(), logger.ERROR)
self._finishEarly()
self._finish_early()
raise
# update internal name cache
@ -1191,14 +1190,14 @@ class QueueItemAdd(ShowQueueItem):
self.finish()
def _finishEarly(self):
def _finish_early(self):
if None is not self.show_obj:
self.show_obj.delete_show()
if self.new_show:
# if we adding a new show, delete the empty folder that was already created
# if adding a new show, delete the empty folder that was already created
try:
ek.ek(os.rmdir, self.showDir)
os.rmdir(self.showDir)
except (BaseException, Exception):
pass
@ -1381,7 +1380,7 @@ class QueueItemUpdate(ShowQueueItem):
if not sickgear.TVInfoAPI(self.show_obj.tvid).config['active']:
logger.log('TV info source %s is marked inactive, aborting update for show %s and continue with refresh.'
% (sickgear.TVInfoAPI(self.show_obj.tvid).config['name'], self.show_obj.name))
sickgear.show_queue_scheduler.action.refreshShow(self.show_obj, self.force, self.scheduled_update,
sickgear.show_queue_scheduler.action.refresh_show(self.show_obj, self.force, self.scheduled_update,
after_update=True)
return
@ -1485,7 +1484,7 @@ class QueueItemUpdate(ShowQueueItem):
sickgear.MEMCACHE['history_tab'] = sickgear.webserve.History.menu_tab(
sickgear.MEMCACHE['history_tab_limit'])
if not getattr(self, 'skip_refresh', False):
sickgear.show_queue_scheduler.action.refreshShow(self.show_obj, self.force, self.scheduled_update,
sickgear.show_queue_scheduler.action.refresh_show(self.show_obj, self.force, self.scheduled_update,
after_update=True, force_image_cache=self.force_web,
**self.kwargs)

21
sickgear/show_updater.py
View file

@ -20,8 +20,6 @@ import traceback
import exceptions_helper
from exceptions_helper import ex
# noinspection PyPep8Naming
import encodingKludge as ek
import sickgear
from . import db, logger, network_timezones, properFinder, ui
@ -72,8 +70,7 @@ class ShowUpdater(object):
if sickgear.db.db_supports_backup and 0 < sickgear.BACKUP_DB_MAX_COUNT:
logger.log('backing up all db\'s')
try:
sickgear.db.backup_all_dbs(sickgear.BACKUP_DB_PATH or
ek.ek(os.path.join, sickgear.DATA_DIR, 'backup'))
sickgear.db.backup_all_dbs(sickgear.BACKUP_DB_PATH or os.path.join(sickgear.DATA_DIR, 'backup'))
except (BaseException, Exception):
logger.log('backup db error', logger.ERROR)
@ -137,7 +134,7 @@ class ShowUpdater(object):
# cleanup ignore and require lists
try:
clean_ignore_require_words()
except Exception:
except (BaseException, Exception):
logger.log('ignore, require words cleanup error', logger.ERROR)
logger.log(traceback.format_exc(), logger.ERROR)
@ -166,7 +163,7 @@ class ShowUpdater(object):
logger.log(traceback.format_exc(), logger.ERROR)
# select 10 'Ended' tv_shows updated more than 90 days ago
# and all shows not updated more then 180 days ago to include in this update
# and all shows not updated more than 180 days ago to include in this update
stale_should_update = []
stale_update_date = (update_date - datetime.timedelta(days=90)).toordinal()
stale_update_date_max = (update_date - datetime.timedelta(days=180)).toordinal()
@ -204,16 +201,16 @@ class ShowUpdater(object):
try:
# if should_update returns True (not 'Ended') or show is selected stale 'Ended' then update,
# otherwise just refresh
if cur_show_obj.should_update(update_date=update_date,
last_indexer_change=show_updates.get(cur_show_obj.tvid, {}).
get(cur_show_obj.prodid)) \
if cur_show_obj.should_update(
update_date=update_date,
last_indexer_change=show_updates.get(cur_show_obj.tvid, {}).get(cur_show_obj.prodid)) \
or cur_show_obj.tvid_prodid in stale_should_update:
cur_queue_item = sickgear.show_queue_scheduler.action.updateShow(cur_show_obj,
scheduled_update=True)
cur_queue_item = sickgear.show_queue_scheduler.action.update_show(
cur_show_obj, scheduled_update=True)
else:
logger.debug(u'Not updating episodes for show %s because it\'s marked as ended and last/next'
u' episode is not within the grace period.' % cur_show_obj.unique_name)
cur_queue_item = sickgear.show_queue_scheduler.action.refreshShow(cur_show_obj, True, True)
cur_queue_item = sickgear.show_queue_scheduler.action.refresh_show(cur_show_obj, True, True)
pi_list.append(cur_queue_item)

59
sickgear/subtitles.py
View file

@ -17,9 +17,6 @@
import datetime
# noinspection PyPep8Naming
import encodingKludge as ek
from . import db, helpers, logger
from .common import *
@ -31,41 +28,41 @@ SINGLE = 'und'
def sorted_service_list():
servicesMapping = dict([(x.lower(), x) for x in subliminal.core.SERVICES])
services_mapping = dict([(x.lower(), x) for x in subliminal.core.SERVICES])
newList = []
new_list = []
# add all services in the priority list, in order
curIndex = 0
for curService in sickgear.SUBTITLES_SERVICES_LIST:
if curService in servicesMapping:
curServiceDict = dict(
id=curService,
image=curService + '.png',
name=servicesMapping[curService],
enabled=1 == sickgear.SUBTITLES_SERVICES_ENABLED[curIndex],
api_based=__import__('lib.subliminal.services.' + curService, globals=globals(),
cur_index = 0
for cur_service in sickgear.SUBTITLES_SERVICES_LIST:
if cur_service in services_mapping:
cur_service_dict = dict(
id=cur_service,
image=cur_service + '.png',
name=services_mapping[cur_service],
enabled=1 == sickgear.SUBTITLES_SERVICES_ENABLED[cur_index],
api_based=__import__('lib.subliminal.services.' + cur_service, globals=globals(),
locals=locals(), fromlist=['Service']).Service.api_based,
url=__import__('lib.subliminal.services.' + curService, globals=globals(),
url=__import__('lib.subliminal.services.' + cur_service, globals=globals(),
locals=locals(), fromlist=['Service']).Service.site_url)
newList.append(curServiceDict)
curIndex += 1
new_list.append(cur_service_dict)
cur_index += 1
# add any services that are missing from that list
for curService in servicesMapping:
if curService not in [x['id'] for x in newList]:
curServiceDict = dict(
id=curService,
image=curService + '.png',
name=servicesMapping[curService],
for cur_service in services_mapping:
if cur_service not in [x['id'] for x in new_list]:
cur_service_dict = dict(
id=cur_service,
image=cur_service + '.png',
name=services_mapping[cur_service],
enabled=False,
api_based=__import__('lib.subliminal.services.' + curService, globals=globals(),
api_based=__import__('lib.subliminal.services.' + cur_service, globals=globals(),
locals=locals(), fromlist=['Service']).Service.api_based,
url=__import__('lib.subliminal.services.' + curService, globals=globals(),
url=__import__('lib.subliminal.services.' + cur_service, globals=globals(),
locals=locals(), fromlist=['Service']).Service.site_url)
newList.append(curServiceDict)
new_list.append(cur_service_dict)
return newList
return new_list
def get_enabled_service_list():
@ -81,10 +78,10 @@ def get_language_name(select_lang):
def wanted_languages(sql_like=False):
wantedLanguages = sorted(sickgear.SUBTITLES_LANGUAGES)
wanted_langs = sorted(sickgear.SUBTITLES_LANGUAGES)
if sql_like:
return '%' + ','.join(wantedLanguages) + '%'
return wantedLanguages
return '%' + ','.join(wanted_langs) + '%'
return wanted_langs
def subtitles_languages(video_path):
@ -166,7 +163,7 @@ class SubtitlesFinder(object):
now = datetime.datetime.now()
for cur_result in sql_result:
if not ek.ek(os.path.isfile, cur_result['location']):
if not os.path.isfile(cur_result['location']):
logger.log('Episode file does not exist, cannot download subtitles for episode %dx%d of show %s'
% (cur_result['season'], cur_result['episode'], cur_result['show_name']), logger.DEBUG)
continue

5
sickgear/traktChecker.py
View file

@ -19,9 +19,6 @@ import datetime
import os
import traceback
# noinspection PyPep8Naming
import encodingKludge as ek
import sickgear
from . import helpers, logger, search_queue
from .common import SKIPPED, WANTED
@ -175,7 +172,7 @@ class TraktChecker(object):
location = None
if location:
showPath = ek.ek(os.path.join, location, helpers.sanitize_filename(name))
showPath = os.path.join(location, helpers.sanitize_filename(name))
dir_exists = helpers.make_dir(showPath)
if not dir_exists:
logger.log(u"Unable to create the folder " + showPath + ", can't add the show", logger.ERROR)

132
sickgear/tv.py
View file

@ -36,8 +36,6 @@ import traceback
from imdbpie import ImdbAPIError
from lxml_etree import etree
# noinspection PyPep8Naming
import encodingKludge as ek
import exceptions_helper
from exceptions_helper import ex
@ -72,7 +70,7 @@ from six import integer_types, iteritems, itervalues, moves, PY2, string_types
if False:
from typing import Any, AnyStr, Dict, List, Optional, Set, Text, Tuple, Union
from sqlite3 import Row
from lib.tvinfo_base import CastList, Character as TVINFO_Character, Person as TVINFO_Person, \
from lib.tvinfo_base import CastList, TVInfoCharacter, TVInfoPerson, \
TVInfoEpisode, TVInfoShow
coreid_warnings = False
@ -453,7 +451,7 @@ class Person(Referential):
'homepage', 'ids', 'image_url', 'name', 'nicknames', 'real_name', 'thumb_url']}
def reset(self, person_obj=None):
# type: (TVINFO_Person) -> None
# type: (TVInfoPerson) -> None
"""
reset all properties with the exception of: name, id, ids
@ -646,7 +644,7 @@ class Person(Referential):
break
def update_prop_from_tvinfo_person(self, person_obj):
# type: (TVINFO_Person) -> None
# type: (TVInfoPerson) -> None
"""
update person with tvinfo person object info
Note: doesn't change: name, id, image_url, thumb_url
@ -747,7 +745,7 @@ class Person(Referential):
continue
if tvsrc_result:
# verify we have the correct person
for cur_person in tvsrc_result: # type: TVINFO_Person
for cur_person in tvsrc_result: # type: TVInfoPerson
if None is not rp:
break
if not (imdb_confirmed and TVINFO_IMDB == tv_src) \
@ -767,7 +765,7 @@ class Person(Referential):
# noinspection PyUnresolvedReferences
if show_obj and None is not pd and pd.characters:
clean_show_name = indexermapper.clean_show_name(show_obj.name.lower())
for ch in pd.characters or []: # type: TVINFO_Character
for ch in pd.characters or []: # type: TVInfoCharacter
if clean_show_name == indexermapper.clean_show_name(ch.show.seriesname.lower()):
rp = pd
confirmed_on_src = True
@ -1635,7 +1633,7 @@ class TVShow(TVShowBase):
if sickgear.CREATE_MISSING_SHOW_DIRS:
return self._location
if ek.ek(os.path.isdir, self._location):
if os.path.isdir(self._location):
return self._location
raise exceptions_helper.ShowDirNotFoundException('Show folder does not exist: \'%s\'' % self._location)
@ -1644,7 +1642,7 @@ class TVShow(TVShowBase):
# type: (AnyStr) -> None
logger.log('Setter sets location to %s' % new_location, logger.DEBUG)
# Don't validate dir if user wants to add shows without creating a dir
if sickgear.ADD_SHOWS_WO_DIR or ek.ek(os.path.isdir, new_location):
if sickgear.ADD_SHOWS_WO_DIR or os.path.isdir(new_location):
self.dirty_setter('_location')(self, new_location)
self.path = new_location
# self._is_location_good = True
@ -2052,7 +2050,7 @@ class TVShow(TVShowBase):
result = False
if not ek.ek(os.path.isdir, self._location):
if not os.path.isdir(self._location):
logger.log('%s: Show directory doesn\'t exist, skipping NFO generation' % self.tvid_prodid)
return False
@ -2068,7 +2066,7 @@ class TVShow(TVShowBase):
:param show_only: only for show
:param force:
"""
if not ek.ek(os.path.isdir, self._location):
if not os.path.isdir(self._location):
logger.log('%s: Show directory doesn\'t exist, skipping NFO generation' % self.tvid_prodid)
return
@ -2084,7 +2082,7 @@ class TVShow(TVShowBase):
def write_episode_nfo(self, force=False):
# type: (bool) -> None
if not ek.ek(os.path.isdir, self._location):
if not os.path.isdir(self._location):
logger.log('%s: Show directory doesn\'t exist, skipping NFO generation' % self.tvid_prodid)
return
@ -2119,7 +2117,7 @@ class TVShow(TVShowBase):
def update_metadata(self):
if not ek.ek(os.path.isdir, self._location):
if not os.path.isdir(self._location):
logger.log('%s: Show directory doesn\'t exist, skipping NFO generation' % self.tvid_prodid)
return
@ -2129,7 +2127,7 @@ class TVShow(TVShowBase):
result = False
if not ek.ek(os.path.isdir, self._location):
if not os.path.isdir(self._location):
logger.log('%s: Show directory doesn\'t exist, skipping NFO generation' % self.tvid_prodid)
return False
@ -2142,7 +2140,7 @@ class TVShow(TVShowBase):
# find all media files in the show folder and create episodes for as many as possible
def load_episodes_from_dir(self):
if not ek.ek(os.path.isdir, self._location):
if not os.path.isdir(self._location):
logger.log('%s: Show directory doesn\'t exist, not loading episodes from disk' % self.tvid_prodid)
return
@ -2159,7 +2157,7 @@ class TVShow(TVShowBase):
logger.log('%s: Creating episode from %s' % (self.tvid_prodid, cur_media_file), logger.DEBUG)
try:
ep_obj = self.ep_obj_from_file(ek.ek(os.path.join, self._location, cur_media_file))
ep_obj = self.ep_obj_from_file(os.path.join(self._location, cur_media_file))
except (exceptions_helper.ShowNotFoundException, exceptions_helper.EpisodeNotFoundException) as e:
logger.log('Episode %s returned an exception: %s' % (cur_media_file, ex(e)), logger.ERROR)
continue
@ -2170,8 +2168,8 @@ class TVShow(TVShowBase):
continue
# see if we should save the release name in the db
ep_file_name = ek.ek(os.path.basename, ep_obj.location)
ep_file_name = ek.ek(os.path.splitext, ep_file_name)[0]
ep_file_name = os.path.basename(ep_obj.location)
ep_file_name = os.path.splitext(ep_file_name)[0]
try:
parse_result = None
@ -2423,7 +2421,7 @@ class TVShow(TVShowBase):
:param path:
:return:
"""
if not ek.ek(os.path.isfile, path):
if not os.path.isfile(path):
logger.log('%s: Not a real file... %s' % (self.tvid_prodid, path))
return None
@ -2474,7 +2472,7 @@ class TVShow(TVShowBase):
if IGNORED == status:
continue
if (ep_obj.location and ek.ek(os.path.normpath, ep_obj.location) != ek.ek(os.path.normpath, path)) or \
if (ep_obj.location and os.path.normpath(ep_obj.location) != os.path.normpath(path)) or \
(not ep_obj.location and path) or \
(SKIPPED == status):
logger.log('The old episode had a different file associated with it, re-checking the quality ' +
@ -2856,14 +2854,14 @@ class TVShow(TVShowBase):
if show_info.cast and self._should_cast_update(show_info.cast):
sickgear.people_queue_scheduler.action.add_cast_update(show_obj=self, show_info_cast=show_info.cast,
scheduled_update=scheduled_update, switch=switch)
scheduled_update=scheduled_update, switch=switch)
else:
logger.log('Not updating cast for show because data is unchanged.')
return show_info
@staticmethod
def _update_person_properties_helper(person_obj, src_person, p_ids):
# type: (Person, TVINFO_Person, Dict) -> None
# type: (Person, TVInfoPerson, Dict) -> None
person_obj.update_properties(
name=src_person.name, gender=src_person.gender,
birthday=src_person.birthdate, deathday=src_person.deathdate,
@ -2898,7 +2896,7 @@ class TVShow(TVShowBase):
cast_list = self._load_cast_from_db()
remove_char_ids = {c.id for c in cast_list or []}
cast_ordered = weakList()
for ct, c_l in iteritems(show_info_cast): # type: (integer_types, List[TVINFO_Character])
for ct, c_l in iteritems(show_info_cast): # type: (integer_types, List[TVInfoCharacter])
if ct not in (RoleTypes.ActorMain, RoleTypes.Host, RoleTypes.Interviewer, RoleTypes.Presenter):
continue
for c in c_l:
@ -3074,7 +3072,7 @@ class TVShow(TVShowBase):
self._imdbid = redirect_check
imdb_id = redirect_check
imdb_info['imdb_id'] = self.imdbid
i = imdbpie.Imdb(exclude_episodes=True, cachedir=ek.ek(os.path.join, sickgear.CACHE_DIR, 'imdb-pie'))
i = imdbpie.Imdb(exclude_episodes=True, cachedir=os.path.join(sickgear.CACHE_DIR, 'imdb-pie'))
if not helpers.parse_imdb_id(imdb_id):
logger.log('Not a valid imdbid: %s for show: %s' % (imdb_id, self._name), logger.WARNING)
return
@ -3276,10 +3274,10 @@ class TVShow(TVShowBase):
# clear the cache
ic = image_cache.ImageCache()
for cache_obj in ek.ek(glob.glob, ic.fanart_path(self.tvid, self.prodid).replace('fanart.jpg', '*')) \
+ ek.ek(glob.glob, ic.poster_thumb_path(self.tvid, self.prodid).replace('poster.jpg', '*')) \
+ ek.ek(glob.glob, ic.poster_path(self.tvid, self.prodid).replace('poster.jpg', '*')):
cache_dir = ek.ek(os.path.isdir, cache_obj)
for cache_obj in glob.glob(ic.fanart_path(self.tvid, self.prodid).replace('fanart.jpg', '*')) \
+ glob.glob(ic.poster_thumb_path(self.tvid, self.prodid).replace('poster.jpg', '*')) \
+ glob.glob(ic.poster_path(self.tvid, self.prodid).replace('poster.jpg', '*')):
cache_dir = os.path.isdir(cache_obj)
result = helpers.remove_file(cache_obj, tree=cache_dir, log_level=logger.WARNING)
if result:
logger.log('%s cache %s %s' % (result, cache_dir and 'dir' or 'file', cache_obj))
@ -3292,12 +3290,12 @@ class TVShow(TVShowBase):
try:
logger.log('Attempt to %s show folder %s' % (action, self._location))
# check first the read-only attribute
file_attribute = ek.ek(os.stat, self.location)[0]
file_attribute = os.stat(self.location)[0]
if not file_attribute & stat.S_IWRITE:
# File is read-only, so make it writeable
logger.log('Attempting to make writeable the read only folder %s' % self._location, logger.DEBUG)
try:
ek.ek(os.chmod, self.location, stat.S_IWRITE)
os.chmod(self.location, stat.S_IWRITE)
except (BaseException, Exception):
logger.log('Unable to change permissions of %s' % self._location, logger.WARNING)
@ -3324,7 +3322,7 @@ class TVShow(TVShowBase):
def refresh_dir(self):
# make sure the show dir is where we think it is unless dirs are created on the fly
if not ek.ek(os.path.isdir, self._location) and not sickgear.CREATE_MISSING_SHOW_DIRS:
if not os.path.isdir(self._location) and not sickgear.CREATE_MISSING_SHOW_DIRS:
return False
# load from dir
@ -3351,7 +3349,7 @@ class TVShow(TVShowBase):
for cur_row in sql_result:
season = int(cur_row['season'])
episode = int(cur_row['episode'])
location = ek.ek(os.path.normpath, cur_row['location'])
location = os.path.normpath(cur_row['location'])
try:
ep_obj = self.get_episode(season, episode, ep_result=[cur_row])
@ -3362,7 +3360,7 @@ class TVShow(TVShowBase):
# if the path exist and if it's in our show dir
if (self.prune and season and ep_obj.location not in attempted and 0 < helpers.get_size(ep_obj.location) and
ek.ek(os.path.normpath, location).startswith(ek.ek(os.path.normpath, self.location))):
os.path.normpath(location).startswith(os.path.normpath(self.location))):
with ep_obj.lock:
if ep_obj.status in Quality.DOWNLOADED:
# locations repeat but attempt to delete once
@ -3377,8 +3375,8 @@ class TVShow(TVShowBase):
kept += 1
# if the path doesn't exist or if it's not in our show dir
if not ek.ek(os.path.isfile, location) or not ek.ek(os.path.normpath, location).startswith(
ek.ek(os.path.normpath, self.location)):
if not os.path.isfile(location) or not os.path.normpath(location).startswith(
os.path.normpath(self.location)):
# check if downloaded files still exist, update our data if this has changed
if 1 != sickgear.SKIP_REMOVED_FILES:
@ -3427,7 +3425,7 @@ class TVShow(TVShowBase):
:param force:
"""
# TODO: Add support for force option
if not ek.ek(os.path.isdir, self._location):
if not os.path.isdir(self._location):
logger.log('%s: Show directory doesn\'t exist, can\'t download subtitles' % self.tvid_prodid, logger.DEBUG)
return
logger.log('%s: Downloading subtitles' % self.tvid_prodid, logger.DEBUG)
@ -3526,11 +3524,11 @@ class TVShow(TVShowBase):
save_mapping(self)
name_cache.remove_from_namecache(old_tvid, old_prodid)
image_cache_dir = ek.ek(os.path.join, sickgear.CACHE_DIR, 'images', 'shows')
old_dir = ek.ek(os.path.join, image_cache_dir, '%s-%s' % (old_tvid, old_prodid))
new_dir = ek.ek(os.path.join, image_cache_dir, '%s-%s' % (self.tvid, self.prodid))
image_cache_dir = os.path.join(sickgear.CACHE_DIR, 'images', 'shows')
old_dir = os.path.join(image_cache_dir, '%s-%s' % (old_tvid, old_prodid))
new_dir = os.path.join(image_cache_dir, '%s-%s' % (self.tvid, self.prodid))
try:
ek.ek(os.rename, old_dir, new_dir)
os.rename(old_dir, new_dir)
except (BaseException, Exception) as e:
logger.log('Unable to rename %s to %s: %s / %s' % (old_dir, new_dir, repr(e), ex(e)),
logger.WARNING)
@ -3556,7 +3554,7 @@ class TVShow(TVShowBase):
if update_show:
# force the update
try:
sickgear.show_queue_scheduler.action.updateShow(
sickgear.show_queue_scheduler.action.update_show(
self, force=True, web=True, priority=QueuePriorities.VERYHIGH,
pausestatus_after=pausestatus_after, switch_src=True)
except exceptions_helper.CantUpdateException as e:
@ -3944,8 +3942,8 @@ class TVEpisode(TVEpisodeBase):
# self._location = newLocation
self.dirty_setter('_location')(self, val)
if val and ek.ek(os.path.isfile, val):
self.file_size = ek.ek(os.path.getsize, val)
if val and os.path.isfile(val):
self.file_size = os.path.getsize(val)
else:
self.file_size = 0
@ -3968,7 +3966,7 @@ class TVEpisode(TVEpisodeBase):
return
# TODO: Add support for force option
if not ek.ek(os.path.isfile, self.location):
if not os.path.isfile(self.location):
logger.log('%s: Episode file doesn\'t exist, can\'t download subtitles for episode %sx%s' %
(self.show_obj.tvid_prodid, self.season, self.episode), logger.DEBUG)
return
@ -3987,7 +3985,7 @@ class TVEpisode(TVEpisodeBase):
if sickgear.SUBTITLES_DIR:
for video in subs:
subs_new_path = ek.ek(os.path.join, ek.ek(os.path.dirname, video.path), sickgear.SUBTITLES_DIR)
subs_new_path = os.path.join(os.path.dirname(video.path), sickgear.SUBTITLES_DIR)
dir_exists = helpers.make_dir(subs_new_path)
if not dir_exists:
logger.log('Unable to create subtitles folder %s' % subs_new_path, logger.ERROR)
@ -3995,7 +3993,7 @@ class TVEpisode(TVEpisodeBase):
helpers.chmod_as_parent(subs_new_path)
for subtitle in subs.get(video):
new_file_path = ek.ek(os.path.join, subs_new_path, ek.ek(os.path.basename, subtitle.path))
new_file_path = os.path.join(subs_new_path, os.path.basename(subtitle.path))
helpers.move_file(subtitle.path, new_file_path)
helpers.chmod_as_parent(new_file_path)
else:
@ -4052,7 +4050,7 @@ class TVEpisode(TVEpisodeBase):
hastbn = False
# check for nfo and tbn
if ek.ek(os.path.isfile, self.location):
if os.path.isfile(self.location):
for cur_provider in itervalues(sickgear.metadata_provider_dict):
if cur_provider.episode_metadata:
new_result = cur_provider.has_episode_metadata(self)
@ -4085,7 +4083,7 @@ class TVEpisode(TVEpisodeBase):
"""
if not self.load_from_db(season, episode, **kwargs):
# only load from NFO if we didn't load from DB
if ek.ek(os.path.isfile, self.location):
if os.path.isfile(self.location):
try:
self.load_from_nfo(self.location)
except exceptions_helper.NoNFOException:
@ -4168,7 +4166,7 @@ class TVEpisode(TVEpisodeBase):
self._subtitles_searchcount = show_result['subtitles_searchcount']
self._timestamp = show_result['timestamp'] or self._make_timestamp()
self._version = self._version if not show_result['version'] else int(show_result['version'])
self.location = show_result['location'] and ek.ek(os.path.normpath, show_result['location']) or self.location
self.location = show_result['location'] and os.path.normpath(show_result['location']) or self.location
if None is not show_result['release_group']:
self._release_group = show_result['release_group']
@ -4414,7 +4412,7 @@ class TVEpisode(TVEpisodeBase):
# don't update show status if show dir is missing, unless it's missing on purpose
# noinspection PyProtectedMember
if not ek.ek(os.path.isdir, self._show_obj._location) \
if not os.path.isdir(self._show_obj._location) \
and not sickgear.CREATE_MISSING_SHOW_DIRS and not sickgear.ADD_SHOWS_WO_DIR:
if UNKNOWN == self._status:
self.status = (SKIPPED, UNAIRED)[future_airtime]
@ -4430,7 +4428,7 @@ class TVEpisode(TVEpisodeBase):
logger.DEBUG)
# if we don't have the file
if not ek.ek(os.path.isfile, self._location):
if not os.path.isfile(self._location):
if self._status in [SKIPPED, UNAIRED, UNKNOWN, WANTED]:
very_old_delta = datetime.timedelta(days=90)
@ -4498,7 +4496,7 @@ class TVEpisode(TVEpisodeBase):
:type location: AnyStr
"""
# noinspection PyProtectedMember
if not ek.ek(os.path.isdir, self._show_obj._location):
if not os.path.isdir(self._show_obj._location):
logger.log('%s: The show directory is missing, not bothering to try loading the episode NFO'
% self._show_obj.tvid_prodid)
return
@ -4518,14 +4516,14 @@ class TVEpisode(TVEpisodeBase):
nfo_file = sickgear.helpers.replace_extension(self.location, 'nfo')
logger.log('%s: Using NFO name %s' % (self._show_obj.tvid_prodid, nfo_file), logger.DEBUG)
if ek.ek(os.path.isfile, nfo_file):
if os.path.isfile(nfo_file):
try:
show_xml = etree.ElementTree(file=nfo_file)
except (SyntaxError, ValueError) as e:
logger.log('Error loading the NFO, backing up the NFO and skipping for now: %s' % ex(e),
logger.ERROR) # TODO: figure out what's wrong and fix it
try:
ek.ek(os.rename, nfo_file, '%s.old' % nfo_file)
os.rename(nfo_file, '%s.old' % nfo_file)
except (BaseException, Exception) as e:
logger.log(
'Failed to rename your episode\'s NFO file - you need to delete it or fix it: %s' % ex(e),
@ -4576,7 +4574,7 @@ class TVEpisode(TVEpisodeBase):
else:
self.hasnfo = False
if ek.ek(os.path.isfile, sickgear.helpers.replace_extension(nfo_file, 'tbn')):
if os.path.isfile(sickgear.helpers.replace_extension(nfo_file, 'tbn')):
self.hastbn = True
else:
self.hastbn = False
@ -4613,7 +4611,7 @@ class TVEpisode(TVEpisodeBase):
def create_meta_files(self, force=False):
# noinspection PyProtectedMember
if not ek.ek(os.path.isdir, self.show_obj._location):
if not os.path.isdir(self.show_obj._location):
logger.log('%s: The show directory is missing, not bothering to try to create metadata'
% self.show_obj.tvid_prodid)
return
@ -4797,7 +4795,7 @@ class TVEpisode(TVEpisodeBase):
# def full_location(self):
# if self.location in (None, ''):
# return None
# return ek.ek(os.path.join, self.show_obj.location, self.location)
# return os.path.join(self.show_obj.location, self.location)
#
# # TODO: remove if unused
# def create_strings(self, pattern=None):
@ -5140,7 +5138,7 @@ class TVEpisode(TVEpisodeBase):
return result
# if not we append the folder on and use that
return ek.ek(os.path.join, self.formatted_dir(), result)
return os.path.join(self.formatted_dir(), result)
def formatted_dir(self, pattern=None, multi=None):
"""
@ -5164,7 +5162,7 @@ class TVEpisode(TVEpisodeBase):
if 1 == len(name_groups):
logger.debug('No Season Folder set in Naming pattern: %s' % pattern)
return ''
return self._format_pattern(ek.ek(os.sep.join, name_groups[:-1]), multi)
return self._format_pattern(os.sep.join(name_groups[:-1]), multi)
def formatted_filename(self, pattern=None, multi=None, anime_type=None):
"""
@ -5193,13 +5191,13 @@ class TVEpisode(TVEpisodeBase):
in the naming settings.
"""
if not ek.ek(os.path.isfile, self.location):
if not os.path.isfile(self.location):
logger.log('Can\'t perform rename on %s when it doesn\'t exist, skipping' % self.location, logger.WARNING)
return
proper_path = self.proper_path()
absolute_proper_path = ek.ek(os.path.join, self._show_obj.location, proper_path)
absolute_current_path_no_ext, file_ext = ek.ek(os.path.splitext, self.location)
absolute_proper_path = os.path.join(self._show_obj.location, proper_path)
absolute_current_path_no_ext, file_ext = os.path.splitext(self.location)
absolute_current_path_no_ext_length = len(absolute_current_path_no_ext)
related_subs = []
@ -5224,7 +5222,7 @@ class TVEpisode(TVEpisodeBase):
if self.show_obj.subtitles and '' != sickgear.SUBTITLES_DIR:
related_subs = postProcessor.PostProcessor(self.location).list_associated_files(sickgear.SUBTITLES_DIR,
subtitles_only=True)
# absolute_proper_subs_path = ek.ek(os.path.join, sickgear.SUBTITLES_DIR, self.formatted_filename())
# absolute_proper_subs_path = os.path.join(sickgear.SUBTITLES_DIR, self.formatted_filename())
logger.log('Files associated to %s: %s' % (self.location, related_files), logger.DEBUG)
@ -5239,7 +5237,7 @@ class TVEpisode(TVEpisodeBase):
logger.log('%s: Unable to rename file %s' % (self._epid, cur_related_file), logger.ERROR)
for cur_related_sub in related_subs:
absolute_proper_subs_path = ek.ek(os.path.join, sickgear.SUBTITLES_DIR, self.formatted_filename())
absolute_proper_subs_path = os.path.join(sickgear.SUBTITLES_DIR, self.formatted_filename())
renamed = helpers.rename_ep_file(cur_related_sub, absolute_proper_subs_path,
absolute_current_path_no_ext_length)
if not renamed:
@ -5277,7 +5275,7 @@ class TVEpisode(TVEpisodeBase):
has_timestamp = isinstance(self._timestamp, int) and 1 < self._timestamp
if not has_timestamp and (not isinstance(self._airdate, datetime.date) or 1 == self._airdate.year):
logger.log('%s: Did not change modify date of %s because episode date is never aired or invalid'
% (self._show_obj.tvid_prodid, ek.ek(os.path.basename, self.location)), logger.DEBUG)
% (self._show_obj.tvid_prodid, os.path.basename(self.location)), logger.DEBUG)
return
aired_dt = None
@ -5292,7 +5290,7 @@ class TVEpisode(TVEpisodeBase):
try:
aired_epoch = SGDatetime.to_file_timestamp(aired_dt)
filemtime = int(ek.ek(os.path.getmtime, self.location))
filemtime = int(os.path.getmtime(self.location))
except (BaseException, Exception):
return
@ -5303,7 +5301,7 @@ class TVEpisode(TVEpisodeBase):
result, loglevel = 'Error changing', logger.WARNING
logger.log('%s: %s modify date of %s to show air date %s'
% (self._show_obj.tvid_prodid, result, ek.ek(os.path.basename, self.location),
% (self._show_obj.tvid_prodid, result, os.path.basename(self.location),
'n/a' if not aired_dt else aired_dt.strftime('%b %d,%Y (%H:%M)')), loglevel)
def __getstate__(self):

4
sickgear/ui.py
View file

@ -158,10 +158,10 @@ class QueueProgressIndicator(object):
return len(self.queueItemList)
def numFinished(self):
return len([x for x in self.queueItemList if not x.isInQueue()])
return len([x for x in self.queueItemList if not x.is_in_queue()])
def numRemaining(self):
return len([x for x in self.queueItemList if x.isInQueue()])
return len([x for x in self.queueItemList if x.is_in_queue()])
def nextName(self):
for curItem in [

10
sickgear/version_checker.py
View file

@ -25,8 +25,6 @@ import time
import traceback
from . import gh_api as github
# noinspection PyPep8Naming
import encodingKludge as ek
from exceptions_helper import ex
import sickgear
@ -176,7 +174,7 @@ class SoftwareUpdater(object):
'git': running from source using git
'source': running from source without git
"""
return ('source', 'git')[os.path.isdir(ek.ek(os.path.join, sickgear.PROG_DIR, '.git'))]
return ('source', 'git')[os.path.isdir(os.path.join(sickgear.PROG_DIR, '.git'))]
def check_for_new_version(self, force=False):
"""
@ -754,7 +752,7 @@ class SourceUpdateManager(UpdateManager):
try:
# prepare the update dir
sg_update_dir = ek.ek(os.path.join, sickgear.PROG_DIR, u'sg-update')
sg_update_dir = os.path.join(sickgear.PROG_DIR, u'sg-update')
if os.path.isdir(sg_update_dir):
logger.log(u'Clearing out update folder %s before extracting' % sg_update_dir)
@ -768,11 +766,11 @@ class SourceUpdateManager(UpdateManager):
tar_download_path = os.path.join(sg_update_dir, u'sg-update.tar')
urllib.request.urlretrieve(tar_download_url, tar_download_path)
if not ek.ek(os.path.isfile, tar_download_path):
if not os.path.isfile(tar_download_path):
logger.error(u'Unable to retrieve new version from %s, can\'t update' % tar_download_url)
return False
if not ek.ek(tarfile.is_tarfile, tar_download_path):
if not tarfile.is_tarfile(tar_download_path):
logger.error(u'Retrieved version from %s is corrupt, can\'t update' % tar_download_url)
return False

50
sickgear/webapi.py
View file

@ -31,8 +31,6 @@ import time
import traceback
from . import webserve
# noinspection PyPep8Naming
import encodingKludge as ek
import exceptions_helper
from exceptions_helper import ex
from json_helper import is_orjson, json_dumps, JSON_INDENT, json_loads, JSONEncoder, ORJSON_OPTIONS
@ -833,7 +831,7 @@ def _getRootDirs():
for root_dir in root_dirs:
valid = 1
try:
ek.ek(os.listdir, root_dir)
os.listdir(root_dir)
except (BaseException, Exception):
valid = 0
default = 0
@ -2003,7 +2001,7 @@ class CMD_SickGearAddRootDir(ApiCall):
index = 0
# disallow adding/setting an invalid dir
if not ek.ek(os.path.isdir, self.location):
if not os.path.isdir(self.location):
return _responds(RESULT_FAILURE, msg="Location is invalid")
root_dirs = []
@ -2340,8 +2338,8 @@ class CMD_SickGearGetIndexerIcon(ApiCall):
self.handler.set_status(404)
return _responds(RESULT_FAILURE, 'Icon not found')
img = i['icon']
image = ek.ek(os.path.join, sickgear.PROG_DIR, 'gui', 'slick', 'images', img)
if not ek.ek(os.path.isfile, image):
image = os.path.join(sickgear.PROG_DIR, 'gui', 'slick', 'images', img)
if not os.path.isfile(image):
self.handler.set_status(404)
return _responds(RESULT_FAILURE, 'Icon not found')
return {'outputType': 'image', 'image': self.handler.get_image(image)}
@ -2361,9 +2359,8 @@ class CMD_SickGearGetNetworkIcon(ApiCall):
ApiCall.__init__(self, handler, args, kwargs)
def run(self):
image = ek.ek(os.path.join, sickgear.PROG_DIR, 'gui', 'slick', 'images', 'network',
'%s.png' % self.network.lower())
if not ek.ek(os.path.isfile, image):
image = os.path.join(sickgear.PROG_DIR, 'gui', 'slick', 'images', 'network', '%s.png' % self.network.lower())
if not os.path.isfile(image):
self.handler.set_status(404)
return _responds(RESULT_FAILURE, 'Icon not found')
return {'outputType': 'image', 'image': self.handler.get_image(image)}
@ -3328,7 +3325,7 @@ class CMD_SickGearShowAddExisting(ApiCall):
if show_obj:
return _responds(RESULT_FAILURE, msg="An existing indexerid already exists in the database")
if not ek.ek(os.path.isdir, self.location):
if not os.path.isdir(self.location):
return _responds(RESULT_FAILURE, msg='Not a valid location')
lINDEXER_API_PARMS = sickgear.TVInfoAPI(self.tvid).api_params.copy()
@ -3460,7 +3457,7 @@ class CMD_SickGearShowAddNew(ApiCall):
else:
return _responds(RESULT_FAILURE, msg="Root directory is not set, please provide a location")
if not ek.ek(os.path.isdir, self.location):
if not os.path.isdir(self.location):
return _responds(RESULT_FAILURE, msg="'" + self.location + "' is not a valid location")
# use default quality as a failsafe
@ -3611,9 +3608,9 @@ class CMD_SickGearShowCache(ApiCall):
has_poster = 0
has_banner = 0
if ek.ek(os.path.isfile, cache_obj.poster_path(show_obj.tvid, show_obj.prodid)):
if os.path.isfile(cache_obj.poster_path(show_obj.tvid, show_obj.prodid)):
has_poster = 1
if ek.ek(os.path.isfile, cache_obj.banner_path(show_obj.tvid, show_obj.prodid)):
if os.path.isfile(cache_obj.banner_path(show_obj.tvid, show_obj.prodid)):
has_banner = 1
return _responds(RESULT_SUCCESS, {"poster": has_poster, "banner": has_banner})
@ -3663,8 +3660,8 @@ class CMD_SickGearShowDelete(ApiCall):
if not show_obj:
return _responds(RESULT_FAILURE, msg="Show not found")
if sickgear.show_queue_scheduler.action.isBeingAdded(
show_obj) or sickgear.show_queue_scheduler.action.isBeingUpdated(show_obj):
if sickgear.show_queue_scheduler.action.is_being_added(
show_obj) or sickgear.show_queue_scheduler.action.is_being_updated(show_obj):
return _responds(RESULT_FAILURE, msg="Show can not be deleted while being added or updated")
show_obj.delete_show(full=self.full_delete)
@ -3834,8 +3831,7 @@ class CMD_SickGearShowListFanart(ApiCall):
fanart = []
rating_names = {10: 'group', 20: 'favorite', 30: 'avoid'}
cache_obj = image_cache.ImageCache()
for img in ek.ek(glob.glob, cache_obj.fanart_path(
show_obj.tvid, show_obj.prodid).replace('fanart.jpg', '*')) or []:
for img in glob.glob(cache_obj.fanart_path(show_obj.tvid, show_obj.prodid).replace('fanart.jpg', '*')) or []:
match = re.search(r'(\d+(?:\.(\w*?(\d*)))?\.(?:\w{5,8}))\.fanart\.', img, re.I)
if match and match.group(1):
fanart += [(match.group(1), rating_names.get(sickgear.FANART_RATINGS.get(
@ -3870,7 +3866,7 @@ class CMD_SickGearShowRateFanart(ApiCall):
cache_obj = image_cache.ImageCache()
fanartfile = cache_obj.fanart_path(self.tvid, self.prodid).replace('fanart.jpg',
'%s.fanart.jpg' % self.fanartname)
if not ek.ek(os.path.isfile, fanartfile):
if not os.path.isfile(fanartfile):
return _responds(RESULT_FAILURE, msg='Unknown Fanart')
fan_ratings = {'unrate': 0, 'group': 10, 'favorite': 20, 'avoid': 30}
show_id = TVidProdid({self.tvid: self.prodid})()
@ -3906,19 +3902,19 @@ class CMD_SickGearShowGetFanart(ApiCall):
def run(self):
""" get the fanart stored for a show """
cache_obj = image_cache.ImageCache()
default_fanartfile = ek.ek(os.path.join, sickgear.PROG_DIR, 'gui', 'slick', 'images', 'trans.png')
default_fanartfile = os.path.join(sickgear.PROG_DIR, 'gui', 'slick', 'images', 'trans.png')
fanartfile = default_fanartfile
used_fanart = 'default'
if self.fanartname:
fanartfile = cache_obj.fanart_path(self.tvid, self.prodid).replace('fanart.jpg',
'%s.fanart.jpg' % self.fanartname)
if not ek.ek(os.path.isfile, fanartfile):
if not os.path.isfile(fanartfile):
fanartfile = default_fanartfile
used_fanart = self.fanartname
else:
fanart = []
for img in ek.ek(glob.glob, cache_obj.fanart_path(self.tvid, self.prodid).replace('fanart.jpg', '*')) or []:
if not ek.ek(os.path.isfile, img):
for img in glob.glob(cache_obj.fanart_path(self.tvid, self.prodid).replace('fanart.jpg', '*')) or []:
if not os.path.isfile(img):
continue
match = re.search(r'(\d+(?:\.(\w*?(\d*)))?\.(?:\w{5,8}))\.fanart\.', img, re.I)
if match and match.group(1):
@ -3933,8 +3929,8 @@ class CMD_SickGearShowGetFanart(ApiCall):
fanartfile = fanartsorted[random_fanart][0]
used_fanart = fanartsorted[random_fanart][1]
if fanartfile and ek.ek(os.path.isfile, fanartfile):
with ek.ek(open, fanartfile, 'rb') as f:
if fanartfile and os.path.isfile(fanartfile):
with open(fanartfile, 'rb') as f:
mime_type, encoding = MimeTypes().guess_type(fanartfile)
self.handler.set_header('X-Fanartname', used_fanart)
self.handler.set_header('Content-Type', mime_type)
@ -4021,7 +4017,7 @@ class CMD_SickGearShowRefresh(ApiCall):
return _responds(RESULT_FAILURE, msg="Show not found")
try:
sickgear.show_queue_scheduler.action.refreshShow(show_obj)
sickgear.show_queue_scheduler.action.refresh_show(show_obj)
return _responds(RESULT_SUCCESS, msg='%s has queued to be refreshed' % show_obj.unique_name)
except exceptions_helper.CantRefreshException as e:
# TODO: log the exception
@ -4443,7 +4439,7 @@ class CMD_SickGearShowUpdate(ApiCall):
return _responds(RESULT_FAILURE, msg="Show not found")
try:
sickgear.show_queue_scheduler.action.updateShow(show_obj, True)
sickgear.show_queue_scheduler.action.update_show(show_obj, True)
return _responds(RESULT_SUCCESS, msg='%s has queued to be updated' % show_obj.unique_name)
except exceptions_helper.CantUpdateException as e:
self.log(u'Unable to update %s. %s' % (show_obj.unique_name, ex(e)), logger.ERROR)
@ -4655,7 +4651,7 @@ class CMD_SickGearShowsForceUpdate(ApiCall):
def run(self):
""" force the daily show update now """
if sickgear.show_queue_scheduler.action.isShowUpdateRunning() \
if sickgear.show_queue_scheduler.action.is_show_update_running() \
or sickgear.show_update_scheduler.action.amActive:
return _responds(RESULT_FAILURE, msg="show update already running.")

325
sickgear/webserve.py
View file

@ -37,8 +37,6 @@ import zipfile
from exceptions_helper import ex, MultipleShowObjectsException
import exceptions_helper
# noinspection PyPep8Naming
import encodingKludge as ek
from json_helper import json_dumps, json_loads
import sg_helpers
from sg_helpers import remove_file, scantree
@ -173,7 +171,7 @@ class BaseStaticFileHandler(StaticFileHandler):
return super(BaseStaticFileHandler, self).write_error(status_code, **kwargs)
def validate_absolute_path(self, root, absolute_path):
if '\\images\\flags\\' in absolute_path and not ek.ek(os.path.isfile, absolute_path):
if '\\images\\flags\\' in absolute_path and not os.path.isfile(absolute_path):
absolute_path = re.sub(r'\\[^\\]+\.png$', '\\\\unknown.png', absolute_path)
return super(BaseStaticFileHandler, self).validate_absolute_path(root, absolute_path)
@ -281,10 +279,10 @@ class BaseHandler(RouteHandler):
return True
def get_image(self, image):
if ek.ek(os.path.isfile, image):
if os.path.isfile(image):
mime_type, encoding = MimeTypes().guess_type(image)
self.set_header('Content-Type', mime_type)
with ek.ek(open, image, 'rb') as img:
with open(image, 'rb') as img:
return img.read()
def show_poster(self, tvid_prodid=None, which=None, api=None):
@ -316,19 +314,19 @@ class BaseHandler(RouteHandler):
('%s' % (re.sub(r'.*?fanart_(\d+(?:\.\w{1,20})?\.\w{5,8}).*', r'\1.', which, 0, re.I)),))]
for cur_name in image_file_name:
if ek.ek(os.path.isfile, cur_name):
if os.path.isfile(cur_name):
static_image_path = cur_name
break
if api:
used_file = ek.ek(os.path.basename, static_image_path)
used_file = os.path.basename(static_image_path)
if static_image_path.startswith('/images'):
used_file = 'default'
static_image_path = ek.ek(os.path.join, sickgear.PROG_DIR, 'gui', 'slick', static_image_path[1:])
static_image_path = os.path.join(sickgear.PROG_DIR, 'gui', 'slick', static_image_path[1:])
mime_type, encoding = MimeTypes().guess_type(static_image_path)
self.set_header('Content-Type', mime_type)
self.set_header('X-Filename', used_file)
with ek.ek(open, static_image_path, 'rb') as img:
with open(static_image_path, 'rb') as img:
return img.read()
else:
static_image_path = os.path.normpath(static_image_path.replace(sickgear.CACHE_DIR, '/cache'))
@ -472,37 +470,37 @@ class RepoHandler(BaseStaticFileHandler):
super(RepoHandler, self).initialize(*args, **kwargs)
logger.log('Kodi req... initialize(path): %s' % kwargs['path'], logger.DEBUG)
cache_client = ek.ek(os.path.join, sickgear.CACHE_DIR, 'clients')
cache_client_kodi = ek.ek(os.path.join, cache_client, 'kodi')
cache_client_kodi_watchedstate = ek.ek(os.path.join, cache_client_kodi, 'service.sickgear.watchedstate.updater')
cache_client = os.path.join(sickgear.CACHE_DIR, 'clients')
cache_client_kodi = os.path.join(cache_client, 'kodi')
cache_client_kodi_watchedstate = os.path.join(cache_client_kodi, 'service.sickgear.watchedstate.updater')
cache_resources = ek.ek(os.path.join, cache_client_kodi_watchedstate, 'resources')
cache_lang = ek.ek(os.path.join, cache_resources, 'language')
cache_other_lang = ek.ek(os.path.join, cache_lang, ('English', 'resource.language.en_gb')[self.kodi_is_legacy])
ek.ek(os.path.exists, cache_other_lang) and remove_file(cache_other_lang, tree=True)
cache_resources = os.path.join(cache_client_kodi_watchedstate, 'resources')
cache_lang = os.path.join(cache_resources, 'language')
cache_other_lang = os.path.join(cache_lang, ('English', 'resource.language.en_gb')[self.kodi_is_legacy])
os.path.exists(cache_other_lang) and remove_file(cache_other_lang, tree=True)
cache_lang_sub = ek.ek(os.path.join, cache_lang, ('resource.language.en_gb', 'English')[self.kodi_is_legacy])
cache_lang_sub = os.path.join(cache_lang, ('resource.language.en_gb', 'English')[self.kodi_is_legacy])
for folder in (cache_client,
cache_client_kodi,
ek.ek(os.path.join, cache_client_kodi, 'repository.sickgear'),
os.path.join(cache_client_kodi, 'repository.sickgear'),
cache_client_kodi_watchedstate,
ek.ek(os.path.join, cache_resources),
os.path.join(cache_resources),
cache_lang, cache_lang_sub,
):
if not ek.ek(os.path.exists, folder):
ek.ek(os.mkdir, folder)
if not os.path.exists(folder):
os.mkdir(folder)
with io.open(ek.ek(os.path.join, cache_client_kodi, 'index.html'), 'w') as fh:
with io.open(os.path.join(cache_client_kodi, 'index.html'), 'w') as fh:
fh.write(self.render_kodi_index())
with io.open(ek.ek(os.path.join, cache_client_kodi, 'repository.sickgear', 'index.html'), 'w') as fh:
with io.open(os.path.join(cache_client_kodi, 'repository.sickgear', 'index.html'), 'w') as fh:
fh.write(self.render_kodi_repository_sickgear_index())
with io.open(ek.ek(os.path.join, cache_client_kodi_watchedstate, 'index.html'), 'w') as fh:
with io.open(os.path.join(cache_client_kodi_watchedstate, 'index.html'), 'w') as fh:
fh.write(self.render_kodi_service_sickgear_watchedstate_updater_index())
with io.open(ek.ek(os.path.join, cache_resources, 'index.html'), 'w') as fh:
with io.open(os.path.join(cache_resources, 'index.html'), 'w') as fh:
fh.write(self.render_kodi_service_sickgear_watchedstate_updater_resources_index())
with io.open(ek.ek(os.path.join, cache_lang, 'index.html'), 'w') as fh:
with io.open(os.path.join(cache_lang, 'index.html'), 'w') as fh:
fh.write(self.render_kodi_service_sickgear_watchedstate_updater_resources_language_index())
with io.open(ek.ek(os.path.join, cache_lang_sub, 'index.html'), 'w') as fh:
with io.open(os.path.join(cache_lang_sub, 'index.html'), 'w') as fh:
fh.write(self.render_kodi_service_sickgear_watchedstate_updater_resources_language_english_index())
'''
@ -511,7 +509,7 @@ class RepoHandler(BaseStaticFileHandler):
if repo rendered md5 changes or flag is true, update the repo addon, where repo version *must* be increased
'''
repo_md5_file = ek.ek(os.path.join, cache_client_kodi, 'addons.xml.md5')
repo_md5_file = os.path.join(cache_client_kodi, 'addons.xml.md5')
saved_md5 = None
try:
with io.open(repo_md5_file, 'r', encoding='utf8') as fh:
@ -520,18 +518,18 @@ class RepoHandler(BaseStaticFileHandler):
pass
rendered_md5 = self.render_kodi_repo_addons_xml_md5()
if saved_md5 != rendered_md5:
with io.open(ek.ek(os.path.join, cache_client_kodi, 'repository.sickgear', 'addon.xml'), 'w') as fh:
with io.open(os.path.join(cache_client_kodi, 'repository.sickgear', 'addon.xml'), 'w') as fh:
fh.write(self.render_kodi_repo_addon_xml())
with io.open(ek.ek(os.path.join, cache_client_kodi_watchedstate, 'addon.xml'), 'w') as fh:
with io.open(os.path.join(cache_client_kodi_watchedstate, 'addon.xml'), 'w') as fh:
fh.write(self.get_watchedstate_updater_addon_xml())
with io.open(ek.ek(os.path.join, cache_client_kodi, 'addons.xml'), 'w') as fh:
with io.open(os.path.join(cache_client_kodi, 'addons.xml'), 'w') as fh:
fh.write(self.render_kodi_repo_addons_xml())
with io.open(ek.ek(os.path.join, cache_client_kodi, 'addons.xml.md5'), 'w') as fh:
with io.open(os.path.join(cache_client_kodi, 'addons.xml.md5'), 'w') as fh:
fh.write(rendered_md5)
def save_zip(name, version, zip_path, zip_method):
zip_name = '%s-%s.zip' % (name, version)
zip_file = ek.ek(os.path.join, zip_path, zip_name)
zip_file = os.path.join(zip_path, zip_name)
for direntry in helpers.scantree(zip_path, ['resources'], [r'\.(?:md5|zip)$'], filter_kind=False):
remove_file_perm(direntry.path)
zip_data = zip_method()
@ -539,11 +537,11 @@ class RepoHandler(BaseStaticFileHandler):
zh.write(zip_data)
# Force a UNIX line ending, like the md5sum utility.
with io.open(ek.ek(os.path.join, zip_path, '%s.md5' % zip_name), 'w', newline='\n') as zh:
with io.open(os.path.join(zip_path, '%s.md5' % zip_name), 'w', newline='\n') as zh:
zh.write(u'%s *%s\n' % (self.md5ify(zip_data), zip_name))
aid, ver = self.repo_sickgear_details()
save_zip(aid, ver, ek.ek(os.path.join, cache_client_kodi, 'repository.sickgear'),
save_zip(aid, ver, os.path.join(cache_client_kodi, 'repository.sickgear'),
self.kodi_repository_sickgear_zip)
aid, ver = self.addon_watchedstate_details()
@ -566,8 +564,8 @@ class RepoHandler(BaseStaticFileHandler):
(cache_lang_sub, 'strings.xml')
))[self.kodi_is_legacy],
):
helpers.copy_file(ek.ek(
os.path.join, *(sickgear.PROG_DIR, 'sickgear', 'clients', 'kodi') + src), ek.ek(os.path.join, *dst))
helpers.copy_file(
os.path.join(*(sickgear.PROG_DIR, 'sickgear', 'clients', 'kodi') + src), os.path.join(*dst))
def get_content_type(self):
if '.md5' == self.absolute_path[-4:] or '.po' == self.absolute_path[-3:]:
@ -583,7 +581,7 @@ class RepoHandler(BaseStaticFileHandler):
t.addon = '%s-%s.zip' % self.addon_watchedstate_details()
try:
with open(ek.ek(os.path.join, sickgear.PROG_DIR, 'CHANGES.md')) as fh:
with open(os.path.join(sickgear.PROG_DIR, 'CHANGES.md')) as fh:
t.version = re.findall(r'###[^0-9x]+([0-9]+\.[0-9]+\.[0-9x]+)', fh.readline())[0]
except (BaseException, Exception):
t.version = ''
@ -640,8 +638,8 @@ class RepoHandler(BaseStaticFileHandler):
return sickgear.MEMCACHE.get(mem_key).get('data')
filename = 'addon%s.xml' % self.kodi_include
with io.open(ek.ek(os.path.join, sickgear.PROG_DIR, 'sickgear', 'clients',
'kodi', 'service.sickgear.watchedstate.updater', filename), 'r', encoding='utf8') as fh:
with io.open(os.path.join(sickgear.PROG_DIR, 'sickgear', 'clients', 'kodi',
'service.sickgear.watchedstate.updater', filename), 'r', encoding='utf8') as fh:
xml = fh.read().strip() % dict(ADDON_VERSION=self.get_addon_version(self.kodi_include))
sickgear.MEMCACHE[mem_key] = dict(last_update=30 + int(timestamp_near(datetime.datetime.now())), data=xml)
@ -662,8 +660,8 @@ class RepoHandler(BaseStaticFileHandler):
return sickgear.MEMCACHE.get(mem_key).get('data')
filename = 'service%s.py' % kodi_include
with io.open(ek.ek(os.path.join, sickgear.PROG_DIR, 'sickgear', 'clients',
'kodi', 'service.sickgear.watchedstate.updater', filename), 'r', encoding='utf8') as fh:
with io.open(os.path.join(sickgear.PROG_DIR, 'sickgear', 'clients', 'kodi',
'service.sickgear.watchedstate.updater', filename), 'r', encoding='utf8') as fh:
version = re.findall(r'ADDON_VERSION\s*?=\s*?\'([^\']+)', fh.read())[0]
sickgear.MEMCACHE[mem_key] = dict(last_update=30 + int(timestamp_near(datetime.datetime.now())), data=version)
@ -705,8 +703,8 @@ class RepoHandler(BaseStaticFileHandler):
with zipfile.ZipFile(bfr, 'w') as zh:
zh.writestr('repository.sickgear/addon.xml', self.render_kodi_repo_addon_xml(), zipfile.ZIP_DEFLATED)
with io.open(ek.ek(os.path.join, sickgear.PROG_DIR,
'sickgear', 'clients', 'kodi', 'repository.sickgear', 'icon.png'), 'rb') as fh:
with io.open(os.path.join(sickgear.PROG_DIR, 'sickgear', 'clients', 'kodi',
'repository.sickgear', 'icon.png'), 'rb') as fh:
infile = fh.read()
zh.writestr('repository.sickgear/icon.png', infile, zipfile.ZIP_DEFLATED)
except OSError as e:
@ -719,12 +717,12 @@ class RepoHandler(BaseStaticFileHandler):
def kodi_service_sickgear_watchedstate_updater_zip(self):
bfr = io.BytesIO()
basepath = ek.ek(os.path.join, sickgear.PROG_DIR, 'sickgear', 'clients', 'kodi')
basepath = os.path.join(sickgear.PROG_DIR, 'sickgear', 'clients', 'kodi')
zip_path = ek.ek(os.path.join, basepath, 'service.sickgear.watchedstate.updater')
devenv_src = ek.ek(os.path.join, sickgear.PROG_DIR, 'tests', '_devenv.py')
devenv_dst = ek.ek(os.path.join, zip_path, '_devenv.py')
if sickgear.ENV.get('DEVENV') and ek.ek(os.path.exists, devenv_src):
zip_path = os.path.join(basepath, 'service.sickgear.watchedstate.updater')
devenv_src = os.path.join(sickgear.PROG_DIR, 'tests', '_devenv.py')
devenv_dst = os.path.join(zip_path, '_devenv.py')
if sickgear.ENV.get('DEVENV') and os.path.exists(devenv_src):
helpers.copy_file(devenv_src, devenv_dst)
else:
helpers.remove_file_perm(devenv_dst)
@ -746,7 +744,7 @@ class RepoHandler(BaseStaticFileHandler):
infile = fh.read()
with zipfile.ZipFile(bfr, 'a') as zh:
zh.writestr(ek.ek(os.path.relpath, direntry.path.replace(self.kodi_legacy, ''), basepath),
zh.writestr(os.path.relpath(direntry.path.replace(self.kodi_legacy, ''), basepath),
infile, zipfile.ZIP_DEFLATED)
except OSError as e:
logger.log('Unable to zip %s: %r / %s' % (direntry.path, e, ex(e)), logger.WARNING)
@ -890,7 +888,7 @@ class LogfileHandler(BaseHandler):
self.set_header('Content-Type', 'text/html; charset=utf-8')
self.set_header('Content-Description', 'Logfile Download')
self.set_header('Content-Disposition', 'attachment; filename=sickgear.log')
# self.set_header('Content-Length', ek.ek(os.path.getsize, logfile_name))
# self.set_header('Content-Length', os.path.getsize(logfile_name))
auths = sickgear.GenericProvider.dedupe_auths(True)
rxc_auths = re.compile('(?i)%s' % '|'.join([(re.escape(_a)) for _a in auths]))
replacements = dict([(_a, starify(_a)) for _a in auths])
@ -1192,7 +1190,7 @@ class MainHandler(WebHandler):
if tvid_prodid in fanarts:
continue
for img in ek.ek(glob.glob, cache_obj.fanart_path(*tvid_prodid_obj.tuple).replace('fanart.jpg', '*')) or []:
for img in glob.glob(cache_obj.fanart_path(*tvid_prodid_obj.tuple).replace('fanart.jpg', '*')) or []:
match = re.search(r'(\d+(?:\.\w*)?\.\w{5,8})\.fanart\.', img, re.I)
if not match:
continue
@ -1276,8 +1274,8 @@ class MainHandler(WebHandler):
elif 'backart' in kwargs:
sickgear.EPISODE_VIEW_BACKGROUND = backart
sickgear.FANART_PANEL = 'highlight-off' == sickgear.FANART_PANEL and 'highlight-off' or \
'highlight2' == sickgear.FANART_PANEL and 'highlight1' or \
'highlight1' == sickgear.FANART_PANEL and 'highlight' or 'highlight-off'
'highlight2' == sickgear.FANART_PANEL and 'highlight1' or \
'highlight1' == sickgear.FANART_PANEL and 'highlight' or 'highlight-off'
elif 'viewmode' in kwargs:
sickgear.EPISODE_VIEW_VIEWMODE = viewmode
@ -1395,7 +1393,7 @@ r.close()
if data:
my_db = db.DBConnection(row_type='dict')
media_paths = map_list(lambda arg: ek.ek(os.path.basename, arg[1]['path_file']), iteritems(data))
media_paths = map_list(lambda arg: os.path.basename(arg[1]['path_file']), iteritems(data))
def chunks(lines, n):
for c in range(0, len(lines), n):
@ -1412,13 +1410,13 @@ r.close()
cl = []
ep_results = {}
map_consume(lambda r: ep_results.update({'%s' % ek.ek(os.path.basename, r['location']).lower(): dict(
map_consume(lambda r: ep_results.update({'%s' % os.path.basename(r['location']).lower(): dict(
episode_id=r['episode_id'], status=r['status'], location=r['location'],
file_size=r['file_size'])}), sql_result)
for (k, v) in iteritems(data):
bname = (ek.ek(os.path.basename, v.get('path_file')) or '').lower()
bname = (os.path.basename(v.get('path_file')) or '').lower()
if not bname:
msg = 'Missing media file name provided'
data[k] = msg
@ -1581,15 +1579,15 @@ class Home(MainHandler):
if 'simple' != sickgear.HOME_LAYOUT:
t.network_images = {}
networks = {}
images_path = ek.ek(os.path.join, sickgear.PROG_DIR, 'gui', 'slick', 'images', 'network')
images_path = os.path.join(sickgear.PROG_DIR, 'gui', 'slick', 'images', 'network')
for cur_show_obj in sickgear.showList:
network_name = 'nonetwork' if None is cur_show_obj.network \
else cur_show_obj.network.replace(u'\u00C9', 'e').lower()
if network_name not in networks:
filename = u'%s.png' % network_name
if not ek.ek(os.path.isfile, ek.ek(os.path.join, images_path, filename)):
if not os.path.isfile(os.path.join(images_path, filename)):
filename = u'%s.png' % re.sub(r'(?m)(.*)\s+\(\w{2}\)$', r'\1', network_name)
if not ek.ek(os.path.isfile, ek.ek(os.path.join, images_path, filename)):
if not os.path.isfile(os.path.join(images_path, filename)):
filename = u'nonetwork.png'
networks.setdefault(network_name, filename)
t.network_images.setdefault(cur_show_obj.tvid_prodid, networks[network_name])
@ -2141,25 +2139,25 @@ class Home(MainHandler):
show_message = []
if sickgear.show_queue_scheduler.action.isBeingAdded(show_obj):
if sickgear.show_queue_scheduler.action.is_being_added(show_obj):
show_message = ['Downloading this show, the information below is incomplete']
elif sickgear.show_queue_scheduler.action.isBeingUpdated(show_obj):
elif sickgear.show_queue_scheduler.action.is_being_updated(show_obj):
show_message = ['Updating information for this show']
elif sickgear.show_queue_scheduler.action.isBeingRefreshed(show_obj):
elif sickgear.show_queue_scheduler.action.is_being_refreshed(show_obj):
show_message = ['Refreshing episodes from disk for this show']
elif sickgear.show_queue_scheduler.action.isBeingSubtitled(show_obj):
elif sickgear.show_queue_scheduler.action.is_being_subtitled(show_obj):
show_message = ['Downloading subtitles for this show']
elif sickgear.show_queue_scheduler.action.isInRefreshQueue(show_obj):
elif sickgear.show_queue_scheduler.action.is_in_refresh_queue(show_obj):
show_message = ['Refresh queued for this show']
elif sickgear.show_queue_scheduler.action.isInUpdateQueue(show_obj):
elif sickgear.show_queue_scheduler.action.is_in_update_queue(show_obj):
show_message = ['Update queued for this show']
elif sickgear.show_queue_scheduler.action.isInSubtitleQueue(show_obj):
elif sickgear.show_queue_scheduler.action.is_in_subtitle_queue(show_obj):
show_message = ['Subtitle download queued for this show']
if sickgear.show_queue_scheduler.action.is_show_being_switched(show_obj):
@ -2185,8 +2183,8 @@ class Home(MainHandler):
show_message = '.<br>'.join(show_message)
t.force_update = 'home/update-show?tvid_prodid=%s&amp;force=1&amp;web=1' % tvid_prodid
if not sickgear.show_queue_scheduler.action.isBeingAdded(show_obj):
if not sickgear.show_queue_scheduler.action.isBeingUpdated(show_obj):
if not sickgear.show_queue_scheduler.action.is_being_added(show_obj):
if not sickgear.show_queue_scheduler.action.is_being_updated(show_obj):
t.submenu.append(
{'title': 'Remove',
'path': 'home/delete-show?tvid_prodid=%s' % tvid_prodid, 'confirm': True})
@ -2211,7 +2209,7 @@ class Home(MainHandler):
t.submenu.append(
{'title': 'Media Rename',
'path': 'home/rename-media?tvid_prodid=%s' % tvid_prodid})
if sickgear.USE_SUBTITLES and not sickgear.show_queue_scheduler.action.isBeingSubtitled(
if sickgear.USE_SUBTITLES and not sickgear.show_queue_scheduler.action.is_being_subtitled(
show_obj) and show_obj.subtitles:
t.submenu.append(
{'title': 'Download Subtitles',
@ -2355,8 +2353,7 @@ class Home(MainHandler):
t.fanart = []
cache_obj = image_cache.ImageCache()
for img in ek.ek(glob.glob,
cache_obj.fanart_path(show_obj.tvid, show_obj.prodid).replace('fanart.jpg', '*')) or []:
for img in glob.glob(cache_obj.fanart_path(show_obj.tvid, show_obj.prodid).replace('fanart.jpg', '*')) or []:
match = re.search(r'(\d+(?:\.(\w*?(\d*)))?\.\w{5,8})\.fanart\.', img, re.I)
if match and match.group(1):
t.fanart += [(match.group(1),
@ -2544,8 +2541,8 @@ class Home(MainHandler):
show_obj = helpers.find_show_by_id({tvid: prodid}, no_mapped_ids=True)
try:
sickgear.show_queue_scheduler.action.switch_show(show_obj=show_obj, new_tvid=m_tvid,
new_prodid=m_prodid, force_id=True,
set_pause=set_pause, mark_wanted=mark_wanted)
new_prodid=m_prodid, force_id=True,
set_pause=set_pause, mark_wanted=mark_wanted)
except (BaseException, Exception) as e:
logger.log('Could not add show %s to switch queue: %s' % (show_obj.tvid_prodid, ex(e)), logger.WARNING)
@ -2666,7 +2663,7 @@ class Home(MainHandler):
t.fanart = []
cache_obj = image_cache.ImageCache()
show_obj = getattr(t, 'show_obj', None) or getattr(t, 'show', None)
for img in ek.ek(glob.glob, cache_obj.fanart_path(
for img in glob.glob(cache_obj.fanart_path(
show_obj.tvid, show_obj.prodid).replace('fanart.jpg', '*')) or []:
match = re.search(r'(\d+(?:\.(\w*?(\d*)))?\.\w{5,8})\.fanart\.', img, re.I)
if match and match.group(1):
@ -2849,7 +2846,7 @@ class Home(MainHandler):
if bool(show_obj.flatten_folders) != bool(flatten_folders):
show_obj.flatten_folders = flatten_folders
try:
sickgear.show_queue_scheduler.action.refreshShow(show_obj)
sickgear.show_queue_scheduler.action.refresh_show(show_obj)
except exceptions_helper.CantRefreshException as e:
errors.append('Unable to refresh this show: ' + ex(e))
@ -2894,11 +2891,11 @@ class Home(MainHandler):
# if we change location clear the db of episodes, change it, write to db, and rescan
# noinspection PyProtectedMember
old_path = ek.ek(os.path.normpath, show_obj._location)
new_path = ek.ek(os.path.normpath, location)
old_path = os.path.normpath(show_obj._location)
new_path = os.path.normpath(location)
if old_path != new_path:
logger.log(u'%s != %s' % (old_path, new_path), logger.DEBUG)
if not ek.ek(os.path.isdir, new_path) and not sickgear.CREATE_MISSING_SHOW_DIRS:
if not os.path.isdir(new_path) and not sickgear.CREATE_MISSING_SHOW_DIRS:
errors.append(u'New location <tt>%s</tt> does not exist' % new_path)
# don't bother if we're going to update anyway
@ -2907,7 +2904,7 @@ class Home(MainHandler):
try:
show_obj.location = new_path
try:
sickgear.show_queue_scheduler.action.refreshShow(show_obj)
sickgear.show_queue_scheduler.action.refresh_show(show_obj)
except exceptions_helper.CantRefreshException as e:
errors.append('Unable to refresh this show:' + ex(e))
# grab updated info from TVDB
@ -2924,7 +2921,7 @@ class Home(MainHandler):
# force the update
if do_update:
try:
sickgear.show_queue_scheduler.action.updateShow(show_obj, True)
sickgear.show_queue_scheduler.action.update_show(show_obj, True)
helpers.cpu_sleep()
except exceptions_helper.CantUpdateException:
errors.append('Unable to force an update on the show.')
@ -2962,8 +2959,8 @@ class Home(MainHandler):
if None is show_obj:
return self._generic_message('Error', 'Unable to find the specified show')
if sickgear.show_queue_scheduler.action.isBeingAdded(
show_obj) or sickgear.show_queue_scheduler.action.isBeingUpdated(show_obj):
if sickgear.show_queue_scheduler.action.is_being_added(
show_obj) or sickgear.show_queue_scheduler.action.is_being_updated(show_obj):
return self._generic_message("Error", "Shows can't be deleted while they're being added or updated.")
# if sickgear.USE_TRAKT and sickgear.TRAKT_SYNC:
@ -3008,7 +3005,7 @@ class Home(MainHandler):
# force the update from the DB
try:
sickgear.show_queue_scheduler.action.refreshShow(show_obj)
sickgear.show_queue_scheduler.action.refresh_show(show_obj)
except exceptions_helper.CantRefreshException as e:
ui.notifications.error('Unable to refresh this show.', ex(e))
@ -3028,7 +3025,7 @@ class Home(MainHandler):
# force the update
try:
sickgear.show_queue_scheduler.action.updateShow(show_obj, bool(force), bool(web))
sickgear.show_queue_scheduler.action.update_show(show_obj, bool(force), bool(web))
except exceptions_helper.CantUpdateException as e:
ui.notifications.error('Unable to update this show.',
ex(e))
@ -3153,7 +3150,7 @@ class Home(MainHandler):
elif status in Quality.DOWNLOADED \
and ep_obj.status not in required + Quality.ARCHIVED + [IGNORED, SKIPPED] \
and not ek.ek(os.path.isfile, ep_obj.location):
and not os.path.isfile(ep_obj.location):
err_msg = 'to downloaded because it\'s not snatched/downloaded/archived'
if err_msg:
@ -4061,7 +4058,7 @@ class AddShows(Home):
any(ids_to_search[si] == results[cur_tvid][tv_src_id].get('ids', {})[si]
for si in ids_to_search):
ids_search_used.update({k: v for k, v in iteritems(
results[cur_tvid][tv_src_id].get('ids',{}))
results[cur_tvid][tv_src_id].get('ids', {}))
if v and k not in iterkeys(ids_to_search)})
results[cur_tvid][tv_src_id]['rename_suggest'] = '' \
if not results[cur_tvid][tv_src_id]['firstaired'] \
@ -4110,7 +4107,8 @@ class AddShows(Home):
show['seriesname'], helpers.xhtml_escape(show['seriesname']), show['firstaired'],
(isinstance(show['firstaired'], string_types)
and SGDatetime.sbfdate(_parse_date(show['firstaired'])) or ''),
show.get('network', '') or '', (show.get('genres', '') or show.get('genre', '') or '').replace('|', ', '), # 11 - 12
show.get('network', '') or '', # 11
(show.get('genres', '') or show.get('genre', '') or '').replace('|', ', '), # 12
show.get('language', ''), show.get('language_country_code') or '', # 13 - 14
re.sub(r'([,.!][^,.!]*?)$', '...',
re.sub(r'([.!?])(?=\w)', r'\1 ',
@ -4275,7 +4273,7 @@ class AddShows(Home):
try:
for cur_dir in scantree(cur_root_dir, filter_kind=True, recurse=False):
normpath = ek.ek(os.path.normpath, cur_dir.path)
normpath = os.path.normpath(cur_dir.path)
highlight = hash_dir == re.sub('[^a-z]', '', sg_helpers.md5_for_text(normpath))
if hash_dir:
display_one_dir = highlight
@ -4318,7 +4316,7 @@ class AddShows(Home):
if display_one_dir and not cur_data['highlight'][cur_enum]:
continue
dir_item = dict(normpath=cur_normpath, rootpath='%s%s' % (ek.ek(os.path.dirname, cur_normpath), os.sep),
dir_item = dict(normpath=cur_normpath, rootpath='%s%s' % (os.path.dirname(cur_normpath), os.sep),
name=cur_data['name'][cur_enum], added_already=any(cur_data['exists'][cur_enum]),
highlight=cur_data['highlight'][cur_enum])
@ -4330,7 +4328,7 @@ class AddShows(Home):
if prodid and show_name:
break
(tvid, prodid, show_name) = cur_provider.retrieveShowMetadata(cur_normpath)
(tvid, prodid, show_name) = cur_provider.retrieve_show_metadata(cur_normpath)
# default to TVDB if TV info src was not detected
if show_name and (not tvid or not prodid):
@ -4376,7 +4374,7 @@ class AddShows(Home):
elif not show_dir:
t.default_show_name = ''
elif not show_name:
t.default_show_name = ek.ek(os.path.basename, ek.ek(os.path.normpath, show_dir)).replace('.', ' ')
t.default_show_name = os.path.basename(os.path.normpath(show_dir)).replace('.', ' ')
else:
t.default_show_name = show_name
@ -5948,7 +5946,7 @@ class AddShows(Home):
tvid, void, prodid, show_name = self.split_extra_show(which_series)
if bool(helpers.try_int(cancel_form)):
tvid = tvid or provided_tvid or '0'
prodid = re.findall(r'tvid_prodid=[^%s]+%s([\d]+)' % tuple(2 * [TVidProdid.glue]), return_to)[0]
prodid = re.findall(r'tvid_prodid=[^%s]+%s(\d+)' % tuple(2 * [TVidProdid.glue]), return_to)[0]
return self.redirect(return_to % (tvid, prodid))
# grab our list of other dirs if given
@ -6001,14 +5999,14 @@ class AddShows(Home):
# use the whole path if it's given, or else append the show name to the root dir to get the full show path
if full_show_path:
show_dir = ek.ek(os.path.normpath, full_show_path)
show_dir = os.path.normpath(full_show_path)
new_show = False
else:
show_dir = helpers.generate_show_dir_name(root_dir, show_name)
new_show = True
# if the dir exists, do 'add existing show'
if ek.ek(os.path.isdir, show_dir) and not full_show_path:
if os.path.isdir(show_dir) and not full_show_path:
ui.notifications.error('Unable to add show', u'Found existing folder: ' + show_dir)
return self.redirect(
'/add-shows/import?tvid_prodid=%s%s%s&hash_dir=%s%s' %
@ -6691,7 +6689,7 @@ class Manage(MainHandler):
for cur_show_obj in show_list:
# noinspection PyProtectedMember
cur_root_dir = ek.ek(os.path.dirname, cur_show_obj._location)
cur_root_dir = os.path.dirname(cur_show_obj._location)
if cur_root_dir not in root_dir_list:
root_dir_list.append(cur_root_dir)
@ -6817,11 +6815,11 @@ class Manage(MainHandler):
continue
# noinspection PyProtectedMember
cur_root_dir = ek.ek(os.path.dirname, show_obj._location)
cur_root_dir = os.path.dirname(show_obj._location)
# noinspection PyProtectedMember
cur_show_dir = ek.ek(os.path.basename, show_obj._location)
cur_show_dir = os.path.basename(show_obj._location)
if cur_root_dir in dir_map and cur_root_dir != dir_map[cur_root_dir]:
new_show_dir = ek.ek(os.path.join, dir_map[cur_root_dir], cur_show_dir)
new_show_dir = os.path.join(dir_map[cur_root_dir], cur_show_dir)
if 'nt' != os.name and ':\\' in cur_show_dir:
# noinspection PyProtectedMember
cur_show_dir = show_obj._location.split('\\')[-1]
@ -6829,7 +6827,7 @@ class Manage(MainHandler):
base_dir = dir_map[cur_root_dir].rsplit(cur_show_dir)[0].rstrip('/')
except IndexError:
base_dir = dir_map[cur_root_dir]
new_show_dir = ek.ek(os.path.join, base_dir, cur_show_dir)
new_show_dir = os.path.join(base_dir, cur_show_dir)
# noinspection PyProtectedMember
logger.log(u'For show %s changing dir from %s to %s' %
(show_obj.unique_name, show_obj._location, new_show_dir))
@ -6945,20 +6943,20 @@ class Manage(MainHandler):
else:
if cur_tvid_prodid in to_update:
try:
sickgear.show_queue_scheduler.action.updateShow(cur_show_obj, True, True)
sickgear.show_queue_scheduler.action.update_show(cur_show_obj, True, True)
update.append(cur_show_obj.name)
except exceptions_helper.CantUpdateException as e:
errors.append('Unable to update show %s: %s' % (cur_show_obj.unique_name, ex(e)))
elif cur_tvid_prodid in to_refresh:
try:
sickgear.show_queue_scheduler.action.refreshShow(cur_show_obj)
sickgear.show_queue_scheduler.action.refresh_show(cur_show_obj)
refresh.append(cur_show_obj.name)
except exceptions_helper.CantRefreshException as e:
errors.append('Unable to refresh show %s: %s' % (cur_show_obj.unique_name, ex(e)))
if cur_tvid_prodid in to_rename:
sickgear.show_queue_scheduler.action.renameShowEpisodes(cur_show_obj)
sickgear.show_queue_scheduler.action.rename_show_episodes(cur_show_obj)
rename.append(cur_show_obj.name)
if sickgear.USE_SUBTITLES and cur_tvid_prodid in to_subtitle:
@ -7067,7 +7065,7 @@ class Manage(MainHandler):
continue
try:
sickgear.show_queue_scheduler.action.switch_show(show_obj=show_obj, new_tvid=new_tvid,
new_prodid=new_prodid, force_id=force_id)
new_prodid=new_prodid, force_id=force_id)
except (BaseException, Exception) as e:
logger.log('Could not add show %s to switch queue: %s' % (show_obj.tvid_prodid, ex(e)), logger.WARNING)
errors.append('Could not add show %s to switch queue: %s' % (show_obj.tvid_prodid, ex(e)))
@ -7172,7 +7170,7 @@ class ShowTasks(Manage):
t.people_queue = sickgear.people_queue_scheduler.action.queue_data()
t.next_run = sickgear.show_update_scheduler.lastRun.replace(
hour=sickgear.show_update_scheduler.start_time.hour)
t.show_update_running = sickgear.show_queue_scheduler.action.isShowUpdateRunning() \
t.show_update_running = sickgear.show_queue_scheduler.action.is_show_update_running() \
or sickgear.show_update_scheduler.action.amActive
my_db = db.DBConnection(row_type='dict')
@ -7613,8 +7611,7 @@ class History(MainHandler):
rd = sickgear.ROOT_DIRS.split('|')[1:] \
+ [x.split('=')[0] for x in sickgear.EMBY_PARENT_MAPS.split(',') if any(x)]
rootpaths = sorted(
['%s%s' % (ek.ek(os.path.splitdrive, x)[1], os.path.sep) for x in rd], key=len, reverse=True)
rootpaths = sorted(['%s%s' % (os.path.splitdrive(x)[1], os.path.sep) for x in rd], key=len, reverse=True)
rootdirs = sorted([x for x in rd], key=len, reverse=True)
headers = {'Content-type': 'application/json'}
states = {}
@ -7667,8 +7664,8 @@ class History(MainHandler):
continue
for index, p in enumerate(rootpaths):
if p in path_file:
path_file = ek.ek(os.path.join, rootdirs[index],
re.sub('.*?%s' % re.escape(p), '', path_file))
path_file = os.path.join(
rootdirs[index], re.sub('.*?%s' % re.escape(p), '', path_file))
root_dir_found = True
break
if not root_dir_found:
@ -7701,11 +7698,11 @@ class History(MainHandler):
if states:
# Prune user removed items that are no longer being returned by API
media_paths = map_list(lambda arg: ek.ek(os.path.basename, arg[1]['path_file']), iteritems(states))
media_paths = map_list(lambda arg: os.path.basename(arg[1]['path_file']), iteritems(states))
sql = 'FROM tv_episodes_watched WHERE hide=1 AND label LIKE "%%{Emby}"'
my_db = db.DBConnection(row_type='dict')
files = my_db.select('SELECT location %s' % sql)
for i in filter_iter(lambda f: ek.ek(os.path.basename, f['location']) not in media_paths, files):
for i in filter_iter(lambda f: os.path.basename(f['location']) not in media_paths, files):
loc = i.get('location')
if loc:
my_db.select('DELETE %s AND location="%s"' % (sql, loc))
@ -7770,11 +7767,11 @@ class History(MainHandler):
if states:
# Prune user removed items that are no longer being returned by API
media_paths = map_list(lambda arg: ek.ek(os.path.basename, arg[1]['path_file']), iteritems(states))
media_paths = map_list(lambda arg: os.path.basename(arg[1]['path_file']), iteritems(states))
sql = 'FROM tv_episodes_watched WHERE hide=1 AND label LIKE "%%{Plex}"'
my_db = db.DBConnection(row_type='dict')
files = my_db.select('SELECT location %s' % sql)
for i in filter_iter(lambda f: ek.ek(os.path.basename, f['location']) not in media_paths, files):
for i in filter_iter(lambda f: os.path.basename(f['location']) not in media_paths, files):
loc = i.get('location')
if loc:
my_db.select('DELETE %s AND location="%s"' % (sql, loc))
@ -7812,7 +7809,7 @@ class History(MainHandler):
refresh = []
for cur_result in sql_result:
if files and cur_result['location'] not in attempted and 0 < helpers.get_size(cur_result['location']) \
and ek.ek(os.path.isfile, cur_result['location']):
and os.path.isfile(cur_result['location']):
# locations repeat with watch events but attempt to delete once
attempted += [cur_result['location']]
@ -7855,7 +7852,7 @@ class History(MainHandler):
for tvid_prodid_dict in refresh:
try:
sickgear.show_queue_scheduler.action.refreshShow(
sickgear.show_queue_scheduler.action.refresh_show(
helpers.find_show_by_id(tvid_prodid_dict))
except (BaseException, Exception):
pass
@ -7899,7 +7896,7 @@ class Config(MainHandler):
t.submenu = self.config_menu()
try:
with open(ek.ek(os.path.join, sickgear.PROG_DIR, 'CHANGES.md')) as fh:
with open(os.path.join(sickgear.PROG_DIR, 'CHANGES.md')) as fh:
t.version = re.findall(r'###[^0-9]+([0-9]+\.[0-9]+\.[0-9x]+)', fh.readline())[0]
except (BaseException, Exception):
t.version = ''
@ -7909,18 +7906,18 @@ class Config(MainHandler):
t.tz_version = None
try:
if None is not current_file:
current_file = ek.ek(os.path.basename, current_file)
zonefile = real_path(ek.ek(os.path.join, sickgear.ZONEINFO_DIR, current_file))
if not ek.ek(os.path.isfile, zonefile):
current_file = os.path.basename(current_file)
zonefile = real_path(os.path.join(sickgear.ZONEINFO_DIR, current_file))
if not os.path.isfile(zonefile):
t.tz_fallback = True
zonefile = ek.ek(os.path.join, ek.ek(os.path.dirname, zoneinfo.__file__), current_file)
if ek.ek(os.path.isfile, zonefile):
zonefile = os.path.join(os.path.dirname(zoneinfo.__file__), current_file)
if os.path.isfile(zonefile):
t.tz_version = zoneinfo.ZoneInfoFile(zoneinfo.getzoneinfofile_stream()).metadata['tzversion']
except (BaseException, Exception):
pass
t.backup_db_path = sickgear.BACKUP_DB_MAX_COUNT and \
(sickgear.BACKUP_DB_PATH or ek.ek(os.path.join, sickgear.DATA_DIR, 'backup')) or 'Disabled'
(sickgear.BACKUP_DB_PATH or os.path.join(sickgear.DATA_DIR, 'backup')) or 'Disabled'
return t.respond()
@ -8058,7 +8055,7 @@ class ConfigGeneral(Config):
best_qualities = ([], best_qualities.split(','))[any(best_qualities)]
sickgear.QUALITY_DEFAULT = int(Quality.combineQualities(map_list(int, any_qualities),
map_list(int, best_qualities)))
map_list(int, best_qualities)))
sickgear.WANTED_BEGIN_DEFAULT = config.minimax(default_wanted_begin, 0, -1, 10)
sickgear.WANTED_LATEST_DEFAULT = config.minimax(default_wanted_latest, 0, -1, 10)
sickgear.SHOW_TAG_DEFAULT = default_tag
@ -8114,7 +8111,7 @@ class ConfigGeneral(Config):
result.update(dict(result='Success: apikey added', added=api_key))
sickgear.USE_API = 1
sickgear.save_config()
ui.notifications.message('Configuration Saved', ek.ek(os.path.join, sickgear.CONFIG_FILE))
ui.notifications.message('Configuration Saved', os.path.join(sickgear.CONFIG_FILE))
return json_dumps(result)
@ -8132,7 +8129,7 @@ class ConfigGeneral(Config):
logger.log('Revoked [%s] apikey [%s]' % (app_name, api_key), logger.DEBUG)
result.update(dict(result='Success: apikey removed', removed=True))
sickgear.save_config()
ui.notifications.message('Configuration Saved', ek.ek(os.path.join, sickgear.CONFIG_FILE))
ui.notifications.message('Configuration Saved', os.path.join(sickgear.CONFIG_FILE))
return json_dumps(result)
@ -8287,7 +8284,7 @@ class ConfigGeneral(Config):
ui.notifications.error('Error(s) Saving Configuration',
'<br>\n'.join(results))
else:
ui.notifications.message('Configuration Saved', ek.ek(os.path.join, sickgear.CONFIG_FILE))
ui.notifications.message('Configuration Saved', os.path.join(sickgear.CONFIG_FILE))
if restart:
self.clear_cookie('sickgear-session-%s' % helpers.md5_for_text(sickgear.WEB_PORT))
@ -8458,7 +8455,7 @@ class ConfigSearch(Config):
ui.notifications.error('Error(s) Saving Configuration',
'<br>\n'.join(results))
else:
ui.notifications.message('Configuration Saved', ek.ek(os.path.join, sickgear.CONFIG_FILE))
ui.notifications.message('Configuration Saved', os.path.join(sickgear.CONFIG_FILE))
self.redirect('/config/search/')
@ -8585,7 +8582,7 @@ class ConfigMediaProcess(Config):
ui.notifications.error('Error(s) Saving Configuration',
'<br>\n'.join(results))
else:
ui.notifications.message('Configuration Saved', ek.ek(os.path.join, sickgear.CONFIG_FILE))
ui.notifications.message('Configuration Saved', os.path.join(sickgear.CONFIG_FILE))
self.redirect('/config/media-process/')
@ -8600,7 +8597,7 @@ class ConfigMediaProcess(Config):
result = naming.test_name(pattern, multi, abd, sports, anime, anime_type)
result = ek.ek(os.path.join, result['dir'], result['name'])
result = os.path.join(result['dir'], result['name'])
return result
@ -8647,8 +8644,8 @@ class ConfigMediaProcess(Config):
try:
if 'win32' == sys.platform:
rarfile.UNRAR_TOOL = ek.ek(os.path.join, sickgear.PROG_DIR, 'lib', 'rarfile', 'UnRAR.exe')
rar_path = ek.ek(os.path.join, sickgear.PROG_DIR, 'lib', 'rarfile', 'test.rar')
rarfile.UNRAR_TOOL = os.path.join(sickgear.PROG_DIR, 'lib', 'rarfile', 'UnRAR.exe')
rar_path = os.path.join(sickgear.PROG_DIR, 'lib', 'rarfile', 'test.rar')
if 'This is only a test.' == decode_str(rarfile.RarFile(rar_path).read(r'test/test.txt')):
return 'supported'
msg = 'Could not read test file content'
@ -8998,7 +8995,7 @@ class ConfigProviders(Config):
logger.log(x, logger.ERROR)
ui.notifications.error('Error(s) Saving Configuration', '<br>\n'.join(results))
else:
ui.notifications.message('Configuration Saved', ek.ek(os.path.join, sickgear.CONFIG_FILE))
ui.notifications.message('Configuration Saved', os.path.join(sickgear.CONFIG_FILE))
if reload_page:
self.write('reload')
@ -9266,7 +9263,7 @@ class ConfigNotifications(Config):
ui.notifications.error('Error(s) Saving Configuration',
'<br>\n'.join(results))
else:
ui.notifications.message('Configuration Saved', ek.ek(os.path.join, sickgear.CONFIG_FILE))
ui.notifications.message('Configuration Saved', os.path.join(sickgear.CONFIG_FILE))
self.redirect('/config/notifications/')
@ -9321,7 +9318,7 @@ class ConfigSubtitles(Config):
ui.notifications.error('Error(s) Saving Configuration',
'<br>\n'.join(results))
else:
ui.notifications.message('Configuration Saved', ek.ek(os.path.join, sickgear.CONFIG_FILE))
ui.notifications.message('Configuration Saved', os.path.join(sickgear.CONFIG_FILE))
self.redirect('/config/subtitles/')
@ -9354,7 +9351,7 @@ class ConfigAnime(Config):
ui.notifications.error('Error(s) Saving Configuration',
'<br>\n'.join(results))
else:
ui.notifications.message('Configuration Saved', ek.ek(os.path.join, sickgear.CONFIG_FILE))
ui.notifications.message('Configuration Saved', os.path.join(sickgear.CONFIG_FILE))
self.redirect('/config/anime/')
@ -9410,7 +9407,7 @@ class EventLogs(MainHandler):
min_level = int(min_level)
regex = re.compile(r'^\d{4}-\d{2}-\d{2}\s*\d{2}:\d{2}:\d{2}\s*([A-Z]+)\s*([^\s]+)\s+:{2}\s*(.*\r?\n)$')
regex = re.compile(r'^\d{4}-\d{2}-\d{2}\s*\d{2}:\d{2}:\d{2}\s*([A-Z]+)\s*(\S+)\s+:{2}\s*(.*\r?\n)$')
final_data = []
normal_data = []
@ -9578,9 +9575,9 @@ class CachedImages(MainHandler):
def should_try_image(filename, source, days=1, minutes=0):
result = True
try:
dummy_file = '%s.%s.dummy' % (ek.ek(os.path.splitext, filename)[0], source)
if ek.ek(os.path.isfile, dummy_file):
if ek.ek(os.stat, dummy_file).st_mtime \
dummy_file = '%s.%s.dummy' % (os.path.splitext(filename)[0], source)
if os.path.isfile(dummy_file):
if os.stat(dummy_file).st_mtime \
< (int(timestamp_near((datetime.datetime.now()
- datetime.timedelta(days=days, minutes=minutes))))):
CachedImages.delete_dummy_image(dummy_file)
@ -9592,7 +9589,7 @@ class CachedImages(MainHandler):
@staticmethod
def create_dummy_image(filename, source):
dummy_file = '%s.%s.dummy' % (ek.ek(os.path.splitext, filename)[0], source)
dummy_file = '%s.%s.dummy' % (os.path.splitext(filename)[0], source)
CachedImages.delete_dummy_image(dummy_file)
try:
with open(dummy_file, 'w'):
@ -9603,28 +9600,28 @@ class CachedImages(MainHandler):
@staticmethod
def delete_dummy_image(dummy_file):
try:
if ek.ek(os.path.isfile, dummy_file):
ek.ek(os.remove, dummy_file)
if os.path.isfile(dummy_file):
os.remove(dummy_file)
except (BaseException, Exception):
pass
@staticmethod
def delete_all_dummy_images(filename):
for f in ['tmdb', 'tvdb', 'tvmaze']:
CachedImages.delete_dummy_image('%s.%s.dummy' % (ek.ek(os.path.splitext, filename)[0], f))
CachedImages.delete_dummy_image('%s.%s.dummy' % (os.path.splitext(filename)[0], f))
def index(self, path='', source=None, filename=None, tmdbid=None, tvdbid=None, trans=True):
path = path.strip('/')
file_name = ''
if None is not source:
file_name = ek.ek(os.path.basename, source)
file_name = os.path.basename(source)
elif filename not in [None, 0, '0']:
file_name = filename
image_file = ek.ek(os.path.join, sickgear.CACHE_DIR, 'images', path, file_name)
image_file = ek.ek(os.path.abspath, image_file.replace('\\', '/'))
if not ek.ek(os.path.isfile, image_file) and has_image_ext(file_name):
basepath = ek.ek(os.path.dirname, image_file)
image_file = os.path.join(sickgear.CACHE_DIR, 'images', path, file_name)
image_file = os.path.abspath(image_file.replace('\\', '/'))
if not os.path.isfile(image_file) and has_image_ext(file_name):
basepath = os.path.dirname(image_file)
helpers.make_path(basepath)
poster_url = ''
tmdb_image = False
@ -9641,13 +9638,15 @@ class CachedImages(MainHandler):
poster_url = show_obj.poster
except (BaseException, Exception):
poster_url = ''
if poster_url and not sg_helpers.download_file(poster_url, image_file, nocache=True) and poster_url.find('trakt.us'):
if poster_url \
and not sg_helpers.download_file(poster_url, image_file, nocache=True) \
and poster_url.find('trakt.us'):
sg_helpers.download_file(poster_url.replace('trakt.us', 'trakt.tv'), image_file, nocache=True)
if tmdb_image and not ek.ek(os.path.isfile, image_file):
if tmdb_image and not os.path.isfile(image_file):
self.create_dummy_image(image_file, 'tmdb')
if None is source and tvdbid not in [None, 'None', 0, '0'] \
and not ek.ek(os.path.isfile, image_file) \
and not os.path.isfile(image_file) \
and self.should_try_image(image_file, 'tvdb'):
try:
tvinfo_config = sickgear.TVInfoAPI(TVINFO_TVDB).api_params.copy()
@ -9660,15 +9659,15 @@ class CachedImages(MainHandler):
poster_url = ''
if poster_url:
sg_helpers.download_file(poster_url, image_file, nocache=True)
if not ek.ek(os.path.isfile, image_file):
if not os.path.isfile(image_file):
self.create_dummy_image(image_file, 'tvdb')
if ek.ek(os.path.isfile, image_file):
if os.path.isfile(image_file):
self.delete_all_dummy_images(image_file)
if not ek.ek(os.path.isfile, image_file):
image_file = ek.ek(os.path.join, sickgear.PROG_DIR, 'gui', 'slick',
'images', ('image-light.png', 'trans.png')[bool(int(trans))])
if not os.path.isfile(image_file):
image_file = os.path.join(sickgear.PROG_DIR, 'gui', 'slick', 'images',
('image-light.png', 'trans.png')[bool(int(trans))])
else:
helpers.set_file_timestamp(image_file, min_age=3, new_time=None)
@ -9683,8 +9682,8 @@ class CachedImages(MainHandler):
:param filename: image file name with path
:param days: max age to trigger reload of image
"""
if not ek.ek(os.path.isfile, filename) or \
ek.ek(os.stat, filename).st_mtime < \
if not os.path.isfile(filename) or \
os.stat(filename).st_mtime < \
(int(timestamp_near((datetime.datetime.now() - datetime.timedelta(days=days))))):
return True
return False
@ -9735,9 +9734,9 @@ class CachedImages(MainHandler):
sg_helpers.download_file(char_obj.thumb_url, image_thumb, nocache=True)
primary, fallback = ((image_normal, image_thumb), (image_thumb, image_normal))[thumb]
if ek.ek(os.path.isfile, primary):
if os.path.isfile(primary):
image_file = primary
elif ek.ek(os.path.isfile, fallback):
elif os.path.isfile(fallback):
image_file = fallback
elif person_id:
@ -9773,9 +9772,9 @@ class CachedImages(MainHandler):
sg_helpers.download_file(person_obj.thumb_url, image_thumb, nocache=True)
primary, fallback = ((image_normal, image_thumb), (image_thumb, image_normal))[thumb]
if ek.ek(os.path.isfile, primary):
if os.path.isfile(primary):
image_file = primary
elif ek.ek(os.path.isfile, fallback):
elif os.path.isfile(fallback):
image_file = fallback
return self.image_data(image_file, cast_default=True)
@ -9790,7 +9789,7 @@ class CachedImages(MainHandler):
:return: binary image data or None
"""
if cast_default and None is image_file:
image_file = ek.ek(os.path.join, sickgear.PROG_DIR, 'gui', 'slick', 'images', 'poster-person.jpg')
image_file = os.path.join(sickgear.PROG_DIR, 'gui', 'slick', 'images', 'poster-person.jpg')
mime_type, encoding = MimeTypes().guess_type(image_file)
self.set_header('Content-Type', mime_type)

8
tests/network_timezone_tests.py
View file

@ -10,8 +10,6 @@ import datetime
from lib.dateutil import tz
import sickgear
from sickgear import network_timezones, helpers
# noinspection PyPep8Naming
import encodingKludge as ek
class NetworkTimezoneTests(test.SickbeardTestDBCase):
@ -33,12 +31,12 @@ class NetworkTimezoneTests(test.SickbeardTestDBCase):
@classmethod
def remove_zoneinfo(cls):
# delete all existing zoneinfo files
for (path, dirs, files) in ek.ek(os.walk, helpers.real_path(sickgear.ZONEINFO_DIR)):
for (path, dirs, files) in os.walk(helpers.real_path(sickgear.ZONEINFO_DIR)):
for filename in files:
if filename.endswith('.tar.gz'):
file_w_path = ek.ek(os.path.join, path, filename)
file_w_path = os.path.join(path, filename)
try:
ek.ek(os.remove, file_w_path)
os.remove(file_w_path)
except (BaseException, Exception):
pass

2
tests/scene_helpers_tests.py
View file

@ -26,7 +26,7 @@ class SceneTests(test.SickbeardTestDBCase):
s.tvid = TVINFO_TVDB
s.name = name
result = show_name_helpers.allPossibleShowNames(s, season=season)
result = show_name_helpers.all_possible_show_names(s, season=season)
self.assertTrue(len(set(expected).intersection(set(result))) == len(expected))
def _test_pass_wordlist_checks(self, name, expected):