def __init__(self): self.updater = None self.install_type = None self.amActive = False self.install_type = self.find_install_type() if self.install_type == 'git': self.updater = GitUpdateManager() elif self.install_type == 'source': self.updater = SourceUpdateManager() self.session = MedusaSafeSession()
def __init__(self, name): """Initialize the class.""" self.name = name self.anime_only = False self.bt_cache_urls = [ 'http://reflektor.karmorra.info/torrent/{info_hash}.torrent', 'https://torrent.cd/torrents/download/{info_hash}/.torrent', 'https://asnet.pw/download/{info_hash}/', 'http://p2pdl.com/download/{info_hash}', 'http://itorrents.org/torrent/{info_hash}.torrent', 'http://thetorrent.org/torrent/{info_hash}.torrent', 'https://cache.torrentgalaxy.org/get/{info_hash}', ] self.cache = tv.Cache(self) self.enable_backlog = False self.enable_manualsearch = False self.enable_daily = False self.enabled = False self.headers = {'User-Agent': USER_AGENT} self.proper_strings = ['PROPER|REPACK|REAL|RERIP'] self.provider_type = None self.public = False self.search_fallback = False self.search_mode = None self.session = MedusaSafeSession(cloudflare=True) self.session.headers.update(self.headers) self.series = None self.supports_absolute_numbering = False self.supports_backlog = True self.url = '' self.urls = {} # Ability to override the search separator. As for example anizb is using '*' instead of space. self.search_separator = ' ' self.season_templates = ( 'S{season:0>2}', # example: 'Series.Name.S03' ) # Use and configure the attribute enable_cookies to show or hide the cookies input field per provider self.enable_cookies = False self.cookies = '' # Paramaters for reducting the daily search results parsing self.max_recent_items = 5 self.stop_at = 3 # Delay downloads self.enable_search_delay = False self.search_delay = 480 # minutes
def __init__(self, name): """Initialize the class.""" self.name = name self.anime_only = False self.bt_cache_urls = [ 'https://torrentproject.se/torrent/{info_hash}.torrent', 'http://reflektor.karmorra.info/torrent/{info_hash}.torrent', 'http://thetorrent.org/torrent/{info_hash}.torrent', 'http://piratepublic.com/download.php?id={info_hash}', 'http://www.legittorrents.info/download.php?id={info_hash}', 'https://torrent.cd/torrents/download/{info_hash}/.torrent', 'https://asnet.pw/download/{info_hash}/', 'https://skytorrents.in/file/{info_hash}/.torrent', 'http://p2pdl.com/download/{info_hash}', 'http://itorrents.org/torrent/{info_hash}.torrent', 'https://torcache.pro/{info_hash}.torrent', ] self.cache = tv.Cache(self) self.enable_backlog = False self.enable_manualsearch = False self.enable_daily = False self.enabled = False self.headers = {'User-Agent': USER_AGENT} self.proper_strings = ['PROPER|REPACK|REAL|RERIP'] self.provider_type = None self.public = False self.search_fallback = False self.search_mode = None self.session = MedusaSafeSession(hooks=[cloudflare]) self.session.headers.update(self.headers) self.show = None self.supports_absolute_numbering = False self.supports_backlog = True self.url = '' self.urls = {} # Ability to override the search separator. As for example anizb is using '*' instead of space. self.search_separator = ' ' # Use and configure the attribute enable_cookies to show or hide the cookies input field per provider self.enable_cookies = False self.cookies = '' # Paramaters for reducting the daily search results parsing self.max_recent_items = 5 self.stop_at = 3 # Police attributes self.enable_api_hit_cooldown = False self.enable_daily_request_reserve = False
class HomeChangeLog(Home): session = MedusaSafeSession() def __init__(self, *args, **kwargs): super(HomeChangeLog, self).__init__(*args, **kwargs) def index(self): # TODO: SESSION: Check if this needs some more explicit exception handling. changes = HomeChangeLog.session.get_text(app.CHANGES_URL) if not changes: logger.log('Could not load changes from repo, giving a link!', logger.DEBUG) changes = 'Could not load changes from the repo. [Click here for CHANGES.md]({url})'.format( url=app.CHANGES_URL) t = PageTemplate(rh=self, filename='markdown.mako') data = markdown2.markdown( changes if changes else 'The was a problem connecting to github, please refresh and try again', extras=['header-ids']) return t.render(title='Changelog', header='Changelog', data=data, controller='changes', action='index')
def __init__(self): self.github_org = self.get_github_org() self.github_repo = self.get_github_repo() self.branch = app.BRANCH if app.BRANCH == '': self.branch = self._find_installed_branch() self._cur_commit_hash = app.CUR_COMMIT_HASH self._newest_commit_hash = None self._num_commits_behind = 0 self._num_commits_ahead = 0 self.session = MedusaSafeSession()
def __init__(self, name): """Initialize the class.""" self.name = name self.anime_only = False self.bt_cache_urls = [ 'http://reflektor.karmorra.info/torrent/{info_hash}.torrent', 'https://asnet.pw/download/{info_hash}/', 'http://p2pdl.com/download/{info_hash}', 'http://itorrents.org/torrent/{info_hash}.torrent', 'http://thetorrent.org/torrent/{info_hash}.torrent', 'https://cache.torrentgalaxy.org/get/{info_hash}', 'https://www.seedpeer.me/torrent/{info_hash}', ] self.cache = tv.Cache(self) self.enable_backlog = False self.enable_manualsearch = False self.enable_daily = False self.enabled = False self.headers = {'User-Agent': USER_AGENT} self.proper_strings = ['PROPER|REPACK|REAL|RERIP'] self.provider_type = None self.public = False self.search_fallback = False self.search_mode = None self.session = MedusaSafeSession(cloudflare=True) self.session.headers.update(self.headers) self.series = None self.supports_absolute_numbering = False self.supports_backlog = True self.url = '' self.urls = {} # Ability to override the search separator. As for example anizb is using '*' instead of space. self.search_separator = ' ' self.season_templates = ( 'S{season:0>2}', # example: 'Series.Name.S03' ) # Use and configure the attribute enable_cookies to show or hide the cookies input field per provider self.enable_cookies = False self.cookies = '' # Paramaters for reducting the daily search results parsing self.max_recent_items = 5 self.stop_at = 3 # Delay downloads self.enable_search_delay = False self.search_delay = 480 # minutes
def resource_get_changelog(self): """Retrieve changelog and convert the markdown to html.""" # TODO: SESSION: Check if this needs some more explicit exception handling. from medusa.session.core import MedusaSafeSession changes = MedusaSafeSession().get_text(app.CHANGES_URL) if not changes: changes = 'Could not load changes from the repo. [Click here for CHANGES.md]({url})'.format( url=app.CHANGES_URL) data = markdown2.markdown( changes if changes else 'The was a problem connecting to github, please refresh and try again', extras=['header-ids']) return self._ok(data)
from __future__ import unicode_literals import datetime import logging from medusa import app from medusa.helper.common import sanitize_filename from medusa.logger.adapters.style import BraceAdapter from medusa.session.core import MedusaSafeSession from requests.compat import urljoin log = BraceAdapter(logging.getLogger(__name__)) log.logger.addHandler(logging.NullHandler()) session = MedusaSafeSession() def send_nzb(nzb): """ Dispatch method for sending an nzb to sabnzbd using it's api. :param nzb: nzb SearchResult object :return: result of the communication with sabnzbd (True/False) """ session.params.update({ 'output': 'json', 'ma_username': app.SAB_USERNAME, 'ma_password': app.SAB_PASSWORD, 'apikey': app.SAB_APIKEY, })
class GenericProvider(object): """Generic provider.""" NZB = 'nzb' TORRENT = 'torrent' def __init__(self, name): """Initialize the class.""" self.name = name self.anime_only = False self.bt_cache_urls = [ 'http://reflektor.karmorra.info/torrent/{info_hash}.torrent', 'https://torrent.cd/torrents/download/{info_hash}/.torrent', 'https://asnet.pw/download/{info_hash}/', 'http://p2pdl.com/download/{info_hash}', 'http://itorrents.org/torrent/{info_hash}.torrent', ] self.cache = tv.Cache(self) self.enable_backlog = False self.enable_manualsearch = False self.enable_daily = False self.enabled = False self.headers = {'User-Agent': USER_AGENT} self.proper_strings = ['PROPER|REPACK|REAL|RERIP'] self.provider_type = None self.public = False self.search_fallback = False self.search_mode = None self.session = MedusaSafeSession(hooks=[cloudflare]) self.session.headers.update(self.headers) self.show = None self.supports_absolute_numbering = False self.supports_backlog = True self.url = '' self.urls = {} # Ability to override the search separator. As for example anizb is using '*' instead of space. self.search_separator = ' ' self.season_templates = ( 'S{season:0>2}', # example: 'Series.Name.S03' ) # Use and configure the attribute enable_cookies to show or hide the cookies input field per provider self.enable_cookies = False self.cookies = '' # Paramaters for reducting the daily search results parsing self.max_recent_items = 5 self.stop_at = 3 # Police attributes self.enable_api_hit_cooldown = False self.enable_daily_request_reserve = False def download_result(self, result): """Download result from provider.""" if not self.login(): return False urls, filename = self._make_url(result) for url in urls: if 'NO_DOWNLOAD_NAME' in url: continue if url.startswith('http'): self.headers.update( {'Referer': '/'.join(url.split('/')[:3]) + '/'}) log.info('Downloading {result} from {provider} at {url}', { 'result': result.name, 'provider': self.name, 'url': url }) verify = False if self.public else None if download_file(url, filename, session=self.session, headers=self.headers, hooks={'response': self.get_url_hook}, verify=verify): if self._verify_download(filename): log.info('Saved {result} to {location}', { 'result': result.name, 'location': filename }) return True if urls: log.warning('Failed to download any results for {result}', {'result': result.name}) return False def get_content(self, url, params=None, timeout=30, **kwargs): """Retrieve the torrent/nzb content.""" return self.session.get_content(url, params=params, timeout=timeout, **kwargs) def find_propers(self, proper_candidates): """Find propers in providers.""" results = [] for proper_candidate in proper_candidates: show_obj = Show.find(app.showList, int(proper_candidate[b'showid']) ) if proper_candidate[b'showid'] else None if show_obj: self.show = show_obj episode_obj = show_obj.get_episode( proper_candidate[b'season'], proper_candidate[b'episode']) for term in self.proper_strings: search_strings = self._get_episode_search_strings( episode_obj, add_string=term) for item in self.search(search_strings[0], ep_obj=episode_obj): search_result = self.get_result() results.append(search_result) search_result.name, search_result.url = self._get_title_and_url( item) search_result.seeders, search_result.leechers = self._get_result_info( item) search_result.size = self._get_size(item) search_result.pubdate = self._get_pubdate(item) # This will be retrieved from the parser search_result.proper_tags = '' search_result.search_type = PROPER_SEARCH search_result.date = datetime.today() search_result.show = show_obj return results def find_search_results(self, show, episodes, search_mode, forced_search=False, download_current_quality=False, manual_search=False, manual_search_type='episode'): """Search episodes based on param.""" self._check_auth() self.show = show results = {} items_list = [] for episode in episodes: if not manual_search: cache_result = self.cache.search_cache( episode, forced_search=forced_search, down_cur_quality=download_current_quality) if cache_result: if episode.episode not in results: results[episode.episode] = cache_result else: results[episode.episode].extend(cache_result) continue search_strings = [] season_search = (len(episodes) > 1 or manual_search_type == 'season') and search_mode == 'sponly' if season_search: search_strings = self._get_season_search_strings(episode) elif search_mode == 'eponly': search_strings = self._get_episode_search_strings(episode) for search_string in search_strings: # Find results from the provider items_list += self.search(search_string, ep_obj=episode, manual_search=manual_search) # In season search, we can't loop in episodes lists as we only need one episode to get the season string if search_mode == 'sponly': break if len(results) == len(episodes): return results if items_list: # categorize the items into lists by quality items = defaultdict(list) for item in items_list: items[self.get_quality(item, anime=show.is_anime)].append(item) # temporarily remove the list of items with unknown quality unknown_items = items.pop(Quality.UNKNOWN, []) # make a generator to sort the remaining items by descending quality items_list = (items[quality] for quality in sorted(items, reverse=True)) # unpack all of the quality lists into a single sorted list items_list = list(chain(*items_list)) # extend the list with the unknown qualities, now sorted at the bottom of the list items_list.extend(unknown_items) cl = [] # Move through each item and parse it into a quality search_results = [] for item in items_list: # Make sure we start with a TorrentSearchResult, NZBDataSearchResult or NZBSearchResult search result obj. search_result = self.get_result() search_results.append(search_result) search_result.item = item search_result.download_current_quality = download_current_quality # FIXME: Should be changed to search_result.search_type search_result.forced_search = forced_search (search_result.name, search_result.url) = self._get_title_and_url(item) (search_result.seeders, search_result.leechers) = self._get_result_info(item) search_result.size = self._get_size(item) search_result.pubdate = self._get_pubdate(item) search_result.result_wanted = True try: search_result.parsed_result = NameParser( parse_method=('normal', 'anime')[show.is_anime]).parse( search_result.name) except (InvalidNameException, InvalidShowException) as error: log.debug( 'Error during parsing of release name: {release_name}, with error: {error}', { 'release_name': search_result.name, 'error': error }) search_result.add_cache_entry = False search_result.result_wanted = False continue # I don't know why i'm doing this. Maybe remove it later on all together, now i've added the parsed_result # to the search_result. search_result.show = search_result.parsed_result.show search_result.quality = search_result.parsed_result.quality search_result.release_group = search_result.parsed_result.release_group search_result.version = search_result.parsed_result.version search_result.actual_season = search_result.parsed_result.season_number search_result.actual_episodes = search_result.parsed_result.episode_numbers if not manual_search: if not (search_result.show.air_by_date or search_result.show.sports): if search_mode == 'sponly': if search_result.parsed_result.episode_numbers: log.debug( 'This is supposed to be a season pack search but the result {0} is not a valid ' 'season pack, skipping it', search_result.name) search_result.result_wanted = False continue elif not [ ep for ep in episodes if search_result.parsed_result.season_number == (ep.season, ep.scene_season)[ep.series.is_scene] ]: log.debug( 'This season result {0} is for a season we are not searching for, ' 'skipping it', search_result.name) search_result.result_wanted = False continue else: # I'm going to split these up for better readability # Check if at least got a season parsed. if search_result.parsed_result.season_number is None: log.debug( "The result {0} doesn't seem to have a valid season that we are currently trying to " "snatch, skipping it", search_result.name) search_result.result_wanted = False continue # Check if we at least got some episode numbers parsed. if not search_result.parsed_result.episode_numbers: log.debug( "The result {0} doesn't seem to match an episode that we are currently trying to " "snatch, skipping it", search_result.name) search_result.result_wanted = False continue # Compare the episodes and season from the result with what was searched. if not [ searched_episode for searched_episode in episodes if searched_episode.season == search_result.parsed_result.season_number and (searched_episode.episode, searched_episode. scene_episode)[searched_episode.series.is_scene] in search_result.parsed_result.episode_numbers ]: log.debug( "The result {0} doesn't seem to match an episode that we are currently trying to " "snatch, skipping it", search_result.name) search_result.result_wanted = False continue # We've performed some checks to decided if we want to continue with this result. # If we've hit this, that means this is not an air_by_date and not a sports show. And it seems to be # a valid result. Let's store the parsed season and episode number and continue. search_result.actual_season = search_result.parsed_result.season_number search_result.actual_episodes = search_result.parsed_result.episode_numbers else: # air_by_date or sportshow. search_result.same_day_special = False if not search_result.parsed_result.is_air_by_date: log.debug( "This is supposed to be a date search but the result {0} didn't parse as one, " "skipping it", search_result.name) search_result.result_wanted = False continue else: # Use a query against the tv_episodes table, to match the parsed air_date against. air_date = search_result.parsed_result.air_date.toordinal( ) db = DBConnection() sql_results = db.select( 'SELECT season, episode FROM tv_episodes WHERE showid = ? AND airdate = ?', [search_result.show.indexerid, air_date]) if len(sql_results) == 2: if int(sql_results[0][b'season']) == 0 and int( sql_results[1][b'season']) != 0: search_result.actual_season = int( sql_results[1][b'season']) search_result.actual_episodes = [ int(sql_results[1][b'episode']) ] search_result.same_day_special = True elif int(sql_results[1][b'season']) == 0 and int( sql_results[0][b'season']) != 0: search_result.actual_season = int( sql_results[0][b'season']) search_result.actual_episodes = [ int(sql_results[0][b'episode']) ] search_result.same_day_special = True elif len(sql_results) != 1: log.warning( "Tried to look up the date for the episode {0} but the database didn't return proper " "results, skipping it", search_result.name) search_result.result_wanted = False continue # @TODO: Need to verify and test this. if search_result.result_wanted and not search_result.same_day_special: search_result.actual_season = int( sql_results[0][b'season']) search_result.actual_episodes = [ int(sql_results[0][b'episode']) ] # Iterate again over the search results, and see if there is anything we want. for search_result in search_results: # Try to cache the item if we want to. cache_result = search_result.add_result_to_cache(self.cache) if cache_result is not None: cl.append(cache_result) if not search_result.result_wanted: log.debug( "We aren't interested in this result: {0} with url: {1}", search_result.name, search_result.url) continue log.debug('Found result {0} at {1}', search_result.name, search_result.url) episode_object = search_result.create_episode_object() # result = self.get_result(episode_object, search_result) search_result.finish_search_result(self) if not episode_object: episode_number = SEASON_RESULT log.debug('Found season pack result {0} at {1}', search_result.name, search_result.url) elif len(episode_object) == 1: episode_number = episode_object[0].episode log.debug('Found single episode result {0} at {1}', search_result.name, search_result.url) else: episode_number = MULTI_EP_RESULT log.debug( 'Found multi-episode ({0}) result {1} at {2}', ', '.join( map(str, search_result.parsed_result.episode_numbers)), search_result.name, search_result.url) if episode_number not in results: results[episode_number] = [search_result] else: results[episode_number].append(search_result) if cl: # Access to a protected member of a client class db = self.cache._get_db() db.mass_action(cl) return results def get_id(self): """Get ID of the provider.""" return GenericProvider.make_id(self.name) def get_quality(self, item, anime=False): """Get scene quality of the result.""" (title, _) = self._get_title_and_url(item) quality = Quality.scene_quality(title, anime) return quality def get_result(self, episodes=None): """Get result.""" return self._get_result(episodes) @staticmethod def get_url_hook(response, **kwargs): """Get URL hook.""" request = response.request log.debug( '{method} URL: {url} [Status: {status}]', { 'method': request.method, 'url': request.url, 'status': response.status_code, }) log.debug('User-Agent: {}'.format(request.headers['User-Agent'])) if request.method.upper() == 'POST': body = request.body # try to log post data using various codecs to decode if isinstance(body, unicode): log.debug('With post data: {0}', body) return codecs = ('utf-8', 'latin1', 'cp1252') for codec in codecs: try: data = body.decode(codec) except UnicodeError as error: log.debug('Failed to decode post data as {codec}: {msg}', { 'codec': codec, 'msg': error }) else: log.debug('With post data: {0}', data) break else: log.warning('Failed to decode post data with {codecs}', {'codecs': codecs}) def get_url(self, url, post_data=None, params=None, timeout=30, **kwargs): """Load the given URL.""" log.info( 'providers.generic_provider.get_url() is deprecated, ' 'please rewrite your provider to make use of the MedusaSession session class.' ) kwargs['hooks'] = {'response': self.get_url_hook} if not post_data: return self.session.get(url, params=params, headers=self.headers, timeout=timeout, **kwargs) else: return self.session.post(url, post_data=post_data, params=params, headers=self.headers, timeout=timeout, **kwargs) def image_name(self): """Return provider image name.""" return self.get_id() + '.png' def is_active(self): """Check if provider is active.""" return False def is_enabled(self): """Check if provider is enabled.""" return bool(self.enabled) @staticmethod def make_id(name): """Make ID of the provider.""" if not name: return '' return re.sub(r'[^\w\d_]', '_', str(name).strip().lower()) def search_rss(self, episodes): """Find cached needed episodes.""" return self.cache.find_needed_episodes(episodes) def seed_ratio(self): """Return ratio.""" return '' def _check_auth(self): """Check if we are autenticated.""" return True def login(self): """Login to provider.""" return True def search(self, search_strings, age=0, ep_obj=None, **kwargs): """Search the provider.""" return [] @staticmethod def parse_pubdate(pubdate, human_time=False, timezone=None, **kwargs): """ Parse publishing date into a datetime object. :param pubdate: date and time string :param human_time: string uses human slang ("4 hours ago") :param timezone: use a different timezone ("US/Eastern") :keyword dayfirst: Interpret the first value as the day :keyword yearfirst: Interpret the first value as the year :returns: a datetime object or None """ now_alias = ('right now', 'just now', 'now') df = kwargs.pop('dayfirst', False) yf = kwargs.pop('yearfirst', False) # This can happen from time to time if pubdate is None: log.debug('Skipping invalid publishing date.') return try: if human_time: if pubdate.lower() in now_alias: seconds = 0 else: match = re.search(r'(?P<time>\d+\W*\w+)', pubdate) seconds = parse(match.group('time')) return datetime.now(tz.tzlocal()) - timedelta(seconds=seconds) dt = parser.parse(pubdate, dayfirst=df, yearfirst=yf, fuzzy=True) # Always make UTC aware if naive if dt.tzinfo is None or dt.tzinfo.utcoffset(dt) is None: dt = dt.replace(tzinfo=tz.gettz('UTC')) if timezone: dt = dt.astimezone(tz.gettz(timezone)) return dt except (AttributeError, TypeError, ValueError): log.exception('Failed parsing publishing date: {0}', pubdate) def _get_result(self, episodes=None): """Get result.""" return SearchResult(episodes) def _get_episode_search_strings(self, episode, add_string=''): """Get episode search strings.""" if not episode: return [] search_string = {'Episode': []} all_possible_show_names = episode.series.get_all_possible_names() if episode.scene_season: all_possible_show_names = all_possible_show_names.union( episode.series.get_all_possible_names( season=episode.scene_season)) for show_name in all_possible_show_names: episode_string = show_name + self.search_separator episode_string_fallback = None if episode.series.air_by_date: episode_string += str(episode.airdate).replace('-', ' ') elif episode.series.sports: episode_string += str(episode.airdate).replace('-', ' ') episode_string += ('|', ' ')[len(self.proper_strings) > 1] episode_string += episode.airdate.strftime('%b') elif episode.series.anime: # If the showname is a season scene exception, we want to use the indexer episode number. if (episode.scene_season > 1 and show_name in get_scene_exceptions( episode.series.indexerid, episode.series.indexer, episode.scene_season)): # This is apparently a season exception, let's use the scene_episode instead of absolute ep = episode.scene_episode else: ep = episode.scene_absolute_number episode_string_fallback = episode_string + '{episode:0>3}'.format( episode=ep) episode_string += '{episode:0>2}'.format(episode=ep) else: episode_string += config.naming_ep_type[2] % { 'seasonnumber': episode.scene_season, 'episodenumber': episode.scene_episode, } if add_string: episode_string += self.search_separator + add_string if episode_string_fallback: episode_string_fallback += self.search_separator + add_string search_string['Episode'].append(episode_string.strip()) if episode_string_fallback: search_string['Episode'].append( episode_string_fallback.strip()) return [search_string] def _get_tvdb_id(self): """Return the tvdb id if the shows indexer is tvdb. If not, try to use the externals to get it.""" if not self.show: return None return self.show.indexerid if self.show.indexer == INDEXER_TVDBV2 else self.show.externals.get( 'tvdb_id') def _get_season_search_strings(self, episode): search_string = {'Season': []} for show_name in episode.series.get_all_possible_names( season=episode.scene_season): episode_string = show_name + self.search_separator if episode.series.air_by_date or episode.series.sports: search_string['Season'].append( episode_string + str(episode.airdate).split('-')[0]) elif episode.series.anime: search_string['Season'].append(episode_string + 'Season') else: for season_template in self.season_templates: templated_episode_string = episode_string + season_template.format( season=episode.scene_season) search_string['Season'].append( templated_episode_string.strip()) return [search_string] def _get_size(self, item): """Return default size.""" return -1 def _get_storage_dir(self): """Return storage dir.""" return '' def _get_result_info(self, item): """Return default seeders and leechers.""" return -1, -1 def _get_pubdate(self, item): """Return publish date of the item. If provider doesnt have _get_pubdate function this will be used """ return None def _get_title_and_url(self, item): """Return title and url from result.""" if not item: return '', '' title = item.get('title', '') url = item.get('link', '') if title: title = title.replace(' ', '.') else: title = '' if url: url = url.replace('&', '&').replace('%26tr%3D', '&tr=') else: url = '' return title, url def _make_url(self, result): """Return url if result is a magnet link.""" if not result: return '', '' urls = [] filename = '' if result.url.startswith('magnet:'): try: info_hash = re.findall(r'urn:btih:([\w]{32,40})', result.url)[0].upper() try: torrent_name = re.findall('dn=([^&]+)', result.url)[0] except Exception: torrent_name = 'NO_DOWNLOAD_NAME' if len(info_hash) == 32: info_hash = b16encode(b32decode(info_hash)).upper() if not info_hash: log.error( 'Unable to extract torrent hash from magnet: {0}', result.url) return urls, filename urls = [ x.format(info_hash=info_hash, torrent_name=torrent_name) for x in self.bt_cache_urls ] shuffle(urls) except Exception: log.error( 'Unable to extract torrent hash or name from magnet: {0}', result.url) return urls, filename else: urls = [result.url] result_name = sanitize_filename(result.name) # Some NZB providers (e.g. Jackett) can also download torrents if (result.url.endswith(GenericProvider.TORRENT) or result.url.startswith('magnet:') ) and self.provider_type == GenericProvider.NZB: filename = join(app.TORRENT_DIR, result_name + '.torrent') else: filename = join(self._get_storage_dir(), result_name + '.' + self.provider_type) return urls, filename def _verify_download(self, file_name=None): return True @property def recent_results(self): """Return recent RSS results from provier.""" return recent_results.get(self.get_id(), []) @recent_results.setter def recent_results(self, items): """Set recent results from provider.""" if not recent_results.get(self.get_id()): recent_results.update({self.get_id(): []}) if items: add_to_list = [] for item in items: if item['link'] not in { cache_item['link'] for cache_item in recent_results[self.get_id()] }: add_to_list += [item] results = add_to_list + recent_results[self.get_id()] recent_results[self.get_id()] = results[:self.max_recent_items] def add_cookies_from_ui(self): """ Add the cookies configured from UI to the providers requests session. :return: A dict with the the keys result as bool and message as string """ # Added exception for rss torrent providers, as for them adding cookies initial should be optional. from medusa.providers.torrent.rss.rsstorrent import TorrentRssProvider if isinstance(self, TorrentRssProvider) and not self.cookies: return { 'result': True, 'message': 'This is a TorrentRss provider without any cookies provided. ' 'Cookies for this provider are considered optional.' } # This is the generic attribute used to manually add cookies for provider authentication if not self.enable_cookies: return { 'result': False, 'message': 'Adding cookies is not supported for provider: {0}'.format( self.name) } if not self.cookies: return { 'result': False, 'message': 'No Cookies added from ui for provider: {0}'.format(self.name) } cookie_validator = re.compile(r'^([\w%]+=[\w%]+)(;[\w%]+=[\w%]+)*$') if not cookie_validator.match(self.cookies): ui.notifications.message( 'Failed to validate cookie for provider {provider}'.format( provider=self.name), 'Cookie is not correctly formatted: {0}'.format(self.cookies)) return { 'result': False, 'message': 'Cookie is not correctly formatted: {0}'.format(self.cookies) } if not all(req_cookie in [x.rsplit('=', 1)[0] for x in self.cookies.split(';')] for req_cookie in self.required_cookies): return { 'result': False, 'message': "You haven't configured the requied cookies. Please login at {provider_url}, " "and make sure you have copied the following cookies: {required_cookies!r}" .format(provider_url=self.name, required_cookies=self.required_cookies) } # cookie_validator got at least one cookie key/value pair, let's return success add_dict_to_cookiejar( self.session.cookies, dict(x.rsplit('=', 1) for x in self.cookies.split(';'))) return {'result': True, 'message': ''} def check_required_cookies(self): """ Check if we have the required cookies in the requests sessions object. Meaning that we've already successfully authenticated once, and we don't need to go through this again. Note! This doesn't mean the cookies are correct! """ if not hasattr(self, 'required_cookies'): # A reminder for the developer, implementing cookie based authentication. log.error( 'You need to configure the required_cookies attribute, for the provider: {provider}', {'provider': self.name}) return False return all( dict_from_cookiejar(self.session.cookies).get(cookie) for cookie in self.required_cookies) def cookie_login(self, check_login_text, check_url=None): """ Check the response for text that indicates a login prompt. In that case, the cookie authentication was not successful. :param check_login_text: A string that's visible when the authentication failed. :param check_url: The url to use to test the login with cookies. By default the providers home page is used. :return: False when authentication was not successful. True if successful. """ check_url = check_url or self.url if self.check_required_cookies(): # All required cookies have been found within the current session, we don't need to go through this again. return True if self.cookies: result = self.add_cookies_from_ui() if not result['result']: ui.notifications.message(result['message']) log.warning(result['message']) return False else: log.warning( 'Failed to login, you will need to add your cookies in the provider settings' ) ui.notifications.error( 'Failed to auth with {provider}'.format(provider=self.name), 'You will need to add your cookies in the provider settings') return False response = self.session.get(check_url) if not response or any([ not (response.text and response.status_code == 200), check_login_text.lower() in response.text.lower() ]): log.warning( 'Please configure the required cookies for this provider. Check your provider settings' ) ui.notifications.error( 'Wrong cookies for {provider}'.format(provider=self.name), 'Check your provider settings') self.session.cookies.clear() return False else: return True def __str__(self): """Return provider name and provider type.""" return '{provider_name} ({provider_type})'.format( provider_name=self.name, provider_type=self.provider_type) def __unicode__(self): """Return provider name and provider type.""" return '{provider_name} ({provider_type})'.format( provider_name=self.name, provider_type=self.provider_type)
def __init__(self): self.amActive = False self.updater = self.find_install_type() self.session = MedusaSafeSession()
class CheckVersion(object): """Version check class meant to run as a thread object with the sr scheduler.""" def __init__(self): self.amActive = False self.updater = self.find_install_type() self.session = MedusaSafeSession() def run(self, force=False): self.amActive = True # Update remote branches and store in app.GIT_REMOTE_BRANCHES self.list_remote_branches() if self.updater: # set current branch version app.BRANCH = self.get_branch() if self.check_for_new_version(force): if app.AUTO_UPDATE: log.info(u'New update found, starting auto-updater ...') ui.notifications.message( 'New update found, starting auto-updater') if self.run_backup_if_safe(): if self.update(): log.info(u'Update was successful!') ui.notifications.message('Update was successful') app.events.put(app.events.SystemEvent.RESTART) else: log.info(u'Update failed!') ui.notifications.message('Update failed!') self.check_for_new_news(force) self.amActive = False def run_backup_if_safe(self): return self.safe_to_update() is True and self._runbackup() is True def _runbackup(self): # Do a system backup before update log.info(u'Config backup in progress...') ui.notifications.message('Backup', 'Config backup in progress...') try: backupDir = os.path.join(app.DATA_DIR, app.BACKUP_DIR) if not os.path.isdir(backupDir): os.mkdir(backupDir) if self._keeplatestbackup(backupDir) and self._backup(backupDir): log.info(u'Config backup successful') ui.notifications.message('Backup', 'Config backup successful') return True else: log.warning(u'Config backup failed') ui.notifications.message('Backup', 'Config backup failed') return False except Exception as e: log.error(u'Update: Config backup failed. Error: {0!r}', e) ui.notifications.message('Backup', 'Config backup failed') return False @staticmethod def _keeplatestbackup(backupDir=None): if not backupDir: return False import glob files = glob.glob(os.path.join(backupDir, '*.zip')) if not files: return True now = time.time() newest = files[0], now - os.path.getctime(files[0]) for f in files[1:]: age = now - os.path.getctime(f) if age < newest[1]: newest = f, age files.remove(newest[0]) for f in files: os.remove(f) return True # TODO: Merge with backup in helpers @staticmethod def _backup(backupDir=None): if not backupDir: return False source = [ os.path.join(app.DATA_DIR, app.APPLICATION_DB), app.CONFIG_FILE, os.path.join(app.DATA_DIR, app.FAILED_DB), os.path.join(app.DATA_DIR, app.CACHE_DB) ] target = os.path.join( backupDir, app.BACKUP_FILENAME.format( timestamp=time.strftime('%Y%m%d%H%M%S'))) for (path, dirs, files) in os.walk(app.CACHE_DIR, topdown=True): for dirname in dirs: if path == app.CACHE_DIR and dirname not in ['images']: dirs.remove(dirname) for filename in files: source.append(os.path.join(path, filename)) return helpers.backup_config_zip(source, target, app.DATA_DIR) def safe_to_update(self): def db_safe(self): message = { 'equal': { 'type': DEBUG, 'text': u'We can proceed with the update. New update has same DB version' }, 'upgrade': { 'type': DEBUG, 'text': u'We can proceed with the update. New update has a new DB version' }, 'downgrade': { 'type': WARNING, 'text': u"We can't proceed with the update. New update has an old DB version. It's not possible to downgrade" }, } try: result = self.getDBcompare() if result in message: log.log( message[result]['type'], message[result] ['text']) # unpack the result message into a log entry else: log.warning( u"We can't proceed with the update. Unable to check remote DB version. Error: {0}", result) return result in ['equal', 'upgrade' ] # add future True results to the list except Exception as error: log.error( u"We can't proceed with the update. Unable to compare DB version. Error: {0!r}", error) return False def postprocessor_safe(): if not app.post_processor_scheduler.action.amActive: log.debug( u'We can proceed with the update. Post-Processor is not running' ) return True else: log.debug( u"We can't proceed with the update. Post-Processor is running" ) return False def showupdate_safe(): if app.show_update_scheduler.action.amActive: log.debug( u"We can't proceed with the update. Shows are being updated" ) return False if app.episode_update_scheduler.action.amActive: log.debug( u"We can't proceed with the update. Episodes are being updated" ) return False log.debug( u'We can proceed with the update. Shows or episodes are not being updated' ) return True db_safe = db_safe(self) postprocessor_safe = postprocessor_safe() showupdate_safe = showupdate_safe() if db_safe and postprocessor_safe and showupdate_safe: log.debug(u'Proceeding with auto update') return True else: log.debug(u'Auto update aborted') return False def getDBcompare(self): """ Compare the current DB version with the new branch version. :return: 'upgrade', 'equal', or 'downgrade' """ try: self.updater.need_update() cur_hash = str(self.updater.newest_commit_hash) assert len( cur_hash ) == 40, 'Commit hash wrong length: {length} hash: {hash}'.format( length=len(cur_hash), hash=cur_hash) check_url = 'http://rawcdn.githack.com/{org}/{repo}/{commit}/medusa/databases/main_db.py'.format( org=app.GIT_ORG, repo=app.GIT_REPO, commit=cur_hash) response = self.session.get(check_url) # Get remote DB version match_max_db = re.search( r'MAX_DB_VERSION\s*=\s*(?P<version>\d{2,3})', response.text) new_branch_major_db_version = int( match_max_db.group('version')) if match_max_db else None # Check local DB version main_db_con = db.DBConnection() cur_branch_major_db_version, cur_branch_minor_db_version = main_db_con.checkDBVersion( ) if any([ cur_branch_major_db_version is None, cur_branch_minor_db_version is None, new_branch_major_db_version is None ]): return 'Could not compare database versions, aborting' if new_branch_major_db_version > cur_branch_major_db_version: return 'upgrade' elif new_branch_major_db_version == cur_branch_major_db_version: return 'equal' else: return 'downgrade' except Exception as e: return repr(e) def find_install_type(self): """ Determine how this copy of Medusa was installed. :return: type of installation. Possible values are: 'docker': any docker build 'git': running from source using git 'source': running from source without git """ if self.runs_in_docker(): return DockerUpdateManager() elif os.path.isdir(os.path.join(app.PROG_DIR, u'.git')): return GitUpdateManager() return SourceUpdateManager() def check_for_new_version(self, force=False): """ Check the internet for a newer version. :force: if true the VERSION_NOTIFY setting will be ignored and a check will be forced :return: bool, True for new version or False for no new version. """ if not self.updater or (not app.VERSION_NOTIFY and not app.AUTO_UPDATE and not force): log.info( u'Version checking is disabled, not checking for the newest version' ) app.NEWEST_VERSION_STRING = None return False # checking for updates if not app.AUTO_UPDATE: log.info(u'Checking for updates using {0}', self.updater) if not self.updater.need_update(): app.NEWEST_VERSION_STRING = None if force: ui.notifications.message('No update needed') log.info(u'No update needed') # no updates needed return False # found updates return self.updater.can_update() def check_for_new_news(self, force=False): """ Check GitHub for the latest news. :return: unicode, a copy of the news :force: ignored """ # Grab a copy of the news log.debug(u'Checking GitHub for latest news.') response = self.session.get(app.NEWS_URL) if not response or not response.text: log.debug(u'Could not load news from URL: {0}', app.NEWS_URL) return try: last_read = datetime.datetime.strptime(app.NEWS_LAST_READ, '%Y-%m-%d') except ValueError: log.warning(u'Invalid news last read date: {0}', app.NEWS_LAST_READ) last_read = 0 news = response.text app.NEWS_UNREAD = 0 got_latest = False for match in re.finditer(r'^####\s*(\d{4}-\d{2}-\d{2})\s*####', news, re.M): if not got_latest: got_latest = True app.NEWS_LATEST = match.group(1) try: if datetime.datetime.strptime(match.group(1), '%Y-%m-%d') > last_read: app.NEWS_UNREAD += 1 except ValueError: log.warning( u'Unable to match latest news date. Repository news date: {0}', match.group(1)) pass return news def need_update(self): if self.updater: return self.updater.need_update() def update(self): if self.updater: # update branch with current config branch value self.updater.branch = app.BRANCH # check for updates if self.updater.need_update() and self.updater.can_update(): return self.updater.update() return False def list_remote_branches(self): if self.updater: app.GIT_REMOTE_BRANCHES = self.updater.list_remote_branches() return app.GIT_REMOTE_BRANCHES def get_branch(self): if self.updater: return self.updater.branch @staticmethod def runs_in_docker(): """ Check if Medusa is run in a docker container. If run in a container, we don't want to use the auto update feature, but just want to inform the user there is an update available. The user can update through getting the latest docker tag. """ if app.RUNS_IN_DOCKER is not None: return app.RUNS_IN_DOCKER path = '/proc/{pid}/cgroup'.format(pid=os.getpid()) try: if not os.path.isfile(path): return False with open(path) as f: for line in f: if re.match(r'\d+:[\w=]+:/docker(-[ce]e)?/\w+', line): log.debug(u'Running in a docker container') app.RUNS_IN_DOCKER = True return True return False except (EnvironmentError, OSError) as error: log.info( u'Tried to check the path {path} if we are running in a docker container, ' u'but an error occurred: {error}', { 'path': path, 'error': error }) return False
def __init__(self): self.amActive = False self.updater = self.find_install_type() self.session = MedusaSafeSession()
class CheckVersion(object): """Version check class meant to run as a thread object with the sr scheduler.""" def __init__(self): self.amActive = False self.updater = self.find_install_type() self.session = MedusaSafeSession() def run(self, force=False): self.amActive = True # Update remote branches and store in app.GIT_REMOTE_BRANCHES self.list_remote_branches() if self.updater: # set current branch version app.BRANCH = self.get_branch() if self.check_for_new_version(force): if app.AUTO_UPDATE: log.info(u'New update found, starting auto-updater ...') ui.notifications.message('New update found, starting auto-updater') if self.run_backup_if_safe(): if self.update(): log.info(u'Update was successful!') ui.notifications.message('Update was successful') app.events.put(app.events.SystemEvent.RESTART) else: log.info(u'Update failed!') ui.notifications.message('Update failed!') self.check_for_new_news(force) self.amActive = False def run_backup_if_safe(self): return self.safe_to_update() is True and self._runbackup() is True def _runbackup(self): # Do a system backup before update log.info(u'Config backup in progress...') ui.notifications.message('Backup', 'Config backup in progress...') try: backupDir = os.path.join(app.DATA_DIR, app.BACKUP_DIR) if not os.path.isdir(backupDir): os.mkdir(backupDir) if self._keeplatestbackup(backupDir) and self._backup(backupDir): log.info(u'Config backup successful, updating...') ui.notifications.message('Backup', 'Config backup successful, updating...') return True else: log.warning(u'Config backup failed, aborting update') ui.notifications.message('Backup', 'Config backup failed, aborting update') return False except Exception as e: log.error(u'Update: Config backup failed. Error: {0!r}', e) ui.notifications.message('Backup', 'Config backup failed, aborting update') return False @staticmethod def _keeplatestbackup(backupDir=None): if not backupDir: return False import glob files = glob.glob(os.path.join(backupDir, '*.zip')) if not files: return True now = time.time() newest = files[0], now - os.path.getctime(files[0]) for f in files[1:]: age = now - os.path.getctime(f) if age < newest[1]: newest = f, age files.remove(newest[0]) for f in files: os.remove(f) return True # TODO: Merge with backup in helpers @staticmethod def _backup(backupDir=None): if not backupDir: return False source = [ os.path.join(app.DATA_DIR, app.APPLICATION_DB), app.CONFIG_FILE, os.path.join(app.DATA_DIR, app.FAILED_DB), os.path.join(app.DATA_DIR, app.CACHE_DB) ] target = os.path.join(backupDir, app.BACKUP_FILENAME.format(timestamp=time.strftime('%Y%m%d%H%M%S'))) for (path, dirs, files) in os.walk(app.CACHE_DIR, topdown=True): for dirname in dirs: if path == app.CACHE_DIR and dirname not in ['images']: dirs.remove(dirname) for filename in files: source.append(os.path.join(path, filename)) return helpers.backup_config_zip(source, target, app.DATA_DIR) def safe_to_update(self): def db_safe(self): message = { 'equal': { 'type': DEBUG, 'text': u'We can proceed with the update. New update has same DB version'}, 'upgrade': { 'type': DEBUG, 'text': u'We can proceed with the update. New update has a new DB version'}, 'downgrade': { 'type': WARNING, 'text': u"We can't proceed with the update. New update has an old DB version. It's not possible to downgrade"}, } try: result = self.getDBcompare() if result in message: log.log(message[result]['type'], message[result]['text']) # unpack the result message into a log entry else: log.warning(u"We can't proceed with the update. Unable to check remote DB version. Error: {0}", result) return result in ['equal', 'upgrade'] # add future True results to the list except Exception as error: log.error(u"We can't proceed with the update. Unable to compare DB version. Error: {0!r}", error) return False def postprocessor_safe(): if not app.auto_post_processor_scheduler.action.amActive: log.debug(u'We can proceed with the update. Post-Processor is not running') return True else: log.debug(u"We can't proceed with the update. Post-Processor is running") return False def showupdate_safe(): if not app.show_update_scheduler.action.amActive: log.debug(u'We can proceed with the update. Shows are not being updated') return True else: log.debug(u"We can't proceed with the update. Shows are being updated") return False db_safe = db_safe(self) postprocessor_safe = postprocessor_safe() showupdate_safe = showupdate_safe() if db_safe and postprocessor_safe and showupdate_safe: log.debug(u'Proceeding with auto update') return True else: log.debug(u'Auto update aborted') return False def getDBcompare(self): """ Compare the current DB version with the new branch version. :return: 'upgrade', 'equal', or 'downgrade' """ try: self.updater.need_update() cur_hash = str(self.updater.newest_commit_hash) assert len(cur_hash) == 40, 'Commit hash wrong length: {length} hash: {hash}'.format( length=len(cur_hash), hash=cur_hash) check_url = 'http://rawcdn.githack.com/{org}/{repo}/{commit}/medusa/databases/main_db.py'.format( org=app.GIT_ORG, repo=app.GIT_REPO, commit=cur_hash) response = self.session.get(check_url) # Get remote DB version match_max_db = re.search(r'MAX_DB_VERSION\s*=\s*(?P<version>\d{2,3})', response.text) new_branch_major_db_version = int(match_max_db.group('version')) if match_max_db else None # Check local DB version main_db_con = db.DBConnection() cur_branch_major_db_version, cur_branch_minor_db_version = main_db_con.checkDBVersion() if any([cur_branch_major_db_version is None, cur_branch_minor_db_version is None, new_branch_major_db_version is None]): return 'Could not compare database versions, aborting' if new_branch_major_db_version > cur_branch_major_db_version: return 'upgrade' elif new_branch_major_db_version == cur_branch_major_db_version: return 'equal' else: return 'downgrade' except Exception as e: return repr(e) def find_install_type(self): """ Determine how this copy of Medusa was installed. :return: type of installation. Possible values are: 'docker': any docker build 'git': running from source using git 'source': running from source without git """ if self.runs_in_docker(): return DockerUpdateManager() elif os.path.isdir(os.path.join(app.PROG_DIR, u'.git')): return GitUpdateManager() return SourceUpdateManager() def check_for_new_version(self, force=False): """ Check the internet for a newer version. :force: if true the VERSION_NOTIFY setting will be ignored and a check will be forced :return: bool, True for new version or False for no new version. """ if not self.updater or (not app.VERSION_NOTIFY and not app.AUTO_UPDATE and not force): log.info(u'Version checking is disabled, not checking for the newest version') app.NEWEST_VERSION_STRING = None return False # checking for updates if not app.AUTO_UPDATE: log.info(u'Checking for updates using {0}', self.updater) if not self.updater.need_update(): app.NEWEST_VERSION_STRING = None if force: ui.notifications.message('No update needed') log.info(u'No update needed') # no updates needed return False # found updates return self.updater.can_update() def check_for_new_news(self, force=False): """ Check GitHub for the latest news. :return: unicode, a copy of the news :force: ignored """ # Grab a copy of the news log.debug(u'Checking GitHub for latest news.') response = self.session.get(app.NEWS_URL) if not response or not response.text: log.debug(u'Could not load news from URL: {0}', app.NEWS_URL) return try: last_read = datetime.datetime.strptime(app.NEWS_LAST_READ, '%Y-%m-%d') except ValueError: log.warning(u'Invalid news last read date: {0}', app.NEWS_LAST_READ) last_read = 0 news = response.text app.NEWS_UNREAD = 0 got_latest = False for match in re.finditer(r'^####\s*(\d{4}-\d{2}-\d{2})\s*####', news, re.M): if not got_latest: got_latest = True app.NEWS_LATEST = match.group(1) try: if datetime.datetime.strptime(match.group(1), '%Y-%m-%d') > last_read: app.NEWS_UNREAD += 1 except ValueError: log.warning(u'Unable to match latest news date. Repository news date: {0}', match.group(1)) pass return news def need_update(self): if self.updater: return self.updater.need_update() def update(self): if self.updater: # update branch with current config branch value self.updater.branch = app.BRANCH # check for updates if self.updater.need_update() and self.updater.can_update(): return self.updater.update() return False def list_remote_branches(self): if self.updater: app.GIT_REMOTE_BRANCHES = self.updater.list_remote_branches() return app.GIT_REMOTE_BRANCHES def get_branch(self): if self.updater: return self.updater.branch @staticmethod def runs_in_docker(): """ Check if Medusa is run in a docker container. If run in a container, we don't want to use the auto update feature, but just want to inform the user there is an update available. The user can update through getting the latest docker tag. """ if app.RUNS_IN_DOCKER is not None: return app.RUNS_IN_DOCKER path = '/proc/{pid}/cgroup'.format(pid=os.getpid()) try: if not os.path.isfile(path): return False with open(path) as f: for line in f: if re.match(r'\d+:[\w=]+:/docker(-[ce]e)?/\w+', line): log.debug(u'Running in a docker container') app.RUNS_IN_DOCKER = True return True return False except (EnvironmentError, OSError) as error: log.info(u'Tried to check the path {path} if we are running in a docker container, ' u'but an error occurred: {error}', {'path': path, 'error': error}) return False
class GenericProvider(object): """Generic provider.""" NZB = 'nzb' TORRENT = 'torrent' def __init__(self, name): """Initialize the class.""" self.name = name self.anime_only = False self.cache = tv.Cache(self) self.enable_backlog = False self.enable_manualsearch = False self.enable_daily = False self.enabled = False self.headers = {'User-Agent': USER_AGENT} self.proper_strings = ['PROPER|REPACK|REAL|RERIP'] self.provider_type = None self.public = False self.search_fallback = False self.search_mode = None self.session = MedusaSafeSession(cloudflare=True) self.session.headers.update(self.headers) self.series = None self.supports_absolute_numbering = False self.supports_backlog = True self.url = '' self.urls = {} # Ability to override the search separator. As for example anizb is using '*' instead of space. self.search_separator = ' ' self.season_templates = ( 'S{season:0>2}', # example: 'Series.Name.S03' ) # Use and configure the attribute enable_cookies to show or hide the cookies input field per provider self.enable_cookies = False self.cookies = '' # Paramaters for reducting the daily search results parsing self.max_recent_items = 5 self.stop_at = 3 # Delay downloads self.enable_search_delay = False self.search_delay = 480 # minutes @classmethod def kind(cls): """Return the name of the current class.""" return cls.__name__ def download_result(self, result): """Download result from provider.""" if not self.login(): return False urls, filename = self._make_url(result) for url in urls: if 'NO_DOWNLOAD_NAME' in url: continue if url.startswith('http'): self.headers.update({ 'Referer': '/'.join(url.split('/')[:3]) + '/' }) log.info('Downloading {result} from {provider} at {url}', {'result': result.name, 'provider': self.name, 'url': url}) verify = False if self.public else None if download_file(url, filename, session=self.session, headers=self.headers, verify=verify): if self._verify_download(filename): log.info('Saved {result} to {location}', {'result': result.name, 'location': filename}) return True log.warning('Failed to download any results for {result}', {'result': result.name}) return False def _make_url(self, result): """Return url if result is a magnet link.""" urls = [] filename = '' if not result or not result.url: return urls, filename urls = [result.url] result_name = sanitize_filename(result.name) # TODO: Remove this in future versions, kept for the warning # Some NZB providers (e.g. Jackett) can also download torrents # A similar check is performed for NZB splitting in medusa/search/core.py @ search_providers() if (result.url.endswith(GenericProvider.TORRENT) or result.url.startswith('magnet:')) and self.provider_type == GenericProvider.NZB: filename = join(app.TORRENT_DIR, result_name + '.torrent') log.warning('Using Jackett providers as Newznab providers is deprecated!' ' Switch them to Jackett providers as soon as possible.') else: filename = join(self._get_storage_dir(), result_name + '.' + self.provider_type) return urls, filename def _verify_download(self, file_name=None): return True def get_content(self, url, params=None, timeout=30, **kwargs): """Retrieve the torrent/nzb content.""" return self.session.get_content(url, params=params, timeout=timeout, **kwargs) def find_propers(self, proper_candidates): """Find propers in providers.""" results = [] for proper_candidate in proper_candidates: series_obj = Show.find_by_id(app.showList, proper_candidate['indexer'], proper_candidate['showid']) if series_obj: self.series = series_obj episode_obj = series_obj.get_episode(proper_candidate['season'], proper_candidate['episode']) for term in self.proper_strings: search_strings = self._get_episode_search_strings(episode_obj, add_string=term) for item in self.search(search_strings[0], ep_obj=episode_obj): search_result = self.get_result(series=series_obj, item=item) if search_result in results: continue search_result.search_type = PROPER_SEARCH results.append(search_result) return results def search_results_in_cache(self, episodes): """ Search episodes based on param in cache. Search the cache (db) for this provider :param episodes: List of Episode objects :return: A dict of search results, ordered by episode number """ return self.cache.find_episodes(episodes) def find_search_results(self, series, episodes, search_mode, forced_search=False, download_current_quality=False, manual_search=False, manual_search_type='episode'): """ Search episodes based on param. Search the provider using http queries. :param series: Series object :param episodes: List of Episode objects :param search_mode: 'eponly' or 'sponly' :param forced_search: Flag if the search was triggered by a forced search :param download_current_quality: Flag if we want to include an already downloaded quality in the new search :param manual_search: Flag if the search was triggered by a manual search :param manual_search_type: How the manual search was started: For example an 'episode' or 'season' :return: A dict of search results, ordered by episode number. """ self._check_auth() self.series = series season_search = (len(episodes) > 1 or manual_search_type == 'season') and search_mode == 'sponly' results = [] for episode in episodes: search_strings = [] if season_search: search_strings = self._get_season_search_strings(episode) elif search_mode == 'eponly': search_strings = self._get_episode_search_strings(episode) for search_string in search_strings: # Find results from the provider items = self.search(search_string, ep_obj=episode, manual_search=manual_search) for item in items: result = self.get_result(series=series, item=item) if result not in results: result.quality = Quality.quality_from_name(result.name, series.is_anime) results.append(result) # In season search, we can't loop in episodes lists as we # only need one episode to get the season string if search_mode == 'sponly': break log.debug('Found {0} unique search results', len(results)) # sort qualities in descending order results.sort(key=operator.attrgetter('quality'), reverse=True) # Move through each item and parse with NameParser() for search_result in results: if forced_search: search_result.search_type = FORCED_SEARCH search_result.download_current_quality = download_current_quality search_result.result_wanted = True try: search_result.parsed_result = NameParser( parse_method=('normal', 'anime')[series.is_anime]).parse( search_result.name) except (InvalidNameException, InvalidShowException) as error: log.debug('Error during parsing of release name: {release_name}, with error: {error}', {'release_name': search_result.name, 'error': error}) search_result.add_cache_entry = False search_result.result_wanted = False continue # I don't know why i'm doing this. Maybe remove it later on all together, now i've added the parsed_result # to the search_result. search_result.series = search_result.parsed_result.series search_result.quality = search_result.parsed_result.quality search_result.release_group = search_result.parsed_result.release_group search_result.version = search_result.parsed_result.version search_result.actual_season = search_result.parsed_result.season_number search_result.actual_episodes = search_result.parsed_result.episode_numbers if not manual_search: if not (search_result.series.air_by_date or search_result.series.sports): if search_mode == 'sponly': if search_result.parsed_result.episode_numbers: log.debug( 'This is supposed to be a season pack search but the result {0} is not a valid ' 'season pack, skipping it', search_result.name ) search_result.result_wanted = False continue elif not [ep for ep in episodes if search_result.parsed_result.season_number == (ep.season, ep.scene_season) [ep.series.is_scene]]: log.debug( 'This season result {0} is for a season we are not searching for, ' 'skipping it', search_result.name ) search_result.result_wanted = False continue else: # I'm going to split these up for better readability # Check if at least got a season parsed. if search_result.parsed_result.season_number is None: log.debug( "The result {0} doesn't seem to have a valid season that we are currently trying to " 'snatch, skipping it', search_result.name ) search_result.result_wanted = False continue # Check if we at least got some episode numbers parsed. if not search_result.parsed_result.episode_numbers: log.debug( "The result {0} doesn't seem to match an episode that we are currently trying to " 'snatch, skipping it', search_result.name ) search_result.result_wanted = False continue # Compare the episodes and season from the result with what was searched. wanted_ep = False for searched_ep in episodes: if searched_ep.series.is_scene: season = searched_ep.scene_season episode = searched_ep.scene_episode else: season = searched_ep.season episode = searched_ep.episode if (season == search_result.parsed_result.season_number and episode in search_result.parsed_result.episode_numbers): wanted_ep = True break if not wanted_ep: log.debug( "The result {0} doesn't seem to match an episode that we are currently trying to " 'snatch, skipping it', search_result.name ) search_result.result_wanted = False continue # We've performed some checks to decided if we want to continue with this result. # If we've hit this, that means this is not an air_by_date and not a sports show. And it seems to be # a valid result. Let's store the parsed season and episode number and continue. search_result.actual_season = search_result.parsed_result.season_number search_result.actual_episodes = search_result.parsed_result.episode_numbers else: # air_by_date or sportshow. search_result.same_day_special = False if not search_result.parsed_result.is_air_by_date: log.debug( "This is supposed to be a date search but the result {0} didn't parse as one, " 'skipping it', search_result.name ) search_result.result_wanted = False continue else: # Use a query against the tv_episodes table, to match the parsed air_date against. air_date = search_result.parsed_result.air_date.toordinal() db = DBConnection() sql_results = db.select( 'SELECT season, episode FROM tv_episodes WHERE indexer = ? AND showid = ? AND airdate = ?', [search_result.series.indexer, search_result.series.series_id, air_date] ) if len(sql_results) == 2: if int(sql_results[0]['season']) == 0 and int(sql_results[1]['season']) != 0: search_result.actual_season = int(sql_results[1]['season']) search_result.actual_episodes = [int(sql_results[1]['episode'])] search_result.same_day_special = True elif int(sql_results[1]['season']) == 0 and int(sql_results[0]['season']) != 0: search_result.actual_season = int(sql_results[0]['season']) search_result.actual_episodes = [int(sql_results[0]['episode'])] search_result.same_day_special = True elif len(sql_results) != 1: log.warning( "Tried to look up the date for the episode {0} but the database didn't return proper " 'results, skipping it', search_result.name ) search_result.result_wanted = False continue # @TODO: Need to verify and test this. if search_result.result_wanted and not search_result.same_day_special: search_result.actual_season = int(sql_results[0]['season']) search_result.actual_episodes = [int(sql_results[0]['episode'])] final_results = {} cl = [] # Iterate again over the search results, and see if there is anything we want. for search_result in results: # Try to cache the item if we want to. cache_result = search_result.add_result_to_cache(self.cache) if cache_result is not None: cl.append(cache_result) if not search_result.result_wanted: log.debug("We aren't interested in this result: {0} with url: {1}", search_result.name, search_result.url) continue log.debug('Found result {0} at {1}', search_result.name, search_result.url) search_result.update_search_result() if search_result.episode_number == SEASON_RESULT: log.debug('Found season pack result {0} at {1}', search_result.name, search_result.url) elif search_result.episode_number == MULTI_EP_RESULT: log.debug('Found multi-episode ({0}) result {1} at {2}', ', '.join(map(str, search_result.parsed_result.episode_numbers)), search_result.name, search_result.url) else: log.debug('Found single episode result {0} at {1}', search_result.name, search_result.url) if search_result.episode_number not in final_results: final_results[search_result.episode_number] = [search_result] else: final_results[search_result.episode_number].append(search_result) if cl: # Access to a protected member of a client class db = self.cache._get_db() db.mass_action(cl) return final_results def get_id(self): """Get ID of the provider.""" return GenericProvider.make_id(self.name) def get_result(self, series, item=None, cache=None): """Get result.""" search_result = SearchResult(provider=self, series=series, item=item, cache=cache) return search_result def image_name(self): """Return provider image name.""" return self.get_id() + '.png' def is_active(self): """Check if provider is active.""" return False def is_enabled(self): """Check if provider is enabled.""" return bool(self.enabled) @staticmethod def make_id(name): """Make ID of the provider.""" if not name: return '' return re.sub(r'[^\w\d_]', '_', str(name).strip().lower()) def seed_ratio(self): """Return ratio.""" return '' def _check_auth(self): """Check if we are autenticated.""" return True def login(self): """Login to provider.""" return True def search(self, search_strings, age=0, ep_obj=None, **kwargs): """Search the provider.""" return [] @staticmethod def parse_pubdate(pubdate, human_time=False, timezone=None, **kwargs): """ Parse publishing date into a datetime object. :param pubdate: date and time string :param human_time: string uses human slang ("4 hours ago") :param timezone: use a different timezone ("US/Eastern") :keyword dayfirst: Interpret the first value as the day :keyword yearfirst: Interpret the first value as the year :returns: a datetime object or None """ now_alias = ('right now', 'just now', 'now') df = kwargs.pop('dayfirst', False) yf = kwargs.pop('yearfirst', False) fromtimestamp = kwargs.pop('fromtimestamp', False) # This can happen from time to time if pubdate is None: log.debug('Skipping invalid publishing date.') return try: if human_time: if pubdate.lower() in now_alias: seconds = 0 else: match = re.search(r'(?P<time>[\d.]+\W*)(?P<granularity>\w+)', pubdate) matched_time = match.group('time') matched_granularity = match.group('granularity') # The parse method does not support decimals used with the month, # months, year or years granularities. if matched_granularity and matched_granularity in ('month', 'months', 'year', 'years'): matched_time = int(round(float(matched_time.strip()))) seconds = parse('{0} {1}'.format(matched_time, matched_granularity)) if seconds is None: log.warning('Failed parsing human time: {0} {1}', matched_time, matched_granularity) raise ValueError('Failed parsing human time: {0} {1}'.format(matched_time, matched_granularity)) return datetime.now(tz.tzlocal()) - timedelta(seconds=seconds) if fromtimestamp: dt = datetime.fromtimestamp(int(pubdate), tz=tz.gettz('UTC')) else: day_offset = 0 if 'yesterday at' in pubdate.lower() or 'today at' in pubdate.lower(): # Extract a time time = re.search(r'(?P<time>[0-9:]+)', pubdate) if time: if 'yesterday' in pubdate: day_offset = 1 pubdate = time.group('time').strip() dt = parser.parse(pubdate, dayfirst=df, yearfirst=yf, fuzzy=True) - timedelta(days=day_offset) # Always make UTC aware if naive if dt.tzinfo is None or dt.tzinfo.utcoffset(dt) is None: dt = dt.replace(tzinfo=tz.gettz('UTC')) if timezone: dt = dt.astimezone(tz.gettz(timezone)) return dt except (AttributeError, TypeError, ValueError): log.exception('Failed parsing publishing date: {0}', pubdate) def _create_air_by_date_search_string(self, show_scene_name, episode, search_string, add_string=None): """Create a search string used for series that are indexed by air date.""" episode_string = show_scene_name + self.search_separator episode_string += str(episode.airdate).replace('-', ' ') if add_string: episode_string += self.search_separator + add_string search_string['Episode'].append(episode_string.strip()) def _create_sports_search_string(self, show_scene_name, episode, search_string, add_string=None): """Create a search string used for sport series.""" episode_string = show_scene_name + self.search_separator episode_string += str(episode.airdate).replace('-', ' ') episode_string += ('|', ' ')[len(self.proper_strings) > 1] episode_string += episode.airdate.strftime('%b') if add_string: episode_string += self.search_separator + add_string search_string['Episode'].append(episode_string.strip()) def _create_anime_search_string(self, show_scene_name, episode, search_string, add_string=None): """Create a search string used for as anime 'marked' shows.""" episode_string = show_scene_name + self.search_separator # If the show name is a season scene exception, we want to use the episode number if episode.scene_season > 0 and show_scene_name in scene_exceptions.get_season_scene_exceptions( episode.series, episode.scene_season): # This is apparently a season exception, let's use the episode instead of absolute ep = episode.scene_episode else: ep = episode.scene_absolute_number if episode.series.is_scene else episode.absolute_number episode_string += '{episode:0>2}'.format(episode=ep) if add_string: episode_string += self.search_separator + add_string search_string['Episode'].append(episode_string.strip()) def _create_default_search_string(self, show_scene_name, episode, search_string, add_string=None): """Create a default search string, used for standard type S01E01 tv series.""" episode_string = show_scene_name + self.search_separator episode_string += config.naming_ep_type[2] % { 'seasonnumber': episode.scene_season if episode.series.is_scene else episode.season, 'episodenumber': episode.scene_episode if episode.series.is_scene else episode.episode, } if add_string: episode_string += self.search_separator + add_string search_string['Episode'].append(episode_string.strip()) def _get_episode_search_strings(self, episode, add_string=''): """Get episode search strings.""" if not episode: return [] search_string = { 'Episode': [] } all_possible_show_names = episode.series.get_all_possible_names() if episode.scene_season: all_possible_show_names = all_possible_show_names.union( episode.series.get_all_possible_names(season=episode.scene_season) ) for show_name in all_possible_show_names: if episode.series.air_by_date: self._create_air_by_date_search_string(show_name, episode, search_string, add_string=add_string) elif episode.series.sports: self._create_sports_search_string(show_name, episode, search_string, add_string=add_string) elif episode.series.anime: self._create_anime_search_string(show_name, episode, search_string, add_string=add_string) else: self._create_default_search_string(show_name, episode, search_string, add_string=add_string) return [search_string] def _get_tvdb_id(self): """Return the tvdb id if the shows indexer is tvdb. If not, try to use the externals to get it.""" if not self.series: return None return self.series.indexerid if self.series.indexer == INDEXER_TVDBV2 else self.series.externals.get('tvdb_id') def _get_season_search_strings(self, episode): search_string = { 'Season': [] } for show_name in episode.series.get_all_possible_names(season=episode.scene_season): episode_string = show_name + self.search_separator if episode.series.air_by_date or episode.series.sports: search_string['Season'].append(episode_string + str(episode.airdate).split('-')[0]) elif episode.series.anime: search_string['Season'].append(episode_string + 'Season') else: for season_template in self.season_templates: templated_episode_string = episode_string + season_template.format(season=episode.scene_season) search_string['Season'].append(templated_episode_string.strip()) return [search_string] def _get_size(self, item): """Return default size.""" return -1 def _get_storage_dir(self): """Return storage dir.""" return '' def _get_result_info(self, item): """Return default seeders and leechers.""" return -1, -1 def _get_pubdate(self, item): """Return publish date of the item. If provider doesnt have _get_pubdate function this will be used """ return None def _get_title_and_url(self, item): """Return title and url from result.""" if not item: return '', '' title = item.get('title', '') url = item.get('link', '') if title: title = title.replace(' ', '.') else: title = '' if url: url = url.replace('&', '&').replace('%26tr%3D', '&tr=') else: url = '' return title, url @staticmethod def _get_identifier(item): """ Return the identifier for the item. By default this is the url. Providers can overwrite this, when needed. """ return item.url @property def recent_results(self): """Return recent RSS results from provier.""" return recent_results.get(self.get_id(), []) @recent_results.setter def recent_results(self, items): """Set recent results from provider.""" if not recent_results.get(self.get_id()): recent_results.update({self.get_id(): []}) if items: add_to_list = [] for item in items: if item not in recent_results[self.get_id()]: add_to_list += [item] results = add_to_list + recent_results[self.get_id()] recent_results[self.get_id()] = results[:self.max_recent_items] def add_cookies_from_ui(self): """ Add the cookies configured from UI to the providers requests session. :return: A dict with the the keys result as bool and message as string """ # Added exception for rss torrent providers, as for them adding cookies initial should be optional. from medusa.providers.torrent.rss.rsstorrent import TorrentRssProvider if isinstance(self, TorrentRssProvider) and not self.cookies: return {'result': True, 'message': 'This is a TorrentRss provider without any cookies provided. ' 'Cookies for this provider are considered optional.'} # This is the generic attribute used to manually add cookies for provider authentication if not self.enable_cookies: return {'result': False, 'message': 'Adding cookies is not supported for provider: {0}'.format(self.name)} if not self.cookies: return {'result': False, 'message': 'No Cookies added from ui for provider: {0}'.format(self.name)} cookie_validator = re.compile(r'^([\w%]+=[\w%]+)(;[\w%]+=[\w%]+)*$') if not cookie_validator.match(self.cookies): ui.notifications.message( 'Failed to validate cookie for provider {provider}'.format(provider=self.name), 'Cookie is not correctly formatted: {0}'.format(self.cookies)) return {'result': False, 'message': 'Cookie is not correctly formatted: {0}'.format(self.cookies)} if self.required_cookies: if self.name == 'Beyond-HD': if not any('remember_web_' in x.rsplit('=', 1)[0] for x in self.cookies.split(';')): return { 'result': False, 'message': "You haven't configured the required cookies. Please login at {provider_url}, " 'and make sure you have copied the following cookies: {required_cookies!r}'.format( provider_url=self.name, required_cookies=self.required_cookies ) } else: if not all(req_cookie in [x.rsplit('=', 1)[0] for x in self.cookies.split(';')] for req_cookie in self.required_cookies): return { 'result': False, 'message': "You haven't configured the required cookies. Please login at {provider_url}, " 'and make sure you have copied the following cookies: {required_cookies!r}'.format( provider_url=self.name, required_cookies=self.required_cookies ) } # cookie_validator got at least one cookie key/value pair, let's return success add_dict_to_cookiejar(self.session.cookies, dict(x.rsplit('=', 1) for x in self.cookies.split(';'))) return {'result': True, 'message': ''} def check_required_cookies(self): """ Check if we have the required cookies in the requests sessions object. Meaning that we've already successfully authenticated once, and we don't need to go through this again. Note! This doesn't mean the cookies are correct! """ if not hasattr(self, 'required_cookies'): # A reminder for the developer, implementing cookie based authentication. log.error( 'You need to configure the required_cookies attribute, for the provider: {provider}', {'provider': self.name} ) return False return all(dict_from_cookiejar(self.session.cookies).get(cookie) for cookie in self.required_cookies) def cookie_login(self, check_login_text, check_url=None): """ Check the response for text that indicates a login prompt. In that case, the cookie authentication was not successful. :param check_login_text: A string that's visible when the authentication failed. :param check_url: The url to use to test the login with cookies. By default the providers home page is used. :return: False when authentication was not successful. True if successful. """ check_url = check_url or self.url if self.check_required_cookies(): # All required cookies have been found within the current session, we don't need to go through this again. return True if self.cookies: result = self.add_cookies_from_ui() if not result['result']: ui.notifications.message(result['message']) log.warning(result['message']) return False else: log.warning('Failed to login, you will need to add your cookies in the provider settings') ui.notifications.error('Failed to auth with {provider}'.format(provider=self.name), 'You will need to add your cookies in the provider settings') return False response = self.session.get(check_url) if not response or any([not (response.text and response.status_code == 200), check_login_text.lower() in response.text.lower()]): log.warning('Please configure the required cookies for this provider. Check your provider settings') ui.notifications.error('Wrong cookies for {provider}'.format(provider=self.name), 'Check your provider settings') self.session.cookies.clear() return False else: return True def __str__(self): """Return provider name and provider type.""" return '{provider_name} ({provider_type})'.format(provider_name=self.name, provider_type=self.provider_type) def __unicode__(self): """Return provider name and provider type.""" return '{provider_name} ({provider_type})'.format(provider_name=self.name, provider_type=self.provider_type) def to_json(self): """Return a json representation for a provider.""" from medusa.providers.torrent.torrent_provider import TorrentProvider return { 'name': self.name, 'id': self.get_id(), 'config': { 'enabled': self.enabled, 'search': { 'backlog': { 'enabled': self.enable_backlog }, 'manual': { 'enabled': self.enable_backlog }, 'daily': { 'enabled': self.enable_backlog, 'maxRecentItems': self.max_recent_items, 'stopAt': self.stop_at }, 'fallback': self.search_fallback, 'mode': self.search_mode, 'separator': self.search_separator, 'seasonTemplates': self.season_templates, 'delay': { 'enabled': self.enable_search_delay, 'duration': self.search_delay } } }, 'animeOnly': self.anime_only, 'type': self.provider_type, 'public': self.public, 'btCacheUrls': self.bt_cache_urls if isinstance(self, TorrentProvider) else [], 'properStrings': self.proper_strings, 'headers': self.headers, 'supportsAbsoluteNumbering': self.supports_absolute_numbering, 'supportsBacklog': self.supports_backlog, 'url': self.url, 'urls': self.urls, 'cookies': { 'enabled': self.enable_cookies, 'required': self.cookies } }
class GenericProvider(object): """Generic provider.""" NZB = 'nzb' TORRENT = 'torrent' def __init__(self, name): """Initialize the class.""" self.name = name self.anime_only = False self.bt_cache_urls = [ 'http://reflektor.karmorra.info/torrent/{info_hash}.torrent', 'https://asnet.pw/download/{info_hash}/', 'http://p2pdl.com/download/{info_hash}', 'http://itorrents.org/torrent/{info_hash}.torrent', 'http://thetorrent.org/torrent/{info_hash}.torrent', 'https://cache.torrentgalaxy.org/get/{info_hash}', 'https://www.seedpeer.me/torrent/{info_hash}', ] self.cache = tv.Cache(self) self.enable_backlog = False self.enable_manualsearch = False self.enable_daily = False self.enabled = False self.headers = {'User-Agent': USER_AGENT} self.proper_strings = ['PROPER|REPACK|REAL|RERIP'] self.provider_type = None self.public = False self.search_fallback = False self.search_mode = None self.session = MedusaSafeSession(cloudflare=True) self.session.headers.update(self.headers) self.series = None self.supports_absolute_numbering = False self.supports_backlog = True self.url = '' self.urls = {} # Ability to override the search separator. As for example anizb is using '*' instead of space. self.search_separator = ' ' self.season_templates = ( 'S{season:0>2}', # example: 'Series.Name.S03' ) # Use and configure the attribute enable_cookies to show or hide the cookies input field per provider self.enable_cookies = False self.cookies = '' # Paramaters for reducting the daily search results parsing self.max_recent_items = 5 self.stop_at = 3 # Delay downloads self.enable_search_delay = False self.search_delay = 480 # minutes @classmethod def kind(cls): """Return the name of the current class.""" return cls.__name__ def download_result(self, result): """Download result from provider.""" if not self.login(): return False urls, filename = self._make_url(result) for url in urls: if 'NO_DOWNLOAD_NAME' in url: continue if url.startswith('http'): self.headers.update({ 'Referer': '/'.join(url.split('/')[:3]) + '/' }) log.info('Downloading {result} from {provider} at {url}', {'result': result.name, 'provider': self.name, 'url': url}) verify = False if self.public else None if download_file(url, filename, session=self.session, headers=self.headers, verify=verify): if self._verify_download(filename): log.info('Saved {result} to {location}', {'result': result.name, 'location': filename}) return True log.warning('Failed to download any results for {result}', {'result': result.name}) return False def _make_url(self, result): """Return url if result is a magnet link.""" urls = [] filename = '' if not result or not result.url: return urls, filename urls = [result.url] result_name = sanitize_filename(result.name) # TODO: Remove this in future versions, kept for the warning # Some NZB providers (e.g. Jackett) can also download torrents # A similar check is performed for NZB splitting in medusa/search/core.py @ search_providers() if (result.url.endswith(GenericProvider.TORRENT) or result.url.startswith('magnet:')) and self.provider_type == GenericProvider.NZB: filename = join(app.TORRENT_DIR, result_name + '.torrent') log.warning('Using Jackett providers as Newznab providers is deprecated!' ' Switch them to Jackett providers as soon as possible.') else: filename = join(self._get_storage_dir(), result_name + '.' + self.provider_type) return urls, filename def _verify_download(self, file_name=None): return True def get_content(self, url, params=None, timeout=30, **kwargs): """Retrieve the torrent/nzb content.""" return self.session.get_content(url, params=params, timeout=timeout, **kwargs) def find_propers(self, proper_candidates): """Find propers in providers.""" results = [] for proper_candidate in proper_candidates: series_obj = Show.find_by_id(app.showList, proper_candidate['indexer'], proper_candidate['showid']) if series_obj: self.series = series_obj episode_obj = series_obj.get_episode(proper_candidate['season'], proper_candidate['episode']) for term in self.proper_strings: search_strings = self._get_episode_search_strings(episode_obj, add_string=term) for item in self.search(search_strings[0], ep_obj=episode_obj): search_result = self.get_result() results.append(search_result) search_result.name, search_result.url = self._get_title_and_url(item) search_result.seeders, search_result.leechers = self._get_result_info(item) search_result.size = self._get_size(item) search_result.pubdate = self._get_pubdate(item) # This will be retrieved from the parser search_result.proper_tags = '' search_result.search_type = PROPER_SEARCH search_result.date = datetime.today() search_result.series = series_obj return results @staticmethod def remove_duplicate_mappings(items, pk='link'): """ Remove duplicate items from an iterable of mappings. :param items: An iterable of mappings :param pk: Primary key for removing duplicates :return: An iterable of unique mappings """ return list( itervalues(OrderedDict( (item[pk], item) for item in items )) ) def search_results_in_cache(self, episodes): """ Search episodes based on param in cache. Search the cache (db) for this provider :param episodes: List of Episode objects :return: A dict of search results, ordered by episode number """ return self.cache.find_episodes(episodes) def find_search_results(self, series, episodes, search_mode, forced_search=False, download_current_quality=False, manual_search=False, manual_search_type='episode'): """ Search episodes based on param. Search the provider using http queries. :param series: Series object :param episodes: List of Episode objects :param search_mode: 'eponly' or 'sponly' :param forced_search: Flag if the search was triggered by a forced search :param download_current_quality: Flag if we want to include an already downloaded quality in the new search :param manual_search: Flag if the search was triggered by a manual search :param manual_search_type: How the manual search was started: For example an 'episode' or 'season' :return: A dict of search results, ordered by episode number. """ self._check_auth() self.series = series results = {} items_list = [] season_search = (len(episodes) > 1 or manual_search_type == 'season') and search_mode == 'sponly' for episode in episodes: search_strings = [] if season_search: search_strings = self._get_season_search_strings(episode) elif search_mode == 'eponly': search_strings = self._get_episode_search_strings(episode) for search_string in search_strings: # Find results from the provider items_list += self.search( search_string, ep_obj=episode, manual_search=manual_search ) # In season search, we can't loop in episodes lists as we # only need one episode to get the season string if search_mode == 'sponly': break # Remove duplicate items unique_items = self.remove_duplicate_mappings(items_list) log.debug('Found {0} unique items', len(unique_items)) # categorize the items into lists by quality categorized_items = defaultdict(list) for item in unique_items: quality = self.get_quality(item, anime=series.is_anime) categorized_items[quality].append(item) # sort qualities in descending order sorted_qualities = sorted(categorized_items, reverse=True) log.debug('Found qualities: {0}', sorted_qualities) # chain items sorted by quality sorted_items = chain.from_iterable( categorized_items[quality] for quality in sorted_qualities ) # unpack all of the quality lists into a single sorted list items_list = list(sorted_items) # Move through each item and parse it into a quality search_results = [] for item in items_list: # Make sure we start with a TorrentSearchResult, NZBDataSearchResult or NZBSearchResult search result obj. search_result = self.get_result() search_results.append(search_result) search_result.item = item search_result.download_current_quality = download_current_quality # FIXME: Should be changed to search_result.search_type search_result.forced_search = forced_search (search_result.name, search_result.url) = self._get_title_and_url(item) (search_result.seeders, search_result.leechers) = self._get_result_info(item) search_result.size = self._get_size(item) search_result.pubdate = self._get_pubdate(item) search_result.result_wanted = True try: search_result.parsed_result = NameParser( parse_method=('normal', 'anime')[series.is_anime]).parse( search_result.name) except (InvalidNameException, InvalidShowException) as error: log.debug('Error during parsing of release name: {release_name}, with error: {error}', {'release_name': search_result.name, 'error': error}) search_result.add_cache_entry = False search_result.result_wanted = False continue # I don't know why i'm doing this. Maybe remove it later on all together, now i've added the parsed_result # to the search_result. search_result.series = search_result.parsed_result.series search_result.quality = search_result.parsed_result.quality search_result.release_group = search_result.parsed_result.release_group search_result.version = search_result.parsed_result.version search_result.actual_season = search_result.parsed_result.season_number search_result.actual_episodes = search_result.parsed_result.episode_numbers if not manual_search: if not (search_result.series.air_by_date or search_result.series.sports): if search_mode == 'sponly': if search_result.parsed_result.episode_numbers: log.debug( 'This is supposed to be a season pack search but the result {0} is not a valid ' 'season pack, skipping it', search_result.name ) search_result.result_wanted = False continue elif not [ep for ep in episodes if search_result.parsed_result.season_number == (ep.season, ep.scene_season) [ep.series.is_scene]]: log.debug( 'This season result {0} is for a season we are not searching for, ' 'skipping it', search_result.name ) search_result.result_wanted = False continue else: # I'm going to split these up for better readability # Check if at least got a season parsed. if search_result.parsed_result.season_number is None: log.debug( "The result {0} doesn't seem to have a valid season that we are currently trying to " 'snatch, skipping it', search_result.name ) search_result.result_wanted = False continue # Check if we at least got some episode numbers parsed. if not search_result.parsed_result.episode_numbers: log.debug( "The result {0} doesn't seem to match an episode that we are currently trying to " 'snatch, skipping it', search_result.name ) search_result.result_wanted = False continue # Compare the episodes and season from the result with what was searched. if not [searched_episode for searched_episode in episodes if searched_episode.season == search_result.parsed_result.season_number and (searched_episode.episode, searched_episode.scene_episode) [searched_episode.series.is_scene] in search_result.parsed_result.episode_numbers]: log.debug( "The result {0} doesn't seem to match an episode that we are currently trying to " 'snatch, skipping it', search_result.name ) search_result.result_wanted = False continue # We've performed some checks to decided if we want to continue with this result. # If we've hit this, that means this is not an air_by_date and not a sports show. And it seems to be # a valid result. Let's store the parsed season and episode number and continue. search_result.actual_season = search_result.parsed_result.season_number search_result.actual_episodes = search_result.parsed_result.episode_numbers else: # air_by_date or sportshow. search_result.same_day_special = False if not search_result.parsed_result.is_air_by_date: log.debug( "This is supposed to be a date search but the result {0} didn't parse as one, " 'skipping it', search_result.name ) search_result.result_wanted = False continue else: # Use a query against the tv_episodes table, to match the parsed air_date against. air_date = search_result.parsed_result.air_date.toordinal() db = DBConnection() sql_results = db.select( 'SELECT season, episode FROM tv_episodes WHERE indexer = ? AND showid = ? AND airdate = ?', [search_result.series.indexer, search_result.series.series_id, air_date] ) if len(sql_results) == 2: if int(sql_results[0]['season']) == 0 and int(sql_results[1]['season']) != 0: search_result.actual_season = int(sql_results[1]['season']) search_result.actual_episodes = [int(sql_results[1]['episode'])] search_result.same_day_special = True elif int(sql_results[1]['season']) == 0 and int(sql_results[0]['season']) != 0: search_result.actual_season = int(sql_results[0]['season']) search_result.actual_episodes = [int(sql_results[0]['episode'])] search_result.same_day_special = True elif len(sql_results) != 1: log.warning( "Tried to look up the date for the episode {0} but the database didn't return proper " 'results, skipping it', search_result.name ) search_result.result_wanted = False continue # @TODO: Need to verify and test this. if search_result.result_wanted and not search_result.same_day_special: search_result.actual_season = int(sql_results[0]['season']) search_result.actual_episodes = [int(sql_results[0]['episode'])] cl = [] # Iterate again over the search results, and see if there is anything we want. for search_result in search_results: # Try to cache the item if we want to. cache_result = search_result.add_result_to_cache(self.cache) if cache_result is not None: cl.append(cache_result) if not search_result.result_wanted: log.debug("We aren't interested in this result: {0} with url: {1}", search_result.name, search_result.url) continue log.debug('Found result {0} at {1}', search_result.name, search_result.url) search_result.create_episode_object() # result = self.get_result(episode_object, search_result) search_result.finish_search_result(self) if not search_result.actual_episodes: episode_number = SEASON_RESULT log.debug('Found season pack result {0} at {1}', search_result.name, search_result.url) elif len(search_result.actual_episodes) == 1: episode_number = search_result.actual_episode log.debug('Found single episode result {0} at {1}', search_result.name, search_result.url) else: episode_number = MULTI_EP_RESULT log.debug('Found multi-episode ({0}) result {1} at {2}', ', '.join(map(str, search_result.parsed_result.episode_numbers)), search_result.name, search_result.url) if episode_number not in results: results[episode_number] = [search_result] else: results[episode_number].append(search_result) if cl: # Access to a protected member of a client class db = self.cache._get_db() db.mass_action(cl) return results def get_id(self): """Get ID of the provider.""" return GenericProvider.make_id(self.name) def get_quality(self, item, anime=False): """Get quality of the result from its name.""" (title, _) = self._get_title_and_url(item) quality = Quality.quality_from_name(title, anime) return quality def get_result(self, episodes=None): """Get result.""" return self._get_result(episodes) def image_name(self): """Return provider image name.""" return self.get_id() + '.png' def is_active(self): """Check if provider is active.""" return False def is_enabled(self): """Check if provider is enabled.""" return bool(self.enabled) @staticmethod def make_id(name): """Make ID of the provider.""" if not name: return '' return re.sub(r'[^\w\d_]', '_', str(name).strip().lower()) def seed_ratio(self): """Return ratio.""" return '' def _check_auth(self): """Check if we are autenticated.""" return True def login(self): """Login to provider.""" return True def search(self, search_strings, age=0, ep_obj=None, **kwargs): """Search the provider.""" return [] @staticmethod def parse_pubdate(pubdate, human_time=False, timezone=None, **kwargs): """ Parse publishing date into a datetime object. :param pubdate: date and time string :param human_time: string uses human slang ("4 hours ago") :param timezone: use a different timezone ("US/Eastern") :keyword dayfirst: Interpret the first value as the day :keyword yearfirst: Interpret the first value as the year :returns: a datetime object or None """ now_alias = ('right now', 'just now', 'now') df = kwargs.pop('dayfirst', False) yf = kwargs.pop('yearfirst', False) fromtimestamp = kwargs.pop('fromtimestamp', False) # This can happen from time to time if pubdate is None: log.debug('Skipping invalid publishing date.') return try: if human_time: if pubdate.lower() in now_alias: seconds = 0 else: match = re.search(r'(?P<time>[\d.]+\W*)(?P<granularity>\w+)', pubdate) matched_time = match.group('time') matched_granularity = match.group('granularity') # The parse method does not support decimals used with the month, # months, year or years granularities. if matched_granularity and matched_granularity in ('month', 'months', 'year', 'years'): matched_time = int(round(float(matched_time.strip()))) seconds = parse('{0} {1}'.format(matched_time, matched_granularity)) if seconds is None: log.warning('Failed parsing human time: {0} {1}', matched_time, matched_granularity) raise ValueError('Failed parsing human time: {0} {1}'.format(matched_time, matched_granularity)) return datetime.now(tz.tzlocal()) - timedelta(seconds=seconds) if fromtimestamp: dt = datetime.fromtimestamp(int(pubdate), tz=tz.gettz('UTC')) else: day_offset = 0 if 'yesterday at' in pubdate.lower() or 'today at' in pubdate.lower(): # Extract a time time = re.search(r'(?P<time>[0-9:]+)', pubdate) if time: if 'yesterday' in pubdate: day_offset = 1 pubdate = time.group('time').strip() dt = parser.parse(pubdate, dayfirst=df, yearfirst=yf, fuzzy=True) - timedelta(days=day_offset) # Always make UTC aware if naive if dt.tzinfo is None or dt.tzinfo.utcoffset(dt) is None: dt = dt.replace(tzinfo=tz.gettz('UTC')) if timezone: dt = dt.astimezone(tz.gettz(timezone)) return dt except (AttributeError, TypeError, ValueError): log.exception('Failed parsing publishing date: {0}', pubdate) def _get_result(self, episodes=None): """Get result.""" return SearchResult(episodes) def _create_air_by_date_search_string(self, show_scene_name, episode, search_string, add_string=None): """Create a search string used for series that are indexed by air date.""" episode_string = show_scene_name + self.search_separator episode_string += str(episode.airdate).replace('-', ' ') if add_string: episode_string += self.search_separator + add_string search_string['Episode'].append(episode_string.strip()) def _create_sports_search_string(self, show_scene_name, episode, search_string, add_string=None): """Create a search string used for sport series.""" episode_string = show_scene_name + self.search_separator episode_string += str(episode.airdate).replace('-', ' ') episode_string += ('|', ' ')[len(self.proper_strings) > 1] episode_string += episode.airdate.strftime('%b') if add_string: episode_string += self.search_separator + add_string search_string['Episode'].append(episode_string.strip()) def _create_anime_search_string(self, show_scene_name, episode, search_string, add_string=None): """Create a search string used for as anime 'marked' shows.""" episode_string = show_scene_name + self.search_separator # If the show name is a season scene exception, we want to use the indexer episode number. if (episode.scene_season > 1 and show_scene_name in scene_exceptions.get_season_scene_exceptions(episode.series, episode.scene_season)): # This is apparently a season exception, let's use the scene_episode instead of absolute ep = episode.scene_episode else: ep = episode.scene_absolute_number episode_string += '{episode:0>2}'.format(episode=ep) episode_string_fallback = episode_string + '{episode:0>3}'.format(episode=ep) if add_string: episode_string += self.search_separator + add_string episode_string_fallback += self.search_separator + add_string search_string['Episode'].append(episode_string.strip()) def _create_default_search_string(self, show_scene_name, episode, search_string, add_string=None): """Create a default search string, used for standard type S01E01 tv series.""" episode_string = show_scene_name + self.search_separator episode_string += config.naming_ep_type[2] % { 'seasonnumber': episode.scene_season, 'episodenumber': episode.scene_episode, } if add_string: episode_string += self.search_separator + add_string search_string['Episode'].append(episode_string.strip()) def _get_episode_search_strings(self, episode, add_string=''): """Get episode search strings.""" if not episode: return [] search_string = { 'Episode': [] } all_possible_show_names = episode.series.get_all_possible_names() if episode.scene_season: all_possible_show_names = all_possible_show_names.union( episode.series.get_all_possible_names(season=episode.scene_season) ) for show_name in all_possible_show_names: if episode.series.air_by_date: self._create_air_by_date_search_string(show_name, episode, search_string, add_string=add_string) elif episode.series.sports: self._create_sports_search_string(show_name, episode, search_string, add_string=add_string) elif episode.series.anime: self._create_anime_search_string(show_name, episode, search_string, add_string=add_string) else: self._create_default_search_string(show_name, episode, search_string, add_string=add_string) return [search_string] def _get_tvdb_id(self): """Return the tvdb id if the shows indexer is tvdb. If not, try to use the externals to get it.""" if not self.series: return None return self.series.indexerid if self.series.indexer == INDEXER_TVDBV2 else self.series.externals.get('tvdb_id') def _get_season_search_strings(self, episode): search_string = { 'Season': [] } for show_name in episode.series.get_all_possible_names(season=episode.scene_season): episode_string = show_name + self.search_separator if episode.series.air_by_date or episode.series.sports: search_string['Season'].append(episode_string + str(episode.airdate).split('-')[0]) elif episode.series.anime: search_string['Season'].append(episode_string + 'Season') else: for season_template in self.season_templates: templated_episode_string = episode_string + season_template.format(season=episode.scene_season) search_string['Season'].append(templated_episode_string.strip()) return [search_string] def _get_size(self, item): """Return default size.""" return -1 def _get_storage_dir(self): """Return storage dir.""" return '' def _get_result_info(self, item): """Return default seeders and leechers.""" return -1, -1 def _get_pubdate(self, item): """Return publish date of the item. If provider doesnt have _get_pubdate function this will be used """ return None def _get_title_and_url(self, item): """Return title and url from result.""" if not item: return '', '' title = item.get('title', '') url = item.get('link', '') if title: title = title.replace(' ', '.') else: title = '' if url: url = url.replace('&', '&').replace('%26tr%3D', '&tr=') else: url = '' return title, url @property def recent_results(self): """Return recent RSS results from provier.""" return recent_results.get(self.get_id(), []) @recent_results.setter def recent_results(self, items): """Set recent results from provider.""" if not recent_results.get(self.get_id()): recent_results.update({self.get_id(): []}) if items: add_to_list = [] for item in items: if item['link'] not in {cache_item['link'] for cache_item in recent_results[self.get_id()]}: add_to_list += [item] results = add_to_list + recent_results[self.get_id()] recent_results[self.get_id()] = results[:self.max_recent_items] def add_cookies_from_ui(self): """ Add the cookies configured from UI to the providers requests session. :return: A dict with the the keys result as bool and message as string """ # Added exception for rss torrent providers, as for them adding cookies initial should be optional. from medusa.providers.torrent.rss.rsstorrent import TorrentRssProvider if isinstance(self, TorrentRssProvider) and not self.cookies: return {'result': True, 'message': 'This is a TorrentRss provider without any cookies provided. ' 'Cookies for this provider are considered optional.'} # This is the generic attribute used to manually add cookies for provider authentication if not self.enable_cookies: return {'result': False, 'message': 'Adding cookies is not supported for provider: {0}'.format(self.name)} if not self.cookies: return {'result': False, 'message': 'No Cookies added from ui for provider: {0}'.format(self.name)} cookie_validator = re.compile(r'^([\w%]+=[\w%]+)(;[\w%]+=[\w%]+)*$') if not cookie_validator.match(self.cookies): ui.notifications.message( 'Failed to validate cookie for provider {provider}'.format(provider=self.name), 'Cookie is not correctly formatted: {0}'.format(self.cookies)) return {'result': False, 'message': 'Cookie is not correctly formatted: {0}'.format(self.cookies)} if not all(req_cookie in [x.rsplit('=', 1)[0] for x in self.cookies.split(';')] for req_cookie in self.required_cookies): return { 'result': False, 'message': "You haven't configured the requied cookies. Please login at {provider_url}, " 'and make sure you have copied the following cookies: {required_cookies!r}' .format(provider_url=self.name, required_cookies=self.required_cookies) } # cookie_validator got at least one cookie key/value pair, let's return success add_dict_to_cookiejar(self.session.cookies, dict(x.rsplit('=', 1) for x in self.cookies.split(';'))) return {'result': True, 'message': ''} def check_required_cookies(self): """ Check if we have the required cookies in the requests sessions object. Meaning that we've already successfully authenticated once, and we don't need to go through this again. Note! This doesn't mean the cookies are correct! """ if not hasattr(self, 'required_cookies'): # A reminder for the developer, implementing cookie based authentication. log.error( 'You need to configure the required_cookies attribute, for the provider: {provider}', {'provider': self.name} ) return False return all(dict_from_cookiejar(self.session.cookies).get(cookie) for cookie in self.required_cookies) def cookie_login(self, check_login_text, check_url=None): """ Check the response for text that indicates a login prompt. In that case, the cookie authentication was not successful. :param check_login_text: A string that's visible when the authentication failed. :param check_url: The url to use to test the login with cookies. By default the providers home page is used. :return: False when authentication was not successful. True if successful. """ check_url = check_url or self.url if self.check_required_cookies(): # All required cookies have been found within the current session, we don't need to go through this again. return True if self.cookies: result = self.add_cookies_from_ui() if not result['result']: ui.notifications.message(result['message']) log.warning(result['message']) return False else: log.warning('Failed to login, you will need to add your cookies in the provider settings') ui.notifications.error('Failed to auth with {provider}'.format(provider=self.name), 'You will need to add your cookies in the provider settings') return False response = self.session.get(check_url) if not response or any([not (response.text and response.status_code == 200), check_login_text.lower() in response.text.lower()]): log.warning('Please configure the required cookies for this provider. Check your provider settings') ui.notifications.error('Wrong cookies for {provider}'.format(provider=self.name), 'Check your provider settings') self.session.cookies.clear() return False else: return True def __str__(self): """Return provider name and provider type.""" return '{provider_name} ({provider_type})'.format(provider_name=self.name, provider_type=self.provider_type) def __unicode__(self): """Return provider name and provider type.""" return '{provider_name} ({provider_type})'.format(provider_name=self.name, provider_type=self.provider_type)