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()
