def start(self):
"""
Starts the engine.
This function should be called before doing anything with the engine,
as it initializes the data handler.
"""
if self.loaded:
raise utils.TrackmaError("Already loaded.")
# Start the data handler
try:
(self.api_info, self.mediainfo) = self.data_handler.start()
except utils.DataError as e:
raise utils.DataFatal(str(e))
except utils.APIError as e:
raise utils.APIFatal(str(e))
# Load redirection file if supported
api = self.api_info['shortname']
mediatype = self.data_handler.userconfig['mediatype']
if redirections.supports(api, mediatype):
if utils.file_exists(utils.to_config_path('anime-relations.txt')):
fname = utils.to_config_path('anime-relations.txt')
self.msg.debug(self.name, "Using user-provided redirection file.")
else:
fname = utils.to_data_path('anime-relations.txt')
if self.config['redirections_time'] and (
not utils.file_exists(fname) or
utils.file_older_than(fname, self.config['redirections_time'] * 86400)):
self.msg.info(self.name, "Syncing redirection file...")
self.msg.debug(self.name, "Syncing from: %s" % self.config['redirections_url'])
utils.sync_file(fname, self.config['redirections_url'])
if not utils.file_exists(fname):
self.msg.debug(self.name, "Defaulting to repo provided redirections file.")
fname = utils.DATADIR + '/anime-relations/anime-relations.txt'
self.msg.info(self.name, "Parsing redirection file...")
try:
self.redirections = redirections.parse_anime_relations(fname, api)
except Exception as e:
self.msg.warn(self.name, "Error parsing anime-relations.txt!")
self.msg.debug(self.name, "{}".format(e))
# Rescan library if necessary
if self.config['library_autoscan']:
try:
self.scan_library()
except utils.TrackmaError as e:
self.msg.warn(
self.name, "Can't auto-scan library: {}".format(e))
# Load hook files
if self.config['use_hooks']:
hooks_dir = utils.to_config_path('hooks')
if os.path.isdir(hooks_dir):
import pkgutil
self.msg.info(self.name, "Importing user hooks...")
for loader, name, ispkg in pkgutil.iter_modules([hooks_dir]):
# List all the hook files in the hooks folder, import them
# and call the init() function if they have them
# We build the list "hooks available" with the loaded modules
# for later calls.
try:
self.msg.debug(
self.name, "Importing hook {}...".format(name))
module = loader.find_module(name).load_module(name)
if hasattr(module, 'init'):
module.init(self)
self.hooks_available.append(module)
except ImportError:
self.msg.warn(
self.name, "Error importing hook {}.".format(name))
import traceback
exc_type, exc_value, exc_traceback = sys.exc_info()
for line in traceback.format_exception(exc_type, exc_value, exc_traceback):
self.msg.debug(self.name, line.rstrip())
# Start tracker
if self.mediainfo.get('can_play') and self.config['tracker_enabled']:
self.msg.debug(self.name, "Initializing tracker...")
try:
TrackerClass = self._get_tracker_class(
self.config['tracker_type'])
self.tracker = TrackerClass(self.msg,
self._get_tracker_list(),
self.config,
self.searchdirs,
self.redirections,
)
self.tracker.connect_signal('detected', self._tracker_detected)
self.tracker.connect_signal('removed', self._tracker_removed)
self.tracker.connect_signal('playing', self._tracker_playing)
self.tracker.connect_signal('update', self._tracker_update)
self.tracker.connect_signal(
'unrecognised', self._tracker_unrecognised)
self.tracker.connect_signal('state', self._tracker_state)
except ImportError:
self.msg.warn(self.name, "Couldn't import specified tracker: {}".format(
self.config['tracker_type']))
self.loaded = True
return True
def _save(self):
is_new = not utils.file_exists(self.filename)
with open(self.filename, 'wb') as f:
if is_new:
utils.change_permissions(self.filename, 0o600)
pickle.dump(self.accounts, f, protocol=2)
def _save(self):
is_new = not utils.file_exists(self.filename)
with open(self.filename, 'wb') as f:
if is_new:
utils.change_permissions(self.filename, 0o600)
pickle.dump(self.accounts, f, protocol=2)
def _load(self):
if utils.file_exists(self.filename):
with open(self.filename, 'rb') as f:
self.accounts = pickle.load(f)
def _load(self):
if utils.file_exists(self.filename):
with open(self.filename, 'rb') as f:
self.accounts = pickle.load(f)
