def login(self): if any(dict_from_cookiejar(self.session.cookies).values()): return True if self._uid and self._hash: add_dict_to_cookiejar(self.session.cookies, self.cookies) else: login_params = { 'username': self.custom_settings['username'], 'password': self.custom_settings['password'], 'login': '******', 'keeplogged': '1' } try: self.session.get(self.urls['login']) response = self.session.post(self.urls['login'], data=login_params).text except Exception: sickrage.app.log.warning("Unable to connect to provider") return False if re.search('logout.php', response): return True elif re.search('Your username or password was incorrect.', response): sickrage.app.log.warning( "Invalid username or password. Check your settings")
def add_cookies_from_ui(self): """ Adds the cookies configured from UI to the providers requests session :return: A dict with the the keys result as bool and message as string """ # This is the generic attribute used to manually add cookies for provider authentication if self.enable_cookies: if self.cookies: 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)} # 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': ''} else: # Else is not needed, but placed it here for readability ui.notifications.message('Failed to validate cookie for provider {provider}'.format(provider=self.name), 'No Cookies added from ui for provider: {0}'.format(self.name)) return {'result': False, 'message': 'No Cookies added from ui for provider: {0}'.format(self.name)} return {'result': False, 'message': 'Adding cookies is not supported for provider: {0}'.format(self.name)}
def _identify_captcha(): """ 验证码识别 :return: True/False """ for _ in range(setting.repeat_times): _session.headers.update({'Referer': 'https://weixin.sogou.com'}) resp = _session.get( f'http://weixin.sogou.com/antispider/util/seccode.php?tc={int(time())}' ) tf = TemporaryFile() tf.write(resp.content) code = setting.sougo_captcha_callback(Image.open(tf)) if not code: continue resp = _session.post('https://weixin.sogou.com/antispider/thank.php', data={ 'c': code, 'r': 'https://weixin.sogou.com/', 'v': 5, }) resp.encoding = 'utf-8' msg = resp.json() if msg['code'] == 0: add_dict_to_cookiejar(_session.cookies, {'SNUID': msg['id']}) return True print('验证码错误!') return False
def login(self): """Login method used for logging in before doing a search and torrent downloads.""" cookie_dict = dict_from_cookiejar(self.session.cookies) if cookie_dict.get('session'): return True if self.cookies: add_dict_to_cookiejar( self.session.cookies, dict(x.rsplit('=', 1) for x in self.cookies.split(';'))) cookie_dict = dict_from_cookiejar(self.session.cookies) if cookie_dict.get('session'): return True login_params = { 'submit': 'Login', 'username': self.username, 'password': self.password, 'keeplogged': 1, } response = self.get_url(self.urls['login'], post_data=login_params, returns='text') if not response: logger.log("Unable to connect to provider", logger.WARNING) return False if re.search('<title>Login :: BJ-Share</title>', response): logger.log("Invalid username or password. Check your settings", logger.WARNING) return False return True
def identify_captcha(): while True: sogou_session.headers.update( {'Referer': 'https://weixin.sogou.com/antispider/'}) resp = sogou_session.get( f'http://weixin.sogou.com/antispider/util/seccode.php?tc={int(time())}' ) code = sogou_captcha_callback(resp.content) if not code or not isinstance(code, str): logging.warning("Sogou 验证码错误!") continue code = code.strip().lower() if code == 'exit': raise KeyboardInterrupt resp = sogou_session.post( 'https://weixin.sogou.com/antispider/thank.php', data={ 'c': code, 'r': 'https://weixin.sogou.com/', 'v': 5, }) resp.encoding = 'utf-8' msg = resp.json() if msg['code'] == 0: add_dict_to_cookiejar(sogou_session.cookies, {'SNUID': msg['id']}) break logging.warning("Sogou 验证码错误!")
def _getRSSData(self): logger.log(u"Cache update URL: %s" % self.provider.url, logger.DEBUG) if self.provider.cookies: add_dict_to_cookiejar(self.provider.session.cookies, dict(x.rsplit('=', 1) for x in self.provider.cookies.split(';'))) return self.getRSSFeed(self.provider.url)
def courseUtils(self, courseId, clazzId): """拉取用于刷课的cookies""" self.courseId = courseId self.clazzId = clazzId url = "https://passport2.chaoxing.com/api/cookie" self.headers["Host"] = "passport2.chaoxing.com" response = requestUtils(url=url, headers=self.headers, cookies=self.cookiesForCourse) t = dict_from_cookiejar(response.cookies) # for get other cookies add_dict_to_cookiejar(self.cookiesForClass, t) url = "https://mooc1-api.chaoxing.com/gas/clazzperson" params = { "courseid": courseId, "clazzid": clazzId, "userid": self.uid, "view": "json", "fields": "clazzid,popupagreement,personid,clazzname" } self.headers["Host"] = "mooc1-api.chaoxing.com" response = requestUtils(url=url, params=params, headers=self.headers, cookies=self.cookiesForClass) try: content = response.json() except JSONDecodeError as e: error(str(e)) exit(1) self.personId = content["data"][0]["personid"]
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 """ # This is the generic attribute used to manually add cookies for provider authentication if self.enable_cookies: if self.cookies: 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)} # 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': ''} else: # Cookies not set. Don't need to check cookies return {'result': True, 'message': 'No Cookies added from ui for provider: {0}'.format(self.name)} return {'result': False, 'message': 'Adding cookies is not supported for provider: {0}'.format(self.name)}
def _get_citations_from_detail_url(self, detail_url, eid): add_dict_to_cookiejar(self.session.cookies, {'javaScript': 'true'}) with self.throttler(): r = self.session.get(detail_url) et = html5lib.parse(r.text, treebuilder="lxml") def get_cited_by_link(et): namespaces = {'html': 'http://www.w3.org/1999/xhtml'} cite_links = et.xpath( ".//html:a[starts-with(@href, 'http://www.scopus.com/search/submit/citedby.url') and @title='View all citing documents']", namespaces=namespaces) for link in cite_links: if 'title' in link.attrib: logging.debug('Trying citation link: %s', link.attrib['title']) return link.attrib['href'] return None link = get_cited_by_link(et) if link == None: logging.warning('No SCOPUS citation link found') return [] headers = {'Referer': r.url} with self.throttler(): r2 = self.session.get(link, headers=headers) return self._download_from_results_form( r2, context=['_get_citations_from_detail_url', detail_url, eid])
def __init__(self, ticket=None, at_token=None): self.session = requests.session() self.__at = None self.__boss_ticket = None if ticket is not None: add_dict_to_cookiejar(self.session.cookies, {TICKET_NAME: ticket}) if at_token is not None: self.__at = at_token
def _get_rss_data(self): sickrage.app.log.debug("Cache update URL: %s" % self.provider.urls['base_url']) if self.provider.cookies: add_dict_to_cookiejar(self.provider.session.cookies, dict(x.rsplit('=', 1) for x in self.provider.cookies.split(';'))) return self.get_rss_feed(self.provider.urls['base_url'])
def _get_rss_data(self): if self.provider.cookies: add_dict_to_cookiejar( self.provider.session.cookies, dict( x.rsplit('=', 1) for x in self.provider.cookies.split(';'))) return self.get_rss_feed(self.provider.url)
def _set_cookie(self, url): response1 = self.session.get(url) jsl_clearance_s = re.findall(r'cookie=(.*?);location', response1.text)[0] jsl_clearance_s = str(execjs.eval(jsl_clearance_s)).split('=')[1].split(';')[0] add_dict_to_cookiejar(self.session.cookies, {'__jsl_clearance_s': jsl_clearance_s}) response2 = self.session.get(url) data = json.loads(re.findall(r';go\((.*?)\)', response2.text)[0]) jsl_clearance_s = self._get__jsl_clearance_s(data) add_dict_to_cookiejar(self.session.cookies, {'__jsl_clearance_s': jsl_clearance_s})
def __init__(self, cookie_file='cookies.txt', debug_files=False, dest_directory='.'): self.debug_files = debug_files self.cookies = self.get_cookies(cookie_file) self.session = BaseURLSession(prefix_url="https://echo360.org.uk") add_dict_to_cookiejar(self.session.cookies, self.cookies) self.dest_directory = dest_directory
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 _getRSSData(self): logger.log(u"Cache update URL: %s" % self.provider.url, logger.DEBUG) if self.provider.cookies: add_dict_to_cookiejar( self.provider.session.cookies, dict( x.rsplit('=', 1) for x in self.provider.cookies.split(';'))) return self.getRSSFeed(self.provider.url)
def run(): # 第一次请求 response = session.get(url, headers=header, verify=False) # 获取参数及加密方式 parameter, js_file = get_parameter(response) # 获取cookie clearance = get_cookie(parameter, js_file) # 修改cookie add_dict_to_cookiejar(session.cookies, {'__jsl_clearance_s': clearance}) # 第三次请求 html = session.get(url, headers=header, verify=False) print(html.content.decode())
def login(self): if any(dict_from_cookiejar(self.session.cookies).values()): return True if self._uid and self._hash: add_dict_to_cookiejar(self.session.cookies, self._cookies) else: login_params = { 'username': self.username, 'password': self.password, 'login': '******' } response = self.get_url(self.urls['login'], post_data=login_params, returns='text') if not response: logger.log(u"Unable to connect to provider", logger.WARNING) return False if re.search('/logout.php', response): try: if dict_from_cookiejar(self.session.cookies )['uid'] and dict_from_cookiejar( self.session.cookies)['pass']: self._uid = dict_from_cookiejar( self.session.cookies)['uid'] self._hash = dict_from_cookiejar( self.session.cookies)['pass'] self._cookies = {'uid': self._uid, 'pass': self._hash} return True except Exception: logger.log(u"Unable to login to provider (cookie)", logger.WARNING) return False else: if re.search( 'Username does not exist in the userbase or the account is not confirmed yet.', response): logger.log( u"Invalid username or password. Check your settings", logger.WARNING) if re.search('DDoS protection by CloudFlare', response): logger.log( u"Unable to login to provider due to CloudFlare DDoS javascript check", logger.WARNING) return False
def login(self): """Login method used for logging in before doing search and torrent downloads.""" if any(dict_from_cookiejar(self.session.cookies).values()): return True login_params = { 'username': self.username, 'password': self.password, } if self._uid and self._hash: add_dict_to_cookiejar(self.session.cookies, self.cookies) else: response = self.get_url(self.urls['login'], post_data=login_params, returns='response') if not response or not response.text: logger.log('Unable to connect to provider', logger.WARNING) return False if re.search('/logout.php', response.text): try: if dict_from_cookiejar(self.session.cookies)['uid'] and \ dict_from_cookiejar(self.session.cookies)['pass']: self._uid = dict_from_cookiejar( self.session.cookies)['uid'] self._hash = dict_from_cookiejar( self.session.cookies)['pass'] self.cookies = {'uid': self._uid, 'pass': self._hash} return True except Exception: logger.log('Unable to login to provider (cookie)', logger.WARNING) return False else: if re.search('Username does not exist in the userbase or the account is not confirmed yet.', response.text) or \ re.search('Username or password is incorrect. If you have an account here please use the' ' recovery system or try again.', response.text): logger.log( 'Invalid username or password. Check your settings', logger.WARNING) if re.search('DDoS protection by CloudFlare', response.text): logger.log( 'Unable to login to provider due to CloudFlare DDoS javascript check', logger.WARNING) return False
def search_by_author(self, surname, name=None, year=None): form_url = 'http://www.scopus.com' post_url = 'http://www.scopus.com/search/submit/basic.url' with self.throttler(): r_form = self.session.get(form_url) add_dict_to_cookiejar(self.session.cookies, { 'javaScript': 'true', 'xmlHttpRequest': 'true' }) et = html5lib.parse(r_form.text, treebuilder="lxml") namespaces = {'html': 'http://www.w3.org/1999/xhtml'} search_form_html = et.find( "//{http://www.w3.org/1999/xhtml}form[@name='SearchResultsForm']") search_form = HTMLForm(search_form_html) search_term = surname if name: search_term += u', {}'.format(name) search_form.set_value('searchterm1', search_term) search_form.set_value('field1', 'AUTHOR-NAME') if year != None: search_form.set_value('yearFrom', str(year)) search_form.set_value('yearTo', str(year)) search_form.set_value('dateType', 'Publication_Date_Type') headers = {'Referer': r_form.url} with self.throttler(): r_results = self.session.post(post_url, data=search_form.to_params(), headers=headers) et = html5lib.parse(r_results.text, treebuilder="lxml") namespaces = {'html': 'http://www.w3.org/1999/xhtml'} errors = et.xpath( ".//html:form[@name='SearchResultsForm']//*[contains(concat(' ', normalize-space(@class), ' '), ' errText ')]", namespaces=namespaces) for error in errors: if error.text.strip() == 'No results were found.': return [] raise IOError('Error encountered during document search: ' + error.text.strip()) return self._download_from_results_form( r_results, context=['_search_by_author', surname, name, year])
def add_cookies_from_ui(self): """ Adds the cookies configured from UI to the providers requests session :return: A tuple with the the (success result, and a descriptive message in str) """ # This is the generic attribute used to manually add cookies for provider authentication if self.enable_cookies and self.cookies: cookie_validator = re.compile(r'^(\w+=\w+)(;\w+=\w+)*$') if not cookie_validator.match(self.cookies): return False, 'Cookie is not correctly formatted: {0}'.format(self.cookies) add_dict_to_cookiejar(self.session.cookies, dict(x.rsplit('=', 1) for x in self.cookies.split(';'))) return True, 'torrent cookie' return False, 'No Cookies added from ui for provider: {0}'.format(self.name)
def add_cookies_from_ui(self): """ Adds the cookies configured from UI to the providers requests session :return: A tuple with the the (success result, and a descriptive message in str) """ # This is the generic attribute used to manually add cookies for provider authentication if self.enable_cookies and self.cookies: cookie_validator = re.compile(r'^(\w+=\w+)(;\w+=\w+)*$') if cookie_validator.match(self.cookies): add_dict_to_cookiejar(sickrage.srCore.srWebSession.cookies, dict(x.rsplit('=', 1) for x in self.cookies.split(';'))) return True return False
def captcha_login_post(): mongo_accounts = mongoCollection('accounts') data = request.get_data().decode('utf-8') data = json.loads(data) logger.debug(data) login_cookie = redis_db.get(settings.LOGIN_KEY % data['username']) if not login_cookie: return jsonify({ 'status': False, 'message': { 'reason': '更换用户名后请刷新验证码' } }) login_cookie = json.loads(login_cookie.decode('utf-8')) session = requests.Session() login_cookie_jar = add_dict_to_cookiejar(session.cookies, login_cookie) # session = login_session[data['username']] cookies, result = pylogins.bilibili_login.login(data['username'], data['password'], data['captcha'], session) # Write cookie to mongo if cookies: logger.debug('Write login to mongo...') mongo_accounts.update_one( { 'username': data['username'], 'source': data['source'], }, {'$set': { 'cookies': cookies, 'update_ts': datetime.now(), }}) return jsonify(result)
def add_cookies_from_ui(self): """ Adds the cookies configured from UI to the providers requests session :return: A tuple with the the (success result, and a descriptive message in str) """ # This is the generic attribute used to manually add cookies for provider authentication if self.enable_cookies and self.cookies: cookie_validator = re.compile(r'^(\w+=\w+)(;\w+=\w+)*$') if cookie_validator.match(self.cookies): add_dict_to_cookiejar( sickrage.srCore.srWebSession.cookies, dict(x.rsplit('=', 1) for x in self.cookies.split(';'))) return True return False
def test_add_dict_to_cookiejar(cookiejar): """Ensure add_dict_to_cookiejar works for non-RequestsCookieJar CookieJars """ cookiedict = {"test": "cookies", "good": "cookies"} cj = add_dict_to_cookiejar(cookiejar, cookiedict) cookies = {cookie.name: cookie.value for cookie in cj} assert cookiedict == cookies
def test_add_dict_to_cookiejar(cookiejar): """Ensure add_dict_to_cookiejar works for non-RequestsCookieJar CookieJars """ cookiedict = {'test': 'cookies', 'good': 'cookies'} cj = add_dict_to_cookiejar(cookiejar, cookiedict) cookies = dict((cookie.name, cookie.value) for cookie in cj) assert cookiedict == cookies
def _new_session(self): """ A new `requests.Session` which is authenticated with umd and can be used to access umd websites. "authenticated" here just means that this session has the `auth_cookies` we retrieved set, which is all being authenticated means to umd. """ print("creating a new session") if not self.auth_cookies: self.authenticate() session = requests.Session() add_dict_to_cookiejar(session.cookies, self.auth_cookies) session.cookies.set("JSESSION", self.identity_jsession_id, domain="identity.umd.edu", path="/") return session
def run(url): # 第一次请求 response = ss.get( url, headers=headers, ) if response.status_code == 200: return response else: # 获取参数及加密方式 parameter, js_file = get_parameter(response, url) # 获取cookie clearance = get_cookie(parameter, js_file) # 修改cookie add_dict_to_cookiejar(ss.cookies, {'__jsl_clearance_s': clearance}) # 第三次请求 html = ss.get(url, headers=headers) return html
def validateRSS(self): # pylint: disable=too-many-return-statements try: if self.cookies: cookie_validator = re.compile(r'^(\w+=\w+)(;\w+=\w+)*$') if not cookie_validator.match(self.cookies): return False, 'Cookie is not correctly formatted: {0}'.format( self.cookies) add_dict_to_cookiejar( self.session.cookies, dict(x.rsplit('=', 1) for x in self.cookies.split(';'))) # pylint: disable=protected-access # Access to a protected member of a client class data = self.cache._get_rss_data()['entries'] if not data: return False, 'No items found in the RSS feed {0}'.format( self.url) title, url = self._get_title_and_url(data[0]) if not title: return False, 'Unable to get title from first item' if not url: return False, 'Unable to get torrent url from first item' if url.startswith('magnet:') and re.search( r'urn:btih:([\w]{32,40})', url): return True, 'RSS feed Parsed correctly' else: torrent_file = self.get_url(url, returns='content') try: helpers.bdecode(torrent_file, True) except (BTFailure, Exception) as error: self.dumpHTML(torrent_file) return False, 'Torrent link is not a valid torrent file: {0}'.format( error) return True, 'RSS feed Parsed correctly' except Exception as error: return False, 'Error when trying to load RSS: {0}'.format( ex(error))
def login(self): if any(dict_from_cookiejar(self.session.cookies).values()): return True if self._uid and self._hash: add_dict_to_cookiejar(self.session.cookies, self.cookies) else: login_params = { 'username': self.username, 'password': self.password, 'submit.x': 0, 'submit.y': 0 } response = self.get_url(self.urls['login'], post_data=login_params, timeout=30) if not response: logger.log(u"Unable to connect to provider", logger.WARNING) return False if re.search('You tried too often', response): logger.log(u"Too many login access attempts", logger.WARNING) return False try: if dict_from_cookiejar( self.session.cookies)['uid'] and dict_from_cookiejar( self.session.cookies)['pass']: self._uid = dict_from_cookiejar( self.session.cookies)['uid'] self._hash = dict_from_cookiejar( self.session.cookies)['pass'] self.cookies = {'uid': self._uid, 'pass': self._hash} return True except Exception: pass logger.log(u"Unable to obtain cookie", logger.WARNING) return False
def __init__(self, ansible_module): if not HAS_REQUESTS: ansible_module.fail_json( msg='The "requests"' ' python library is required to use the aoscx connection type.' ) s = RequestsSession() connection = Connection(ansible_module._socket_path) session_data = connection.get_session() if session_data['success'] is False: ansible_module.fail_json(msg="Connection Failed") add_dict_to_cookiejar(s.cookies, session_data["cookies"]) if session_data["use_proxy"] is False: s.proxies = {"http": None, "https": None} self._session = dict(s=s, url=session_data["url"], credentials=session_data["credentials"])
def run(): # 第一次请求 response = session.get(url, params=params, headers=headers, verify=False) # 获取参数及加密方式 parameter, js_file = get_parameter(response) # 获取cookie clearance = get_cookie(parameter, js_file) # 修改cookie add_dict_to_cookiejar(session.cookies, {'__jsl_clearance_s': clearance}) # 第三次请求 html = session.get( url, params=params, headers=headers, ) if html.status_code == 200: content = html.content.decode('utf-8') print()
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 add_cookies_from_ui(self): """ Add the cookies configured from UI to the providers requests session. :return: dict """ 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: {}'.format(self.name)} if not self.cookies: return {'result': False, 'message': 'No Cookies added from ui for provider: {}'.format(self.name)} cookie_validator = re.compile(r'^([\w%]+=[\w%]+)(;[\w%]+=[\w%]+)*$') if not cookie_validator.match(self.cookies): sickrage.app.alerts.message( 'Failed to validate cookie for provider {}'.format(self.name), 'Cookie is not correctly formatted: {}'.format(self.cookies)) return {'result': False, 'message': 'Cookie is not correctly formatted: {}'.format(self.cookies)} if hasattr(self, 'required_cookies') and 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 login(self): if any(dict_from_cookiejar(self.session.cookies).values()): return True login_params = { 'username': self.username, 'password': self.password, } if self._uid and self._hash: add_dict_to_cookiejar(self.session.cookies, self.cookies) else: response = self.get_url(self.urls['login'], post_data=login_params, returns='text') if not response: logger.log('Unable to connect to provider', logger.WARNING) return False if re.search('/logout.php', response): try: if dict_from_cookiejar(self.session.cookies)['uid'] and \ dict_from_cookiejar(self.session.cookies)['pass']: self._uid = dict_from_cookiejar(self.session.cookies)['uid'] self._hash = dict_from_cookiejar(self.session.cookies)['pass'] self.cookies = {'uid': self._uid, 'pass': self._hash} return True except Exception: logger.log('Unable to login to provider (cookie)', logger.WARNING) return False else: if re.search('Username does not exist in the userbase or the account is not confirmed yet.', response) or \ re.search('Username or password is incorrect. If you have an account here please use the' ' recovery system or try again.', response): logger.log('Invalid username or password. Check your settings', logger.WARNING) if re.search('DDoS protection by CloudFlare', response): logger.log('Unable to login to provider due to CloudFlare DDoS javascript check', logger.WARNING) return False
def validateRSS(self): try: if self.cookies: cookie_validator = re.compile(r"^(\w+=\w+)(;\w+=\w+)*$") if not cookie_validator.match(self.cookies): return False, 'Cookie is not correctly formatted: ' + self.cookies # pylint: disable=protected-access # Access to a protected member of a client class data = self.cache._getRSSData()['entries'] if not data: return False, 'No items found in the RSS feed ' + self.url (title, url) = self._get_title_and_url(data[0]) if not title: return False, 'Unable to get title from first item' if not url: return False, 'Unable to get torrent url from first item' if url.startswith('magnet:') and re.search(r'urn:btih:([\w]{32,40})', url): return True, 'RSS feed Parsed correctly' else: if self.cookies: add_dict_to_cookiejar(self.session.cookies, dict(x.rsplit('=', 1) for x in self.cookies.split(';'))) torrent_file = self.get_url(url, need_bytes=True) try: bdecode(torrent_file) except Exception as e: self.dumpHTML(torrent_file) return False, 'Torrent link is not a valid torrent file: ' + ex(e) return True, 'RSS feed Parsed correctly' except Exception as e: return False, 'Error when trying to load RSS: ' + ex(e)
def login(self): if any(dict_from_cookiejar(self.session.cookies).values()): return True if self._uid and self._hash: add_dict_to_cookiejar(self.session.cookies, self.cookies) else: login_params = {"username": self.username, "password": self.password, "login": "******"} response = self.get_url(self.urls["login"], post_data=login_params, returns="text") if not response: logger.log(u"Unable to connect to provider", logger.WARNING) return False if re.search("/logout.php", response): try: if ( dict_from_cookiejar(self.session.cookies)["uid"] and dict_from_cookiejar(self.session.cookies)["pass"] ): self._uid = dict_from_cookiejar(self.session.cookies)["uid"] self._hash = dict_from_cookiejar(self.session.cookies)["pass"] self.cookies = {"uid": self._uid, "pass": self._hash} return True except Exception: logger.log(u"Unable to login to provider (cookie)", logger.WARNING) return False else: if re.search("Username does not exist in the userbase or the account is not confirmed yet.", response): logger.log(u"Invalid username or password. Check your settings", logger.WARNING) if re.search("DDoS protection by CloudFlare", response): logger.log(u"Unable to login to provider due to CloudFlare DDoS javascript check", logger.WARNING) return False
def login(self): if any(dict_from_cookiejar(self.session.cookies).values()): return True if self._uid and self._hash: add_dict_to_cookiejar(self.session.cookies, self.cookies) else: login_params = { 'username': self.username, 'password': self.password, 'submit.x': 0, 'submit.y': 0 } response = self.get_url(self.urls['login'], post_data=login_params, timeout=30) if not response: logger.log(u"Unable to connect to provider", logger.WARNING) return False if re.search('You tried too often', response): logger.log(u"Too many login access attempts", logger.WARNING) return False try: if dict_from_cookiejar(self.session.cookies)['uid'] and dict_from_cookiejar(self.session.cookies)['pass']: self._uid = dict_from_cookiejar(self.session.cookies)['uid'] self._hash = dict_from_cookiejar(self.session.cookies)['pass'] self.cookies = {'uid': self._uid, 'pass': self._hash} return True except Exception: pass logger.log(u"Unable to obtain cookie", logger.WARNING) return False
def login(self): if any(dict_from_cookiejar(self.session.cookies).values()): return True if self._uid and self._hash: add_dict_to_cookiejar(self.session.cookies, self.cookies) else: login_params = {'username': self.username, 'password': self.password, 'login': '******'} response = self.get_url(self.urls['login'], post_data=login_params, timeout=30) if not response: logger.log(u"Unable to connect to provider", logger.WARNING) return False if re.search('/logout.php', response): try: if dict_from_cookiejar(self.session.cookies)['uid'] and dict_from_cookiejar(self.session.cookies)['pass']: self._uid = dict_from_cookiejar(self.session.cookies)['uid'] self._hash = dict_from_cookiejar(self.session.cookies)['pass'] self.cookies = {'uid': self._uid, 'pass': self._hash} return True except Exception: logger.log(u"Unable to login to provider (cookie)", logger.WARNING) return False else: if re.search('Username does not exist in the userbase or the account is not confirmed yet.', response): logger.log(u"Invalid username or password. Check your settings", logger.WARNING) if re.search('DDoS protection by CloudFlare', response): logger.log(u"Unable to login to provider due to CloudFlare DDoS javascript check", logger.WARNING) return False
def validateRSS(self): # pylint: disable=too-many-return-statements try: if self.cookies: cookie_validator = re.compile(r'^(\w+=\w+)(;\w+=\w+)*$') if not cookie_validator.match(self.cookies): return False, 'Cookie is not correctly formatted: {0}'.format(self.cookies) add_dict_to_cookiejar(self.session.cookies, dict(x.rsplit('=', 1) for x in self.cookies.split(';'))) # pylint: disable=protected-access # Access to a protected member of a client class data = self.cache._get_rss_data()['entries'] if not data: return False, 'No items found in the RSS feed {0}'.format(self.url) title, url = self._get_title_and_url(data[0]) if not title: return False, 'Unable to get title from first item' if not url: return False, 'Unable to get torrent url from first item' if url.startswith('magnet:') and re.search(r'urn:btih:([\w]{32,40})', url): return True, 'RSS feed Parsed correctly' else: torrent_file = self.get_url(url, returns='content') try: bencode.bdecode(torrent_file) except (bencode.BTL.BTFailure, Exception) as error: self.dumpHTML(torrent_file) return False, 'Torrent link is not a valid torrent file: {0}'.format(error) return True, 'RSS feed Parsed correctly' except Exception as error: return False, 'Error when trying to load RSS: {0}'.format(ex(error))
def _get_rss_data(self): if self.provider.cookies: add_dict_to_cookiejar(self.provider.session.cookies, dict(x.rsplit('=', 1) for x in self.provider.cookies.split(';'))) return self.get_rss_feed(self.provider.url)
def login(self): """Login method used for logging in before doing a search and torrent downloads.""" cookie_dict = dict_from_cookiejar(self.session.cookies) if cookie_dict.get('session'): return True if self.cookies: add_dict_to_cookiejar(self.session.cookies, dict(x.rsplit('=', 1) for x in self.cookies.split(';'))) cookie_dict = dict_from_cookiejar(self.session.cookies) if cookie_dict.get('session'): return True login_params = { 'submit': 'Login', 'username': self.username, 'password': self.password, 'keeplogged': 1, } response = self.get_url(self.urls['login'], post_data=login_params, returns='text') if not response: logger.log(u"Unable to connect to provider", logger.WARNING) return False if re.search('<title>Login :: BJ-Share</title>', response): logger.log(u"Invalid username or password. Check your settings", logger.WARNING) return False return True