mirror of
https://github.com/SickGear/SickGear.git
synced 2024-12-05 02:43:37 +00:00
348 lines
12 KiB
Python
348 lines
12 KiB
Python
# Author: Nic Wolfe <nic@wolfeden.ca>
|
|
# URL: http://code.google.com/p/sickbeard/
|
|
#
|
|
# 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/>.
|
|
|
|
from lib.six import iteritems
|
|
|
|
from lib.dateutil import tz, zoneinfo
|
|
from sickbeard import db
|
|
from sickbeard import helpers
|
|
from sickbeard import logger
|
|
from sickbeard import encodingKludge as ek
|
|
from os.path import basename, join, isfile
|
|
import os
|
|
import re
|
|
import datetime
|
|
|
|
# regex to parse time (12/24 hour format)
|
|
time_regex = re.compile(r'(\d{1,2})(([:.](\d{2}))? ?([PA][. ]? ?M)|[:.](\d{2}))\b', flags=re.I)
|
|
am_regex = re.compile(r'(A[. ]? ?M)', flags=re.I)
|
|
pm_regex = re.compile(r'(P[. ]? ?M)', flags=re.I)
|
|
|
|
network_dict = None
|
|
|
|
sb_timezone = tz.tzlocal()
|
|
|
|
|
|
# helper to remove failed temp download
|
|
def _remove_zoneinfo_failed(filename):
|
|
try:
|
|
ek.ek(os.remove, filename)
|
|
except:
|
|
pass
|
|
|
|
|
|
# helper to remove old unneeded zoneinfo files
|
|
def _remove_old_zoneinfo():
|
|
zonefilename = zoneinfo.ZONEFILENAME
|
|
if None is zonefilename:
|
|
return
|
|
cur_zoneinfo = ek.ek(basename, zonefilename)
|
|
|
|
cur_file = helpers.real_path(ek.ek(join, ek.ek(os.path.dirname, zoneinfo.__file__), cur_zoneinfo))
|
|
|
|
for (path, dirs, files) in ek.ek(os.walk,
|
|
helpers.real_path(ek.ek(os.path.dirname, zoneinfo.__file__))):
|
|
for filename in files:
|
|
if filename.endswith('.tar.gz'):
|
|
file_w_path = ek.ek(join, path, filename)
|
|
if file_w_path != cur_file and ek.ek(isfile, file_w_path):
|
|
try:
|
|
ek.ek(os.remove, file_w_path)
|
|
logger.log(u'Delete unneeded old zoneinfo File: %s' % file_w_path)
|
|
except:
|
|
logger.log(u'Unable to delete: %s' % file_w_path, logger.ERROR)
|
|
|
|
|
|
# update the dateutil zoneinfo
|
|
def _update_zoneinfo():
|
|
global sb_timezone
|
|
sb_timezone = tz.tzlocal()
|
|
|
|
# now check if the zoneinfo needs update
|
|
url_zv = 'https://raw.githubusercontent.com/Prinz23/sb_network_timezones/master/zoneinfo.txt'
|
|
|
|
url_data = helpers.getURL(url_zv)
|
|
if url_data is None:
|
|
# When urlData is None, trouble connecting to github
|
|
logger.log(u'Loading zoneinfo.txt failed, this can happen from time to time. Unable to get URL: %s' % url_zv,
|
|
logger.WARNING)
|
|
return
|
|
|
|
zonefilename = zoneinfo.ZONEFILENAME
|
|
cur_zoneinfo = zonefilename
|
|
if None is not cur_zoneinfo:
|
|
cur_zoneinfo = ek.ek(basename, zonefilename)
|
|
zonefile = helpers.real_path(ek.ek(join, ek.ek(os.path.dirname, zoneinfo.__file__), cur_zoneinfo))
|
|
zonemetadata = zoneinfo.gettz_db_metadata() if ek.ek(os.path.isfile, zonefile) else None
|
|
(new_zoneinfo, zoneinfo_md5) = url_data.decode('utf-8').strip().rsplit(u' ')
|
|
newtz_regex = re.search(r'(\d{4}[^.]+)', new_zoneinfo)
|
|
if not newtz_regex or len(newtz_regex.groups()) != 1:
|
|
return
|
|
newtzversion = newtz_regex.group(1)
|
|
|
|
if cur_zoneinfo is not None and zonemetadata is not None and 'tzversion' in zonemetadata and zonemetadata['tzversion'] == newtzversion:
|
|
return
|
|
|
|
# now load the new zoneinfo
|
|
url_tar = u'https://raw.githubusercontent.com/Prinz23/sb_network_timezones/master/%s' % new_zoneinfo
|
|
|
|
zonefile_tmp = re.sub(r'\.tar\.gz$', '.tmp', zonefile)
|
|
|
|
if ek.ek(os.path.exists, zonefile_tmp):
|
|
try:
|
|
ek.ek(os.remove, zonefile_tmp)
|
|
except:
|
|
logger.log(u'Unable to delete: %s' % zonefile_tmp, logger.ERROR)
|
|
return
|
|
|
|
if not helpers.download_file(url_tar, zonefile_tmp):
|
|
return
|
|
|
|
if not ek.ek(os.path.exists, zonefile_tmp):
|
|
logger.log(u'Download of %s failed.' % zonefile_tmp, logger.ERROR)
|
|
return
|
|
|
|
new_hash = str(helpers.md5_for_file(zonefile_tmp))
|
|
|
|
if zoneinfo_md5.upper() == new_hash.upper():
|
|
logger.log(u'Updating timezone info with new one: %s' % new_zoneinfo, logger.MESSAGE)
|
|
try:
|
|
# remove the old zoneinfo file
|
|
if cur_zoneinfo is not None:
|
|
old_file = helpers.real_path(
|
|
ek.ek(join, ek.ek(os.path.dirname, zoneinfo.__file__), cur_zoneinfo))
|
|
if ek.ek(os.path.exists, old_file):
|
|
ek.ek(os.remove, old_file)
|
|
# rename downloaded file
|
|
ek.ek(os.rename, zonefile_tmp, zonefile)
|
|
from dateutil.zoneinfo import gettz
|
|
if '_CLASS_ZONE_INSTANCE' in gettz.func_globals:
|
|
gettz.func_globals.__setitem__('_CLASS_ZONE_INSTANCE', list())
|
|
|
|
sb_timezone = tz.tzlocal()
|
|
except:
|
|
_remove_zoneinfo_failed(zonefile_tmp)
|
|
return
|
|
else:
|
|
_remove_zoneinfo_failed(zonefile_tmp)
|
|
logger.log(u'MD5 hash does not match: %s File: %s' % (zoneinfo_md5.upper(), new_hash.upper()), logger.ERROR)
|
|
return
|
|
|
|
|
|
# update the network timezone table
|
|
def update_network_dict():
|
|
_remove_old_zoneinfo()
|
|
_update_zoneinfo()
|
|
load_network_conversions()
|
|
|
|
d = {}
|
|
|
|
# network timezones are stored on github pages
|
|
url = 'https://raw.githubusercontent.com/Prinz23/sb_network_timezones/master/network_timezones.txt'
|
|
|
|
url_data = helpers.getURL(url)
|
|
if url_data is None:
|
|
# When urlData is None, trouble connecting to github
|
|
logger.log(u'Updating network timezones failed, this can happen from time to time. URL: %s' % url, logger.WARNING)
|
|
load_network_dict()
|
|
return
|
|
|
|
try:
|
|
for line in url_data.splitlines():
|
|
(key, val) = line.decode('utf-8').strip().rsplit(u':', 1)
|
|
if key is None or val is None:
|
|
continue
|
|
d[key] = val
|
|
except (IOError, OSError):
|
|
pass
|
|
|
|
my_db = db.DBConnection('cache.db')
|
|
|
|
# load current network timezones
|
|
old_d = dict(my_db.select('SELECT * FROM network_timezones'))
|
|
|
|
# list of sql commands to update the network_timezones table
|
|
cl = []
|
|
for cur_d, cur_t in iteritems(d):
|
|
h_k = cur_d in old_d
|
|
if h_k and cur_t != old_d[cur_d]:
|
|
# update old record
|
|
cl.append(
|
|
['UPDATE network_timezones SET network_name=?, timezone=? WHERE network_name=?', [cur_d, cur_t, cur_d]])
|
|
elif not h_k:
|
|
# add new record
|
|
cl.append(['INSERT INTO network_timezones (network_name, timezone) VALUES (?,?)', [cur_d, cur_t]])
|
|
if h_k:
|
|
del old_d[cur_d]
|
|
|
|
# remove deleted records
|
|
if len(old_d) > 0:
|
|
old_items = list(va for va in old_d)
|
|
cl.append(['DELETE FROM network_timezones WHERE network_name IN (%s)' % ','.join(['?'] * len(old_items)), old_items])
|
|
|
|
# change all network timezone infos at once (much faster)
|
|
if len(cl) > 0:
|
|
my_db.mass_action(cl)
|
|
load_network_dict()
|
|
|
|
|
|
# load network timezones from db into dict
|
|
def load_network_dict():
|
|
try:
|
|
my_db = db.DBConnection('cache.db')
|
|
cur_network_list = my_db.select('SELECT * FROM network_timezones')
|
|
if cur_network_list is None or len(cur_network_list) < 1:
|
|
update_network_dict()
|
|
cur_network_list = my_db.select('SELECT * FROM network_timezones')
|
|
d = dict(cur_network_list)
|
|
except:
|
|
d = {}
|
|
global network_dict
|
|
network_dict = d
|
|
|
|
|
|
# get timezone of a network or return default timezone
|
|
def get_network_timezone(network, network_dict):
|
|
if network is None:
|
|
return sb_timezone
|
|
|
|
try:
|
|
if zoneinfo.ZONEFILENAME is not None:
|
|
try:
|
|
n_t = tz.gettz(network_dict[network])
|
|
except:
|
|
return sb_timezone
|
|
|
|
if n_t is not None:
|
|
return n_t
|
|
else:
|
|
return sb_timezone
|
|
else:
|
|
return sb_timezone
|
|
except:
|
|
return sb_timezone
|
|
|
|
|
|
# parse date and time string into local time
|
|
def parse_date_time(d, t, network):
|
|
if network_dict is None:
|
|
load_network_dict()
|
|
mo = time_regex.search(t)
|
|
if mo is not None and len(mo.groups()) >= 5:
|
|
if mo.group(5) is not None:
|
|
try:
|
|
hr = helpers.tryInt(mo.group(1))
|
|
m = helpers.tryInt(mo.group(4))
|
|
ap = mo.group(5)
|
|
# convert am/pm to 24 hour clock
|
|
if ap is not None:
|
|
if pm_regex.search(ap) is not None and hr != 12:
|
|
hr += 12
|
|
elif am_regex.search(ap) is not None and hr == 12:
|
|
hr -= 12
|
|
except:
|
|
hr = 0
|
|
m = 0
|
|
else:
|
|
try:
|
|
hr = helpers.tryInt(mo.group(1))
|
|
m = helpers.tryInt(mo.group(6))
|
|
except:
|
|
hr = 0
|
|
m = 0
|
|
else:
|
|
hr = 0
|
|
m = 0
|
|
if hr < 0 or hr > 23 or m < 0 or m > 59:
|
|
hr = 0
|
|
m = 0
|
|
|
|
te = datetime.datetime.fromordinal(helpers.tryInt(d))
|
|
try:
|
|
foreign_timezone = get_network_timezone(network, network_dict)
|
|
foreign_naive = datetime.datetime(te.year, te.month, te.day, hr, m, tzinfo=foreign_timezone)
|
|
return foreign_naive
|
|
except:
|
|
return datetime.datetime(te.year, te.month, te.day, hr, m, tzinfo=sb_timezone)
|
|
|
|
|
|
def test_timeformat(t):
|
|
mo = time_regex.search(t)
|
|
if mo is None or len(mo.groups()) < 2:
|
|
return False
|
|
else:
|
|
return True
|
|
|
|
|
|
def standardize_network(network, country):
|
|
my_db = db.DBConnection('cache.db')
|
|
sql_results = my_db.select('SELECT * FROM network_conversions WHERE tvrage_network = ? and tvrage_country = ?',
|
|
[network, country])
|
|
if len(sql_results) == 1:
|
|
return sql_results[0]['tvdb_network']
|
|
else:
|
|
return network
|
|
|
|
|
|
def load_network_conversions():
|
|
|
|
conversions = []
|
|
|
|
# network conversions are stored on github pages
|
|
url = 'https://raw.githubusercontent.com/prinz23/sg_network_conversions/master/conversions.txt'
|
|
|
|
url_data = helpers.getURL(url)
|
|
if url_data is None:
|
|
# When urlData is None, trouble connecting to github
|
|
logger.log(u'Updating network conversions failed, this can happen from time to time. URL: %s' % url, logger.WARNING)
|
|
return
|
|
|
|
try:
|
|
for line in url_data.splitlines():
|
|
(tvdb_network, tvrage_network, tvrage_country) = line.decode('utf-8').strip().rsplit(u'::', 2)
|
|
if not (tvdb_network and tvrage_network and tvrage_country):
|
|
continue
|
|
conversions.append({'tvdb_network': tvdb_network, 'tvrage_network': tvrage_network, 'tvrage_country': tvrage_country})
|
|
except (IOError, OSError):
|
|
pass
|
|
|
|
my_db = db.DBConnection('cache.db')
|
|
|
|
old_d = my_db.select('SELECT * FROM network_conversions')
|
|
old_d = helpers.build_dict(old_d, 'tvdb_network')
|
|
|
|
# list of sql commands to update the network_conversions table
|
|
cl = []
|
|
|
|
for n_w in conversions:
|
|
cl.append(['INSERT OR REPLACE INTO network_conversions (tvdb_network, tvrage_network, tvrage_country)'
|
|
'VALUES (?,?,?)', [n_w['tvdb_network'], n_w['tvrage_network'], n_w['tvrage_country']]])
|
|
try:
|
|
del old_d[n_w['tvdb_network']]
|
|
except:
|
|
pass
|
|
|
|
# remove deleted records
|
|
if len(old_d) > 0:
|
|
old_items = list(va for va in old_d)
|
|
cl.append(['DELETE FROM network_conversions WHERE tvdb_network'
|
|
' IN (%s)' % ','.join(['?'] * len(old_items)), old_items])
|
|
|
|
# change all network conversion info at once (much faster)
|
|
if len(cl) > 0:
|
|
my_db.mass_action(cl)
|