def scroble(self, id, season=None, episode=None, percent=0, action='stop'):
data = {
"action": action,
"progress": float(percent),
"parse": False,
}
if season is not None:
# ep_info = self.get_episode_info(id, season, episode)
data.update({
"show": {
"ids": {
"trakt": id
}
},
"episode": {
"season": season,
"number": episode
}
})
else:
data.update({"movie": {"ids": {"trakt": id}}})
with Trakt.configuration.oauth.from_response(self.authorization):
with Trakt.configuration.http(retry=True):
debug('scrobble obj: {}'.format(data))
try:
result = Trakt['scrobble'].action(**data).json()
except:
result = None
return result
pass
def speedtest(self, isp, ident='15VFNFJrCKHn'):
kr = Kraska()
url = kr.resolve(ident)
smin = 999999999
smax = 0
durmin = 999999999
hosts = ['b01', 's01', 'v01']
for h in hosts:
u = re.sub(r':\/\/([^.]+)', '://{}'.format(h), url)
debug('speedtest URL {}'.format(u))
s, dur = self.calculate_speed(u)
debug('speedtest host {} speed: {}'.format(h, convert_bitrate(s)))
smin = min(s, smin)
smax = max(s, smax)
durmin = min(dur, durmin)
isp.update({h: s})
debug('min/max {}/{}'.format(convert_bitrate(smin),
convert_bitrate(smax)))
debug('res: {}'.format(isp))
try:
st = Sc.post('/Stats/speedtest', json=isp)
debug('Speed stats: {}'.format(st))
except:
pass
speed = smin
settings.set_setting('stream.adv.speedtest', speed)
settings.set_setting('stream.adv.speedtest.asn', isp.get('a', 'N/A'))
settings.set_setting('stream.adv.speedtest.last', int(time.time()))
return (smin, smax, durmin)
def on_authenticated(self, token):
self.authorization = token
set_setting('trakt.authorization', dumps(self.authorization))
debug('TRAKT Authentication complete: %r' % token)
self.authDialog.close()
dok('Trakt', 'Autorizacia uspesna')
self.update_user()
def login(self):
with Trakt.configuration.http(timeout=90):
code = Trakt['oauth/device'].code()
if not code:
debug('TRAKT Error can not reach trakt')
dok('ERROR', 'Trakt.tv error')
else:
# Construct device authentication poller
poller = Trakt['oauth/device'].poll(**code) \
.on('aborted', self.on_aborted) \
.on('authenticated', self.on_authenticated) \
.on('expired', self.on_expired) \
.on('poll', self.on_poll)
debug(
'TRAKT Enter the code "%s" at %s to authenticate your account'
% (code.get('user_code'), code.get('verification_url')))
self.authDialog = dprogress()
self.authDialog.create(
'Trakt', '{} -> {}'.format(code.get('verification_url'),
code.get('user_code')))
self.authPollProgress = [
float(code.get('expires_in')),
float(code.get('interval')), 0
]
# Start polling for authentication token
poller.start(daemon=False)
def onNotification(self, sender, method, data):
try:
self.wsapp.send(method)
except:
pass
logger.debug('[WS] monitor onNotification {} {} {}'.format(
decode(sender), decode(method), decode(data)))
def action_csearch(self):
self.succeeded = True
self.end_of_directory()
_id = self.args.get(SC.ITEM_ID)
home_win.setProperty('SC.search', '{}'.format(_id))
search = dinput('', '', xbmcgui.INPUT_TYPE_TEXT)
home_win.clearProperty('SC.search')
info('search string: {}'.format(search))
if search == '':
exec_build_in('Action(Back)')
return
query = {'search': search, SC.ITEM_ID: _id}
if _id.startswith('search-people'):
query.update({'ms': '1'})
st = List(_id)
st.add(search)
debug('SEARCH: _ID "{}" search for "{}" people "{}"'.format(
_id, search, 1 if 'ms' in query else 0))
url = '/Search/{}?{}'.format(_id, urlencode(query))
info('search url: {}'.format(url))
self.url = url
self.call_url()
if 'msgERROR' in self.response.get('system', {}):
self.msg_error()
exec_build_in('Action(Back)')
return
plugin_url = create_plugin_url({'url': url})
container_update(plugin_url)
return
def add(self, item, remove_only=False):
# debug('List add {} | {}'.format(item, remove_only))
if item is None:
debug('List ignore None item')
return
if self.sorted is True and item in self.data \
or remove_only is True:
# debug('--- remove {}'.format(item))
try:
self.data.remove(item)
except:
pass
if remove_only is False \
or (self.sorted is False and item not in self.data and remove_only is False):
self.data.insert(0, item)
# debug('List insert item')
if self.max_items:
remove = len(self.data) - self.max_items
if remove > 0:
# debug('List to remove {}'.format(remove))
for i in range(remove):
self.data.pop()
# debug('List end add {}'.format(self.data))
self.set(self.data)
def notify(self, filter):
return
try:
plugin_url = 'plugin://{}/{}'.format(
ADDON_ID, params.orig_args if params.orig_args else '')
kv = KodiViewModeDb()
sort = kv.get_sort(plugin_url)
if sort is not None:
j = dumps({
'm': sort[0],
'o': sort[1],
'u': plugin_url,
'f': filter
}).encode()
else:
j = dumps({
'm': 0,
'o': 1,
'u': plugin_url,
'f': filter
}).encode()
from base64 import b64encode
data = b64encode(j).decode()
notify(sender=ADDON_ID, message='List.Sort', data=data)
except:
debug('notify List.Sort ERR: {}'.format(traceback.format_exc()))
pass
def clean_textures():
try:
from resources.lib.common.storage import TexturesDb
t = TexturesDb()
t.clean()
except:
debug('player err: {}'.format(traceback.format_exc()))
def isp_ipinfo():
from resources.lib.system import Http
r = Http.get('https://ipinfo.io/widget', headers={'referer': 'https://ipinfo.io/'})
d = r.json()
debug('isp_ipinfo: {}'.format(r.text))
asn = d.get('asn', {}).get('asn', 'N/A')
return {'c': d.get('country', 'N/A'), 'a': asn.replace('AS', '')}
def container_update(url, replace=False):
if replace:
debug('containter replace {}'.format(url))
exec_build_in('Container.Update({},replace)'.format(url))
else:
debug('containter update {}'.format(url))
exec_build_in('Container.Update({})'.format(url))
def __init__(self, args):
self.args = args
id = self.args.get(SC.ITEM_ID, ['search'])
debug('ID: {}'.format(id))
if id[0] == 'search':
self.search()
else:
self.type()
def set_i18n_art(self):
i18n = self.data.get(SC.ITEM_I18N_ART)
lang = SYSTEM_LANG_CODE
if lang not in i18n:
debug('jazyk {} nemame, tak nastavujem cs'.format(lang))
lang = SC.DEFAULT_LANG
# debug('jazyk {}'.format(lang))
self.item.setArt(i18n.get(lang))
def i18n_info(self, item_info={}):
i18n = self.data.get(SC.ITEM_I18N_INFO)
lang = SYSTEM_LANG_CODE
if lang not in i18n:
debug('jazyk {} nemame, tak nastavujem cs'.format(lang))
lang = SC.DEFAULT_LANG
item_info.update(i18n.get(lang))
return item_info
def save_cache(ret, key, ttl=None):
ttl = 3600 if ttl is None else ttl
if SC.ITEM_SYSTEM in ret and 'TTL' in ret[SC.ITEM_SYSTEM]:
ttl = int(ret[SC.ITEM_SYSTEM]['TTL'])
debug('SAVE TO CACHE {} / {}'.format(ttl, key))
Sc.cache.set(key, ret, expiration=datetime.timedelta(seconds=ttl))
def get_app_name():
try:
data = jsonrpc(method='Application.GetProperties', params=dict(properties=["name"]))
if "result" in data and "name" in data["result"]:
return data["result"]["name"]
except:
debug('ERR app name: {}'.format(traceback.format_exc()))
pass
return "EKodi"
def onAVStarted(self):
debug('player onAVStarted')
for i in range(0, 500):
if self.isPlayback():
break
else:
debug('not playing')
sleep(1000)
self.set_item()
def set_watched_path(self, path, times):
res = self.get_watched_path(path)
if res and res[0]:
# debug('MAME PATH: {}'.find(path))
sql = 'update files set playcount=? where idfile=?'
self._db.execute(sql, times, res[0])
else:
debug('Nemame PATH: {}'.format(path))
pass
def on_poll(self, callback):
debug('TRAKT poll')
if self.authDialog.iscanceled():
callback(False)
else:
self.authPollProgress[2] += self.authPollProgress[1]
exp, _, current = self.authPollProgress
self.authDialog.update(int(current / exp * 100))
callback(True)
def trakt2sc(self, items, typ):
debug('items {}'.format(len(items)))
res = Sc.post('/Ftrakt2sc',
data={
'trakt': dumps(list(items.keys())),
't': typ
})
debug('res: {}'.format(len(res)))
return res, items
def post(path, **kwargs):
sorted_values, url = Sc.prepare(path=path, params={})
start = time.time()
res = Http.post(url,
params=sorted_values,
headers=Sc.headers(),
**kwargs)
end = time.time()
debug('POST took {0:.2f}ms'.format((end - start) * 1000))
return res.json()
def call_url(self):
try:
if self.payload is not None:
debug('POST DATA: {}'.format(self.payload))
self.response = Sc.post(self.url, data=self.payload)
else:
self.response = Sc.get(self.url)
except:
debug('CALL URL ERR: {}'.format(traceback.format_exc()))
self.response = {}
def clean(self):
zoznam = self.to_clean()
total = len(zoznam)
d = dprogressgb()
d.create('mazanie', 'mazem')
for pos, i in enumerate(zoznam):
p = int(pos/total*100)
debug('item: {}/{} {}'.format(pos, total, TexturesDb.file_name(i)))
self.remove_item(i)
d.update(p, 'mazanie', 'mazem {}'.format(i[1]))
d.close()
def read(self, sock, read_callback, check_callback):
while self.app.keep_running and not monitor.abortRequested():
logger.debug('[WS] loop')
r, w, e = select.select((self.app.sock.sock, ), (), (),
self.ping_timeout)
if r:
if not read_callback():
break
check_callback()
logger.debug('[WS] Koncim....')
self.app.close(status=websocket.STATUS_PROTOCOL_ERROR)
def get(self):
tmp = {}
for k in self.list._data.items():
if k[1]['t'] is not None:
tmp.update({k[0]: k[1]})
else:
debug('ERR ITEM: {}'.format(k))
debug('GET NEXT EP: {}'.format(tmp))
ret = [k[0] for k in sorted(tmp.items(), key=lambda x: x[1]['t'], reverse=True)]
return ret
def _remove_settings_file():
try:
fn = make_legal_filename(
translate_path(
"special://profile/addon_data/{}/settings.xml".format(
ADDON_ID)))
debug('REMOVE SETTINGS FILE: {} -> {}'.format(fn, xbmcvfs.exists(fn)))
if xbmcvfs.exists(fn):
xbmcvfs.delete(fn)
except:
pass
def get_isp():
for fn in [isp_ipinfo, isp_ipapi, isp_dbip, isp_ipgeolocationioapi]:
try:
isp = fn()
if isp.get('a') is not None:
debug('*************************************************** ISP: {}'.format(isp))
return isp
except:
debug('ERRO ISP: {}'.format(traceback.format_exc()))
return None
def intro(step=None, credentials_only=False):
info('Step: {}'.format(step))
auto_close = 60
if step is None and get_setting('kraska.user') != '':
info('Uz nieje treba intro....')
return
elif step is None:
step = 1
if step == 1:
start = dyesno(Strings.txt(Strings.INTRO_STEP1_H1),
Strings.txt(Strings.INTRO_STEP1_L1),
autoclose=auto_close)
info('RET: [{}] [{}]'.format(start, 'Ano' if start else 'Nie'))
return intro(step + 1, credentials_only) if start == 1 else 0
if step == 2:
user = dinput(Strings.txt(Strings.INTRO_STEP2_H1),
get_setting('kraska.user'))
info(Strings.INTRO_STEP1_H1)
info(Strings.txt(Strings.INTRO_STEP1_H1))
info('RET: {}'.format(user))
settings.set_setting('kraska.user', user)
if user != settings.get_setting('kraska.user'):
_remove_settings_file()
debug('Zmazanie nastaveni')
return 0
return intro(step + 1, credentials_only) if user != '' else 0
if step == 3:
password = dinput(Strings.txt(Strings.INTRO_STEP3_H1), '')
info('RET: {}'.format(password))
settings.set_setting('kraska.pass', password)
if password != settings.get_setting('kraska.pass'):
debug('skusam znova zapisat heslo...')
settings.set_setting('kraska.pass', password)
kr = Kraska(p=password)
data = kr.user_info()
return intro(step +
1, credentials_only) if data is False else intro(step + 2)
if step == 4:
dok(Strings.txt(Strings.INTRO_STEP4_H1),
Strings.txt(Strings.INTRO_STEP4_L1))
return intro(step - 2, credentials_only)
if step == 5 and credentials_only is False:
res = dyesno(Strings.txt(Strings.INTRO_STEP5_H1),
Strings.txt(Strings.INTRO_STEP5_L1))
if res:
open_settings('1.0')
def set_stream_info(self):
stream_info = self.data.get('stream_info')
for k, v in enumerate(stream_info):
self.item.addStreamInfo(
v, stream_info.get(v)) if v in ['video', 'audio'] else ''
if 'fvideo' in stream_info:
debug('FVIDEO: {}'.format(stream_info['fvideo']))
self.item.setProperty('video', stream_info['fvideo'])
if 'faudio' in stream_info:
self.item.setProperty('audio', stream_info['faudio'])
def _set_info(self, item_info):
if self.debug:
debug('set_info {}'.format(item_info))
self.info.update(item_info)
try:
if SC.ITEM_TITLE in item_info:
title = '{}'.format(item_info.get(SC.ITEM_TITLE))
self.item.setLabel(title)
if self.data.get('play'):
if 'otitle' in item_info:
item_info.update({SC.ITEM_TITLE: item_info['otitle']})
del item_info['otitle']
if 'epname' in item_info:
item_info.update({SC.ITEM_TITLE: item_info['epname']})
del item_info['epname']
else:
if 'epname' in item_info:
del item_info['epname']
if 'otitle' in item_info:
del item_info['otitle']
for i, e in enumerate(item_info):
# debug('set info {} {}'.format(i, e))
self.item.setProperty(e, '{}'.format(item_info[e]))
if item_info.get('mediatype',
'') == 'season' and item_info.get('episode'):
item = SCKODIItem(self.data.get(SC.ITEM_ID))
data = item.data
total_episodes = item_info.get('episode')
watched = len(
data.get('series:{}'.format(item_info.get('season')), {}))
debug('Mame seriu {} s {}/{} epizodami'.format(
item_info.get('season'), watched, total_episodes))
if watched >= total_episodes:
item_info.update({'playcount': '1'})
self.item.setInfo('video', item_info)
self.item.setProperty('original_title',
item_info.get('originaltitle'))
self.info_set = True
except Exception as e:
import traceback
info(
'-----------------------------------------------------------------'
)
info('set info error [{}]'.format(str(traceback.format_exc())))
info(
'-----------------------------------------------------------------'
)
