def _sendTORRENT(self, torrent): ################################################################################################### try: if hasattr(torrent.provider, 'session'): self.session = torrent.provider.session else: self.session = requests.Session() except Exception: self.session = requests.Session() if not torrent.url.startswith("magnet:"): ################################################################################################### # Attempt to download torrent file. try: r = self.session.get(torrent.url, verify=False) except (requests.exceptions.ConnectionError, requests.exceptions.HTTPError), e: logger.log( "[" + self.name + "] _sendTORRENT() Error grabbing torrent " + torrent.url + " - " + ex(e), logger.ERROR) return False if r.content: logger.log( "[" + self.name + "] _sendTORRENT() Succesfully downloaded torrent from " + torrent.url, logger.DEBUG) else: logger.log( "[" + self.name + "] _sendTORRENT() Error no content data found for torrent file.", logger.ERROR) return False
def __init__(self): self.NMA_URL = "https://www.notifymyandroid.com/publicapi/notify" self.apikey = mylar.NMA_APIKEY self.priority = mylar.NMA_PRIORITY self._session = requests.Session()
def getURL(url, post_data=None, headers=None, params=None, timeout=30, json=False): """ Returns a byte-string retrieved from the url provider. """ global session if not session: session = requests.Session() req_headers = ['User-Agent', USER_AGENT, 'Accept-Encoding', 'gzip,deflate'] if headers: for cur_header in headers: req_headers.append(cur_header) try: # Remove double-slashes from url parsed = list(urlparse.urlparse(url)) parsed[2] = re.sub("/{2,}", "/", parsed[2]) # replace two or more / with one url = urlparse.urlunparse(parsed) it = iter(req_headers) if sickbeard.PROXY_SETTING: proxies = { "http": sickbeard.PROXY_SETTING, "https": sickbeard.PROXY_SETTING, } r = session.get(url, params=params, data=post_data, headers=dict(zip(it, it)), proxies=proxies, timeout=timeout, verify=False) else: r = session.get(url, params=params, data=post_data, headers=dict(zip(it, it)), timeout=timeout, verify=False) except requests.HTTPError, e: logger.log(u"HTTP error " + str(e.errno) + " while loading URL " + url, logger.WARNING) return None
def __init__(self): generic.TorrentProvider.__init__(self, "TorrentDay") self.supportsBacklog = True self.cache = TorrentDayCache(self) self.url = self.urls['base_url'] self.session = requests.Session() self.cookies = None self.categories = { 'Season': { 'c14': 1 }, 'Episode': { 'c2': 1, 'c26': 1, 'c7': 1, 'c24': 1 }, 'RSS': { 'c2': 1, 'c26': 1, 'c7': 1, 'c24': 1, 'c14': 1 } }
def __init__(self, name, url): generic.TorrentProvider.__init__(self, name) self.cache = TorrentRssCache(self) self.url = re.sub('\/$', '', url) self.enabled = True self.supportsBacklog = False self.session = requests.Session()
def _doLogin(self): login_params = { 'username': sickbeard.REVOLUTIONTT_USERNAME, 'password': sickbeard.REVOLUTIONTT_PASSWORD, 'submit': 'login' } self.session = requests.Session() logger.log("[" + self.name + "] Attempting to Login") try: # have to init first... self.session.get(self.url + "login.php", headers=self.header, timeout=30, verify=False) response = self.session.post(self.url + "takelogin.php", data=login_params, headers=self.header, timeout=30, verify=False) except (requests.exceptions.ConnectionError, requests.exceptions.HTTPError), e: raise Exception("[" + self.name + "] _doLogin() Error: " + ex(e)) return False
def _doLogin(self): login_params = { 'username': sickbeard.SCC_USERNAME, 'password': sickbeard.SCC_PASSWORD, 'submit': 'come on in', } self.session = requests.Session() try: 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' } response = self.session.post(self.urls['login'], data=login_params, headers=headers, timeout=30, verify=False) except (requests.exceptions.ConnectionError, requests.exceptions.HTTPError), e: logger.log( u'Unable to connect to ' + self.name + ' provider: ' + ex(e), logger.ERROR) return False
def getURL(self, url, post_data=None, headers=None, json=False): if not self.session: self.session = requests.Session() try: # Remove double-slashes from url parsed = list(urlparse.urlparse(url)) parsed[2] = re.sub("/{2,}", "/", parsed[2]) # replace two or more / with one url = urlparse.urlunparse(parsed) if sickbeard.PROXY_SETTING: proxies = { "http": sickbeard.PROXY_SETTING, "https": sickbeard.PROXY_SETTING, } r = self.session.get(url, proxies=proxies, verify=False) else: r = self.session.get(url, verify=False) except (requests.exceptions.ConnectionError, requests.exceptions.HTTPError), e: logger.log( u"Error loading " + self.name + " URL: " + str(sys.exc_info()) + " - " + ex(e), logger.ERROR) return None
def downloadResult(self, result): """ Save the result to disk. """ if not self.session: self.session = requests.Session() torrent_hash = re.findall('urn:btih:([\w]{32,40})', result.url)[0].upper() if not torrent_hash: logger.log( "Unable to extract torrent hash from link: " + ex(result.url), logger.ERROR) return False try: r = self.session.get('http://torcache.net/torrent/' + torrent_hash + '.torrent', verify=False) except Exception, e: logger.log("Unable to connect to TORCACHE: " + ex(e), logger.ERROR) try: logger.log("Trying TORRAGE cache instead") r = self.session.get('http://torrage.com/torrent/' + torrent_hash + '.torrent', verify=False) except Exception, e: logger.log("Unable to connect to TORRAGE: " + ex(e), logger.ERROR) return False
def _doLogin(self): if not self.session: self.session = requests.Session() if sickbeard.TORRENTDAY_EMAIL_URL: self._handleEmailLink() if sickbeard.TORRENTDAY_UID and sickbeard.TORRENTDAY_PASS: self.checkAuthCookies() response = self.session.get(self.url + '/browse.php') if 'login.php' in response.url: if sickbeard.TORRENTDAY_ANTICAPTCHA_KEY and sickbeard.TORRENTDAY_USERNAME and sickbeard.TORRENTDAY_PASSWORD: if not self._bypassCaptcha(): return False else: logger.log( "[{0}] {1} Appears we cannot authenicate with TorrentDay.". format(self.name, self.funcName()), logger.ERROR) return False if not self._getPassKey() or not self.rss_uid or not self.rss_passkey: logger.log( "[{0}] {1} Could not extract rss uid/passkey... aborting.". format(self.name, self.funcName()), logger.ERROR) return False return True
def _doLogin(self): if self.token is not None: if time.time() < (self.tokenLastUpdate + 30 * 60): logger.log('T411 Authentication token is still valid', logger.DEBUG) return True login_params = {'username': self.username, 'password': self.password} self.session = requests.Session() logger.log('Performing authentication to T411', logger.DEBUG) try: response = helpers.getURL(self.urls['login_page'], post_data=login_params, timeout=30, session=self.session, json=True) except (requests.exceptions.ConnectionError, requests.exceptions.HTTPError), e: logger.log( u'Unable to connect to ' + self.name + ' provider: ' + ex(e), logger.ERROR) return False
def _doLogin(self): login_params = { 'username': sickbeard.REVOLUTIONTT_USERNAME, 'password': sickbeard.REVOLUTIONTT_PASSWORD } self.session = requests.Session() logger.log("[" + self.name + "] Attempting to Login") try: # have to init first... self.session.get(self.url + "login.php", headers=self.header, timeout=30, verify=False) response = self.session.post(self.url + "takelogin.php", data=login_params, headers=self.header, timeout=30, verify=False) except (requests.exceptions.ConnectionError, requests.exceptions.HTTPError), e: sys.tracebacklimit = 0 # raise exception to sickbeard but hide the stack trace. raise Exception("[" + self.name + "] " + self.funcName() + " Error: " + ex(e)) return False
def _doLogin(self): if self.token and self.tokenExpireDate and datetime.datetime.now() < self.tokenExpireDate: return True self.session = requests.Session() resp_json = None try: response = self.session.get(self.urls['token'], timeout=30, verify=False) response.raise_for_status() resp_json = response.json() except RequestException as e: logger.log(u'Unable to connect to {name} provider: {error}'.format(name=self.name, error=ex(e)), logger.ERROR) return False if not resp_json: logger.log(u'{name} provider: empty json response'.format(name=self.name), logger.ERROR) return False else: try: if resp_json['token']: self.token = resp_json['token'] self.tokenExpireDate = datetime.datetime.now() + datetime.timedelta(minutes=15) return True except Exception as e: logger.log(u'{name} provider: No token found'.format(name=self.name), logger.ERROR) logger.log(u'{name} provider: No token found: {error}'.format(name=self.name, error=ex(e)), logger.DEBUG) return False
def _doLogin(self): login_params = { 'username': sickbeard.TORRENTLEECH_USERNAME, 'password': sickbeard.TORRENTLEECH_PASSWORD, 'remember_me': 'on', 'login': '******' } self.session = requests.Session() logger.log("[" + self.name + "] Attempting to Login") try: response = self.session.post( "{0}user/account/login".format(self.url), data=login_params, timeout=30, verify=False ) if (True, True) == self._cloudFlare(response): response = self.session.post( "{0}user/account/login".format(self.url), data=login_params, timeout=30, verify=False ) except (requests.exceptions.ConnectionError, requests.exceptions.HTTPError), e: logger.log("[{0}] {1} Error: {2}".format( self.name, self.funcName(), e ), logger.ERROR ) return False
def __init__(self, un, pw, session_path=None): ''' Params: un: account username (required) pw: account password (required) session_path: the path to the actual file you want to persist your cookies in If blank, saves to $HOME/.32p_cookies.dat ''' self.module = '[32P-AUTHENTICATION]' self.ses = requests.Session() self.session_path = session_path if session_path is not None else os.path.join( mylar.CACHE_DIR, ".32p_cookies.dat") self.ses.cookies = LWPCookieJar(self.session_path) if not os.path.exists(self.session_path): logger.fdebug( self.module + ' Session cookie does not exist. Signing in and Creating.') self.ses.cookies.save() else: logger.fdebug(self.module + ' Session cookie found. Attempting to load...') self.ses.cookies.load(ignore_discard=True) self.un = un self.pw = pw self.authkey = None self.passkey = None self.uid = None
def getURL(self, url, post_data=None, headers=None, json=False): if not headers: headers = {} if not self.session: self.session = requests.Session() # Glype Proxies does not support Direct Linking. # We have to fake a search on the proxy site to get data if self.proxy.isEnabled(): headers.update({'referer': self.proxy.getProxyURL()}) try: if sickbeard.PROXY_SETTING: proxies = { "http": sickbeard.PROXY_SETTING, "https": sickbeard.PROXY_SETTING, } r = self.session.get(url, headers=headers, proxies=proxies, verify=False) else: r = self.session.get(url, headers=headers, verify=False) except (requests.exceptions.ConnectionError, requests.exceptions.HTTPError), e: logger.log(u"Error loading " + self.name + " URL: " + str(sys.exc_info()) + " - " + ex(e), logger.ERROR) return None
def _doLogin(self): if any(requests.utils.dict_from_cookiejar(self.session.cookies).values()): return True if self._uid and self._hash: requests.utils.add_dict_to_cookiejar(self.session.cookies, self.cookies) else: login_params = {'username': self.username, 'password': self.password, 'login': '******' } if not self.session: self.session = requests.Session() try: response = self.session.post(self.urls['login'], data=login_params, timeout=30, verify=False) 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('Your username or password was incorrect.', response.text): logger.log(u'Invalid username or password for ' + self.name + ' Check your settings', logger.ERROR) return False return True
def __init__(self,url,data={},method='GET',headers={},timeout=None,proxy={},session=None,callback=None): if url and url.startswith('//'): url = 'http:'+url if url and not url.upper().startswith('HTTP'): url = 'http://%s'%url self.url = url self.data = data self.method = method.strip() self.version= 'HTTP/1.1' parser = urlparse.urlsplit(self.url) self.scheme = parser.scheme #https self.netloc = parser.netloc #www.baidu.com self.path = parser.path #/query.php query = parser.query #a=1&b=2 self.headers= { "User-Agent":"Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36", "Accept-Encoding":"gzip, deflate, sdch", "Accept-Language":"zh-CN,zh;q=0.8", "Connection":"keep-alive", "Referer":'%s://%s/'%(self.scheme,self.netloc),} self.headers.update(headers) self.query = {} if query: self.query = dict([q.split('=')[:2] for q in query.split('&') if '=' in q]) if data and method == 'GET': self.method = 'POST' self.timeout = timeout self.proxies = proxy self.session = session or requests.Session() #adapter = requests.adapters.HTTPAdapter( # pool_connections=100, pool_maxsize=100) #self.session.mount('http://', adapter) #self.session.headers.update({'Connection':'Close'}) self.callback = callback or (lambda x: x)
def __init__(self): generic.TorrentProvider.__init__(self, "EZTV") self.cache = EZTVCache(self) self.name = "EZTV" self.session = requests.Session() self.supportsBacklog = True self.url = "https://eztv.ag/" logger.log("[" + self.name + "] initializing...")
def __init__(self): self.PUSH_URL = "https://api.pushbullet.com/v2/pushes" self.apikey = mylar.PUSHBULLET_APIKEY self.deviceid = mylar.PUSHBULLET_DEVICEID self._json_header = {'Content-Type': 'application/json', 'Authorization': 'Basic %s' % base64.b64encode(mylar.PUSHBULLET_APIKEY + ":")} self._session = requests.Session() self._session.headers.update(self._json_header)
def __init__(self): generic.TorrentProvider.__init__(self, "Torrentz") self.cache = TORRENTZCache(self) self.url = 'https://torrentz2.eu/' self.name = "Torrentz" self.supportsBacklog = True self.session = requests.Session() self.funcName = lambda n=0: sys._getframe(n + 1).f_code.co_name + "()" logger.log("[" + self.name + "] initializing...")
def _doLogin(self): self.session = requests.Session() self.checkAuthCookies() if not self._getPassKey() or not self.rss_uid or not self.rss_passkey: raise Exception("[" + self.name + "] " + self.funcName() + " Could not extract rss uid/passkey... aborting.") return True
def _doLogin(self): if any( requests.utils.dict_from_cookiejar( self.session.cookies).values()): return True if self._uid and self._hash: requests.utils.add_dict_to_cookiejar(self.session.cookies, self.cookies) else: login_params = { 'username': self.username, 'password': self.password, 'login': '******' } if not self.session: self.session = requests.Session() try: response = self.session.post(self.urls['login'], data=login_params, timeout=30, verify=False) 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( 'Username does not exist in the userbase or the account is not confirmed yet.', response.text): logger.log( u'Invalid username or password for ' + self.name + ' Check your settings', logger.ERROR) return False if requests.utils.dict_from_cookiejar( self.session.cookies )['uid'] and requests.utils.dict_from_cookiejar( self.session.cookies)['pass']: self._uid = requests.utils.dict_from_cookiejar( self.session.cookies)['uid'] self._hash = requests.utils.dict_from_cookiejar( self.session.cookies)['pass'] self.cookies = {'uid': self._uid, 'pass': self._hash} return True else: logger.log(u'Unable to obtain cookie for FreshOnTV', logger.ERROR) return False
def __init__(self): generic.TorrentProvider.__init__(self, "BTDigg") self.name = "BTDigg" self.session = None self.supportsBacklog = True self.url = 'https://api.btdigg.org/' logger.log("[" + self.name + "] initializing...") if not self.session: self.session = requests.Session()
def __init__(self, secure, auth=None, proxies=None, verify_ssl=True): xmlrpclib.Transport.__init__(self) self.secure = secure # Construct session self.session = requests.Session() self.session.auth = self.parse_auth(auth) self.session.proxies = proxies or {} self.session.verify = False #verify_ssl
def getURL(self, url, headers=None): if not self.session: self.session = requests.Session() try: response = self.session.get(url) except (requests.exceptions.ConnectionError, requests.exceptions.HTTPError), e: logger.log(u"Error loading "+self.name+" URL: " + ex(e), logger.ERROR) return None
def __init__(self): generic.TorrentProvider.__init__(self, "KickAssTorrents") self.supportsBacklog = True self.cache = KATCache(self) self.url = 'http://kickass.to/' self.searchurl = self.url + 'usearch/%s/?field=seeders&sorder=desc' #order by seed self.session = requests.Session()
def _authToken(session=None,host=None, username=None, password=None): auth = None if not session: session = requests.Session() response = session.get(host + "gui/token.html",auth=(username, password), verify=False,timeout=30) if response.status_code == 200: auth = re.search("<div.*?>(\S+)<\/div>", response.text).group(1) else: logger.log("[uTorrent] Authenication Failed.",logger.ERROR) return auth,session
def __init__(self): threading.Thread.__init__(self) if not (self.baseurl and self.nextkey): raise Exception('self.baseurl 没有初始化') self.url = None self.keyword = None self.timeout = 10 self.timesleep = 60 self.errorflag = 5 self.session = requests.Session() self.lock = threading.Lock() self.headers = {} self.STAT = True
def __init__(self): generic.TorrentProvider.__init__(self, "Torrentz") self.cache = TORRENTZCache(self) self.url = 'https://torrentz.eu/' self.name = "Torrentz" self.supportsBacklog = True self.rss = False self.session = None logger.log("[" + self.name + "] initializing...") if not self.session: self.session = requests.Session()