monkee.ch/SickGear
1
0
Fork 0
mirror of https://github.com/SickGear/SickGear.git synced 2024-11-27 15:13:38 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2
SickGear/sickgear/common.py
JackDandy fb6ef08f01 Change remove redundant py2 import futures.
2023-04-27 12:53:49 +01:00

751 lines
28 KiB
Python
Raw Blame History

#
# This file is part of SickGear.
#
# SickGear is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# SickGear is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with SickGear. If not, see <http://www.gnu.org/licenses/>.
from functools import reduce
import operator
import os.path
import platform
import re
import traceback
import uuid
import sickgear
from six import integer_types, iterkeys, string_types
# noinspection PyUnresolvedReferences
# noinspection PyUnreachableCode
if False:
from typing import List, Tuple
try:
INSTANCE_ID = str(uuid.uuid1())
except ValueError:
INSTANCE_ID = str(uuid.uuid4())
USER_AGENT = ('SickGear/(%s; %s; %s)' % (platform.system(), platform.release(), INSTANCE_ID))
mediaExtensions = ['avi', 'mkv', 'mpg', 'mpeg', 'wmv', 'ogm', 'mp4', 'iso', 'img', 'divx', 'm2ts', 'm4v', 'ts', 'flv',
'f4v', 'mov', 'rmvb', 'vob', 'dvr-ms', 'wtv', 'ogv', '3gp', 'webm']
subtitleExtensions = ['srt', 'sub', 'ass', 'idx', 'ssa']
cpu_presets = {'DISABLED': 0, 'LOW': 0.01, 'NORMAL': 0.05, 'HIGH': 0.1}
# Other constants
MULTI_EP_RESULT = -1
SEASON_RESULT = -2
# Episode statuses
UNKNOWN = -1 # should never happen
UNAIRED = 1 # episodes that haven't aired yet
SNATCHED = 2 # qualified with quality
WANTED = 3 # episodes we don't have but want to get
DOWNLOADED = 4 # qualified with quality
SKIPPED = 5 # episodes we don't want
ARCHIVED = 6 # episodes that you don't have locally (counts toward download completion stats)
IGNORED = 7 # episodes that you don't want included in your download stats
SNATCHED_PROPER = 9 # qualified with quality
SUBTITLED = 10 # qualified with quality
FAILED = 11 # episode downloaded or snatched we don't want
SNATCHED_BEST = 12 # episode redownloaded using best quality
SNATCHED_ANY = [SNATCHED, SNATCHED_PROPER, SNATCHED_BEST]
NAMING_REPEAT = 1
NAMING_EXTEND = 2
NAMING_DUPLICATE = 4
NAMING_LIMITED_EXTEND = 8
NAMING_SEPARATED_REPEAT = 16
NAMING_LIMITED_EXTEND_E_PREFIXED = 32
multiEpStrings = {NAMING_REPEAT: 'Repeat',
NAMING_SEPARATED_REPEAT: 'Repeat (Separated)',
NAMING_DUPLICATE: 'Duplicate',
NAMING_EXTEND: 'Extend',
NAMING_LIMITED_EXTEND: 'Extend (Limited)',
NAMING_LIMITED_EXTEND_E_PREFIXED: 'Extend (Limited, E-prefixed)'}
class Quality(object):
NONE = 0 # 0
SDTV = 1 # 1
SDDVD = 1 << 1 # 2
HDTV = 1 << 2 # 4
RAWHDTV = 1 << 3 # 8 -- 720p/1080i mpeg2 (trollhd releases)
FULLHDTV = 1 << 4 # 16 -- 1080p HDTV (QCF releases)
HDWEBDL = 1 << 5 # 32
FULLHDWEBDL = 1 << 6 # 64 -- 1080p web-dl
HDBLURAY = 1 << 7 # 128
FULLHDBLURAY = 1 << 8 # 256
# UHD4KTV = 1 << 9 # reserved for the future
UHD4KWEB = 1 << 10
UHD4KBLURAY = 1 << 11
# put these bits at the other end of the spectrum, far enough out that they shouldn't interfere
UNKNOWN = 1 << 15 # 32768
qualityStrings = {NONE: 'N/A',
UNKNOWN: 'Unknown',
SDTV: 'SD TV',
SDDVD: 'SD DVD',
HDTV: 'HD TV',
RAWHDTV: 'RawHD TV',
FULLHDTV: '1080p HD TV',
HDWEBDL: '720p WEB-DL',
FULLHDWEBDL: '1080p WEB-DL',
HDBLURAY: '720p BluRay',
FULLHDBLURAY: '1080p BluRay',
UHD4KWEB: '2160p UHD 4K WEB',
UHD4KBLURAY: '2160p UHD BluRay'}
statusPrefixes = {DOWNLOADED: 'Downloaded',
SNATCHED: 'Snatched',
SNATCHED_PROPER: 'Snatched (Proper)',
FAILED: 'Failed',
SNATCHED_BEST: 'Snatched (Best)'}
real_check = r'\breal\b\W?' \
r'(?=proper|repack|e?ac3|aac|dts|read\Wnfo|(ws\W)?[ph]dtv|(ws\W)?dsr|web|dvd|blu|\d{2,3}0([pi]))' \
r'(?!.*\d+([ex])\d+)'
proper_levels = [(re.compile(r'\brepack\b(?!.*\d+([ex])\d+)', flags=re.I), True),
(re.compile(r'\bproper\b(?!.*\d+([ex])\d+)', flags=re.I), False),
(re.compile(real_check, flags=re.I), False)]
@staticmethod
def get_proper_level(extra_no_name, version, is_anime=False, check_is_repack=False):
"""
:param extra_no_name: extra info
:type extra_no_name: AnyStr
:param version: version
:type version: int
:param is_anime: is anime
:type is_anime: bool
:param check_is_repack: check for repack
:type check_is_repack: bool
:return: proper level or tuple of is_repack, proper level
:rtype: int or Tuple[bool, int]
"""
level = 0
is_repack = False
if is_anime:
if isinstance(version, integer_types):
level = (0, version - 1)[1 < version]
elif isinstance(extra_no_name, string_types):
for p, r_check in Quality.proper_levels:
a = len(p.findall(extra_no_name))
level += a
if 0 < a and r_check:
is_repack = True
if check_is_repack:
return is_repack, level
return level
@staticmethod
def get_quality_css(quality):
"""
:param quality: quality
:type quality: int
:return:
:rtype: AnyStr
"""
return (Quality.qualityStrings[quality].replace('2160p', 'UHD2160p').replace('1080p', 'HD1080p')
.replace('720p', 'HD720p').replace('HD TV', 'HD720p').replace('RawHD TV', 'RawHD'))
@staticmethod
def get_quality_ui(quality):
"""
:param quality: quality
:type quality: int
:return:
:rtype: AnyStr
"""
return Quality.qualityStrings[quality].replace('SD DVD', 'SD DVD/BR/BD')
@staticmethod
def _get_status_strings(status):
"""
:param status: status
:type status: int
:return:
:rtype: AnyStr
"""
to_return = {}
for _x in Quality.qualityStrings:
to_return[Quality.composite_status(status, _x)] = '%s (%s)' % (
Quality.statusPrefixes[status], Quality.qualityStrings[_x])
return to_return
@staticmethod
def combine_qualities(any_qualities, best_qualities):
# type: (List[int], List[int]) -> int
"""
:param any_qualities: any qualities
:param best_qualities: best qualities
"""
any_quality = 0
best_quality = 0
if any_qualities:
any_quality = reduce(operator.or_, any_qualities)
if best_qualities:
best_quality = reduce(operator.or_, best_qualities)
return any_quality | (best_quality << 16)
@staticmethod
def split_quality(quality):
# type: (int) -> Tuple[List[int], List[int]]
"""
:param quality: show quality
"""
any_qualities = []
best_qualities = []
for cur_quality in Quality.qualityStrings:
if cur_quality & quality:
any_qualities.append(cur_quality)
if cur_quality << 16 & quality:
best_qualities.append(cur_quality)
return sorted(any_qualities), sorted(best_qualities)
@staticmethod
def name_quality(name, anime=False):
"""
Return The quality from an episode File renamed by SickGear
If no quality is achieved it will try scene_quality regex
:param name: name
:type name: AnyStr
:param anime: is anmie
:type anime: bool
:return:
:rtype: int
"""
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):
if Quality.UNKNOWN == _x:
continue
if Quality.NONE == _x: # Last chance
return Quality.scene_quality(name, anime)
regex = r'\W' + Quality.qualityStrings[_x].replace(' ', r'\W') + r'\W'
regex_match = re.search(regex, name, re.I)
if regex_match:
return _x
@staticmethod
def scene_quality(name, anime=False):
"""
Return The quality from the scene episode File
:param name: name
:type name: AnyStr
:param anime: is anmie
:type anime: bool
:return:
:rtype: int
"""
from sickgear import logger
name = os.path.basename(name)
name_has = (lambda quality_list, func=all: func([re.search(q, name, re.I) for q in quality_list]))
if anime:
sd_options = name_has(['360p', '480p', '848x480', 'XviD'], any)
sd_options |= name_has([r'^SD\.|\.SD$'], any) # specific to a provider
dvd_options = name_has(['dvd', 'dvdrip'], any)
blue_ray_options = name_has(['bluray', 'blu-ray', 'BD'], any)
if sd_options and not dvd_options and not blue_ray_options:
return Quality.SDTV
if dvd_options:
return Quality.SDDVD
hd_options = name_has(['720p', r'\[720\]', '1280x720', '960x720'], any)
hd_options |= name_has([r'^HD\s*720\.|\.HD\s*720$'], any) # specific to a provider
full_hd = name_has(['1080p', r'\[1080\]', '1920x1080'], any)
full_hd |= name_has([r'^HD(\s*1080)?\.|\.HD(\s*1080)?$'], any) # specific to a provider
if not blue_ray_options:
if hd_options and not full_hd:
return Quality.HDTV
if not hd_options and full_hd:
return Quality.FULLHDTV
# this cond already checked above, commented out for now
# if hd_options and not full_hd:
# return Quality.HDWEBDL
else:
if hd_options and not full_hd:
return Quality.HDBLURAY
if not hd_options and full_hd:
return Quality.FULLHDBLURAY
if sickgear.ANIME_TREAT_AS_HDTV:
logger.debug(f'Treating file: {name} with "unknown" quality as HDTV per user settings')
return Quality.HDTV
return Quality.UNKNOWN
fmt = '((h.?|x)26[45]|vp9|av1|hevc)'
webfmt = 'web.?(dl|rip|.%s)' % fmt
rips = 'b[r|d]rip'
hd_rips = 'blu.?ray|hddvd|%s' % rips
if not name_has(['(720|1080|2160)[pi]|720hd']):
if name_has(['(dvd.?rip|%s)(.ws)?(.(xvid|divx|%s))?' % (rips, fmt)]):
return Quality.SDDVD
if (not name_has(['hr.ws.pdtv.(h.?|x)264'])
and (name_has([r'(hdtv|pdtv|dsr|tvrip)([-]|.((aac|ac3|dd).?\d\.?\d.)*(xvid|%s))' % fmt])
or name_has(['(xvid|divx|480p|hevc|x265)']))) \
or name_has([webfmt, 'xvid|%s' % fmt]):
return Quality.SDTV
if not name_has(['(1080|2160)[pi]']):
if name_has(['720p']):
if name_has([hd_rips, fmt]):
return Quality.HDBLURAY
if name_has([webfmt]) or name_has(['itunes', fmt]):
return Quality.HDWEBDL
if name_has([fmt]):
return Quality.HDTV
# p2p
if name_has(['720hd']) \
or name_has(['hr.ws.pdtv.%s' % fmt]):
return Quality.HDTV
if name_has(['720p|1080i', 'hdtv', 'mpeg-?2']) or name_has(['1080[pi].hdtv', 'h.?264']):
return Quality.RAWHDTV
if name_has(['1080[pi]', 'remux']) and not name_has(['hdtv']):
return Quality.FULLHDBLURAY
if name_has(['1080p']):
if name_has([hd_rips, fmt]) or name_has([hd_rips, 'avc|vc[ -.]?1']):
return Quality.FULLHDBLURAY
if name_has([webfmt]) or name_has(['itunes', fmt]):
return Quality.FULLHDWEBDL
if name_has([fmt]):
return Quality.FULLHDTV
if name_has(['2160p']):
if name_has(['bluray']):
return Quality.UHD4KBLURAY
if name_has([webfmt]):
return Quality.UHD4KWEB
return Quality.UNKNOWN
@staticmethod
def file_quality(filename):
"""
:param filename: filename
:type filename: AnyStr
:return:
:rtype: int
"""
from exceptions_helper import ex
from sickgear import logger
if os.path.isfile(filename):
from hachoir.parser import createParser
from hachoir.metadata import extractMetadata
from hachoir.stream import InputStreamError
parser = height = None
msg = 'Hachoir can\'t parse file "%s" content quality because it found error: %s'
try:
parser = createParser(filename)
except InputStreamError as e:
logger.warning(msg % (filename, ex(e)))
except (BaseException, Exception) as e:
logger.error(msg % (filename, ex(e)))
logger.error(traceback.format_exc())
if parser:
extract = None
try:
args = ({}, {'scan_index': False})['.avi' == filename[-4::].lower()]
parser.parse_exif = False
parser.parse_photoshop_content = False
parser.parse_comments = False
extract = extractMetadata(parser, **args)
except (BaseException, Exception) as e:
logger.warning(msg % (filename, ex(e)))
if extract:
try:
height = extract.get('height')
except (AttributeError, ValueError):
try:
for metadata in extract.iterGroups():
if re.search('(?i)video', metadata.header):
height = metadata.get('height')
break
except (AttributeError, ValueError):
pass
# noinspection PyProtectedMember
parser.stream._input.close()
tolerance = (lambda value, percent: int(round(value - (value * percent / 100.0))))
if None is not height and height >= tolerance(352, 5):
if height <= tolerance(720, 2):
return Quality.SDTV
return (Quality.HDTV, Quality.FULLHDTV)[height >= tolerance(1080, 1)]
return Quality.UNKNOWN
@staticmethod
def assume_quality(name):
"""
:param name: name
:type name: AnyStr
:return:
:rtype: int
"""
if name.lower().endswith(('.avi', '.mp4', '.mkv')):
return Quality.SDTV
elif name.lower().endswith('.ts'):
return Quality.RAWHDTV
return Quality.UNKNOWN
@staticmethod
def composite_status(status, quality):
"""
:param status: status
:type status: int
:param quality: quality
:type quality: int
:return:
:rtype: int or long
"""
return status + 100 * quality
@staticmethod
def quality_downloaded(status):
# type: (int) -> int
"""
:param status: status
:type status: int or long
:return:
:rtype: int or long
"""
return (status - DOWNLOADED) // 100
@staticmethod
def split_composite_status(status):
# type: (int) -> Tuple[int, int]
"""Returns a tuple containing (status, quality)
:param status: status
"""
if UNKNOWN == status:
return UNKNOWN, Quality.UNKNOWN
for q in sorted(iterkeys(Quality.qualityStrings), reverse=True):
if status > q * 100:
return status - q * 100, q
return status, Quality.NONE
@staticmethod
def status_from_name(name, assume=True, anime=False):
"""
:param name: name
:type name: AnyStr
:param assume:
:type assume: bool
:param anime: is anime
:type anime: bool
:return:
:rtype: int or long
"""
quality = Quality.name_quality(name, anime)
if assume and Quality.UNKNOWN == quality:
quality = Quality.assume_quality(name)
return Quality.composite_status(DOWNLOADED, quality)
@staticmethod
def status_from_name_or_file(file_path, assume=True, anime=False):
"""
:param file_path: file path
:type file_path: AnyStr
:param assume:
:type assume: bool
:param anime: is anime
:type anime: bool
:return:
:rtype: int or long
"""
quality = Quality.name_quality(file_path, anime)
if Quality.UNKNOWN == quality:
quality = Quality.file_quality(file_path)
if assume and Quality.UNKNOWN == quality:
quality = Quality.assume_quality(file_path)
return Quality.composite_status(DOWNLOADED, quality)
SNATCHED = None
SNATCHED_PROPER = None
SNATCHED_BEST = None
SNATCHED_ANY = None
DOWNLOADED = None
ARCHIVED = None
FAILED = None
class WantedQualities(dict):
wantedlist = 1
bothlists = 2
upgradelist = 3
def __init__(self, **kwargs):
super(WantedQualities, self).__init__(**kwargs)
def _generate_wantedlist(self, qualities):
initial_qualities, upgrade_qualities = Quality.split_quality(qualities)
max_initial_quality = max(initial_qualities or [Quality.NONE])
min_upgrade_quality = min(upgrade_qualities or [1 << 16])
self[qualities] = {0: {self.bothlists: False, self.wantedlist: initial_qualities, self.upgradelist: False}}
for q in Quality.qualityStrings:
if 0 < q:
self[qualities][q] = {self.wantedlist: [i for i in upgrade_qualities if q < i], self.upgradelist: False}
if q not in upgrade_qualities and q in initial_qualities:
# quality is only in initial_qualities
w = {self.bothlists: False}
elif q in upgrade_qualities and q in initial_qualities:
# quality is in initial_qualities and upgrade_qualities
w = {self.bothlists: True, self.upgradelist: True}
elif q in upgrade_qualities:
# quality is only in upgrade_qualities
w = {self.bothlists: False, self.upgradelist: True}
else:
# quality is not in any selected quality for the show (known as "unwanted")
w = {self.bothlists: max_initial_quality >= q >= min_upgrade_quality}
self[qualities][q].update(w)
def __getitem__(self, k):
if k not in self:
self._generate_wantedlist(k)
return super(WantedQualities, self).__getitem__(k)
def get(self, k, *args, **kwargs):
if k not in self:
self._generate_wantedlist(k)
return super(WantedQualities, self).get(k, *args, **kwargs)
def get_wantedlist(self, qualities, upgradeonce, quality, status, unaired=False, manual=False):
if not manual:
if status in [ARCHIVED, IGNORED, SKIPPED] + ([UNAIRED], [])[unaired]:
return []
if upgradeonce:
if status == SNATCHED_BEST or \
(not self[qualities][quality][self.bothlists] and self[qualities][quality][self.upgradelist] and
status in (DOWNLOADED, SNATCHED, SNATCHED_BEST, SNATCHED_PROPER)):
return []
return self[qualities][quality][self.wantedlist]
for (attr_name, qual_val) in [
('SNATCHED', SNATCHED), ('SNATCHED_PROPER', SNATCHED_PROPER), ('SNATCHED_BEST', SNATCHED_BEST),
('DOWNLOADED', DOWNLOADED), ('ARCHIVED', ARCHIVED), ('FAILED', FAILED),
]:
setattr(Quality, attr_name, list(map(lambda qk: Quality.composite_status(qual_val, qk),
iterkeys(Quality.qualityStrings))))
Quality.SNATCHED_ANY = Quality.SNATCHED + Quality.SNATCHED_PROPER + Quality.SNATCHED_BEST
SD = Quality.combine_qualities([Quality.SDTV, Quality.SDDVD], [])
HD = Quality.combine_qualities(
[Quality.HDTV, Quality.FULLHDTV, Quality.HDWEBDL, Quality.FULLHDWEBDL, Quality.HDBLURAY, Quality.FULLHDBLURAY],
[]) # HD720p + HD1080p
HD720p = Quality.combine_qualities([Quality.HDTV, Quality.HDWEBDL, Quality.HDBLURAY], [])
HD1080p = Quality.combine_qualities([Quality.FULLHDTV, Quality.FULLHDWEBDL, Quality.FULLHDBLURAY], [])
UHD2160p = Quality.combine_qualities([Quality.UHD4KWEB, Quality.UHD4KBLURAY], [])
ANY = Quality.combine_qualities(
[Quality.SDTV, Quality.SDDVD, Quality.HDTV, Quality.FULLHDTV, Quality.HDWEBDL, Quality.FULLHDWEBDL,
Quality.HDBLURAY, Quality.FULLHDBLURAY, Quality.UNKNOWN], []) # SD + HD
# legacy template, can't remove due to reference in mainDB upgrade?
BEST = Quality.combine_qualities([Quality.SDTV, Quality.HDTV, Quality.HDWEBDL], [Quality.HDTV])
qualityPresets = (SD, HD, HD720p, HD1080p, UHD2160p, ANY)
qualityPresetStrings = {SD: 'SD',
HD: 'HD',
HD720p: 'HD720p',
HD1080p: 'HD1080p',
UHD2160p: 'UHD2160p',
ANY: 'Any'}
class StatusStrings(object):
def __init__(self):
self.statusStrings = {UNKNOWN: 'Unknown',
UNAIRED: 'Unaired',
SNATCHED: 'Snatched',
SNATCHED_PROPER: 'Snatched (Proper)',
SNATCHED_BEST: 'Snatched (Best)',
DOWNLOADED: 'Downloaded',
ARCHIVED: 'Archived',
SKIPPED: 'Skipped',
WANTED: 'Wanted',
IGNORED: 'Ignored',
SUBTITLED: 'Subtitled',
FAILED: 'Failed'}
def __getitem__(self, name):
if name in Quality.SNATCHED_ANY + Quality.DOWNLOADED + Quality.ARCHIVED:
status, quality = Quality.split_composite_status(name)
if quality == Quality.NONE:
return self.statusStrings[status]
return '%s (%s)' % (self.statusStrings[status], Quality.qualityStrings[quality])
return self.statusStrings[name] if name in self.statusStrings else ''
def __contains__(self, item):
return item in self.statusStrings or item in Quality.SNATCHED_ANY + Quality.DOWNLOADED + Quality.ARCHIVED
statusStrings = StatusStrings()
class Overview(object):
UNAIRED = UNAIRED # 1
QUAL = 2
WANTED = WANTED # 3
GOOD = 4
SKIPPED = SKIPPED # 5
# For both snatched statuses. Note: SNATCHED/QUAL have same value and break dict.
SNATCHED = SNATCHED_PROPER = SNATCHED_BEST # 9
SNATCHED_QUAL = 15
overviewStrings = {UNKNOWN: 'unknown',
SKIPPED: 'skipped',
WANTED: 'wanted',
QUAL: 'qual',
GOOD: 'good',
UNAIRED: 'unaired',
SNATCHED: 'snatched',
SNATCHED_QUAL: 'snatched/qual'}
countryList = {'Australia': 'AU',
'Canada': 'CA',
'USA': 'US'}
class NeededQualities(object):
def __init__(self, need_anime=False, need_sports=False, need_sd=False, need_hd=False, need_uhd=False,
need_webdl=False, need_all_qualities=False, need_all_types=False, need_all=False):
self.need_anime = need_anime or need_all_types or need_all
self.need_sports = need_sports or need_all_types or need_all
self.need_sd = need_sd or need_all_qualities or need_all
self.need_hd = need_hd or need_all_qualities or need_all
self.need_uhd = need_uhd or need_all_qualities or need_all
self.need_webdl = need_webdl or need_all_qualities or need_all
max_sd = Quality.SDDVD
hd_qualities = [Quality.HDTV, Quality.FULLHDTV, Quality.HDWEBDL, Quality.FULLHDWEBDL,
Quality.HDBLURAY, Quality.FULLHDBLURAY]
webdl_qualities = [Quality.SDTV, Quality.HDWEBDL, Quality.FULLHDWEBDL, Quality.UHD4KWEB]
max_hd = Quality.FULLHDBLURAY
@property
def all_needed(self):
"""
:rtype: bool
"""
return self.all_qualities_needed and self.all_types_needed
@property
def all_types_needed(self):
"""
:rtype: bool
"""
return self.need_anime and self.need_sports
@property
def all_qualities_needed(self):
"""
:rtype: bool
"""
return self.need_sd and self.need_hd and self.need_uhd and self.need_webdl
@all_qualities_needed.setter
def all_qualities_needed(self, v):
"""
:param v:
:type v: bool
"""
if isinstance(v, bool) and True is v:
self.need_sd = self.need_hd = self.need_uhd = self.need_webdl = True
def all_show_qualities_needed(self, show_obj):
"""
:param show_obj: show object
:type show_obj: sickgear.tv.TVShow
:return:
:rtype: bool
"""
from sickgear.tv import TVShow
if isinstance(show_obj, TVShow):
init, upgrade = Quality.split_quality(show_obj.quality)
all_qual = set(init + upgrade)
need_sd = need_hd = need_uhd = need_webdl = False
for wanted_qualities in all_qual:
if not need_sd and wanted_qualities <= NeededQualities.max_sd:
need_sd = True
if not need_hd and wanted_qualities in NeededQualities.hd_qualities:
need_hd = True
if not need_webdl and wanted_qualities in NeededQualities.webdl_qualities:
need_webdl = True
if not need_uhd and wanted_qualities > NeededQualities.max_hd:
need_uhd = True
return self.need_sd == need_sd and self.need_hd == need_hd and self.need_webdl == need_webdl and \
self.need_uhd == need_uhd
def check_needed_types(self, show_obj):
"""
:param show_obj: show object
:type show_obj: sickgear.tv.TVShow
"""
if getattr(show_obj, 'is_anime', False):
self.need_anime = True
if getattr(show_obj, 'is_sports', False):
self.need_sports = True
def check_needed_qualities(self, wanted_qualities):
# type: (List[int]) -> None
"""
:param wanted_qualities: wanted qualities list
"""
if wanted_qualities:
if Quality.UNKNOWN in wanted_qualities:
self.need_sd = self.need_hd = self.need_uhd = self.need_webdl = True
else:
if not self.need_sd and min(wanted_qualities) <= NeededQualities.max_sd:
self.need_sd = True
if not self.need_hd and any(i in NeededQualities.hd_qualities for i in wanted_qualities):
self.need_hd = True
if not self.need_webdl and any(i in NeededQualities.webdl_qualities for i in wanted_qualities):
self.need_webdl = True
if not self.need_uhd and max(wanted_qualities) > NeededQualities.max_hd:
self.need_uhd = True
Reference in a new issue View git blame Copy permalink