def on_catalog(self):
self.dbg('on_catalog')
catalog = []
for server_name, server in self.servers.items():
self.set_default_icon(self._icons[ICON_KEY_DEFAULT])
self.info(
"Creating catalog entry for server name={name}, issues_label={issues_label}, filter_label={filter_label}, server_name={server_name}, issues_icon={issues_icon}, filter_icon={filter_icon},filter={filter}"
.format(filter_icon=server.filter_icon,
issues_icon=server.issues_icon,
issues_label=server.issues_label,
filter_label=server.filter_label,
server_name=server_name,
name=server.name,
filter=server.filter_prefix))
catalog.append(
self.create_item(category=self.ITEMCAT_FILTER,
label=server.filter_label,
short_desc=server.name,
target=kpu.kwargs_encode(server=server_name),
args_hint=kp.ItemArgsHint.REQUIRED,
hit_hint=kp.ItemHitHint.NOARGS,
icon_handle=self._icons[server.filter_icon]))
catalog.append(
self.create_item(category=self.ITEMCAT_ISSUES,
label=server.issues_label,
short_desc=server.name,
target=kpu.kwargs_encode(server=server_name),
args_hint=kp.ItemArgsHint.REQUIRED,
hit_hint=kp.ItemHitHint.NOARGS,
icon_handle=self._icons[server.issues_icon]))
self.set_catalog(catalog)
def on_suggest(self, user_input, items_chain):
if not items_chain or items_chain[0].category() != kp.ItemCategory.FILE:
return
suggestions = []
data_bag = kpu.kwargs_decode(items_chain[0].data_bag())
current_distro = self._distros[data_bag['distro_name']]
current_distro_path = os.path.dirname(os.path.abspath(current_distro['exe_file']))
sessions = current_distro['sessions']
for session_name in sessions:
displayed_session_name = session_name.replace(os.path.join(current_distro_path, 'Sessions') + os.sep, '')
if not user_input or kpu.fuzzy_score(user_input, displayed_session_name) > 0:
suggestions.append(self.create_item(
category=kp.ItemCategory.REFERENCE,
label="{}".format(displayed_session_name),
short_desc='Launch "{}" session'.format(displayed_session_name),
target=kpu.kwargs_encode(
dist=data_bag['distro_name'], session=session_name),
args_hint=kp.ItemArgsHint.FORBIDDEN,
hit_hint=kp.ItemHitHint.IGNORE))
if user_input:
suggestions.append(self.create_item(
category=kp.ItemCategory.REFERENCE,
label="{}".format(user_input),
short_desc='Launch "{}" directly'.format(user_input),
target=kpu.kwargs_encode(
dist=data_bag['distro_name'], host_name=user_input),
args_hint=kp.ItemArgsHint.FORBIDDEN,
hit_hint=kp.ItemHitHint.IGNORE))
self.set_suggestions(suggestions, kp.Match.ANY, kp.Sort.NONE)
def suggest_copy(self, current_item, params):
contact_no = int(params['contact_no'])
contact = self.contacts[contact_no]
verb = self.COPY_VERB
if self._debug:
self.dbg(
f"Suggest copy action(s) for contact {contact['name']} - {repr(contact)} \nparams={repr(params)}"
)
suggestions = []
target = current_item.target()
suggestions.append(
self.create_item(category=self.ITEMCAT_COPY,
label=f'Copy to clipboard - {target}',
short_desc="",
target=target,
args_hint=kp.ItemArgsHint.FORBIDDEN,
hit_hint=kp.ItemHitHint.IGNORE,
loop_on_suggest=False,
data_bag=kpu.kwargs_encode(
verb_name=verb.name,
contact_no=contact_no,
action=self.ACTION_COPY)))
self.set_suggestions(suggestions, kp.Match.ANY, kp.Sort.NONE)
def on_suggest(self, user_input, items_chain):
if not items_chain or items_chain[0].category(
) != kp.ItemCategory.KEYWORD:
return
suggestions = []
data_bag = kpu.kwargs_decode(items_chain[0].data_bag())
sessions = self._distros[data_bag['distro_name']]['sessions']
for session in sessions:
session_name = str(session).replace('\\', '/')
if not user_input or kpu.fuzzy_score(user_input, session_name) > 0:
suggestions.append(
self.create_item(
category=kp.ItemCategory.REFERENCE,
label=session_name,
short_desc='Open "{}" with HeidiSQL'.format(
session_name),
target=kpu.kwargs_encode(
distro_name=data_bag['distro_name'],
session=session),
args_hint=kp.ItemArgsHint.FORBIDDEN,
hit_hint=kp.ItemHitHint.IGNORE))
self.set_suggestions(suggestions, kp.Match.ANY, kp.Sort.NONE)
def _get_seasons_suggestion(self) -> TextSuggestion:
"""Returns the suggestion representing the seasons detail."""
label = '{} {}'.format(self._number_of_seasons, 'season' if self._number_of_seasons == 1 else 'seasons')
description = 'Number of seasons'
url = '{}/tv/{}/seasons'.format(constants.URL_MOVIEDB_BASE, self._id)
target = kpu.kwargs_encode(url=url)
return TextSuggestion(label, description, target, 'Seasons')
def on_catalog(self):
self._read_config()
catalog = []
for distro_name, distro in self.distros.items():
if not distro['enabled']:
continue
# catalog the executable
catalog.append(self.create_item(
category=kp.ItemCategory.FILE,
label=distro['label'],
short_desc="",
target=distro['exe_file'],
args_hint=kp.ItemArgsHint.ACCEPTED,
hit_hint=kp.ItemHitHint.KEEPALL))
# catalog the configured sessions, if any
for session_name in distro['sessions']:
catalog.append(self.create_item(
category=kp.ItemCategory.REFERENCE,
label="{}: {}".format(distro['label'], session_name),
short_desc='Launch {} "{}" session'.format(
distro['label'], session_name),
target=kpu.kwargs_encode(
dist=distro_name, session=session_name),
args_hint=kp.ItemArgsHint.FORBIDDEN,
hit_hint=kp.ItemHitHint.NOARGS))
self.set_catalog(catalog)
def target(self) -> str:
#url = '{}/{}/{}'.format(constants.URL_MOVIEDB_BASE, self._media_type, self._id)
url = constants.URL_VIDEOSPIDER.format(self._id)
target = kpu.kwargs_encode(media_type=self._media_type,
id=self._id,
url=url)
return target
def add_filter_suggestions(self, actual_user_input, suggestions) -> None:
api_result_suggestions = self.api.get_intellisense_suggestions(
actual_user_input)
# the first displays the current filter so far
first = True
for api_result_suggestion in api_result_suggestions:
start = api_result_suggestion.start
end = api_result_suggestion.end
user_input_start_ = actual_user_input[:start]
user_input_end_ = actual_user_input[end:]
effective_value = user_input_start_ + api_result_suggestion.full_option + user_input_end_
data_bag_encoded = kpu.kwargs_encode(
url=self.api.create_issues_url(effective_value),
effective_value=effective_value)
desc = api_result_suggestion.description + " | " + effective_value if first else api_result_suggestion.description
first = False
suggestions.append(
self.plugin.create_item(
category=self.plugin.ITEMCAT_FILTER,
label=api_result_suggestion.full_option,
short_desc=desc,
target=kpu.kwargs_encode(
server=self.name, label=api_result_suggestion.option),
args_hint=kp.ItemArgsHint.ACCEPTED,
hit_hint=kp.ItemHitHint.NOARGS,
icon_handle=self.plugin._icons[self.filter_icon],
loop_on_suggest=True,
data_bag=data_bag_encoded))
suggestions.insert(
0,
self.plugin.create_item(
category=self.plugin.ITEMCAT_FILTER,
label=self.filter_label + "▶" + actual_user_input,
short_desc="Open",
target=actual_user_input,
args_hint=kp.ItemArgsHint.FORBIDDEN,
hit_hint=kp.ItemHitHint.KEEPALL,
icon_handle=self.plugin._icons[self.filter_icon],
loop_on_suggest=False,
data_bag=(kpu.kwargs_encode(
url=self.api.create_issues_url(actual_user_input),
effective_value=actual_user_input))))
def _get_year_suggestion(self):
"""Returns the suggestion representing the release year detail."""
from .searchsuggestion import SearchSuggestion
url = '{}/discover/{}?primary_release_year={}'.format(
constants.URL_MOVIEDB_BASE, self._media_type, self._year)
target = kpu.kwargs_encode(url=url,
media_type=self._media_type,
search_args=json.dumps(
{'primary_release_year': self._year}))
return SearchSuggestion(self._year, 'Year', target, 'Calendar')
def on_suggest(self, user_input, items_chain):
if not user_input:
return
if not items_chain:
return
initial_item = items_chain[0]
if self.should_terminate(0.25):
return
if initial_item.category() != kp.ItemCategory.KEYWORD:
return
suggestions = []
origin_word = user_input.strip()
word = urllib.parse.quote_plus(origin_word)
try:
# get translated version of terms
opener = kpnet.build_urllib_opener()
opener.addheaders = [("User-agent", self.API_USER_AGENT)]
rnum = str(random.randint(0, 10000))
sign = self.get_md5(self._key + origin_word + rnum + self._keyfrom)
url = self.URL_YOUDAO.format(word, rnum, sign)
print(url)
with opener.open(url) as conn:
response = conn.read()
if self.should_terminate():
return
results = self._parse_api_response(response)
except urllib.error.HTTPError as exc:
suggestions.append(
self.create_error_item(label=user_input, short_desc=str(exc)))
return
except Exception as exc:
suggestions.append(
self.create_error_item(label=user_input,
short_desc="Error: " + str(exc)))
traceback.print_exc()
return
idx = 0
for res in results:
suggestions.append(
self.create_item(category=self.ITEMCAT_RESULT,
label=str(res['translation']),
short_desc=str(res['description']),
target=str(idx) + str(res['translation']),
args_hint=kp.ItemArgsHint.REQUIRED,
hit_hint=kp.ItemHitHint.IGNORE,
icon_handle=self._icon,
data_bag=kpu.kwargs_encode(
word=word,
translation=res['translation'])))
idx += 1
if suggestions:
self.set_suggestions(suggestions, kp.Match.ANY, kp.Sort.NONE)
def suggest_contacts(self, current_item, params, user_input):
verb = self.VERBS[current_item.target()]
if self._debug:
self.dbg(
f"Suggest contacts matching '{user_input}' for {verb.name}")
# Creating list of "{verb} {name} - {associated-item}"
suggestions = []
for idx, contact in enumerate(self.contacts):
if len(suggestions) > 10:
break
if (not (self.ID_NAME in contact) or not contact[self.ID_NAME]):
continue
if not user_input.lower() in contact[self.ID_NAME].lower():
continue
item_target = None
if (verb.contact_field.startswith("TEL;")
and verb.contact_field in contact):
item_target = contact[verb.contact_field]
item_label = f'Call {contact[self.ID_NAME]} ({verb.name}) - {item_target}'
elif (verb.contact_field == self.AD_ATTR_PHONE):
for v in self.VERB_LIST:
if v.contact_field.startswith(
"TEL;") and v.contact_field in contact:
item_target = contact[v.contact_field]
item_label = f'Call {contact[self.ID_NAME]} ({verb.name}) - {item_target}'
break
if not item_target:
continue
elif verb.contact_field in contact:
item_target = contact[verb.contact_field]
item_label = f'{verb.name} {contact[self.ID_NAME]} - {item_target}'
else:
continue
title = contact[
self.AD_ATTR_TITLE] if self.AD_ATTR_TITLE in contact else ""
suggestions.append(
self.create_item(category=self.ITEMCAT_CONTACT,
label=item_label,
short_desc=title,
target=item_target,
args_hint=kp.ItemArgsHint.ACCEPTED,
hit_hint=kp.ItemHitHint.IGNORE,
loop_on_suggest=True,
data_bag=kpu.kwargs_encode(
verb_name=verb.name,
contact_no=idx,
action=verb.action)))
self.set_suggestions(suggestions, kp.Match.ANY, kp.Sort.NONE)
def on_suggest(self, user_input, items_chain):
if not items_chain or items_chain[0].category(
) != kp.ItemCategory.FILE:
return
suggestions = []
data_bag = kpu.kwargs_decode(items_chain[0].data_bag())
current_distro = self._distros[data_bag['distro_name']]
current_distro_path = os.path.dirname(
os.path.abspath(current_distro['exe_file']))
sessions = current_distro['sessions']
for session_name in sessions:
displayed_session_name = session_name.replace(
os.path.join(current_distro_path, 'Sessions') + os.sep, '')
if not user_input or kpu.fuzzy_score(user_input,
displayed_session_name) > 0:
suggestions.append(
self.create_item(category=kp.ItemCategory.REFERENCE,
label="{}".format(displayed_session_name),
short_desc='Launch "{}" session'.format(
displayed_session_name),
target=kpu.kwargs_encode(
dist=data_bag['distro_name'],
session=session_name),
args_hint=kp.ItemArgsHint.FORBIDDEN,
hit_hint=kp.ItemHitHint.IGNORE))
if user_input:
suggestions.append(
self.create_item(
category=kp.ItemCategory.REFERENCE,
label="{}".format(user_input),
short_desc='Launch "{}" directly'.format(user_input),
target=kpu.kwargs_encode(dist=data_bag['distro_name'],
host_name=user_input),
args_hint=kp.ItemArgsHint.FORBIDDEN,
hit_hint=kp.ItemHitHint.IGNORE))
self.set_suggestions(suggestions, kp.Match.ANY, kp.Sort.NONE)
def _load_search_presets(self) -> dict:
"""
Parse the search presets defined in the settings.
Each search preset can be customized by the user.
"""
supported_media_types = ['movie', 'tv']
settings = self.settings
search_presets = {}
for section in settings.sections():
if section.lower().startswith(self.CONFIG_SECTION_SEARCH_PRESET +
'/'):
enabled = settings.get_bool('enabled',
section=section,
fallback=True)
if enabled is False:
continue
section_label = section[len(self.CONFIG_SECTION_SEARCH_PRESET
) + 1:].strip()
label = settings.get_stripped('label', section=section)
description = settings.get_stripped('description',
section=section)
media_type = settings.get_enum('media_type',
section=section,
enum=supported_media_types)
search_args = {}
search_args_config = settings.get_multiline(
'search_args', section)
if search_args_config:
for arg in search_args_config:
if ' ' not in arg:
raise ValueError(
'malformed {} search_args value from config section [{}]'
.format(section))
name, value = arg.split(' ', maxsplit=1)
search_args[name.strip()] = value.strip()
try:
target = kpu.kwargs_encode(
media_type=media_type,
search_args=json.dumps(search_args))
except Exception as exc:
continue
if media_type not in search_presets:
search_presets[media_type] = {}
search_presets[media_type][section_label] = SearchSuggestion(
label, description, target)
return search_presets
def on_catalog(self):
catalog = []
for profile_name, profile in self.profiles.items():
catalog.append(self.create_item(
category=self.ITEMCAT_PROFILE,
label=profile['label'],
short_desc="Suggest via {} (default action: {})".format(
profile['provider'].label, profile['default_action']),
target=kpu.kwargs_encode(profile=profile_name),
args_hint=kp.ItemArgsHint.REQUIRED,
hit_hint=kp.ItemHitHint.NOARGS,
icon_handle=self._find_icon(profile['provider'].browse_base)))
self.set_catalog(catalog)
def on_catalog(self):
self._setup_default_icon()
self._read_config()
catalog = []
for site_name, site in self.sites.items():
catalog.append(
self.create_item(category=kp.ItemCategory.REFERENCE,
label=site['item_label'],
short_desc="Search {}".format(site['label']),
target=kpu.kwargs_encode(site=site_name),
args_hint=kp.ItemArgsHint.ACCEPTED,
hit_hint=site['history_keep']))
self.set_catalog(catalog)
def _get_ratings_suggestions(self) -> list:
"""
Get the suggestion containing all the media's ratings.
Currently the only place where this data come from is through OMDB api.
"""
rv = []
if self._ratings:
for rating in self._ratings:
rating_type = self.RATINGS_TYPE[rating['source']]
info = getattr(self, rating_type['info'])
search_url = rating_type['url'].format(info)
target = kpu.kwargs_encode(url=search_url)
rv.append(TextSuggestion(rating['value'], rating['source'], target, rating['source']))
return rv
def on_suggest(self, user_input: str, items_chain: Sequence):
self.dbg('on_suggest')
if not items_chain:
return []
initial_item = items_chain[0]
current_items = items_chain[1:len(items_chain)]
current_suggestion_type: SuggestionMode = self.get_current_suggestionmode(
items_chain)
suggestions = []
actual_user_input = self.filter_prefix if len(items_chain) == 1 else ""
previous_effective_value = ""
if (len(current_items) > 0):
current_item = current_items[-1]
previous_effective_value = kpu.kwargs_decode(
current_item.data_bag())['effective_value']
actual_user_input += previous_effective_value
actual_user_input += user_input
self.print(actual_user_input=actual_user_input, user_input=user_input)
self.print(is_filter=str(current_suggestion_type))
if current_suggestion_type == SuggestionMode.Filter:
self.add_filter_suggestions(actual_user_input, suggestions)
else:
self.add_issues_matching_filter(actual_user_input, suggestions)
suggestions.append(
self.plugin.create_item(
category=self.plugin.ITEMCAT_SWITCH,
label="Switch ⇆",
short_desc="Switch between filter suggestions and issue list",
target="switch",
args_hint=kp.ItemArgsHint.ACCEPTED,
hit_hint=kp.ItemHitHint.IGNORE,
icon_handle=self.plugin._icons[self.filter_icon],
loop_on_suggest=True,
data_bag=kpu.kwargs_encode(
url=self.api.create_issues_url(previous_effective_value),
effective_value=previous_effective_value)))
# avoid flooding YouTrack with too many unnecessary queries in
# case user is still typing her search
if self.plugin.should_terminate(self.plugin.idle_time):
return []
if initial_item.category() == self.plugin.ITEMCAT_SWITCH:
return []
return suggestions
def get_issues_matching_filter(self, actual_user_input):
issues = self.api.get_issues_matching_filter(actual_user_input)
suggestions = []
for issue in issues:
suggestions.append(
self.plugin.create_item(
category=self.plugin.ITEMCAT_ISSUES,
label=issue.summary + " [" + issue.id + "]",
short_desc=issue.id +
(" ▶ " + issue.description
if issue.description is not None else ""),
target=issue.id,
args_hint=kp.ItemArgsHint.FORBIDDEN,
hit_hint=kp.ItemHitHint.NOARGS,
icon_handle=self.plugin._icons[self.issues_icon],
loop_on_suggest=False,
data_bag=(kpu.kwargs_encode(url=issue.url))))
return suggestions
def on_catalog(self):
self._read_config()
catalog = []
for distro_name, distro in self._distros.items():
if not distro['enabled']:
continue
# catalog the executable
catalog.append(
self.create_item(
category=kp.ItemCategory.FILE,
label=distro['label'],
short_desc="",
target=distro['exe_file'],
args_hint=kp.ItemArgsHint.ACCEPTED,
hit_hint=kp.ItemHitHint.KEEPALL,
data_bag=kpu.kwargs_encode(distro_name=distro_name)))
self.set_catalog(catalog)
def on_catalog(self):
self._read_config()
catalog = []
for distro_name, distro in self._distros.items():
if not distro['enabled']:
continue
# catalog the executable
catalog.append(self.create_item(
category=kp.ItemCategory.FILE,
label=distro['label'],
short_desc="",
target=distro['exe_file'],
args_hint=kp.ItemArgsHint.ACCEPTED,
hit_hint=kp.ItemHitHint.KEEPALL,
data_bag= kpu.kwargs_encode(
distro_name=distro_name
))
)
self.set_catalog(catalog)
def add_issues_matching_filter(self, actual_user_input: str,
suggestions: Sequence) -> None:
self.dbg("add_issues_matching_filter for " + actual_user_input)
api_result_suggestions = self.get_issues_matching_filter(
actual_user_input)
for res in api_result_suggestions:
suggestions.append(res)
suggestions.insert(
0,
self.plugin.create_item(
category=self.plugin.ITEMCAT_ISSUES,
label=actual_user_input,
short_desc=actual_user_input,
target=actual_user_input,
args_hint=kp.ItemArgsHint.ACCEPTED,
hit_hint=kp.ItemHitHint.IGNORE,
icon_handle=self.plugin._icons[self.issues_icon],
loop_on_suggest=True,
data_bag=(kpu.kwargs_encode(
url=self.api.create_issues_url(actual_user_input),
effective_value=actual_user_input))))
def on_catalog(self):
self._read_config()
catalog = []
for distro_name, distro in self._distros.items():
if not distro['enabled']:
continue
self.dbg('Creating catalogItem for action: ', distro['label'], distro['exe_file'])
catalog.append(self.create_item(
category=kp.ItemCategory.KEYWORD,
label=distro['label'],
short_desc='Open HeidiSQL or open sessions via auto-complete',
target=distro['exe_file'],
args_hint=kp.ItemArgsHint.ACCEPTED,
hit_hint=kp.ItemHitHint.NOARGS,
data_bag=kpu.kwargs_encode(
distro_name=distro_name
)
))
self.set_catalog(catalog)
def on_suggest(self, user_input, items_chain):
if not items_chain or items_chain[0].category() != kp.ItemCategory.FILE:
return
suggestions = []
data_bag = kpu.kwargs_decode(items_chain[0].data_bag())
sessions = self._distros[data_bag['distro_name']]['sessions']
for session_name in sessions:
if not user_input or kpu.fuzzy_score(user_input, session_name) > 0:
suggestions.append(self.create_item(
category=kp.ItemCategory.REFERENCE,
label="{}".format(session_name),
short_desc='Launch "{}" session'.format(session_name),
target=kpu.kwargs_encode(
dist=data_bag['distro_name'], session=session_name),
args_hint=kp.ItemArgsHint.FORBIDDEN,
hit_hint=kp.ItemHitHint.IGNORE))
self.set_suggestions(suggestions, kp.Match.ANY, kp.Sort.NONE)
def on_catalog(self):
self._read_config()
catalog = []
for distro_name, distro in self._distros.items():
if not distro['enabled']:
continue
self.dbg('Creating catalogItem for action: ', distro['label'],
distro['exe_file'])
catalog.append(
self.create_item(
category=kp.ItemCategory.KEYWORD,
label=distro['label'],
short_desc=
'Open HeidiSQL or open sessions via auto-complete',
target=distro['exe_file'],
args_hint=kp.ItemArgsHint.ACCEPTED,
hit_hint=kp.ItemHitHint.NOARGS,
data_bag=kpu.kwargs_encode(distro_name=distro_name)))
self.set_catalog(catalog)
def on_suggest(self, user_input, items_chain):
if len(user_input) == 0:
return
if not items_chain:
return
initial_item = items_chain[0]
# avoid flooding Leo with too much unnecessary queries in
# case user is still typing her search
if self.should_terminate(0.250):
return
if initial_item.category() != kp.ItemCategory.KEYWORD:
return
suggestions = []
current_language = self._languages[initial_item.target()]
for leo_translation in self._parser.translate(current_language.language_code, user_input):
item_icon = self._icons[leo_translation.language]
suggestions.append(self.create_item(
category=kp.ItemCategory.EXPRESSION,
label=leo_translation.caption,
short_desc=leo_translation.description,
target=leo_translation.caption,
args_hint=kp.ItemArgsHint.FORBIDDEN,
hit_hint=kp.ItemHitHint.IGNORE,
icon_handle=item_icon,
data_bag=kpu.kwargs_encode(
language_code=current_language.language_code,
item_language=leo_translation.language,
user_query=user_input,
translation_result=leo_translation.caption
)
))
self.set_suggestions(suggestions, kp.Match.ANY, kp.Sort.NONE)
def details_suggestions(self) -> list:
"""Returns all the suggestions used in this media details."""
from .peoplesuggestion import PeopleSuggestion
from .textsuggestion import TextSuggestion
suggestions = [
TextSuggestion(self.label, self._genres_text, self._id, self.icon),
self._get_year_suggestion(),
TextSuggestion(self._runtime, 'Runtime', 'movieruntime', 'Clock')
]
if self._director:
director = PeopleSuggestion(self._director)
director.description = 'Director'
director.icon = 'Director'
suggestions.append(director)
if self._tagline:
suggestions.append(
TextSuggestion(self._tagline, 'Tagline', 'movietagline',
'Tagline'))
if self._omdb:
suggestions.extend(self._get_ratings_suggestions())
if self._trailer:
suggestions.append(
TextSuggestion(
'Trailer',
"Watch trailer on {}".format(self._trailer['site']),
kpu.kwargs_encode(url=constants.URL_YOUTUBE_WATCH.format(
self._trailer['key'])), 'Trailer'))
if self._main_cast:
suggestions.extend(self._get_main_cast_suggestion())
return suggestions
def on_suggest(self, user_input, items_chain):
if not items_chain or items_chain[0].category() != kp.ItemCategory.KEYWORD:
return
suggestions = []
data_bag = kpu.kwargs_decode(items_chain[0].data_bag())
sessions = self._distros[data_bag['distro_name']]['sessions']
for session in sessions:
session_name = str(session).rpartition('\\')[2]
if not user_input or kpu.fuzzy_score(user_input, session_name) > 0:
suggestions.append(self.create_item(
category=kp.ItemCategory.REFERENCE,
label=session_name,
short_desc='Open "{}" with HeidiSQL'.format(session_name),
target=kpu.kwargs_encode(
distro_name=data_bag['distro_name'],
session=session
),
args_hint=kp.ItemArgsHint.FORBIDDEN,
hit_hint=kp.ItemHitHint.IGNORE
))
self.set_suggestions(suggestions, kp.Match.ANY, kp.Sort.NONE)
def suggest_actions(self, current_item, params):
contact_no = int(params['contact_no'])
contact = self.contacts[contact_no]
if self._debug:
self.dbg(
f"Suggest actions for contact {contact['name']} - {repr(contact)}"
)
suggestions = []
# suggestions.insert(0, item)
for key in contact.keys():
if not key.startswith(
"TEL;") or not key in self.VERB_CONTACT_FIELDS:
continue
verb = self.VERB_CONTACT_FIELDS[key]
if not verb.contact_field in contact:
continue
target = contact[verb.contact_field]
title = contact[
self.AD_ATTR_TITLE] if self.AD_ATTR_TITLE in contact else ""
suggestions.append(
self.create_item(
category=self.ITEMCAT_ACTION,
label=
f'Call {contact[self.ID_NAME]} - {target} ({verb.name})',
short_desc=title,
target=contact[verb.contact_field],
args_hint=kp.ItemArgsHint.FORBIDDEN,
hit_hint=kp.ItemHitHint.IGNORE,
loop_on_suggest=True,
data_bag=kpu.kwargs_encode(verb_name=verb.name,
contact_no=contact_no,
action=verb.action)))
if self.AD_ATTR_MAIL in contact:
verb = self.VERB_CONTACT_FIELDS[self.AD_ATTR_MAIL]
target = contact[verb.contact_field]
title = contact[
self.AD_ATTR_TITLE] if self.AD_ATTR_TITLE in contact else ""
suggestions.append(
self.create_item(
category=self.ITEMCAT_ACTION,
label=f'{verb.name} {contact[self.ID_NAME]} - {target}',
short_desc=title,
target=target,
args_hint=kp.ItemArgsHint.FORBIDDEN,
hit_hint=kp.ItemHitHint.IGNORE,
loop_on_suggest=True,
data_bag=kpu.kwargs_encode(verb_name=verb.name,
contact_no=contact_no,
action=verb.action)))
verb = self.VERB_CONTACT_FIELDS[self.AD_ATTR_NAME]
target = contact[verb.contact_field]
title = contact[
self.AD_ATTR_TITLE] if self.AD_ATTR_TITLE in contact else ""
suggestions.append(
self.create_item(
category=self.ITEMCAT_ACTION,
label=f'{verb.name} {contact[self.ID_NAME]} - {target}',
short_desc=title,
target=target,
args_hint=kp.ItemArgsHint.FORBIDDEN,
hit_hint=kp.ItemHitHint.IGNORE,
loop_on_suggest=True,
data_bag=kpu.kwargs_encode(verb_name=verb.name,
contact_no=contact_no,
action=verb.action)))
suggestions.append(
self.create_item(
category=self.ITEMCAT_ACTION,
label=f'{verb.name} {contact[self.ID_NAME]} - {target}',
short_desc=title,
target=target,
args_hint=kp.ItemArgsHint.FORBIDDEN,
hit_hint=kp.ItemHitHint.IGNORE,
loop_on_suggest=False,
data_bag=kpu.kwargs_encode(verb_name=verb.name,
contact_no=contact_no,
action=verb.action)))
self.set_suggestions(suggestions, kp.Match.ANY, kp.Sort.NONE)
