def lotteryDialog(self):
from resources.lib.extensions import interface
type = tools.Settings.getString('general.statistics.lottery.type')
voucher = tools.Settings.getString('general.statistics.lottery.voucher')
description = tools.Settings.getString('general.statistics.lottery.description')
instruction = tools.Settings.getString('general.statistics.lottery.instruction')
timeClaim = tools.Settings.getInteger('general.statistics.lottery.time.claim')
timeExpiry = tools.Settings.getInteger('general.statistics.lottery.time.expiry')
timeDuration = tools.Settings.getInteger('general.statistics.lottery.time.duration')
indent = ' '
message = interface.Format.bold(interface.Translation.string(33875)) + interface.Format.newline()
message += '%s%s: %s' % (indent, interface.Translation.string(33343), interface.Format.bold(type)) + interface.Format.newline()
message += '%s%s: %s' % (indent, interface.Translation.string(33876), interface.Format.bold(voucher)) + interface.Format.newline()
if description:
message += '%s%s: %s' % (indent, interface.Translation.string(33040), interface.Format.bold(description)) + interface.Format.newline()
if instruction:
message += instruction
if not message.endswith('.'): message += '.'
if timeExpiry and timeDuration:
expirationDuration = convert.ConverterDuration(timeDuration, convert.ConverterDuration.UnitSecond).string(format = convert.ConverterDuration.FormatWordLong, unit = convert.ConverterDuration.UnitDay)
expirationTime = convert.ConverterTime(timeExpiry, convert.ConverterTime.FormatTimestamp).string(format = convert.ConverterTime.FormatDate)
expiration = '%s (%s)' % (expirationDuration, expirationTime)
message += ' ' + (interface.Translation.string(33877) % expiration)
message += ' ' + interface.Translation.string(33878)
interface.Dialog.confirm(title = 33879, message = message)
interface.Player().stop()
def markEpisodeDuringPlayback(imdb, tvdb, season, episode, watched):
try:
if trakt.getTraktIndicatorsInfo() == False:
raise Exception()
setting = None
if int(watched) == 7:
# Only mark as watched if the previous watch is more than a week ago.
# Trakt allows to mark an item with multiple watches, eg: watching a movie multiple times.
# However, if the playback is stopped at almost the end of the stream and then finished a few days later, it will be marked watched multiple times.
# Ignore these marks for items watched more than a week ago.
allow = True
setting = tools.Settings.getInteger(
'accounts.informants.trakt.watched')
if setting == 0:
try:
watchedTime = trakt.watchedShowsTime(tvdb, season, episode)
watchedTime = convert.ConverterTime(
value=watchedTime,
format=convert.ConverterTime.FormatDateTimeJson
).timestamp()
currentTime = tools.Time.timestamp()
differenceTime = currentTime - watchedTime
allow = differenceTime > 604800
except:
pass
elif setting == 1:
trakt.markEpisodeAsNotWatched(imdb, tvdb, season, episode)
if allow: trakt.markEpisodeAsWatched(imdb, tvdb, season, episode)
else:
trakt.markEpisodeAsNotWatched(imdb, tvdb, season, episode)
trakt.cachesyncTVShows()
if (setting == None
or setting == 1) and trakt.getTraktAddonEpisodeInfo() == True:
trakt.markEpisodeAsNotWatched(imdb, tvdb, season, episode)
except:
pass
try:
from metahandler import metahandlers
metaget = metahandlers.MetaData(preparezip=False)
metaget.get_meta('tvshow', name='', imdb_id=imdb)
metaget.get_episode_meta('',
imdb_id=imdb,
season=season,
episode=episode)
metaget.change_watched('episode',
'',
imdb_id=imdb,
season=season,
episode=episode,
watched=int(watched))
except:
pass
def markMovieDuringPlayback(imdb, tmdb, watched):
try:
if trakt.getTraktIndicatorsInfo() == False:
raise Exception()
setting = None
watched = int(watched)
watchedIs = watched == 7
if watchedIs:
# Only mark as watched if the previous watch is more than a week ago.
# Trakt allows to mark an item with multiple watches, eg: watching a movie multiple times.
# However, if the playback is stopped at almost the end of the stream and then finished a few days later, it will be marked watched multiple times.
# Ignore these marks for items watched more than a week ago.
allow = True
setting = tools.Settings.getInteger(
'accounts.informants.trakt.watched')
if setting == 0:
try:
watchedTime = trakt.watchedMoviesTime(imdb)
watchedTime = convert.ConverterTime(
value=watchedTime,
format=convert.ConverterTime.FormatDateTimeJson
).timestamp()
currentTime = tools.Time.timestamp()
differenceTime = currentTime - watchedTime
allow = differenceTime > 604800
except:
pass
elif setting == 1:
trakt.markMovieAsNotWatched(imdb=imdb, tmdb=tmdb)
if allow: trakt.markMovieAsWatched(imdb=imdb, tmdb=tmdb)
else:
trakt.markMovieAsNotWatched(imdb=imdb, tmdb=tmdb)
trakt.syncMoviesCache()
if (setting == None
or setting == 1) and trakt.getTraktAddonMovieInfo() == True:
trakt.markMovieAsNotWatched(imdb)
except:
pass
try:
from metahandler import metahandlers
metaget = metahandlers.MetaData(preparezip=False)
metaget.get_meta('movie', name='', imdb_id=imdb)
metaget.change_watched('movie', name='', imdb_id=imdb, watched=watched)
except:
pass
try:
from resources.lib.extensions import video
if watchedIs: video.Trailer().watch(imdb=imdb)
else: video.Trailer().unwatch(imdb=imdb)
except:
tools.Logger.error()
def account(self, cached = True, minimal = False):
account = None
try:
if self.accountValid():
import datetime
from resources.lib.externals.beautifulsoup import BeautifulSoup
if cached: accountHtml = cache.Cache().cacheShort(self._request, Core.LinkAccount)
else: accountHtml = cache.Cache().cacheClear(self._request, Core.LinkAccount)
if accountHtml == None or accountHtml == '': raise Exception()
accountHtml = BeautifulSoup(accountHtml)
accountHtml = accountHtml.find_all('form', id = 'accountForm')[0]
accountHtml = accountHtml.find_all('table', recursive = False)[0]
accountHtml = accountHtml.find_all('tr', recursive = False)
accountUsername = accountHtml[0].find_all('td', recursive = False)[1].getText()
accountType = accountHtml[1].find_all('td', recursive = False)[2].getText()
accountStatus = accountHtml[3].find_all('td', recursive = False)[2].getText()
accountExpiration = accountHtml[2].find_all('td', recursive = False)[2].getText()
accountTimestamp = convert.ConverterTime(accountExpiration, format = convert.ConverterTime.FormatDate).timestamp()
accountExpiration = datetime.datetime.fromtimestamp(accountTimestamp)
account = {
'user' : accountUsername,
'type' : accountType,
'status' : accountStatus,
'expiration' : {
'timestamp' : accountTimestamp,
'date' : accountExpiration.strftime('%Y-%m-%d'),
'remaining' : (accountExpiration - datetime.datetime.today()).days,
}
}
if not minimal:
if cached: usageHtml = cache.Cache().cacheShort(self._request, Core.LinkUsage)
else: usageHtml = cache.Cache().cacheClear(self._request, Core.LinkUsage)
if usageHtml == None or usageHtml == '': raise Exception()
usageHtml = BeautifulSoup(usageHtml)
usageHtml = usageHtml.find_all('div', class_ = 'table-responsive')[0]
usageHtml = usageHtml.find_all('table', recursive = False)[0]
usageHtml = usageHtml.find_all('tr', recursive = False)
usageTotal = usageHtml[0].find_all('td', recursive = False)[1].getText()
index = usageTotal.find('(')
if index >= 0: usageTotal = int(usageTotal[index + 1 : usageTotal.find(' ', index)].replace(',', '').strip())
else: usageTotal = 0
usageConsumed = usageHtml[1].find_all('td', recursive = False)[2].getText()
index = usageConsumed.find('(')
if index >= 0: usageConsumed = int(usageConsumed[index + 1 : usageConsumed.find(' ', index)].replace(',', '').strip())
else: usageConsumed = 0
usageWeb = usageHtml[2].find_all('td', recursive = False)[2].getText()
index = usageWeb.find('(')
if index >= 0: usageWeb = int(usageWeb[index + 1 : usageWeb.find(' ', index)].replace(',', '').strip())
else: usageWeb = 0
usageNntp = usageHtml[3].find_all('td', recursive = False)[2].getText()
index = usageNntp.find('(')
if index >= 0: usageNntp = int(usageNntp[index + 1 : usageNntp.find(' ', index)].replace(',', '').strip())
else: usageNntp = 0
usageNntpUnlimited = usageHtml[4].find_all('td', recursive = False)[2].getText()
index = usageNntpUnlimited.find('(')
if index >= 0: usageNntpUnlimited = int(usageNntpUnlimited[index + 1 : usageNntpUnlimited.find(' ', index)].replace(',', '').strip())
else: usageNntpUnlimited = 0
usageRemaining = usageHtml[5].find_all('td', recursive = False)[2].getText()
index = usageRemaining.find('(')
if index >= 0: usageRemaining = int(usageRemaining[index + 1 : usageRemaining.find(' ', index)].replace(',', '').strip())
else: usageRemaining = 0
usageLoyalty = usageHtml[6].find_all('td', recursive = False)[2].getText()
index = usageLoyalty.find('(')
if index >= 0:
usageLoyaltyTime = usageLoyalty[:index].strip()
usageLoyaltyTimestamp = convert.ConverterTime(usageLoyaltyTime, format = convert.ConverterTime.FormatDate).timestamp()
usageLoyaltyTime = datetime.datetime.fromtimestamp(usageLoyaltyTimestamp)
usageLoyaltyPoints = float(usageLoyalty[index + 1 : usageLoyalty.find(')', index)].strip())
else:
usageLoyaltyTimestamp = 0
usageLoyaltyTime = None
usagePrecentageRemaining = usageRemaining / float(usageTotal)
usagePrecentageConsumed = usageConsumed / float(usageTotal)
usagePrecentageWeb = usageWeb / float(usageTotal)
usagePrecentageNntp = usageNntp / float(usageTotal)
usagePrecentageNntpUnlimited = usageNntpUnlimited / float(usageTotal)
account.update({
'loyalty' : {
'time' : {
'timestamp' : usageLoyaltyTimestamp,
'date' : usageLoyaltyTime.strftime('%Y-%m-%d')
},
'points' : usageLoyaltyPoints,
},
'usage' : {
'total' : {
'size' : {
'bytes' : usageTotal,
'description' : convert.ConverterSize(float(usageTotal)).stringOptimal(),
},
},
'remaining' : {
'value' : usagePrecentageRemaining,
'percentage' : round(usagePrecentageRemaining * 100.0, 1),
'size' : {
'bytes' : usageRemaining,
'description' : convert.ConverterSize(float(usageRemaining)).stringOptimal(),
},
'description' : '%.0f%%' % round(usagePrecentageRemaining * 100.0, 0), # Must round, otherwise 2.5% changes to 2% instead of 3%.
},
'consumed' : {
'value' : usagePrecentageConsumed,
'percentage' : round(usagePrecentageConsumed * 100.0, 1),
'size' : {
'bytes' : usageConsumed,
'description' : convert.ConverterSize(usageConsumed).stringOptimal(),
},
'description' : '%.0f%%' % round(usagePrecentageConsumed * 100.0, 0), # Must round, otherwise 2.5% changes to 2% instead of 3%.
'web' : {
'value' : usagePrecentageWeb,
'percentage' : round(usagePrecentageWeb * 100.0, 1),
'size' : {
'bytes' : usageWeb,
'description' : convert.ConverterSize(usageWeb).stringOptimal(),
},
'description' : '%.0f%%' % round(usagePrecentageWeb * 100.0, 0), # Must round, otherwise 2.5% changes to 2% instead of 3%.
},
'nntp' : {
'value' : usagePrecentageNntp,
'percentage' : round(usagePrecentageNntp * 100.0, 1),
'size' : {
'bytes' : usageNntp,
'description' : convert.ConverterSize(usageNntp).stringOptimal(),
},
'description' : '%.0f%%' % round(usagePrecentageNntp * 100.0, 0), # Must round, otherwise 2.5% changes to 2% instead of 3%.
},
'nntpunlimited' : {
'value' : usagePrecentageNntpUnlimited,
'percentage' : round(usagePrecentageNntpUnlimited * 100.0, 1),
'size' : {
'bytes' : usageNntpUnlimited,
'description' : convert.ConverterSize(usageNntpUnlimited).stringOptimal(),
},
'description' : '%.0f%%' % round(usagePrecentageNntpUnlimited * 100.0, 0), # Must round, otherwise 2.5% changes to 2% instead of 3%.
},
}
}
})
except:
pass
return account
def sources(self, url, hostDict, hostprDict):
sources = []
try:
debridHas = False
if not debridHas:
premiumize = debrid.Premiumize()
debridHas = premiumize.accountEnabled() and premiumize.accountValid()
if not debridHas:
offcloud = debrid.OffCloud()
debridHas = offcloud.accountEnabled() and offcloud.accountValid()
if not debridHas:
realdebrid = debrid.RealDebrid()
debridHas = realdebrid.accountEnabled() and realdebrid.accountValid()
if not debridHas:
alldebrid = debrid.AllDebrid()
debridHas = alldebrid.accountEnabled() and alldebrid.accountValid()
if not debrid:
rapidpremium = debrid.RapidPremium()
debridHas = rapidpremium.accountEnabled() and rapidpremium.accountValid()
data = urlparse.parse_qs(url)
data = dict([(i, data[i][0]) if data[i] else (i, '') for i in data])
movie = False if 'tvshowtitle' in data else True
title = data['tvshowtitle'] if 'tvshowtitle' in data else data['title']
year = str(data['year']) if 'year' in data and not data['year'] == None else ''
season = str(data['season']) if 'season' in data and not data['season'] == None else ''
episode = str(data['episode']) if 'episode' in data and not data['episode'] == None else ''
imdb = data['imdb'] if 'imdb' in data else ''
tvdb = data['tvdb'] if 'tvdb' in data else ''
scraper = nanscrapers.relevant_scrapers(names_list = self.name.lower(), include_disabled = True, exclude = None)[0]()
if self.base_link and not self.base_link == '': scraper.base_link = self.base_link
if movie:
result = scraper.scrape_movie(title = title, year = year, imdb = imdb, debrid = debridHas)
else:
showYear = year
try:
if 'premiered' in data and not data['premiered'] == None and not data['premiered'] == '':
for format in ['%Y-%m-%d', '%Y-%d-%m', '%d-%m-%Y', '%m-%d-%Y']:
try:
showYear = str(int(convert.ConverterTime(value = data['premiered'], format = format).string(format = '%Y')))
if len(showYear) == 4: break
except:
pass
except:
pass
result = scraper.scrape_episode(title = title, year = year, show_year = showYear, season = season, episode = episode, imdb = imdb, tvdb = tvdb, debrid = debridHas)
if result:
for item in result:
item['external'] = True
item['language']= self.language[0]
item['debridonly'] = False
item['url'] = item['url'].replace('http:http:', 'http:').replace('https:https:', 'https:').replace('http:https:', 'https:').replace('https:http:', 'http:') # Some of the links start with a double http.
# External providers (eg: "Get Out"), sometimes has weird characters in the URL.
# Ignore the links that have non-printable ASCII or UTF8 characters.
try: item['url'].decode('utf-8')
except: continue
source = item['source'].lower().replace(' ', '')
if source == 'direct' or source == 'directlink':
source = urlparse.urlsplit(item['url'])[1].split(':')[0]
if network.Networker.ipIs(source):
source = 'Anonymous'
else:
split = source.split('.')
for i in split:
i = i.lower()
if i in ['www', 'ftp']: continue
source = i
break
item['source'] = source
sources.append(item)
return sources
except:
tools.Logger.error()
return sources