def __init__(self):
"""Workflow data represenative
"""
self.wf_directory = Tools.getEnv('alfred_preferences') + "/workflows"
exclude_disabled = Tools.getEnv('exclude_disabled').lower()
self.exclude_disabled = True if exclude_disabled == "true" else False
self.workflows = self._get_workflows_list()
def getDefaultTemplate():
"""
Read default template setting from environment variable
:return: default template file name
"""
template = Tools.getEnv('default_template')
return 'template.md' if template == str() else template
def getTemplate():
# Get template path from previous wf step
template = Tools.getEnv('template_path')
notes_path = md.getNotesPath()
default_template = getDefaultTemplate()
return Tools.strJoin(notes_path,
default_template) if template == str() else template
def getDefaultDate():
"""
Read default date format from environment variable
:return: default date format file name or default format
"""
d = Tools.getEnv('default_date_format')
return "%d.%m.%Y %H.%M" if d == str() else d
def get_cache_directory():
"""Get Alfreds Cache Directory, if not existent the directory will be created
Returns:
str: Cache Directory
"""
target_dir = Tools.getEnv('alfred_workflow_cache')
if not (os.path.isdir(target_dir)):
os.mkdir(target_dir)
return target_dir
def getUrlScheme(f):
"""
Gets the URL Scheme setup in Alfred Preferences
Args:
f(str): md file to add at the end of url scheme
Returns:
str: URL scheme
"""
url_scheme = Tools.getEnv('url_scheme')
return Tools.strJoin(url_scheme, urllib.pathname2url(f))
def create_hint_file(wf_dir,content):
target_dir = Tools.getEnv('alfred_workflow_cache')
if not(os.path.isdir(target_dir)):
os.mkdir(target_dir)
spath = os.path.normpath(wf_dir).split(os.sep)
wf_dir_name = ''.join([i for i in spath if str(i).startswith('user.workflow')])
if wf_dir_name != str():
target_file = target_dir + '/' + wf_dir_name + '.md'
if os.path.isfile(target_file):
os.remove(target_file)
with open(target_file, "w+") as f:
f.write(content)
return target_file
def readTemplate(file_path, **kwargs):
template_tag = Tools.getEnv('template_tag')
if '#' not in template_tag or template_tag == str():
template_tag = '#Template'
if os.path.exists(file_path):
with open(file_path, "r") as f:
content = f.read()
else:
content = fallback_content()
content = content.replace(template_tag, '')
for k, v in kwargs.iteritems():
content = content.replace('{' + k + '}', v)
return content
#!/usr/bin/env python
# encoding: utf-8
from Alfred import Items, Tools
from Notes import Search
from urllib import pathname2url
import os
items = Items()
query = Tools.getEnv("path_query2")
search = Search()
note_path = Tools.getEnv("path_query1")
note_title = search.getNoteTitle(note_path)
filename = pathname2url(os.path.basename(note_path))
back_query = "<EMPTY>" if not query else query
actions = [
{
"arg": "back|{0}".format(query),
"icon": "icons/back.png",
"subtitle": "Back to Search with query: {0}".format(back_query),
"title": "Back",
},
{
"arg": u"markdown_link|[{0}]({1})".format(note_title, filename),
"icon": "icons/link.png",
"subtitle": u"Copy a Markdown Link for \"{0}\" to the Clipboard".format(note_title),
"title": "Markdown Link",
},
{
"arg": u"wiki_link|[[{0}]]".format(note_title),
#!/usr/bin/python
import os
import sys
from Alfred import Tools
f_path = Tools.getEnv('path')
if os.path.isdir(f_path):
sys.stdout.write("DIR")
if f_path.endswith(".code-workspace") and os.path.isfile(f_path):
sys.stdout.write("FILE")
else:
pass
def getTemplateTag(self):
tt = Tools.getEnv('template_tag')
if '#' not in tt or tt == str():
tt = '#template'
return tt
file_list.extend(f_lst)
return file_list
def get_dirs(r_path):
dir_list = list()
for p in os.listdir(r_path):
if os.path.isdir(r_path):
d = "{0}/{1}".format(r_path, p)
dir_list.append(d)
return dir_list
sys.stderr.write(platform.python_version())
f_path = Tools.getEnv('path')
ws_home = f_path if f_path else os.path.expanduser(
Tools.getEnv('workspaces_home'))
p_path = str(
PurePath(f_path).parent
) if f_path and f_path != Tools.getEnv('workspaces_home') else str()
query = Tools.getArgv(1)
if query == str():
it = sorted(get_dirs(ws_home))
else:
it = sorted(get_files(ws_home))
wf = Items()
if p_path:
wf.setItem(title='Back', arg=p_path)
def getUrlScheme(f):
url_scheme = Tools.getEnv('url_scheme')
return Tools.strJoin(url_scheme, urllib.pathname2url(f))
tt = Tools.getEnv('template_tag')
if '#' not in tt or tt == str():
tt = '#Template'
return tt
SUFFIX = " (DEFAULT)"
# create MD search object
my_notes = MyNotes.Search()
# Load env variables
ext = my_notes.getNotesExtension()
p = my_notes.getNotesPath()
query = Tools.getArgv(1)
default_template = Tools.getEnv('default_template')
template_tag = get_template_tag()
# Get Files sorted in Notes directory
all_files = my_notes.getFilesListSorted()
template_files = sorted(all_files, key=lambda x: x['filename'] != default_template)
wf = Items()
for md_file in template_files:
if my_notes.isNoteTagged(md_file['path'], template_tag) and query in md_file['filename']:
suffix = str()
if md_file['filename'] == default_template:
suffix = SUFFIX
wf.setItem(
title=md_file['filename'] + suffix,
subtitle="Create new file based on \"{0}\"".format(md_file['filename']),
#!/usr/bin/python
# -*- coding: utf-8 -*-
import os
import sys
from Alfred import Tools
from MyNotes import NewNote
from QuerySplitter import QuerySplitter
reload(sys)
sys.setdefaultencoding('utf-8')
query = Tools.getArgv(1).encode('utf-8')
# Read template path from previous wf step in case template ws choosen
template = Tools.getEnv('template_path')
if query.isspace():
query = "My Note {today}".format(today=NewNote.getTodayDate(
fmt='%d-%m-%Y %H-%M-%S'))
qs = QuerySplitter(query)
if query:
Note = NewNote(qs.title, template_path=template, tags=qs.tags)
fPath = Note.create_note()
sys.stdout.write(fPath)
subtitle=u"Value: {0} (\u21E7 for Help)".format(v_subtitle),
title=variable,
)
icon = 'icons/check.png' if value != str(
) else 'icons/question.png'
items.setIcon(icon, 'image')
items.addItem()
def write_config(key, val):
value = Tools.normalize(val)
Plist().setVariable(key, value)
query = Tools.getArgv(1)
action_key_value = Tools.getEnv('action_key_value')
[action, key,
value] = action_key_value.split('|') if action_key_value != str() else [
str(), str(), str()
]
workflow_dir = os.getcwd()
query = Tools.getArgv(1)
items = Items()
if action == str():
print_config(query)
elif action == 'selection':
get_selection(key, query)
else:
write_config(key, value)
#!/usr/bin/python
import json
import os
from Alfred import Items, Tools
# 1Password Cache Dir
CACHE_BASE_DIR = "Library/Containers/com.agilebits.onepassword7/Data/Library/Caches/Metadata/1Password"
user_dir = os.path.expanduser('~')
pass_lib = os.path.join(user_dir, CACHE_BASE_DIR)
query = Tools.getArgv(1)
vaults = Tools.getEnv('vaultNames').split(',')
def get_passwords(pass_lib):
"""
Get all Password items stored in 1Password
Args:
pass_lib (str): Path to 1Password libraries including user roort
Returns:
list(dict): list of dictonaries contain all Passwords
"""
passwords = list()
for r, d, f in os.walk(pass_lib):
for file in f:
file_path = os.path.join(r, file)
with open(file_path, 'r') as content:
def get_workflow_plist_paths():
alfred_dir = Tools.getEnv('alfred_preferences') + "/workflows"
workflow_dir_names = os.listdir(alfred_dir)
return [alfred_dir + '/' + f + '/info.plist' for f in workflow_dir_names if os.path.isfile(alfred_dir + '/' + f + '/info.plist')]
spath = os.path.normpath(wf_dir).split(os.sep)
wf_dir_name = ''.join([i for i in spath if str(i).startswith('user.workflow')])
if wf_dir_name != str():
target_file = target_dir + '/' + wf_dir_name + '.md'
if os.path.isfile(target_file):
os.remove(target_file)
with open(target_file, "w+") as f:
f.write(content)
return target_file
INPUT_TYPES = [
'alfred.workflow.input.scriptfilter',
'alfred.workflow.input.keyword'
]
alf = Items()
exclude_disabled = Tools.getEnv('exclude_disabled').lower()
exclude_disabled = True if exclude_disabled == "true" else False
workflow_plist_lists = get_workflow_plist_paths()
for wf in workflow_plist_lists:
plist_config = get_plist_info(wf)
if exclude_disabled and plist_config['disabled']:
continue
wf_object = plist_config['objects']
kf = KeywordFormatter()
for o in wf_object:
item_type = o.get('type')
if item_type in INPUT_TYPES:
item_config = o.get('config')
keyword = item_config.get('keyword')
title = item_config.get('title')
text = item_config.get('text')
def get_template_tag():
tt = Tools.getEnv('template_tag')
if '#' not in tt or tt == str():
tt = '#Template'
return tt
def search(query, dict_list):
"""
Search string in a list of Dict
:param query: str()
:param dict_list: list(dict())
:return: list(dict())
"""
seq = list()
for d in dict_list:
if d['filename'].lower().startswith(query.lower()):
seq.append(d)
return seq
# Load Env, Argv and set working path
t_dir = Tools.getEnv('directory')
search_subfolders = True if Tools.getEnv(
'search_subfolders') == "True" else False
working_path = t_dir
query = Tools.getArgv(1)
date_format = Tools.getEnv('date_format')
# Read file list deep and normal
files_in_directory = None
file_list = list()
if working_path:
rf = RecentFiles(working_path)
files_in_directory = rf.getRecentFilesDeep(
reverse=True) if search_subfolders else rf.getRecentFiles(reverse=True)
file_list = RecentFiles.search(query, files_in_directory) if bool(
query) and files_in_directory else files_in_directory
#!/usr/bin/python
from Alfred import Items, Tools
from Workflows import Workflows
wf = Workflows()
alf = Items()
wpath = Tools.getEnv('plist_path') + "/info.plist"
keyword_list = wf.get_item(wpath).get('keywords')
if keyword_list:
for k in keyword_list:
withspace = k.get('withspace')
keyw = k.get('keyword')
keyword = '{0} '.format(keyw) if withspace and keyw else keyw
title = k.get('title')
text = k.get('text')
if keyword:
alf.setItem(title=title,
subtitle=u'Press \u23CE to proceed with Keyword: %s' %
keyword,
arg=keyword)
alf.setIcon('icons/start.png', m_type='image')
alf.addItem()
else:
alf.setItem(title="This workflow has not keywords defined", valid=False)
alf.write()
#!/usr/bin/env python
# encoding: utf-8
from Alfred import Tools
import re
import sys
def replace(file, pattern, subst):
file_handle = open(file, 'r')
file_string = file_handle.read()
file_handle.close()
file_string = (re.sub(pattern, subst, file_string))
file_handle = open(file, 'w')
file_handle.write(file_string)
file_handle.close()
path = Tools.getArgv(1)
todo = Tools.getEnv('todo')
status = Tools.getEnv('todo_status')
query = Tools.getEnv('todo_query')
old_val = ' ' if status == 'pending' else 'x'
new_val = ' ' if old_val == 'x' else 'x'
replace(path, "([-|\*] \[){0}(\] {1})".format(old_val, todo), "\\1{0}\\2".format(new_val))
sys.stdout.write(query)
#!/usr/bin/python
from Alfred import Items, Tools
target_dir = Tools.getEnv('directory')
wf = Items()
# Back Item
wf.setItem(title="BACK",
subtitle="Back to List",
arg='{0}|{1}'.format(target_dir, "BACK"))
wf.setIcon(m_path="back.png", m_type="image")
wf.addItem()
# Purge Dir Item
wf.setItem(title="Purge Directory",
subtitle='Purge "{}"'.format(target_dir),
arg='{0}|{1}'.format(target_dir, "PURGE"))
wf.setIcon(m_path="purge.png", m_type="image")
wf.addItem()
# Delete Item
wf.setItem(title="Remove Folder",
subtitle='Remove "{}" from configuration'.format(target_dir),
arg='{0}|{1}'.format(target_dir, "DELETE"))
wf.setIcon(m_path="delete.png", m_type="image")
wf.addItem()
wf.write()
#!/usr/bin/env python
# encoding: utf-8
from Alfred import Tools
from Notes import Note, Search
from QuerySplitter import QuerySplitter
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
query = Tools.getArgv(1).encode('utf-8')
clipboard = Tools.getEnv('clipboard')
template = Tools.getEnv('template')
paste = Tools.getEnv('paste')
qs = QuerySplitter(query)
if query:
note = Note(
content=str() if not paste else clipboard,
tags=qs.tags,
template_path=template,
title=qs.title,
zettel_id=qs.zettel_id,
)
file_path = note.createNote()
output = Search().getNoteFilename(file_path)
sys.stdout.write(output)
@staticmethod
def console_log(msg):
# Create a custom logger
logger = logging.getLogger(__name__)
# Create handlers
c_handler = logging.StreamHandler()
c_handler.setLevel(logging.WARN)
# Create formatters and add it to handlers
c_format = logging.Formatter('%(message)s')
c_handler.setFormatter(c_format)
# Add handlers to the logger
logger.addHandler(c_handler)
logger.warn(msg)
auth_token = Tools.getEnv('evernote_auth_token')
f_path = Tools.getArgv(1)
# f_path = '/Users/jjung/Documents/Notes/test evernote import.md'
if auth_token == str():
Tools.notify('Evernote authentication error',
'Set Evernote AuthToken in worfklow configuration!')
sys.exit("Error")
elif f_path != str():
p = EvernoteUpload(auth_token)
note_app_link = p.upload_to_notebook(f_path, 'Inbox')
if note_app_link is not str():
Tools.notify('Upload in progress',
'The Note will be opened once uploaded!')
sys.stdout.write(note_app_link)
else:
Tools.notify("Something went wrong")
#!/usr/bin/python
# -*- coding: utf-8 -*-
import os
from urllib import pathname2url
from Alfred import Items, Tools
from MyNotes import Search
# Get NotePath as path_query env variable
note_path = Tools.getEnv("path_query1")
# Get query used in search markdown notes as path_query env variable
query = Tools.getEnv("path_query2")
md_notes = Search()
# Get NoteTitle for specific note
note_title = md_notes.getNoteTitle(note_path)
file_name = pathname2url(os.path.basename(note_path))
# If query in notes search was empty subtitle uses following string
back_query = "<EMPTY>" if not query else query
# Actions in ScriptFilter menu data
ACTIONS = [
{
"title": "Back",
"subtitle": "Back to Search with query: {0}".format(back_query),
"arg": "{0}|{1}".format("back", query),
"icon": "icons/back.png",
"visible": True
},
{
"title": "Markdown Link",
#!/usr/bin/python
# -*- coding: utf-8 -*-
from Alfred import Items, Tools
from MyNotes import Search
query = Tools.getArgv(1)
bmt = Tools.getEnv('bookmark_tag')
bookmark_tag = bmt if bmt.startswith('#') else '#' + bmt
search_terms = '{0}&{1}'.format(bookmark_tag, query) if query else bookmark_tag
notes = Search()
search_terms, _ = notes.get_search_config(search_terms)
matches = notes.url_search(search_terms)
alf = Items()
if matches:
for m in matches:
note_title = m.get('title')
note_path = m.get('path')
links = m.get('links')
for l in links:
url_title = l.get('url_title')
url = l.get('url')
# subtitle = '%s > %s' % (url_title, url) if url_title != url else url
subtitle = 'NOTE: {0} URL: {1}...'.format(note_title, url[:30])
alf.setItem(
title=url_title,
subtitle=subtitle,
arg=url,
#!/usr/bin/python
from Alfred import Items, Tools
from MyNotes import Search
query = Tools.getArgv(1)
bookmark_tag = '#' + Tools.getEnv('bookmark_tag')
search_terms = [bookmark_tag, query] if query else [bookmark_tag]
notes = Search()
matches = notes.url_search(search_terms)
alf = Items()
if matches:
for m in matches:
note_title = m['title']
note_path = m['path']
links = m['links']
for l in links:
url_title = l['url_title']
url = l['url']
# subtitle = '%s > %s' % (url_title, url) if url_title != url else url
subtitle = 'NOTE: {0} URL: {1}...'.format(note_title, url[:30])
alf.setItem(title=url_title,
subtitle=subtitle,
arg=url,
quicklookurl=url)
alf.addMod('cmd',
note_path,
'Open MD Note',
