def __call__(self, data_in, accumulator):
"""
Executes the flag
Args:
data_in: The input to the flag. Typically from the last step of the workflow or the input to a trigger
accumulator (dict): A record of executed steps and their results. Of form {step_name: result}
Returns:
(bool): Is the flag true for the given data and accumulator
"""
original_data_in = deepcopy(data_in)
try:
data_in = validate_parameter(data_in, self.data_in_api,
'Filter {0}'.format(self.action))
args = dereference_step_routing(self.args, accumulator,
'In Filter {0}'.format(self.name))
args.update({self.data_in_api['name']: data_in})
result = get_filter(self.action)(**args)
callbacks.FilterSuccess.send(self)
return result
except InvalidInput as e:
callbacks.FilterError.send(self)
logger.error('Filter {0} has invalid input {1}. Error: {2}. '
'Returning unmodified data'.format(
self.action, original_data_in, str(e)))
except Exception as e:
callbacks.FilterError.send(self)
logger.error(
'Filter {0} encountered an error: {1}. Returning unmodified data'
.format(self.action, str(e)))
return original_data_in
def valid_section(session):
title = session.metadata.get('section_title')
if not title:
return True
# Fetch filter
filter = get_filter('filter_sections')
if filter is None:
return True
# Normalize title
title = title.strip().lower()
log.trace('validate section - title: "%s", filter: %s', title, filter)
# Check section title against filter
if title not in filter:
log.info('Ignoring item [%s](%s) played from filtered section "%s"' % (
session.item_key,
session.get_title(),
session.metadata.get('section_title')
))
return False
return True
def library(cls, types=None, keys=None, titles=None):
# Default to 'titles' filter preference
if titles is None:
titles = get_filter('filter_sections')
return PlexLibrary.fetch(types,
keys,
titles,
cache_id=cls.get_cache_id())
def sections(cls, types=None, keys=None, titles=None):
# Default to 'titles' filter preference
if titles is None:
titles = get_filter('filter_sections')
return PlexMediaServer.get_sections(types,
keys,
titles,
cache_id=cls.get_cache_id())
def library(cls, types=None, keys=None, titles=None):
# Default to 'titles' filter preference
if titles is None:
titles, _ = get_filter('filter_sections')
return PlexLibrary.fetch(
types, keys, titles,
cache_id=cls.get_cache_id()
)
def sections(cls, types=None, keys=None, titles=None):
# Default to 'titles' filter preference
if titles is None:
titles, _ = get_filter('filter_sections')
return PlexMediaServer.get_sections(
types, keys, titles,
cache_id=cls.get_cache_id()
)
def sections(cls, types=None, keys=None, titles=None):
# Default to 'titles' filter preference
if titles is None:
titles, _ = get_filter('filter_sections')
# Retrieve all sections
sections = Plex['library'].sections()
# Filter sections based on criteria
return sections.filter(types, keys, titles)
def from_event(cls, info):
account_key = try_convert(info.get('account_key'), int)
rating_key = info.get('rating_key')
if account_key is None or rating_key is None:
log.warn('Invalid action format: %s', info)
return None
if account_key != 1:
log.debug('Ignoring action from shared account')
return None
if WatchSession.is_active(rating_key, lambda ws: not ws.update_required):
log.debug('Ignoring action, item is currently being watched')
return False
metadata = Metadata.get(rating_key)
if not metadata:
log.debug('Ignoring action, unable to retrieve metadata')
return False
section = metadata.section.title.lower()
f_allow, _ = get_filter('filter_sections')
if f_allow is not None and section not in f_allow:
log.debug('Ignoring action, section has been filtered')
return False
guid = Guid.parse(metadata.guid)
request = {}
if type(metadata) is Movie:
request = cls.from_movie(metadata, guid)
elif type(metadata) is Season:
request = cls.from_season(metadata, guid)
elif type(metadata) is Episode:
request = cls.from_episode(metadata, guid)
else:
log.warn('Unsupported metadata type: %r', metadata)
return None
log.debug('request: %r', request)
return request
def SyncMenu(refresh=None):
oc = ObjectContainer(title2=L('sync_menu:title'), no_history=True, no_cache=True)
all_keys = []
create_active_item(oc)
oc.add(DirectoryObject(
key=Callback(Synchronize),
title=pad_title('Synchronize'),
summary=get_task_status('synchronize'),
thumb=R("icon-sync.png")
))
f_allow, f_deny = get_filter('filter_sections')
sections = Plex['library'].sections()
for section in sections.filter(['show', 'movie'], titles=f_allow):
oc.add(DirectoryObject(
key=Callback(Push, section=section.key),
title=pad_title('Push "%s" to trakt' % section.title),
summary=get_task_status('push', section.key),
thumb=R("icon-sync_up.png")
))
all_keys.append(section.key)
if len(all_keys) > 1:
oc.add(DirectoryObject(
key=Callback(Push),
title=pad_title('Push all to trakt'),
summary=get_task_status('push'),
thumb=R("icon-sync_up.png")
))
oc.add(DirectoryObject(
key=Callback(Pull),
title=pad_title('Pull from trakt'),
summary=get_task_status('pull'),
thumb=R("icon-sync_down.png")
))
return oc
def SyncMenu(refresh=None):
oc = ObjectContainer(title2=L("Sync"), no_history=True, no_cache=True)
all_keys = []
create_active_item(oc)
oc.add(DirectoryObject(
key=Callback(Synchronize),
title=pad_title('Synchronize'),
summary=get_task_status('synchronize'),
thumb=R("icon-sync.png")
))
sections = PlexMediaServer.get_sections(['show', 'movie'], titles=get_filter('filter_sections'))
for _, key, title in sections:
oc.add(DirectoryObject(
key=Callback(Push, section=key),
title=pad_title('Push "' + title + '" to trakt'),
summary=get_task_status('push', key),
thumb=R("icon-sync_up.png")
))
all_keys.append(key)
if len(all_keys) > 1:
oc.add(DirectoryObject(
key=Callback(Push),
title=pad_title('Push all to trakt'),
summary=get_task_status('push'),
thumb=R("icon-sync_up.png")
))
oc.add(DirectoryObject(
key=Callback(Pull),
title=pad_title('Pull from trakt'),
summary=get_task_status('pull'),
thumb=R("icon-sync_down.png")
))
return oc
def match(session, key, f_current, f_validate, f_check=None, f_transform=None, normalize_values=True):
if Prefs[key] is None:
return True
if f_check and f_check():
return True
value = f_current()
# Normalize value
if normalize_values:
if value:
value = value.strip()
value = flatten(value)
# Fetch filter
f_allow, f_deny = get_filter(key, normalize_values=normalize_values)
# Wildcard
if f_allow is None and f_deny is None:
return True
if f_transform:
# Transform filter values
f_allow = [f_transform(x) for x in f_allow]
f_deny = [f_transform(x) for x in f_deny]
log.trace('validate "%s" - value: %s, allow: %s, deny: %s', key, repr(value), f_allow, f_deny)
if f_validate(value, f_allow, f_deny):
log.info('Ignoring item [%s](%s) played by filtered "%s": %s' % (
session.rating_key,
session.title,
key, repr(f_current())
))
return False
return True
def valid_client(session):
if Prefs['scrobble_clients'] is None:
return True
# Normalize client name
client_name = session.client.name.lower() if session.client else None
# Fetch filter
filter = get_filter('scrobble_clients')
if filter is None:
return True
log.trace('validate client - client_name: "%s", filter: %s', client_name, filter)
if not session.client or client_name not in filter:
log.info('Ignoring item [%s](%s) played by filtered client: %s' % (
session.item_key,
session.get_title(),
client_name
))
return False
return True
def valid_user(session):
if Prefs['scrobble_names'] is None:
return True
# Normalize username
username = session.user.title.lower() if session.user else None
# Fetch filter
filter = get_filter('scrobble_names')
if filter is None:
return True
log.trace('validate user - username: "******", filter: %s', username, filter)
if not session.user or username not in filter:
log.info('Ignoring item [%s](%s) played by filtered user: %s' % (
session.item_key,
session.get_title(),
session.user.title if session.user else None
))
return False
return True
def SyncMenu(refresh=None):
oc = ObjectContainer(title2=L("Sync"), no_history=True, no_cache=True)
all_keys = []
create_active_item(oc)
oc.add(
DirectoryObject(key=Callback(Synchronize),
title=pad_title('Synchronize'),
summary=get_task_status('synchronize'),
thumb=R("icon-sync.png")))
sections = PlexMediaServer.get_sections(
['show', 'movie'], titles=get_filter('filter_sections'))
for _, key, title in sections:
oc.add(
DirectoryObject(key=Callback(Push, section=key),
title=pad_title('Push "' + title + '" to trakt'),
summary=get_task_status('push', key),
thumb=R("icon-sync_up.png")))
all_keys.append(key)
if len(all_keys) > 1:
oc.add(
DirectoryObject(key=Callback(Push),
title=pad_title('Push all to trakt'),
summary=get_task_status('push'),
thumb=R("icon-sync_up.png")))
oc.add(
DirectoryObject(key=Callback(Pull),
title=pad_title('Pull from trakt'),
summary=get_task_status('pull'),
thumb=R("icon-sync_down.png")))
return oc
def library(cls, types=None, keys=None, titles=None):
# Default to 'titles' filter preference
if titles is None:
titles, _ = get_filter('filter_sections')
return Library.all(types, keys, titles)
