mirror of
https://github.com/SickGear/SickGear.git
synced 2024-12-24 11:43:38 +00:00
478 lines
17 KiB
Python
478 lines
17 KiB
Python
# coding=utf-8
|
|
#
|
|
# This file is part of SickGear.
|
|
#
|
|
# SickGear is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation, either version 3 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# SickGear is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with SickGear. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
try:
|
|
import json as json
|
|
except (BaseException, Exception):
|
|
import simplejson as json
|
|
from os import path, sep
|
|
import datetime
|
|
import socket
|
|
# noinspection PyUnresolvedReferences,PyProtectedMember
|
|
from ssl import _create_unverified_context
|
|
import sys
|
|
import time
|
|
import traceback
|
|
|
|
# these are Kodi specific libs, so block the error reports in pycharm
|
|
# noinspection PyUnresolvedReferences
|
|
import xbmc
|
|
# noinspection PyUnresolvedReferences
|
|
import xbmcaddon
|
|
# noinspection PyUnresolvedReferences
|
|
import xbmcgui
|
|
# noinspection PyUnresolvedReferences
|
|
import xbmcvfs
|
|
|
|
ADDON_VERSION = '1.0.9'
|
|
|
|
# try to locate /temp at parent location
|
|
PATH_TEMP = path.join(path.dirname(path.dirname(path.realpath(__file__))), 'temp')
|
|
|
|
PY2 = 2 == sys.version_info[0]
|
|
|
|
if PY2:
|
|
# noinspection PyCompatibility,PyUnresolvedReferences
|
|
from urllib2 import Request, urlopen, URLError
|
|
# noinspection PyUnresolvedReferences
|
|
from urllib import urlencode
|
|
|
|
# noinspection PyCompatibility,PyUnresolvedReferences
|
|
string_types = (basestring,)
|
|
binary_type = str
|
|
|
|
def iterkeys(d, **kw):
|
|
# noinspection PyCompatibility
|
|
return d.iterkeys(**kw)
|
|
|
|
def itervalues(d, **kw):
|
|
# noinspection PyCompatibility
|
|
return d.itervalues(**kw)
|
|
|
|
def iteritems(d, **kw):
|
|
# noinspection PyCompatibility
|
|
return d.iteritems(**kw)
|
|
|
|
# noinspection PyUnusedLocal
|
|
def decode_bytes(d, **kw):
|
|
if not isinstance(d, binary_type):
|
|
return bytes(d)
|
|
return d
|
|
|
|
else:
|
|
# noinspection PyCompatibility,PyUnresolvedReferences
|
|
from urllib.error import URLError
|
|
# noinspection PyCompatibility,PyUnresolvedReferences
|
|
from urllib.parse import urlencode
|
|
# noinspection PyCompatibility,PyUnresolvedReferences
|
|
from urllib.request import Request, urlopen
|
|
|
|
string_types = (str,)
|
|
binary_type = bytes
|
|
|
|
def iterkeys(d, **kw):
|
|
return iter(d.keys(**kw))
|
|
|
|
def itervalues(d, **kw):
|
|
return iter(d.values(**kw))
|
|
|
|
def iteritems(d, **kw):
|
|
return iter(d.items(**kw))
|
|
|
|
def decode_bytes(d, encoding='utf-8', errors='replace'):
|
|
if not isinstance(d, binary_type):
|
|
# noinspection PyArgumentList
|
|
return bytes(d, encoding=encoding, errors=errors)
|
|
return d
|
|
|
|
|
|
def decode_str(s, encoding='utf-8', errors=None):
|
|
if isinstance(s, binary_type):
|
|
if None is errors:
|
|
return s.decode(encoding)
|
|
return s.decode(encoding, errors)
|
|
return s
|
|
|
|
|
|
class SickGearWatchedStateUpdater(object):
|
|
|
|
def __init__(self):
|
|
self.wait_onstartup = 4000
|
|
|
|
icon_size = '%s'
|
|
try:
|
|
if 1350 > xbmcgui.Window.getWidth(xbmcgui.Window()):
|
|
icon_size += '-sm'
|
|
except (BaseException, Exception):
|
|
pass
|
|
icon = 'special://home/addons/service.sickgear.watchedstate.updater/resources/icon-%s.png' % icon_size
|
|
|
|
self.addon = xbmcaddon.Addon()
|
|
self.red_logo = icon % 'red'
|
|
self.green_logo = icon % 'green'
|
|
self.black_logo = icon % 'black'
|
|
self.addon_name = self.addon.getAddonInfo('name')
|
|
self.kodi_ip = self.addon.getSetting('kodi_ip')
|
|
self.kodi_port = int(self.addon.getSetting('kodi_port'))
|
|
|
|
self.kodi_events = None
|
|
self.sock_kodi = None
|
|
|
|
def run(self):
|
|
"""
|
|
Main start
|
|
|
|
:return:
|
|
:rtype:
|
|
"""
|
|
|
|
if not self.enable_kodi_allow_remote():
|
|
return
|
|
|
|
self.sock_kodi = socket.socket()
|
|
self.sock_kodi.setblocking(True)
|
|
xbmc.sleep(self.wait_onstartup)
|
|
try:
|
|
self.sock_kodi.connect((self.kodi_ip, self.kodi_port))
|
|
except (BaseException, Exception) as e:
|
|
return self.report_contact_fail(e)
|
|
|
|
self.log('Started')
|
|
self.notify('Started in background')
|
|
|
|
cache_pkg = 'special://home/addons/packages/service.sickgear.watchedstate.updater-%s.zip' % ADDON_VERSION
|
|
if xbmcvfs.exists(cache_pkg):
|
|
try:
|
|
xbmcvfs.delete(cache_pkg)
|
|
except (BaseException, Exception):
|
|
pass
|
|
|
|
self.kodi_events = xbmc.Monitor()
|
|
|
|
sock_buffer, depth, methods, method = '', 0, {'VideoLibrary.OnUpdate': self.video_library_on_update}, None
|
|
|
|
# socks listener parsing Kodi json output into action to perform
|
|
while not self.kodi_events.abortRequested():
|
|
chunk = decode_str(self.sock_kodi.recv(1))
|
|
sock_buffer += chunk
|
|
if chunk in '{}':
|
|
if '{' == chunk:
|
|
depth += 1
|
|
else:
|
|
depth -= 1
|
|
if not depth:
|
|
json_msg = json.loads(sock_buffer)
|
|
try:
|
|
method = json_msg.get('method')
|
|
method_handler = methods[method]
|
|
method_handler(json_msg)
|
|
except KeyError:
|
|
if 'System.OnQuit' == method:
|
|
break
|
|
if __dev__:
|
|
self.log('pass on event: %s' % json_msg.get('method'))
|
|
|
|
sock_buffer = ''
|
|
|
|
self.sock_kodi.close()
|
|
del self.kodi_events
|
|
self.log('Stopped')
|
|
|
|
def is_enabled(self, name):
|
|
"""
|
|
Return state of an Add-on setting as Boolean
|
|
|
|
:param name: Name of Addon setting
|
|
:type name: String
|
|
:return: Success as True if addon setting is enabled, else False
|
|
:rtype: Bool
|
|
"""
|
|
return 'true' == self.addon.getSetting(name)
|
|
|
|
def log(self, msg, error=False):
|
|
"""
|
|
Add a message to the Kodi logging system (provided setting allows it)
|
|
|
|
:param msg: Text to add to log file
|
|
:type msg: String
|
|
:param error: Specify whether text indicates an error or action
|
|
:type error: Boolean
|
|
:return:
|
|
:rtype:
|
|
"""
|
|
if self.is_enabled('verbose_log'):
|
|
xbmc.log('[%s]:: %s' % (self.addon_name, msg), (xbmc.LOGNOTICE, xbmc.LOGERROR)[error])
|
|
|
|
def notify(self, msg, period=4, error=None):
|
|
"""
|
|
Invoke the Kodi onscreen notification panel with a message (provided setting allows it)
|
|
|
|
:param msg: Text to display in panel
|
|
:type msg: String
|
|
:param period: Wait seconds before closing dialog
|
|
:type period: Integer
|
|
:param error: Specify whether text indicates an error or action
|
|
:type error: Boolean
|
|
:return:
|
|
:rtype:
|
|
"""
|
|
if not error and self.is_enabled('action_notification') or (error and self.is_enabled('error_notification')):
|
|
xbmc.executebuiltin('Notification(%s, "%s", %s, %s)' % (
|
|
self.addon_name, msg, 1000 * period,
|
|
((self.green_logo, self.red_logo)[any([error])], self.black_logo)[None is error]))
|
|
|
|
@staticmethod
|
|
def ex(e):
|
|
return '\n'.join(['\nEXCEPTION Raised: --> Python callback/script returned the following error <--',
|
|
'Error type: <type \'{0}\'>',
|
|
'Error content: {1!r}',
|
|
'{2}',
|
|
'--> End of Python script error report <--\n'
|
|
]).format(type(e).__name__, e.args, traceback.format_exc())
|
|
|
|
def report_contact_fail(self, e):
|
|
msg = 'Failed to contact Kodi at %s:%s' % (self.kodi_ip, self.kodi_port)
|
|
self.log('%s %s' % (msg, self.ex(e)), error=True)
|
|
self.notify(msg, period=20, error=True)
|
|
|
|
def kodi_request(self, params):
|
|
params.update(dict(jsonrpc='2.0', id='SickGear'))
|
|
try:
|
|
response = xbmc.executeJSONRPC(json.dumps(params))
|
|
except (BaseException, Exception) as e:
|
|
return self.report_contact_fail(e)
|
|
try:
|
|
return json.loads(response)
|
|
except UnicodeDecodeError:
|
|
return json.loads(response.decode('utf-8', 'ignore'))
|
|
|
|
def video_library_on_update(self, json_msg):
|
|
"""
|
|
Actions to perform for: Kodi Notifications / VideoLibrary / VideoLibrary.OnUpdate
|
|
invoked in Kodi when: A video item has been updated
|
|
source: http://kodi.wiki/view/JSON-RPC_API/v8#VideoLibrary.OnUpdate
|
|
|
|
:param json_msg: A JSON parsed from socks
|
|
:type json_msg: String
|
|
:return:
|
|
:rtype:
|
|
"""
|
|
try:
|
|
# note: this is called multiple times when a season is marked as un-/watched
|
|
if 'episode' == json_msg['params']['data']['item']['type']:
|
|
media_id = json_msg['params']['data']['item']['id']
|
|
play_count = json_msg['params']['data']['playcount']
|
|
|
|
json_resp = self.kodi_request(dict(
|
|
method='Profiles.GetCurrentProfile'))
|
|
current_profile = json_resp['result']['label']
|
|
|
|
json_resp = self.kodi_request(dict(
|
|
method='VideoLibrary.GetEpisodeDetails',
|
|
params=dict(episodeid=media_id, properties=['file'])))
|
|
path_file = json_resp['result']['episodedetails']['file'].encode('utf-8')
|
|
|
|
self.update_sickgear(media_id, path_file, play_count, current_profile)
|
|
except (BaseException, Exception):
|
|
pass
|
|
|
|
def update_sickgear(self, media_id, path_file, play_count, profile):
|
|
|
|
self.notify('Update sent to SickGear')
|
|
|
|
file_name = 'sickgear_extra.txt'
|
|
data_extra = self.load_json(file_name)
|
|
scheme = data_extra.get('scheme', 'http')
|
|
|
|
url = '%s://%s:%s/update-watched-state-kodi-legacy/' % (
|
|
scheme, self.addon.getSetting('sickgear_ip'), self.addon.getSetting('sickgear_port'))
|
|
self.log('Notify state to %s with path_file=%s' % (url, path_file))
|
|
|
|
msg_bad = 'Failed to contact SickGear on port %s at %s' % (
|
|
self.addon.getSetting('sickgear_port'), self.addon.getSetting('sickgear_ip'))
|
|
|
|
payload_json = self.payload_prep(dict(media_id=media_id, path_file=path_file, played=play_count, label=profile))
|
|
if payload_json:
|
|
payload = urlencode(dict(payload=payload_json, version=ADDON_VERSION))
|
|
r = None
|
|
change_scheme = False
|
|
try:
|
|
rq = Request(url, data=decode_bytes(payload))
|
|
param = ({'context': _create_unverified_context()}, {})[url.startswith('http:')]
|
|
r = urlopen(rq, **param)
|
|
except (BaseException, Exception):
|
|
change_scheme = True
|
|
|
|
try:
|
|
if change_scheme:
|
|
old_scheme, scheme = 'http', 'https'
|
|
if url.startswith('https'):
|
|
old_scheme, scheme = 'https', 'http'
|
|
url = url.replace(old_scheme, scheme)
|
|
|
|
self.log('Change scheme, notify state to %s' % url)
|
|
|
|
rq = Request(url, data=decode_bytes(payload))
|
|
param = ({'context': _create_unverified_context()}, {})[url.startswith('http:')]
|
|
r = urlopen(rq, **param)
|
|
|
|
response = json.load(r)
|
|
r.close()
|
|
if 'OK' == r.msg:
|
|
if change_scheme:
|
|
data_extra['scheme'] = scheme
|
|
output = json.dumps(data_extra)
|
|
self.save_json(file_name, output)
|
|
|
|
self.payload_prep(response)
|
|
if not all(itervalues(response)):
|
|
msg = 'Success, watched state updated'
|
|
else:
|
|
msg = 'Success, %s/%s watched stated updated' % (
|
|
len([None for v in itervalues(response) if v]), len([None for _ in itervalues(response)]))
|
|
self.log(msg)
|
|
self.notify(msg, error=False)
|
|
else:
|
|
msg_bad = 'Failed to update watched state'
|
|
self.log(msg_bad)
|
|
self.notify(msg_bad, error=True)
|
|
except (BaseException, Exception) as e:
|
|
self.log(u'Couldn\'t contact SickGear %s' % self.ex(e), error=True)
|
|
self.notify(msg_bad, error=True, period=15)
|
|
|
|
@staticmethod
|
|
def load_json(file_name):
|
|
result = {}
|
|
|
|
file_path = path.join(PATH_TEMP, file_name)
|
|
if xbmcvfs.exists(file_path):
|
|
fh = None
|
|
try:
|
|
fh = xbmcvfs.File(file_path)
|
|
result = json.load(fh)
|
|
except (BaseException, Exception):
|
|
pass
|
|
fh and fh.close()
|
|
|
|
return result
|
|
|
|
@staticmethod
|
|
def save_json(file_name, data):
|
|
temp_ok = xbmcvfs.exists(PATH_TEMP) or xbmcvfs.exists(path.join(PATH_TEMP, sep))
|
|
if not temp_ok:
|
|
temp_ok = xbmcvfs.mkdirs(PATH_TEMP)
|
|
|
|
if temp_ok:
|
|
fh = None
|
|
try:
|
|
fh = xbmcvfs.File(path.join(PATH_TEMP, file_name), 'w')
|
|
fh.write(data)
|
|
except (BaseException, Exception):
|
|
pass
|
|
fh and fh.close()
|
|
|
|
def payload_prep(self, payload):
|
|
# type: (dict) -> str
|
|
|
|
file_name = 'sickgear_buffer.txt'
|
|
|
|
data_pool = self.load_json(file_name)
|
|
|
|
response_data = False
|
|
for k, v in iteritems(payload):
|
|
if response_data or k in data_pool:
|
|
response_data = True
|
|
if not v:
|
|
# whether no fail response or bad input, remove this from data
|
|
data_pool.pop(k)
|
|
elif isinstance(v, string_types):
|
|
# error so retry next time
|
|
continue
|
|
if not response_data:
|
|
ts_now = time.mktime(datetime.datetime.now().timetuple())
|
|
timeout = 100
|
|
while ts_now in data_pool and timeout:
|
|
ts_now = time.mktime(datetime.datetime.now().timetuple())
|
|
timeout -= 1
|
|
|
|
max_payload = 50-1
|
|
for k in list(iterkeys(data_pool))[max_payload:]:
|
|
data_pool.pop(k)
|
|
payload.update(dict(date_watched=ts_now))
|
|
data_pool.update({ts_now: payload})
|
|
|
|
output = json.dumps(data_pool)
|
|
self.save_json(file_name, output)
|
|
|
|
return output
|
|
|
|
def enable_kodi_allow_remote(self):
|
|
try:
|
|
# setting esenabled: allow remote control by programs on this system
|
|
# setting esallinterfaces: allow remote control by programs on other systems
|
|
settings = [dict(esenabled=True), dict(esallinterfaces=True)]
|
|
for setting in settings:
|
|
name = next(iterkeys(setting))
|
|
if not self.kodi_request(dict(
|
|
method='Settings.SetSettingValue',
|
|
params=dict(setting='services.%s' % name, value=next(itervalues(setting)))
|
|
)).get('result', {}):
|
|
settings[setting] = self.kodi_request(dict(
|
|
method='Settings.GetSettingValue',
|
|
params=dict(setting='services.%s' % name)
|
|
)).get('result', {}).get('value')
|
|
except (BaseException, Exception):
|
|
return
|
|
|
|
setting_states = [next(itervalues(setting)) for setting in settings]
|
|
if not all(setting_states):
|
|
if not (any(setting_states)):
|
|
msg = 'Please enable *all* Kodi settings to allow remote control by programs...'
|
|
else:
|
|
msg = 'Please enable Kodi setting to allow remote control by programs on other systems'
|
|
msg = 'Failed startup. %s in system service/remote control' % msg
|
|
self.log(msg, error=True)
|
|
self.notify(msg, period=20, error=True)
|
|
return
|
|
return True
|
|
|
|
|
|
__dev__ = True
|
|
if __dev__:
|
|
try:
|
|
# specific to a dev env
|
|
# noinspection PyProtectedMember, PyUnresolvedReferences
|
|
import _devenv as devenv
|
|
except ImportError:
|
|
__dev__ = False
|
|
|
|
|
|
if 1 < len(sys.argv):
|
|
if __dev__:
|
|
devenv.setup_devenv(False)
|
|
if sys.argv[2].endswith('send_all'):
|
|
print('>>>>>> TESTTESTTEST')
|
|
|
|
elif '__main__' == __name__:
|
|
if __dev__:
|
|
devenv.setup_devenv(True)
|
|
WSU = SickGearWatchedStateUpdater()
|
|
WSU.run()
|
|
del WSU
|
|
|
|
if __dev__:
|
|
devenv.stop()
|