Adding SpeedCD provider

Cherrypicking from mr-orange's fork
This is 30d8807d74

Closes #47

gui/slick/interfaces/default/config_providers.tmpl

@@ -115,7 +115,7 @@ var show_nzb_providers = #if $sickbeard.USE_NZBS then "true" else "false"#;
                                 <span class="component-title jumbo">Configure Provider:</span>
                                 <span class="component-desc">
                                     #set $provider_config_list = []
-                                    #for $cur_provider in ("thepiratebay", "tvtorrents", "btn", "torrentleech", "iptorrents", "omgwtfnzbs", "kickasstorrents", "sceneaccess", "hdbits", "nextgen"):
+                                    #for $cur_provider in ("thepiratebay", "tvtorrents", "btn", "torrentleech", "iptorrents", "omgwtfnzbs", "kickasstorrents", "sceneaccess", "hdbits", "nextgen", "speedcd"):
                                         #set $cur_provider_obj = $sickbeard.providers.getProviderClass($cur_provider)
                                         #if $cur_provider_obj.providerType == $GenericProvider.NZB and not $sickbeard.USE_NZBS:
                                         	#continue
@@ -386,6 +386,28 @@ var show_nzb_providers = #if $sickbeard.USE_NZBS then "true" else "false"#;
                         </div>
                     </div><!-- /hdbitsDiv //-->   
 
+                    <div class="providerDiv" id="speedcdDiv">
+                        <div class="field-pair">
+                            <label class="clearfix">
+                                <span class="component-title">Username:</span>
+                                <input class="component-desc" type="text" name="speedcd_username" value="$sickbeard.SPEEDCD_USERNAME" size="40" />
+                            </label>
+                        </div>
+                        <div class="field-pair">
+                            <label class="clearfix">
+                                <span class="component-title">Password:</span>
+                                <input class="component-desc" type="password" name="speedcd_password" value="$sickbeard.SPEEDCD_PASSWORD" size="40" />
+                            </label>
+                        </div>
+                        <div class="field-pair">
+                            <input type="checkbox" name="speedcd_freeleech" id="speedcd_freeleech" #if $sickbeard.SPEEDCD_FREELEECH then "checked=\"checked\"" else ""#/>
+                            <label class="clearfix" for="iptorrents_freeleech">
+                                <span class="component-title">FreeLeech</span>
+                                <span class="component-desc">This will only download <b>[FreeLeech]</b> torrents.</span>
+                            </label>
+                        </div>
+                    </div><!-- /speedcdDiv //-->
+
 <!-- end div for editing providers -->
 
                     <input type="submit" class="btn config_submitter" value="Save Changes" /><br/>

sickbeard/__init__.py

@@ -464,7 +464,7 @@ def initialize(consoleLogging=True):
             THEPIRATEBAY, THEPIRATEBAY_TRUSTED, THEPIRATEBAY_PROXY, THEPIRATEBAY_PROXY_URL, THEPIRATEBAY_BLACKLIST, THEPIRATEBAY_OPTIONS, TORRENTLEECH, TORRENTLEECH_USERNAME, TORRENTLEECH_PASSWORD, TORRENTLEECH_OPTIONS, \
             IPTORRENTS, IPTORRENTS_USERNAME, IPTORRENTS_PASSWORD, IPTORRENTS_FREELEECH, IPTORRENTS_OPTIONS, KAT, KAT_VERIFIED, KAT_OPTIONS, PUBLICHD, PUBLICHD_OPTIONS, SCC, SCC_USERNAME, SCC_PASSWORD, SCC_OPTIONS, HDTORRENTS, HDTORRENTS_USERNAME, HDTORRENTS_PASSWORD, HDTORRENTS_UID, HDTORRENTS_HASH, HDTORRENTS_OPTIONS, TORRENTDAY, TORRENTDAY_USERNAME, TORRENTDAY_PASSWORD, TORRENTDAY_UID, TORRENTDAY_HASH, TORRENTDAY_FREELEECH, TORRENTDAY_OPTIONS, \
             HDBITS, HDBITS_USERNAME, HDBITS_PASSKEY, HDBITS_OPTIONS, TORRENT_DIR, USENET_RETENTION, SOCKET_TIMEOUT, SEARCH_FREQUENCY, DEFAULT_SEARCH_FREQUENCY, BACKLOG_SEARCH_FREQUENCY, \
-            NEXTGEN, NEXTGEN_USERNAME, NEXTGEN_PASSWORD, NEXTGEN_FREELEECH, NEXTGEN_OPTIONS, \
+            NEXTGEN, NEXTGEN_USERNAME, NEXTGEN_PASSWORD, NEXTGEN_FREELEECH, NEXTGEN_OPTIONS, SPEEDCD, SPEEDCD_USERNAME, SPEEDCD_PASSWORD, SPEEDCD_FREELEECH,\
             QUALITY_DEFAULT, FLATTEN_FOLDERS_DEFAULT, SUBTITLES_DEFAULT, STATUS_DEFAULT, \
             GROWL_NOTIFY_ONSNATCH, GROWL_NOTIFY_ONDOWNLOAD, GROWL_NOTIFY_ONSUBTITLEDOWNLOAD, TWITTER_NOTIFY_ONSNATCH, TWITTER_NOTIFY_ONDOWNLOAD, TWITTER_NOTIFY_ONSUBTITLEDOWNLOAD, \
             USE_GROWL, GROWL_HOST, GROWL_PASSWORD, USE_PROWL, PROWL_NOTIFY_ONSNATCH, PROWL_NOTIFY_ONDOWNLOAD, PROWL_NOTIFY_ONSUBTITLEDOWNLOAD, PROWL_API, PROWL_PRIORITY, PROG_DIR, \
@@ -699,6 +699,11 @@ def initialize(consoleLogging=True):
         HDBITS_PASSKEY = check_setting_str(CFG, 'HDBITS', 'hdbits_passkey', '')
         HDBITS_OPTIONS = check_setting_str(CFG, 'HDBITS', 'hdbits_options', '')
 
+        SPEEDCD = bool(check_setting_int(CFG, 'SPEEDCD', 'speedcd', 0))
+        SPEEDCD_USERNAME = check_setting_str(CFG, 'SPEEDCD', 'speedcd_username', '')
+        SPEEDCD_PASSWORD = check_setting_str(CFG, 'SPEEDCD', 'speedcd_password', '')
+        SPEEDCD_FREELEECH = bool(check_setting_int(CFG, 'SPEEDCD', 'speedcd_freeleech', 0))
+
         NZBS = bool(check_setting_int(CFG, 'NZBs', 'nzbs', 0))
         NZBS_UID = check_setting_str(CFG, 'NZBs', 'nzbs_uid', '')
         NZBS_HASH = check_setting_str(CFG, 'NZBs', 'nzbs_hash', '')
@@ -1410,6 +1415,12 @@ def save_config():
     new_config['HDBITS']['hdbits_passkey'] = HDBITS_PASSKEY
     new_config['HDBITS']['hdbits_options'] = HDBITS_OPTIONS
 
+    new_config['SPEEDCD'] = {}
+    new_config['SPEEDCD']['speedcd'] = int(SPEEDCD)
+    new_config['SPEEDCD']['speedcd_username'] = SPEEDCD_USERNAME
+    new_config['SPEEDCD']['speedcd_password'] = helpers.encrypt(SPEEDCD_PASSWORD, ENCRYPTION_VERSION)
+    new_config['SPEEDCD']['speedcd_freeleech'] = int(SPEEDCD_FREELEECH)
+
     new_config['NZBs'] = {}
     new_config['NZBs']['nzbs'] = int(NZBS)
     new_config['NZBs']['nzbs_uid'] = NZBS_UID

sickbeard/providers/__init__.py

@@ -30,7 +30,8 @@ __all__ = ['ezrss',
            'hdbits',
            'iptorrents',
            'omgwtfnzbs',
-           'nextgen'
+           'nextgen',
+           'speedcd'
 ]
 
 import sickbeard

sickbeard/providers/speedcd.py

@@ -0,0 +1,292 @@
+# Author: Mr_Orange
+# URL: https://github.com/mr-orange/Sick-Beard
+#
+# This file is part of Sick Beard.
+#
+# Sick Beard is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# Sick Beard is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Sick Beard.  If not, see <http://www.gnu.org/licenses/>.
+
+import re
+import datetime
+
+import sickbeard
+import generic
+from sickbeard.common import Quality
+from sickbeard import logger
+from sickbeard import tvcache
+from sickbeard import db
+from sickbeard import classes
+from sickbeard import helpers
+from sickbeard import show_name_helpers
+from sickbeard.common import Overview
+from sickbeard.exceptions import ex
+from sickbeard import clients
+from lib import requests
+
+
+class SpeedCDProvider(generic.TorrentProvider):
+
+    urls = {'base_url': 'http://speed.cd/',
+            'login': 'http://speed.cd/takelogin.php',
+            'detail': 'http://speed.cd/t/%s',
+            'search': 'http://speed.cd/V3/API/API.php',
+            'download': 'http://speed.cd/download.php?torrent=%s',
+            }
+
+    def __init__(self):
+
+        generic.TorrentProvider.__init__(self, "Speedcd")
+
+        self.supportsBacklog = True
+
+        self.cache = SpeedCDCache(self)
+
+        self.url = self.urls['base_url']
+
+        self.categories = {'Season': {'c14':1}, 'Episode': {'c2':1, 'c49':1}, 'RSS': {'c14':1, 'c2':1, 'c49':1}}
+
+        self.session = None
+
+    def isEnabled(self):
+        return sickbeard.SPEEDCD
+
+    def imageName(self):
+        return 'speedcd.png'
+
+    def getQuality(self, item):
+
+        quality = Quality.sceneQuality(item[0])
+        return quality
+
+    def _doLogin(self):
+
+        login_params = {'username': sickbeard.SPEEDCD_USERNAME,
+                        'password': sickbeard.SPEEDCD_PASSWORD
+                        }
+
+        self.session = requests.Session()
+        self.session.headers.update({'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:24.0) Gecko/20130519 Firefox/24.0)'})
+
+        try:
+            response = self.session.post(self.urls['login'], data=login_params, timeout=30)
+        except (requests.exceptions.ConnectionError, requests.exceptions.HTTPError), e:
+            logger.log(u'Unable to connect to ' + self.name + ' provider: ' + ex(e), logger.ERROR)
+            return False
+
+        if re.search('Incorrect username or Password. Please try again.', response.text) \
+        or response.status_code == 401:
+            logger.log(u'Invalid username or password for ' + self.name + ' Check your settings', logger.ERROR)
+            return False
+
+        return True
+
+    def _get_season_search_strings(self, show, season=None):
+
+        search_string = {'Episode': []}
+
+        if not show:
+            return []
+
+        seasonEp = show.getAllEpisodes(season)
+
+        wantedEp = [x for x in seasonEp if show.getOverview(x.status) in (Overview.WANTED, Overview.QUAL)]
+
+        #If Every episode in Season is a wanted Episode then search for Season first
+        if wantedEp == seasonEp and not show.air_by_date:
+            search_string = {'Season': [], 'Episode': []}
+            for show_name in set(show_name_helpers.allPossibleShowNames(show)):
+                ep_string = show_name +' S%02d' % int(season) #1) ShowName SXX
+                search_string['Season'].append(ep_string)
+
+        #Building the search string with the episodes we need
+        for ep_obj in wantedEp:
+            search_string['Episode'] += self._get_episode_search_strings(ep_obj)[0]['Episode']
+
+        #If no Episode is needed then return an empty list
+        if not search_string['Episode']:
+            return []
+
+        return [search_string]
+
+    def _get_episode_search_strings(self, ep_obj, add_string=''):
+
+        search_string = {'Episode': []}
+
+        if not ep_obj:
+            return []
+
+        if ep_obj.show.air_by_date:
+            for show_name in set(show_name_helpers.allPossibleShowNames(ep_obj.show)):
+                ep_string = show_name_helpers.sanitizeSceneName(show_name) +' '+ str(ep_obj.airdate)
+                search_string['Episode'].append(ep_string)
+        else:
+            for show_name in set(show_name_helpers.allPossibleShowNames(ep_obj.show)):
+                ep_string = show_name_helpers.sanitizeSceneName(show_name) +' '+ \
+                sickbeard.config.naming_ep_type[2] % {'seasonnumber': ep_obj.season, 'episodenumber': ep_obj.episode}
+
+                search_string['Episode'].append(re.sub('\s+', ' ', ep_string))
+
+        return [search_string]
+
+    def _doSearch(self, search_params, show=None):
+
+        results = []
+        items = {'Season': [], 'Episode': [], 'RSS': []}
+
+        if not self._doLogin():
+            return []
+
+        for mode in search_params.keys():
+            for search_string in search_params[mode]:
+
+                logger.log(u"Search string: " + search_string, logger.DEBUG)
+
+                search_string = '+'.join(search_string.split())
+
+                post_data  = dict({'/browse.php?' : None, 'cata': 'yes','jxt': 4,'jxw': 'b','search': search_string}, **self.categories[mode])
+
+                data = self.session.post(self.urls['search'], data=post_data).json()
+
+                try:
+                    torrents = data.get('Fs', [])[0].get('Cn', {}).get('torrents', [])
+                except:
+                    continue
+
+                for torrent in torrents:
+
+                    if sickbeard.SPEEDCD_FREELEECH and not torrent['free']:
+                        continue
+
+                    title = re.sub('<[^>]*>', '', torrent['name'])
+                    url = self.urls['download'] %(torrent['id'])
+                    seeders = int(torrent['seed'])
+                    leechers = int(torrent['leech'])
+
+                    if mode != 'RSS' and seeders == 0:
+                        continue
+
+                    if not title or not url:
+                        continue
+
+                    item = title, url, seeders, leechers
+                    items[mode].append(item)
+
+            #For each search mode sort all the items by seeders
+            items[mode].sort(key=lambda tup: tup[2], reverse=True)
+
+            results += items[mode]
+
+        return results
+
+    def _get_title_and_url(self, item):
+
+        title, url, seeders, leechers = item
+
+        if url:
+            url = str(url).replace('&amp;','&')
+
+        return (title, url)
+
+    def getURL(self, url, headers=None):
+
+        if not self.session:
+            self._doLogin()
+
+        if not headers:
+            headers = {'user-agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/32.0.1700.107 Safari/537.36'}
+
+        try:
+            response = self.session.get(url, headers=headers)
+        except (requests.exceptions.ConnectionError, requests.exceptions.HTTPError), e:
+            logger.log(u"Error loading "+self.name+" URL: " + ex(e), logger.ERROR)
+            return None
+
+        if response.status_code != 200:
+            logger.log(self.name + u" page requested with url " + url +" returned status code is " + str(response.status_code) + ': ' + clients.http_error_code[response.status_code], logger.WARNING)
+            return None
+
+        return response.content
+
+    def findPropers(self, search_date=datetime.datetime.today()):
+
+        results = []
+
+        sqlResults = db.DBConnection().select('SELECT s.show_name, e.showid, e.season, e.episode, e.status, e.airdate FROM tv_episodes AS e' +
+                                              ' INNER JOIN tv_shows AS s ON (e.showid = s.tvdb_id)' +
+                                              ' WHERE e.airdate >= ' + str(search_date.toordinal()) +
+                                              ' AND (e.status IN (' + ','.join([str(x) for x in Quality.DOWNLOADED]) + ')' +
+                                              ' OR (e.status IN (' + ','.join([str(x) for x in Quality.SNATCHED]) + ')))'
+                                              )
+        if not sqlResults:
+            return []
+
+        for sqlShow in sqlResults:
+            curShow = helpers.findCertainShow(sickbeard.showList, int(sqlShow["showid"]))
+            curEp = curShow.getEpisode(int(sqlShow["season"]), int(sqlShow["episode"]))
+            searchString = self._get_episode_search_strings(curEp, add_string='PROPER|REPACK')
+
+            for item in self._doSearch(searchString[0]):
+                title, url = self._get_title_and_url(item)
+                results.append(classes.Proper(title, url, datetime.datetime.today()))
+
+        return results
+
+
+class SpeedCDCache(tvcache.TVCache):
+
+    def __init__(self, provider):
+
+        tvcache.TVCache.__init__(self, provider)
+
+        # only poll Speedcd every 20 minutes max
+        self.minTime = 20
+
+    def updateCache(self):
+
+        if not self.shouldUpdate():
+            return
+
+        search_params = {'RSS': ['']}
+        rss_results = self.provider._doSearch(search_params)
+
+        if rss_results:
+            self.setLastUpdate()
+        else:
+            return []
+
+        logger.log(u"Clearing " + self.provider.name + " cache and updating with new information")
+        self._clearCache()
+
+        ql = []
+        for result in rss_results:
+            item = (result[0], result[1])
+            ci = self._parseItem(item)
+            if ci is not None:
+                ql.append(ci)
+
+        myDB = self._getDB()
+        myDB.mass_action(ql)
+
+    def _parseItem(self, item):
+
+        (title, url) = item
+
+        if not title or not url:
+            return None
+
+        logger.log(u"Adding item to cache: " + title, logger.DEBUG)
+
+        return self._addCacheEntry(title, url)
+
+provider = SpeedCDProvider()
+

sickbeard/webserve.py

@@ -1528,6 +1528,8 @@ class ConfigProviders:
                 sickbeard.HDBITS = curEnabled
             elif curProvider == 'nextgen':
                 sickbeard.NEXTGEN = curEnabled
+            elif curProvider == 'speedcd':
+                sickbeard.SPEEDCD = curEnabled
             elif curProvider in newznabProviderDict:
                 newznabProviderDict[curProvider].enabled = bool(curEnabled)
             elif curProvider in torrentRssProviderDict:
@@ -1582,6 +1584,10 @@ class ConfigProviders:
         sickbeard.NEXTGEN_USERNAME = nextgen_username.strip()
         sickbeard.NEXTGEN_PASSWORD = nextgen_password.strip()
 
+        sickbeard.SPEEDCD_USERNAME = speedcd_username.strip()
+        sickbeard.SPEEDCD_PASSWORD = speedcd_password.strip()
+        sickbeard.SPEEDCD_FREELEECH = config.checkbox_to_value(speedcd_freeleech)
+
         sickbeard.NEWZNAB_DATA = '!!!'.join([x.configStr() for x in sickbeard.newznabProviderList])
         sickbeard.PROVIDER_ORDER = provider_list