def alfred_search(keyword, query):
infos = []
strings = keyword.split(".")
# Include extension
if len(strings) > 1:
result = domainsearch(keyword)
show_result(infos, keyword, result)
alfred.write(alfred.xml(infos, maxresults=10))
return
# No extension
base_exts = [".com", ".cn", ".net", ".me"]
advanced_exts = [".org", ".tv", ".cc"]
final_exts = base_exts
if query == "all":
final_exts = base_exts+advanced_exts
for ext in final_exts:
domain = keyword+ext
result = domainsearch(domain)
show_result(infos, domain, result)
alfred.write(alfred.xml(infos, maxresults=10))
def get_weather(query=""):
if query:
global QUERY_PARAM
QUERY_PARAM["weather"]["location"] = query
try:
weather = json.loads(request_for("weather"))
if weather["error"]:
raise
except:
return alfred.xml((alfred.Item(title=u"查询失败"),))
weather = weather["results"][0]
result = []
pm25 = PM2_5_rank(int(weather["pm25"]))
pm25 = alfred.Item(
title="".join((u"%s 空气质量：" % weather["currentCity"], weather["pm25"], " ", pm25[0])), icon=pm25[1]
)
result.append(pm25)
now = weather["weather_data"][0]
now = alfred.Item(
title=now["date"].replace(" ", " " * 4, 1),
subtitle="".join((now["weather"], u"，", now["wind"], u"，", u"气温：", now["temperature"])),
icon=(get_weather_icon_name(now["dayPictureUrl"]), {"type": "png"}),
)
result.append(now)
for data in weather["weather_data"][1:]:
title = u"%s %s" % (data["date"], data["weather"])
subtitle = u"%s，气温：%s" % (data["wind"], data["temperature"])
icon = (get_weather_icon_name(data["dayPictureUrl"]), {"type": "png"})
weather_data = alfred.Item(title=title, subtitle=subtitle, icon=icon)
result.append(weather_data)
return alfred.xml(result)
def main(action, query):
# If the configuration file doesn't exist, create an empty one
if not os.path.isfile(_CONFIG_FILE):
create_config()
alfred.write(alfred.xml(config_file_is_empty()))
return
try:
config = get_config()
if not config.sections() and action != 'add':
# If the configuration file is empty, tell the user to add secrets to it
alfred.write(alfred.xml(config_file_is_empty()))
return
except Exception as e:
alfred.write(alfred.xml([alfred.Item({u'uid': alfred.uid(0),
u'arg': '', u'ignore': 'yes'},
"~/.gauth: Invalid syntax",
str(e).replace('\n', ' '),
"error.png")]))
sys.exit(1)
if action == 'list' and not is_command(query):
alfred.write(alfred.xml(list_accounts(config, query), maxresults=_MAX_RESULTS))
elif action == 'add':
alfred.write(add_account(config, query))
def main(action, query):
# If the configuration file doesn't exist, create an empty one
if not os.path.isfile(_CONFIG_FILE):
create_config()
alfred.write(alfred.xml(config_file_is_empty()))
return
try:
config = get_config()
if not config.sections() and action != 'add':
# If the configuration file is empty, tell the user to add secrets to it
alfred.write(alfred.xml(config_file_is_empty()))
return
except Exception as e:
alfred.write(alfred.xml([alfred.Item({u'uid': alfred.uid(0),
u'arg': '', u'ignore': 'yes'},
"~/.gauth: Invalid syntax",
str(e).replace('\n', ' '),
"error.png")]))
sys.exit(1)
if action == 'list' and not is_command(query):
alfred.write(alfred.xml(list_accounts(config, query), maxresults=_MAX_RESULTS))
elif action == 'add':
alfred.write(add_account(config, query))
def define_alias(_dict, definition):
if u'=' in definition:
(alias, pipe) = definition.split(u'=', 1)
else:
(alias, pipe) = (definition, u'')
if not alias:
return alfred.xml([alfred.Item(
attributes = {'uid': u'pipe:help', 'valid': u'no'},
title = u"alias NAME=VALUE",
subtitle = u'Terminate VALUE with @@ to save',
icon = u'icon.png'
)])
if pipe and pipe.endswith('@@'):
pipe = pipe[:-2]
_dict[alias] = pipe
write_aliases(_dict)
return alfred.xml([alfred.Item(
attributes = {'uid': u'pipe:{}'.format(pipe) , 'valid': u'no', 'autocomplete': alias},
title = u"alias {}={}".format(alias, pipe),
subtitle = u'Alias saved! TAB to continue',
icon = u'icon.png'
)])
return alfred.xml([alfred.Item(
attributes = {'uid': u'pipe:{}'.format(pipe) , 'valid': u'no'},
title = u"alias {}={}".format(alias, pipe or 'VALUE'),
subtitle = u'Terminate with @@ to save',
icon = u'icon.png'
)])
def alfred_search(keyword, query):
infos = []
strings = keyword.split(".")
# Include extension
if len(strings) > 1:
result = domainsearch(keyword)
show_result(infos, keyword, result)
alfred.write(alfred.xml(infos, maxresults=10))
return
# No extension
base_exts = [".com", ".cn", ".net", ".me"]
advanced_exts = [".org", ".tv", ".cc"]
final_exts = base_exts
if query == "all":
final_exts = base_exts + advanced_exts
for ext in final_exts:
domain = keyword + ext
result = domainsearch(domain)
show_result(infos, domain, result)
alfred.write(alfred.xml(infos, maxresults=10))
def define_alias(_dict, definition, alias_file):
if '=' in definition:
(alias, pipe) = definition.split('=', 1)
else:
(alias, pipe) = (definition, '')
terminator = os.getenv("alias_terminator", DEFAULT_ALIAS_TERMINATOR)
if not alias:
return alfred.xml([
alfred.Item(
attributes={'valid': 'no'},
title="alias NAME=ARBITRARY-ONE-LINER",
subtitle=
"Terminate ONE-LINER with '{0}' to save or 'NAME={0}' to delete alias"
.format(terminator),
icon='icon.png')
])
if pipe and pipe == terminator:
_dict.pop(alias, None)
write_aliases(_dict, alias_file)
return alfred.xml([
alfred.Item(attributes={
'valid': 'no',
'autocomplete': ''
},
title="alias {0}={1}".format(alias, pipe),
subtitle='Alias deleted! TAB to continue',
icon='icon.png')
])
if pipe and pipe.endswith(terminator):
pipe = pipe[:-len(terminator)]
_dict[alias] = pipe
write_aliases(_dict, alias_file)
return alfred.xml([
alfred.Item(attributes={
'valid': 'no',
'autocomplete': alias
},
title="alias {0}={1}".format(alias, pipe),
subtitle='Alias saved! TAB to continue',
icon='icon.png')
])
return alfred.xml([
alfred.Item(attributes={'valid': 'no'},
title="alias {0}={1}".format(alias, pipe),
subtitle='Terminate with {0} to save'.format(terminator),
icon='icon.png')
])
def wSearch():
if len(sys.argv) <= 2:
alfred.write(alfred.xml([default()]))
return
(lang, query) = alfred.args2()
feedback_items = map(lambda x: parse(lang, x), search_for(lang, query))
# opensearch is used to autocomplete, which means
# it searches based on the starting of the text that entered
# feedback_items = map(lambda x: opensearch_parse(lang, x), opensearch_for(lang, query))
xml = alfred.xml(feedback_items, results=100)
alfred.write(xml)
def process(self, query_str):
""" Entry point """
results = self.get_items_for_query(query_str)
if results:
xml = alfred.xml(results,
self.max_results) # compiles the XML answer
alfred.write(xml) # writes the XML back to Alfred
def searchComics(search_term):
feedback_items = []
for i in getPlugins():
plugin = loadPlugin(i)
title = plugin.title()
subtitle = plugin.subtitle()
should_add = (plugin.enabled()
and (search_term == None
or title.lower().find(search_term.lower()) >= 0
or subtitle.lower().find(search_term.lower()) >= 0)
)
if should_add:
feedback_items.append(
alfred.Item(
attributes = {
'uid' : alfred.uid(i["name"]),
'arg' : i["name"]
},
title = title,
subtitle = subtitle,
icon = os.path.join(i["location"], "icon.png")
)
)
xml = alfred.xml(feedback_items)
alfred.write(xml)
def main():
#read
knowledge_dir = '~/Knowledges'
query = sys.argv[1:]
result = "grep -r key %s" % knowledge_dir
for argu in query:
if argu:
result += "| grep " + argu
(status, output) = commands.getstatusoutput(result)
result = []
i = 1
for line in output.split('\n'):
if line:
file_name = line.split(':')[0]
key_list = line.split(':')[1].decode('utf8')
preview = commands.getoutput("cat %s | grep title" %
file_name).decode('utf8')
result.append(
alfred.Item({
"uid": alfred.uid(i),
'arg': file_name
}, key_list, preview, None))
i = i + 1
if not result:
result.append(
alfred.Item({"uid": alfred.uid(i)}, "nothing find", "", None))
alfred.write(alfred.xml(result))
def process():
dirname = os.path.dirname(os.path.abspath('.'))
dirs = [f for f in os.listdir(dirname) if os.path.isdir(os.path.join(dirname, f))]
results = []
for (idx,d) in enumerate(dirs):
try:
print os.path.join(dirname, d, 'settings.plist')
plist = plistlib.readPlist(os.path.join(dirname, d, 'info.plist'))
except:
continue
title = plist['name']
disabled = plist.get('disabled', None)
createdby = plist['createdby']
displayTitle = title + (' - disabled' if disabled else '')
results.append({'title': displayTitle, 'createdby' : createdby, 'disabled' : disabled, 'directory' : d})
results = sorted(results, key=lambda a: a['title'].lower())
resultsData = [alfred.Item(title=f['title'], subtitle=' by ' + (f['createdby'] or "[noinfo]"), attributes = {'uid':uuid4(), 'arg':os.path.join(dirname,f['directory'])}, icon=os.path.join(dirname, f['directory'], u"icon.png")) for f in results]
alfred.write(alfred.xml(resultsData, maxresults=None))
def complete(query, maxresults=_MAX_RESULTS):
if query == 'latest':
results = latest_results()
else:
results = search_results(query)
return alfred.xml(results, maxresults=_MAX_RESULTS)
def generate_view(query, entered_tag, info):
feedback_items = []
tags = itemlist.get_tags()
# check if we have any tags
if len(tags) == 0:
feedback_items.append(default_no_tags())
config.update_state(tag='#default')
else:
if entered_tag:
feedback_items.append(itemview.generate_add_feedbackitem(query, info))
sorted_tags = sorted(tags, key=lambda x: x)
for tag in sorted_tags:
if not entered_tag or tag.lower().find(entered_tag.lower()) >= 0:
count = tags[tag]
feedback_items.append(
alfred.Item(
attributes={
'uid': uuid4(),
'arg': helpers.encode_tag(tag),
'autocomplete': "#{0} ".format(tag),
'valid': 'yes'
},
title="#{0}".format(tag),
subtitle="{0} item{1}".format(count, ('' if count == 1 else 's')),
icon="todo_tag.png"
)
)
config.update_state(view='tag_view', command='display_tags')
alfred.write(alfred.xml(feedback_items))
def generate_view(query):
if len(query) == 0 and config.get('todo.command.last') == 'quick_create':
add_query = config.get('todo.user.query')
add_tag = config.get('todo.tag.recent')
itemlist.save_todo(add_query,silent=True)
config.update_state(command='', query='')
info = parser.parse(query)
tag = info['tag']
q = info['task']
todos = itemlist.get_todo_list()
# view for pinned items
# pinned items should have unique uuid and different logo
pinned = [t for t in todos if itemlist.feature(t,'pinned') == True]
pinned = [t for t in pinned if (tag is None or t['group'] == tag)]
pinned = [t for t in pinned if (q is None or t['title'].lower().find(q.lower()) >= 0)]
pinned = pinned[::-1]
# view for non-pinned items
normal = [t for t in todos if itemlist.feature(t,'pinned') == False]
normal = [t for t in normal if (tag is None or t['group'] == tag)]
normal = [t for t in normal if (q is None or t['title'].lower().find(q.lower()) >= 0)]
normal = normal[::-1]
feedback_items = []
if len(normal) == 0 and len(pinned) == 0:
feedback_items.append( generate_add_feedbackitem(query, info) )
else:
pinned = map(lambda x: generate_pinned_feedbackitem(x), pinned)
normal = map(lambda x: generate_todo_feedbackitem(x), normal)
feedback_items = pinned + normal
alfred.write(alfred.xml(feedback_items))
def process(query_str):
""" Entry point """
value = parse_query_value(query_str)
if value is not None:
results = alfred_items_for_value(value)
xml = alfred.xml(results) # compiles the XML answer
alfred.write(xml) # writes the XML back to Alfred
def main():
reload(sys) # reload unicode decoder
sys.setdefaultencoding('utf-8') # use utf-8
(param, word) = alfred.args()
cityCode = '100010000' # Beijing
if word.isspace():
url = "http://m.nuomi.com/client/gethotkeyword?cityid=%s&limit=20&client=ios&version=3.2.0" % (cityCode)
else:
word = OnlyCharNum(word)
url = "http://m.nuomi.com/client/searchsuggest?k=%s&cityid=%s" % (word, cityCode)
req = urllib2.Request(url)
response = urllib2.urlopen(req)
data = json.loads(response.read())
results = []
if word.isspace():
if len(data['keywords']) == 0:
results.append(alfred.Item({'uid': 0, 'arg': word}, word, '', 'icon.png'))
else:
for i in range(0, len(data['keywords'])):
results.append(alfred.Item({'uid': i, 'arg': data['keywords'][i]['keyword']}, data['keywords'][i]['keyword'], '', 'icon.png'))
else:
if len(data['data']) == 0:
results.append(alfred.Item({'uid': 0, 'arg': word}, word, '', 'icon.png'))
else:
for i in range(0, len(data['data'])):
results.append(alfred.Item({'uid': i, 'arg': data['data'][i]['t']}, data['data'][i]['t'], '', 'icon.png'))
xml = alfred.xml(results) # compiles the XML answer
alfred.write(xml)
def generate_view_tagedit(old_tag, query):
info = parser.parse(query)
new_tag = info['tag']
new_text = info['task']
tag_changed = new_tag and new_tag != old_tag
only_tag_changed = tag_changed and len(new_text) == 0
feedback_items = []
# action item
feedback_items.append(alfred.Item(
attributes={
'uid': uuid4(),
'arg': query + " ",
'valid': 'yes' if only_tag_changed else 'no'
},
title="Update tag" if only_tag_changed else "Nothing to update",
subtitle="Enter a new tag name" if not only_tag_changed else "",
icon="todo_edit.png"
))
# tag info item
feedback_items.append(alfred.Item(
attributes={
'uid': uuid4(),
'arg': "",
'valid': 'no',
'autocomplete': "#"+old_tag
},
title="#"+old_tag,
subtitle="Change to #" + new_tag if only_tag_changed else "",
icon="todo_tag.png"
))
alfred.write(alfred.xml(feedback_items))
def show_recent_list_of_file(target_file):
'''
Get the recent list saved by the parameter file.
'''
file_path = expanduser('~') + '/Library/Preferences/' + target_file
feedback = []
index = 0
res = True
while res:
sub_cmd = 'Print RecentDocuments:CustomListItems:' + str(index) + ':Name'
cmd = ['/usr/libexec/PlistBuddy', '-c', sub_cmd, file_path]
p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
out, err = p.communicate()
res = out != ''
if res:
out_arg = unicode(target_file, 'utf-8') + ' ' + unicode(out.strip(), 'utf-8')
feedback.append(alfred.Item(
{'arg': out_arg}, # item attribute
unicode(out.strip(), 'utf-8'), # title
unicode(target_file, 'utf-8') # subtitle
)
)
index = index + 1
alfred.write(alfred.xml(feedback))
def test_unicode_value_xml(self):
"""Ensure we can handle converting Items with unicode values to xml"""
item = alfred.Item({}, u'\xb7', u'\xb7')
expected = '<items><item><title>\xc2\xb7</title><subtitle>\xc2\xb7</subtitle></item></items>'
actual = alfred.xml([item])
self.assert_(expected == actual,
'{!r} != {!r}'.format(expected, actual))
def process(query_str):
""" Entry point """
value = parse_query_value(query_str)
if value is not None:
results = alfred_items_for_value(value)
xml = alfred.xml(results) # compiles the XML answer
alfred.write(xml) # writes the XML back to Alfred
def complete(query, maxresults=_MAX_RESULTS):
if query == 'latest':
results = latest_results()
else:
results = search_results(query)
return alfred.xml(results, maxresults=_MAX_RESULTS)
def generate_export_view():
feedback_items = []
todos = itemlist.get_todo_list()
if len(todos) == 0:
feedback_items.append(generate_noitems())
else:
items = []
items.append({
'title': 'Export all items as plain text',
'subtitle': 'Will be copied to your clipboard',
'arg': 'txt',
'icon': 'export_txt.png'
})
todos = itemlist.get_todo_list()
tags = defaultdict(list)
for i in todos:
tags[i['group']].append(1)
for tag in tags:
if tag != 'default':
items.append({
'title': 'Export #' + tag,
'subtitle': 'Will be copied to your clipboard',
'arg': 'txt ' + tag,
'icon': 'export_txt.png'
})
feedback_items = map(lambda x: generate_feedbackitem(x), items)
alfred.write(alfred.xml(feedback_items))
def get_actions():
arr = []
isChrome = bool(int(applescript("isChrome")))
isSafari = bool(int(applescript("isSafari")))
isClipboard = applescript("isClipboard")
if isChrome:
chrome_url = applescript("chrome")
arr.append(alfred.Item(
attributes={'uid': alfred.uid(0), 'arg': "chrome"},
title='Pocket - save url from Chrome',
icon='icon.png',
subtitle= chrome_url["title"].decode('utf8')
))
if isSafari:
s_url = applescript("safari")
arr.append(alfred.Item(
attributes={'uid': alfred.uid(0), 'arg': "safari"},
title='Pocket - save url from Safari',
icon='icon.png',
subtitle=s_url["title"].decode('utf8')
))
if isClipboard:
c_url = applescript("clip")
arr.append(alfred.Item(
attributes={'uid': alfred.uid(0), 'arg': "clip"},
title='Pocket - save url from Clipboard',
icon='icon.png',
subtitle=c_url["url"].decode('utf8')
))
xml = alfred.xml(arr)
alfred.write(xml)
def process(self, query_str):
""" Entry point """
results = self.get_items_for_query(query_str)
if results:
xml = alfred.xml(results,
self.max_results) # compiles the XML answer
alfred.write(xml) # writes the XML back to Alfred
def latest_results(maxresults=_MAX_RESULTS):
response = fetch_justadded()
if not response:
return alfred.xml([
alfred.Item(
attributes={
'uid': u'trailer://404',
'valid': u'no'
},
title=u'404 Latest Movies Not Found',
subtitle=
u'Sorry, the iTunes Movie Trailers server isn\'t responding',
icon=u'icon.png')
])
results = []
for r in response[:maxresults]:
address = u''.join((_BASE_URL, r['location']))
results.append(
alfred.Item(attributes={
'uid': u'trailer://%s' % r['location'],
'arg': address,
'autocomplete': r['title']
},
title=r['title'],
subtitle=u'Studio: %(studio)s' % r,
icon=fetch_poster(r['poster'])))
return results
def process_tag(pins, deleted_url, q, prefix):
tag_list = {}
for p in pins:
url = p['href']
if url in map(lambda x: x.lower(), deleted_url): continue
try:
tags = p['tags'].encode('utf-8').split(' ')
except:
tags = []
for t in tags:
if t in tag_list:
tag_list[t] += 1
else:
tag_list[t] = 1
resultData = []
tag_list_key = sorted(tag_list.keys(), key=str.lower)
for (idx, i) in enumerate(tag_list_key):
if not q or q in i.lower():
expand_str = prefix + (prefix and " " or "") + "#" + i + " : "
resultData.append(
alfred.Item(title=(i and i or "untagged") + " (" +
str(tag_list[i]) + ")",
subtitle='',
attributes={
'autocomplete': expand_str,
'valid': 'no',
'uid': alfred.uid(idx)
},
icon='tag.png'))
alfred.write(alfred.xml(resultData, maxresults=None))
return
def getPlayerInfo(value):
selectItem = None
for item in value:
if item['rating'] == rating:
selectItem = item
break
statusDic = {
u'PACE(速度)': selectItem['attr1'],
u'SHOOTING(射门)': selectItem['attr2'],
u'PASSING(传球)': selectItem['attr3'],
u'DRIBBLING(盘带)': selectItem['attr4'],
u'DEFENDING(防守)': selectItem['attr5'],
u'PHYSICAL(身体)': selectItem['attr6']
}
results = []
index = 0
for (key, value) in statusDic.items():
# print key, value
results.append(alfred.Item(
title= key,
subtitle=value,
attributes={
'uid': alfred.uid(index),
'arg': u'%s\'s %s is %d' % (selectItem['full_name'], key , value),
},
icon='icon.png',
))
index += 1
xml = alfred.xml(results)
alfred.write(xml)
def choose_format():
"""Choose email format"""
items = []
mt = MailTo()
use_name = mt.use_contact_name
if use_name:
title = u'Current Setting: Default (Name & Email)'
subtitle = u'Email-only will be used with some problem clients'
else:
title = u'Current Setting: Email Only'
subtitle = u'E.g. [email protected], [email protected]'
items.append( alfred.Item(
{u'valid':u'no'},
title,
subtitle,
icon=u'icon.png')
)
options = {
u'email' : alfred.Item({u'valid':u'yes', u'arg':u'email'},
u'Call Email Client with Email Only',
u'e.g. [email protected]',
icon=u'icon.png'),
u'default' : alfred.Item({u'valid':u'yes', u'arg':u'name'},
u'Use Default Format (Name & Email)',
u'Name and email except with known problem clients',
icon=u'icon.png')
}
if use_name:
items.append(options[u'email'])
else:
items.append(options[u'default'])
print(alfred.xml(items))
def main():
try:
q = unicode(sys.argv[1])
q = unicodedata.normalize('NFC', q).lower().replace(' ','')
except:
q = ""
rss = rss_data()
config = config_data()
try:
max_results = config['max_results']
except:
max_results = None
results = []
for e in itertools.islice(rss,max_results):
if not q or q in e['title'].lower().replace(' ',''):
results.append(alfred.Item(title=e['title'],subtitle=e['published'],attributes={'arg':e['link']},icon=e['image']))
try:
last_updated = config['last_updated']
except:
last_updated = 0
subtitle = "Last updated: "+(last_updated and util.pretty_date(config['last_updated']) or "no info")
diff = int(time.time())-last_updated
if diff > RELOAD_ASK_THRESHOLD or len(rss) == 0:
results.insert(0,alfred.Item(title="BackToTheMac - Reload Data?", subtitle=subtitle,
attributes={'arg':'reload','uid':alfred.uid('t')}, icon="icon.png"))
else:
results.insert(0,alfred.Item(title="BackToTheMac", subtitle=subtitle,
attributes={'arg':'http://macnews.tistory.com','uid':alfred.uid('t')}, icon="icon.png"))
alfred.write(alfred.xml(results, maxresults=None))
def search_results(query, maxresults=_MAX_RESULTS):
response = fetch_quickfind(query)
if not response or response['error']:
return alfred.xml([alfred.Item(
attributes = {'uid': u'trailer://404', 'valid': u'no'},
title = u'404 Trailer Not Found',
subtitle = u'Sorry, the iTunes Movie Trailers server returned an error',
icon = u'icon.png'
)])
results = []
for r in response['results'][:maxresults]:
address = u''.join((_BASE_URL, r['location']))
results.append(alfred.Item(
attributes = {'uid': u'trailer://%s' % r['location'], 'arg': address, 'autocomplete': r['title']},
title = r['title'],
subtitle = u'Rating: %(rating)s; Studio: %(studio)s' % r,
icon = fetch_poster(u''.join((_BASE_URL, r['poster'])))
))
# no matches
if results == []:
results.append(alfred.Item(
attributes = {'uid': u'trailer://404', 'valid': u'no'},
title = u'404 Trailer Not Found',
subtitle = u'No trailers matching the query were found',
icon = u'icon.png'
))
return results
def process_tag(pins,deleted_url,q,prefix):
tag_list = {}
for p in pins:
url = p['href']
if url in map(lambda x:x.lower(), deleted_url): continue
try:
tags = p['tags'].encode('utf-8').split(' ')
except:
tags = []
for t in tags:
if t in tag_list:
tag_list[t] += 1
else:
tag_list[t] = 1
resultData = []
tag_list_key = sorted(tag_list.keys(),key=str.lower)
for (idx,i) in enumerate(tag_list_key):
if not q or q in i.lower():
expand_str = prefix+(prefix and " " or "")+"#"+i+" : "
resultData.append(alfred.Item(title=(i and i or "untagged")+" ("+str(tag_list[i])+")", subtitle='',
attributes={'autocomplete':expand_str,
'valid':'no',
'uid':alfred.uid(idx)}, icon='tag.png'))
alfred.write(alfred.xml(resultData,maxresults=None))
return
def convert(query):
#Input data
query2 = unicodedata.normalize('NFC', query)
parsed_data = string_div(query2)
# print(parsed_data)
unit = parsed_data['unit']
number = parsed_data['number']
#Load convert data file
try:
f = open("unit.json", 'r')
except:
print("ERROR:can't create file")
unit_data = json.load(f, encoding='utf-8')
#print(unit_data['inch'])
#Data check & convert
output_list = []
# item = alfred.Item({'uid': alfred.uid(1), 'arg': 'some arg', 'valid': 'no'}, unit, number, ('someicon.png', {'type': 'filetype'}))
# output_list.append(item)
for unit_group in unit_data:
inputs = unit_data[unit_group]['input']
outputs = unit_data[unit_group]['output']
for input_keyword in inputs:
if input_keyword == unit:
for output_unit in outputs:
#convert calc type check
find_index = outputs[output_unit].find("?")
if find_index >= 0:
#special pattern
float_str = eval(outputs[output_unit].replace(
'?', number))
float_data = float(float_str)
else:
#normal pattern
float_data = float(
outputs[output_unit]) * float(number)
#output_data = {'number':str(float_data),'unit':output_unit}
output_str = str(float_data) + output_unit
item = alfred.Item(
{
'uid': alfred.uid(len(output_list) + 1),
'arg': output_str,
'valid': 'yes'
}, output_str, query, ('icon.png', {
'type': 'png'
}))
output_list.append(item)
# print(output_list)
xml = alfred.xml(output_list)
alfred.write(xml)
def process(query_str):
query_str = str(query_str).strip('"\' ')
timestamp = parse_query_str(query_str)
if timestamp is None:
return
results = gen_alfred_items(timestamp)
xml = alfred.xml(results)
alfred.write(xml)
def xml(self, _filter=(lambda x: True), maxresults=_MAX_RESULTS):
items = [
self.item(host=self.original, source=self.hosts[self.original])
]
for (host, source) in ((x, y) for (x, y) in self.hosts.iteritems()
if ((x != self.original) and _filter(x))):
items.append(self.item(host, source))
return alfred.xml(items, maxresults=maxresults)
def search(this,kw): html=this.getSearchHTML(kw) problems=re.compile(this.RE_SEARCH,re.DOTALL).findall(html) result=[] for p in problems: this.ad_prob(result,this.getSearchResult(p)) this.checkresult(result,"No result found") alfred.write(alfred.xml(result))
def exact_alias(_dict, query):
pipe = _dict[query]
return alfred.xml([alfred.Item(
attributes = {'uid': u'pipe:{}'.format(pipe), 'arg': pipe},
title = pipe,
subtitle = u'(expanded alias)',
icon = u'icon.png'
)])
def xml(self, _filter=(lambda x: True), maxresults=_MAX_RESULTS):
items = [self.item(host=self.original, source=self.hosts[self.original])]
for (host, source) in (
(x, y) for (x, y) in self.hosts.iteritems()
if ((x != self.original) and _filter(x))
):
items.append(self.item(host, source))
return alfred.xml(items, maxresults=maxresults)
def query_word(word):
output = [];
result = query_api(word);
if handle_error(result, output):
output_word_explains(word, result, output);
xml = alfred.xml(output)
return xml;
def process(query_str):
""" Entry point """
if query_str and len(query_str) > 2:
results = get_results(query_str)
if results is not None:
response = alfred_items_for_results(results)
xml = alfred.xml(response) # compiles the XML answer
alfred.write(xml) # writes the XML back to Alfred
def query_word(word):
output = []
result = query_api(word)
if handle_error(result, output):
output_word_explains(word, result, output)
xml = alfred.xml(output)
return xml
def process(query):
""" Entry point
:param query: query string
:return:
"""
if query:
results = alfred_items_for_query(query)
xml = alfred.xml(results)
alfred.write(xml)
def process(query):
""" Entry point
:param query: query string
:return:
"""
if query:
results = alfred_items_for_query(query)
xml = alfred.xml(results)
alfred.write(xml)
def generate_view():
feedback_items = []
if not all_enabled():
feedback_items.append(feedback_item("Enable all", '', 'special_enable'))
else:
feedback_items.append(feedback_item("Disable all", '', 'special_disable'))
feedback_items = feedback_items + map(lambda f: feedback_item(f['title'], f['subtitle'], f['id']), features)
alfred.write(alfred.xml(feedback_items))
def query(this,pid): if pid==0: return result=[] isget=True for p in this.getProblemList(pid): isget=this.add_problem(result,p,isget) this.checkresult(result,"No this problem %d"%pid) alfred.write(alfred.xml(result))
def complete():
query = sys.argv[1].strip()
maxresults = int(os.getenv('alfredman_max_results', DEFAULT_MAX_RESULTS))
cache_ttl = int(os.getenv('alfredman_cache_ttl', DEFAULT_CACHE_TTL))
whatis = fetch_whatis(cache_ttl)
sections = fetch_sections(whatis, cache_ttl)
results = []
if ' ' in query:
# section page
(_section, _title) = query.split()
pattern = re.compile(r'^.+\(%s\)$' % _section)
_whatis = filter_whatis_name(pattern.match, whatis)
results.extend(result_list(_title, _whatis))
else:
# section filtering
if query in sections:
_uri = man_uri('(%s)' % query)
results.append(
alfred.Item(attributes={
'uid': _uri,
'arg': _uri,
'valid': 'no'
},
title='Open man page',
subtitle='Scope restricted to section %s' % query,
icon='icon.png'))
# direct hit
if query in whatis:
_arg = man_arg(query)
_uri = man_uri(query)
results.append(
alfred.Item(attributes={
'uid': _uri,
'arg': _arg
},
title=query,
subtitle=whatis[query],
icon='icon.png'))
# standard filtering
results.extend(result_list(query, whatis))
# no matches
if not results:
results.append(
alfred.Item(attributes={
'uid': 'x-man-page://404',
'valid': 'no'
},
title='404 Page Not Found',
subtitle='',
icon='icon.png'))
return alfred.xml(results, maxresults=maxresults)
def complete(query, maxresults=_MAX_RESULTS):
whatis = fetch_whatis()
sections = fetch_sections(whatis)
results = []
# direct hit
if query in whatis:
_arg = man_arg(query)
_uri = man_uri(query)
results.append(
alfred.Item(attributes={
'uid': _uri,
'arg': _arg
},
title=query,
subtitle=whatis[query],
icon='icon.png'))
# section filtering
elif query in sections:
_uri = man_uri('(%s)' % query)
results.append(
alfred.Item(attributes={
'uid': _uri,
'arg': _uri,
'valid': 'no'
},
title='Open man page',
subtitle='Scope restricted to section %s' % query,
icon='icon.png'))
elif ' ' in query:
(_section, _title) = query.split()
pattern = re.compile(r'^.+\(%s\)$' % _section)
_whatis = filter_whatis_name(pattern.match, whatis)
results.extend(result_list(_title, _whatis))
# substring matching
elif query.startswith('~'):
results.extend(result_list('*%s*' % query, whatis))
# standard filtering
else:
results.extend(result_list(query, whatis))
# no matches
if results == []:
results.append(
alfred.Item(attributes={
'uid': 'x-man-page://404',
'valid': 'no'
},
title='404 Page Not Found',
subtitle='No man page was found for %s' % query,
icon='icon.png'))
return alfred.xml(results, maxresults=maxresults)
def show_help():
items = []
for text, subtext in __help__:
item = alfred.Item(
{u'valid':u'yes'},
text,
subtext,
icon=u'info.png'
)
items.append(item)
print(alfred.xml(items, maxresults=25))
def generate_view(query):
feedback_items = []
special_added = generate_view_rtm(feedback_items)
lists, active = get_todo_lists()
(path, db) = os.path.split(config.get(ck.KEY_TODO))
lists = [f for f in lists if len(query) == 0 or friendly_file(f).lower().find(query.lower()) >= 0]
feedback_items = feedback_items + map(lambda x: generate_feedback(path, x, x == active), lists)
if len(feedback_items) == 0 or (special_added and len(feedback_items) == 1):
feedback_items.append(generate_add_feedback(path, query))
alfred.write(alfred.xml(feedback_items))
def process_sortoption(q):
result = []
result.append(alfred.Item(title='last accessed time', subtitle='^l ',
attributes={'valid':'no','autocomplete':q+(q and " " or "")+'^l ','uid':alfred.uid(4)}, icon="num-des.png"))
result.append(alfred.Item(title='time ascending', subtitle='^d ',
attributes={'valid':'no','autocomplete':q+(q and " " or "")+'^d ','uid':alfred.uid(1)}, icon="general-des.png"))
result.append(alfred.Item(title='title ascending', subtitle='^a ',
attributes={'valid':'no','autocomplete':q+(q and " " or "")+'^a ','uid':alfred.uid(2)}, icon="alpha-asc.png"))
result.append(alfred.Item(title='title descending', subtitle='^z ',
attributes={'valid':'no','autocomplete':q+(q and " " or "")+'^z ','uid':alfred.uid(3)}, icon="alpha-des.png"))
alfred.write(alfred.xml(result,maxresults=None))
def exact_alias(_dict, query):
pipe = _dict[query]
return alfred.xml([
alfred.Item(attributes={
'uid': u'pipe:{}'.format(pipe),
'arg': pipe
},
title=pipe,
subtitle=u'(expanded alias)',
icon=u'icon.png')
])
def pbauthpocket(q):
ret = pocket.getRequestCode()
config = config_data()
config['pocket_request_code'] = ret['code']
with open(os.path.join(alfred.work(False), 'config.json'), 'w+') as myFile:
myFile.write(json.dumps(config))
result = [alfred.Item(title='Login!', subtitle='Login with Pocket.com (you will be taken to pocket.com)', attributes={'arg':ret['code'],'uid':alfred.uid(0)}, icon="icon.png")]
alfred.write(alfred.xml(result))
def define_alias(_dict, definition):
if u'=' in definition:
(alias, pipe) = definition.split(u'=', 1)
else:
(alias, pipe) = (definition, u'')
if not alias:
return alfred.xml([
alfred.Item(attributes={
'uid': u'pipe:help',
'valid': u'no'
},
title=u"alias NAME=VALUE",
subtitle=u'Terminate VALUE with @@ to save',
icon=u'icon.png')
])
if pipe and pipe.endswith('@@'):
pipe = pipe[:-2]
_dict[alias] = pipe
write_aliases(_dict)
return alfred.xml([
alfred.Item(attributes={
'uid': u'pipe:{}'.format(pipe),
'valid': u'no',
'autocomplete': alias
},
title=u"alias {}={}".format(alias, pipe),
subtitle=u'Alias saved! TAB to continue',
icon=u'icon.png')
])
return alfred.xml([
alfred.Item(attributes={
'uid': u'pipe:{}'.format(pipe),
'valid': u'no'
},
title=u"alias {}={}".format(alias, pipe or 'VALUE'),
subtitle=u'Terminate with @@ to save',
icon=u'icon.png')
])
def main():
try:
q = unicode(sys.argv[1])
q = unicodedata.normalize('NFC', q).lower().replace(' ', '')
except:
q = ""
rss = rss_data()
config = config_data()
try:
max_results = config['max_results']
except:
max_results = None
results = []
for e in itertools.islice(rss, max_results):
if not q or q in e['title'].lower().replace(' ', ''):
results.append(
alfred.Item(title=e['title'],
subtitle=e['published'],
attributes={'arg': e['link']},
icon=e['image']))
try:
last_updated = config['last_updated']
except:
last_updated = 0
subtitle = "Last updated: " + (
last_updated and util.pretty_date(config['last_updated']) or "no info")
diff = int(time.time()) - last_updated
if diff > RELOAD_ASK_THRESHOLD or len(rss) == 0:
results.insert(
0,
alfred.Item(title="BackToTheMac - Reload Data?",
subtitle=subtitle,
attributes={
'arg': 'reload',
'uid': alfred.uid('t')
},
icon="icon.png"))
else:
results.insert(
0,
alfred.Item(title="BackToTheMac",
subtitle=subtitle,
attributes={
'arg': 'http://macnews.tistory.com',
'uid': alfred.uid('t')
},
icon="icon.png"))
alfred.write(alfred.xml(results, maxresults=None))
def list_apps(arg):
apps = subprocess.check_output("ios-deploy -B | sort",
stderr=subprocess.STDOUT,
shell=True)
apps = apps.rstrip().split('\n')
items = []
for app in apps:
if arg is '' or app.startswith(arg):
items.append(alfred.Item({'arg': app}, app, ''))
alfred.write(alfred.xml(items))
def help():
result = []
result.append(alfred.Item(title='Look up Documentation', subtitle='Goto project site', attributes={'arg':'https://github.com/jmjeong/alfred-extension/blob/master/alfred-pinboard/README.md','uid':alfred.uid(0)}, icon="icon.png"))
result.append(alfred.Item(title='pbauth username:token', subtitle='set pinboard authentication token', attributes={'valid':'no','uid':alfred.uid(1)}, icon="icon.png"))
result.append(alfred.Item(title='pbreload', subtitle='load latest bookmarks from pinboard.in', attributes={'valid':'no','uid':alfred.uid(2)}, icon="icon.png"))
result.append(alfred.Item(title='pba query', subtitle='search all fields of bookmarks', attributes={'valid':'no','uid':alfred.uid(3)}, icon="icon.png"))
result.append(alfred.Item(title='pbtag', subtitle='display tags list', attributes={'valid':'no','uid':alfred.uid(7)}, icon="icon.png"))
result.append(alfred.Item(title='pbnote query', subtitle='display note list', attributes={'valid':'no','uid':alfred.uid(10)}, icon="icon.png"))
result.append(alfred.Item(title='pbl query', subtitle='search link of bookmarks', attributes={'valid':'no','uid':alfred.uid(5)}, icon="icon.png"))
result.append(alfred.Item(title='pbu query', subtitle='search title of toread bookmarks', attributes={'valid':'no','uid':alfred.uid(8)}, icon="icon.png"))
result.append(alfred.Item(title='pbauthpocket', subtitle='Login with Pocket!', attributes={'valid':'no','uid':alfred.uid(1)}, icon="icon.png"))
result.append(alfred.Item(title='To selected bookmark', subtitle='enter:goto site, cmd:copy url, alt:delete bookmark, tab:expand', attributes={'valid':'no','uid':alfred.uid(9)}, icon="icon.png"))
alfred.write(alfred.xml(result,maxresults=None))
def query_phonetic(word):
output = []
result = query_api(word)
if handle_error(result, output):
basic = result["basic"]
if "us-phonetic" in basic:
output.append(item(basic["us-phonetic"], word + " 美式音标"))
if "uk-phonetic" in basic:
output.append(item(basic["uk-phonetic"], word + " 英式音标"))
output_word_explains(word, result, output)
xml = alfred.xml(output)
return xml
def showFileList(query):
result = []
filetypes = []
count = 1
filetype = ''
pos = query.find('.')
if pos != -1:
filetype = query[pos + 1:]
query = query[:query.index('.')]
filetypes = [tp for tp in alltypes if tp.startswith(filetype)]
if filetype not in filetypes and filetype != '':
filetypes.insert(0, filetype)
elif query != '':
result.append(
alfred.Item({
'uid': count,
'arg': query
}, 'Make new file..', 'file name "' + query + '"', 'default.png'))
count += 1
if 'Makefile'.startswith(query):
result.append(
alfred.Item({
'uid': count,
'arg': 'Makefile'
}, 'Make new file..', 'file name "Makefile"', 'make.png'))
count += 1
if 'makefile'.startswith(query):
result.append(
alfred.Item({
'uid': count,
'arg': 'makefile'
}, 'Make new file..', 'file name "makefile"', 'make.png'))
count += 1
filetypes = alltypes
for ch in filetypes:
filename = query + '.' + ch
result.append(
alfred.Item({
'uid': count,
'arg': filename
}, 'Make new file..', 'file name "' + filename + '"',
(ch, {
'type': 'filetype'
})))
count += 1
xml = alfred.xml(result)
alfred.write(xml)
def main(query):
suggested_items = []
uid = uid_generator()
suggested_items.append(alfred.Item(
attributes = { 'uid': uid.next(), 'arg': query },
title = 'Execute following commands', subtitle = '',
icon = 'icon.png'))
for command, script in keymacro.generate_applescripts(query):
script = script.replace('''tell application "System Events" to ''', '')
suggested_items.append(alfred.Item(
attributes = { 'uid': uid.next(), 'arg': command },
title = script, subtitle = '',
icon = 'icon.png'))
alfred.write(alfred.xml(suggested_items))
