from pathlib import Path
from fuzzywuzzy import process
import albertv0 as v0
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "Alternativeto: Search suggestions for Alternativeto"
__version__ = "0.1.0"
__trigger__ = "alt "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = "https://github.com/bergercookie/awesome-albert-plugins"
icon_path = str(Path(__file__).parent / "search_alternativeto")
cache_path = Path(v0.cacheLocation()) / "search_alternativeto"
config_path = Path(v0.configLocation()) / "search_alternativeto"
data_path = Path(v0.dataLocation()) / "search_alternativeto"
# set it to the corresponding site for the search at hand
# see: https://github.com/jarun/googler/blob/master/auto-completion/googler_at/googler_at
googler_at = "alternativeto.net"
# plugin main functions -----------------------------------------------------------------------
def initialize():
# Called when the extension is loaded (ticked in the settings) - blocking
# create plugin locations
for p in (cache_path, config_path, data_path):
# initial checks ------------------------------------------------------------------------------
if not which("task"):
raise RuntimeError(
"xkcd-dl not in $PATH - Please install it via pip3 first.")
# icon ----------------------------------------------------------------------------------------
icon_path = os.path.join(os.path.dirname(__file__), "taskwarrior")
icon_path_b = os.path.join(os.path.dirname(__file__), "taskwarrior_blue")
icon_path_r = os.path.join(os.path.dirname(__file__), "taskwarrior_red")
icon_path_y = os.path.join(os.path.dirname(__file__), "taskwarrior_yellow")
icon_path_c = os.path.join(os.path.dirname(__file__), "taskwarrior_cyan")
icon_path_g = os.path.join(os.path.dirname(__file__), "taskwarrior_green")
# initial configuration -----------------------------------------------------------------------
settings_path = Path(v0.cacheLocation()) / "taskwarrior"
tw_side = TaskWarriorSide()
tw_side.start()
reminder_tag = "remindme"
def initialize():
# Called when the extension is loaded (ticked in the settings) - blocking
# create cache location
settings_path.mkdir(parents=False, exist_ok=True)
def finalize():
from pathlib import Path
from fuzzywuzzy import process
import albertv0 as v0
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "Quora: Search suggestions for Quora"
__version__ = "0.1.0"
__trigger__ = "q "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = "https://github.com/bergercookie/awesome-albert-plugins"
icon_path = str(Path(__file__).parent / "search_quora")
cache_path = Path(v0.cacheLocation()) / "search_quora"
config_path = Path(v0.configLocation()) / "search_quora"
data_path = Path(v0.dataLocation()) / "search_quora"
# set it to the corresponding site for the search at hand
# see: https://github.com/jarun/googler/blob/master/auto-completion/googler_at/googler_at
googler_at = "quora.com"
# plugin main functions -----------------------------------------------------------------------
def initialize():
# Called when the extension is loaded (ticked in the settings) - blocking
# create plugin locations
for p in (cache_path, config_path, data_path):
from fuzzywuzzy import process
import albertv0 as v0
__iid__ = "PythonInterface/{{ cookiecutter.albert_plugin_interface }}"
__prettyname__ = "{{ cookiecutter.plugin_short_description }}"
__version__ = "{{ cookiecutter.version }}"
__trigger__ = "{{ cookiecutter.plugin_name }} "
__author__ = "{{ cookiecutter.author }}"
__dependencies__ = []
__homepage__ = "{{ cookiecutter.repo_base_url }}/{{ cookiecutter.plugin_name }}"
icon_path = str(Path(__file__).parent / "{{ cookiecutter.plugin_name }}")
cache_path = Path(v0.cacheLocation()) / "{{ cookiecutter.plugin_name }}"
config_path = Path(v0.configLocation()) / "{{ cookiecutter.plugin_name }}"
data_path = Path(v0.dataLocation()) / "{{ cookiecutter.plugin_name }}"
# plugin main functions -----------------------------------------------------------------------
def initialize():
# Called when the extension is loaded (ticked in the settings) - blocking
# create plugin locations
for p in (cache_path, config_path, data_path):
p.mkdir(parents=False, exist_ok=True)
def finalize():
from pathlib import Path
from fuzzywuzzy import process
import albertv0 as v0
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "Opensubtitles: Search suggestions for Opensubtitles"
__version__ = "0.1.0"
__trigger__ = "op "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = "https://github.com/bergercookie/awesome-albert-plugins"
icon_path = str(Path(__file__).parent / "search_opensubtitles")
cache_path = Path(v0.cacheLocation()) / "search_opensubtitles"
config_path = Path(v0.configLocation()) / "search_opensubtitles"
data_path = Path(v0.dataLocation()) / "search_opensubtitles"
# set it to the corresponding site for the search at hand
# see: https://github.com/jarun/googler/blob/master/auto-completion/googler_at/googler_at
googler_at = "opensubtitles.org"
# plugin main functions -----------------------------------------------------------------------
def initialize():
# Called when the extension is loaded (ticked in the settings) - blocking
# create plugin locations
for p in (cache_path, config_path, data_path):
from pathlib import Path
from fuzzywuzzy import process
import albertv0 as v0
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "Kernel: Search suggestions for Kernel"
__version__ = "0.1.0"
__trigger__ = "kernel "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = "https://github.com/bergercookie/awesome-albert-plugins"
icon_path = str(Path(__file__).parent / "search_kernel")
cache_path = Path(v0.cacheLocation()) / "search_kernel"
config_path = Path(v0.configLocation()) / "search_kernel"
data_path = Path(v0.dataLocation()) / "search_kernel"
# set it to the corresponding site for the search at hand
# see: https://github.com/jarun/googler/blob/master/auto-completion/googler_at/googler_at
googler_at = "kernel.org"
# plugin main functions -----------------------------------------------------------------------
def initialize():
# Called when the extension is loaded (ticked in the settings) - blocking
# create plugin locations
for p in (cache_path, config_path, data_path):
from pathlib import Path
from fuzzywuzzy import process
import albertv0 as v0
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "Howstuffworks: Search suggestions for Howstuffworks"
__version__ = "0.1.0"
__trigger__ = "hsw "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = "https://github.com/bergercookie/awesome-albert-plugins"
icon_path = str(Path(__file__).parent / "search_howstuffworks")
cache_path = Path(v0.cacheLocation()) / "search_howstuffworks"
config_path = Path(v0.configLocation()) / "search_howstuffworks"
data_path = Path(v0.dataLocation()) / "search_howstuffworks"
# set it to the corresponding site for the search at hand
# see: https://github.com/jarun/googler/blob/master/auto-completion/googler_at/googler_at
googler_at = "howstuffworks.com"
# plugin main functions -----------------------------------------------------------------------
def initialize():
# Called when the extension is loaded (ticked in the settings) - blocking
# create plugin locations
for p in (cache_path, config_path, data_path):
from pathlib import Path
from fuzzywuzzy import process
import albertv0 as v0
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "Crunchbase: Search suggestions for Crunchbase"
__version__ = "0.1.0"
__trigger__ = "cb "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = "https://github.com/bergercookie/awesome-albert-plugins"
icon_path = str(Path(__file__).parent / "search_crunchbase")
cache_path = Path(v0.cacheLocation()) / "search_crunchbase"
config_path = Path(v0.configLocation()) / "search_crunchbase"
data_path = Path(v0.dataLocation()) / "search_crunchbase"
# set it to the corresponding site for the search at hand
# see: https://github.com/jarun/googler/blob/master/auto-completion/googler_at/googler_at
googler_at = "crunchbase.com"
# plugin main functions -----------------------------------------------------------------------
def initialize():
# Called when the extension is loaded (ticked in the settings) - blocking
# create plugin locations
for p in (cache_path, config_path, data_path):
import albertv0 as v0
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "Kill Process v2"
__version__ = "0.1.0"
__trigger__ = "kill "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = (
"https://github.com/bergercookie/awesome-albert-plugins/blob/master/plugins/killproc"
)
icon_path = str(Path(__file__).parent / "logo.png")
cache_path = Path(v0.cacheLocation()) / "killproc"
config_path = Path(v0.configLocation()) / "killproc"
data_path = Path(v0.dataLocation()) / "killproc"
dev_mode = True
# plugin main functions -----------------------------------------------------------------------
def initialize():
"""Called when the extension is loaded (ticked in the settings) - blocking."""
# create plugin locations
for p in (cache_path, config_path, data_path):
p.mkdir(parents=False, exist_ok=True)
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "GMaps - Launch route planner"
__version__ = "0.1.0"
__trigger__ = "gmaps "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = (
"https://github.com/bergercookie/awesome-albert-plugins/blob/master/plugins//gmaps"
)
icon_path = v0.iconLookup("gmaps")
if not icon_path:
icon_path = os.path.join(os.path.dirname(__file__), "gmaps")
cache_path = Path(v0.cacheLocation()) / "gmaps"
config_path = Path(v0.configLocation()) / "gmaps"
data_path = Path(v0.dataLocation()) / "gmaps"
gmaps_exe = Path(__file__).parent / "gmaps-cli" / "gmaps-cli.py"
available_means = ["walk", "drive", "bicycle", "fly", "transit"]
default_means = "transit"
# plugin main functions -----------------------------------------------------------------------
def initialize():
# Called when the extension is loaded (ticked in the settings) - blocking
# create plugin locations
for p in (cache_path, config_path, data_path):
import zoopla as z
import albertv0 as v0
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "Zoopla - Search Properties"
__version__ = "0.1.0"
__trigger__ = "z "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = "https://github.com/bergercookie/zoopla-albert-plugin"
iconPath = v0.iconLookup("zoopla")
if not iconPath:
iconPath = os.path.join(os.path.dirname(__file__), "zoopla")
settings_path = Path(v0.cacheLocation()) / "zoopla"
api_key = "khagqa497wsgfa5ya35rwfnt"
zoopla = z.Zoopla(api_key=api_key)
str_to_key = {
"sale": "listing_status",
"rent": "listing_status",
}
str_to_actual_name = {
"sale": "sale",
"rent": "rent",
}
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "Words: meaning, synonyms, antonyms, examples"
__version__ = "0.1.0"
__trigger__ = "word "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = (
"https://github.com/bergercookie/awesome-albert-plugins/blob/master/plugins/words"
)
icon_path = str(Path(__file__).parent / "words")
icon_path_g = str(Path(__file__).parent / "words_g")
icon_path_r = str(Path(__file__).parent / "words_r")
cache_path = Path(v0.cacheLocation()) / "words"
config_path = Path(v0.configLocation()) / "words"
data_path = Path(v0.dataLocation()) / "words"
dev_mode = True
pd = PyDictionary()
# plugin main functions -----------------------------------------------------------------------
class KeystrokeMonitor:
def __init__(self):
super(KeystrokeMonitor, self)
self.thres = 0.3 # s
self.prev_time = time.time()
self.curr_time = time.time()
from fuzzywuzzy import process
import albertv0 as v0
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "IPs of the host machine"
__version__ = "0.1.0"
__trigger__ = "ip "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = "https://github.com/bergercookie/awesome-albert-plugins/blob/master/plugins//ipshow"
icon_path = str(Path(__file__).parent / "ipshow")
cache_path = Path(v0.cacheLocation()) / "ipshow"
config_path = Path(v0.configLocation()) / "ipshow"
data_path = Path(v0.dataLocation()) / "ipshow"
show_ipv4_only = True
families = netifaces.address_families
dev_mode = False
# plugin main functions -----------------------------------------------------------------------
def initialize():
# Called when the extension is loaded (ticked in the settings) - blocking
# create plugin locations
for p in (cache_path, config_path, data_path):
from pathlib import Path
from fuzzywuzzy import process
import albertv0 as v0
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "Facebook: Search suggestions for Facebook"
__version__ = "0.1.0"
__trigger__ = "fb "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = "https://github.com/bergercookie/awesome-albert-plugins"
icon_path = str(Path(__file__).parent / "search_facebook")
cache_path = Path(v0.cacheLocation()) / "search_facebook"
config_path = Path(v0.configLocation()) / "search_facebook"
data_path = Path(v0.dataLocation()) / "search_facebook"
# set it to the corresponding site for the search at hand
# see: https://github.com/jarun/googler/blob/master/auto-completion/googler_at/googler_at
googler_at = "facebook.com"
# plugin main functions -----------------------------------------------------------------------
def initialize():
# Called when the extension is loaded (ticked in the settings) - blocking
# create plugin locations
for p in (cache_path, config_path, data_path):
__dependencies__ = []
__homepage__ = "https://github.com/bergercookie/xkcd-albert-plugin"
# TODO pyproject toml file
# TODO xkcd-dl executable?
# TODO Upload to github - change support url on error
# TODO Send to albert plugins
if not which("xkcd-dl"):
raise RuntimeError("xkcd-dl not in $PATH - Please install it via pip3 first.")
iconPath = v0.iconLookup("xkcd")
if not iconPath:
iconPath = os.path.join(os.path.dirname(__file__), "image.png")
SETTINGS_PATH = Path(v0.cacheLocation()) / "xkcd"
LAST_UPDATE_PATH = SETTINGS_PATH / "last_update"
XKCD_DICT = Path.home() / ".xkcd_dict.json"
def initialize():
# Called when the extension is loaded (ticked in the settings) - blocking
# create cache location
SETTINGS_PATH.mkdir(parents=False, exist_ok=True)
if not LAST_UPDATE_PATH.is_file():
update_date_file()
update_xkcd_db()
def finalize():
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "Countdown/Stopwatch functionalities"
__version__ = "0.1.0"
__trigger__ = "clock "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = (
"https://github.com/bergercookie/awesome-albert-plugins/blob/master/plugins/clock"
)
countdown_path = str(Path(__file__).parent / "countdown.png")
stopwatch_path = str(Path(__file__).parent / "stopwatch.png")
sound_path = Path(__file__).parent.absolute() / "bing.wav"
cache_path = Path(v0.cacheLocation()) / "clock"
config_path = Path(v0.configLocation()) / "clock"
data_path = Path(v0.dataLocation()) / "clock"
dev_mode = True
# plugin main functions -----------------------------------------------------------------------
def play_sound(num):
for x in range(num):
t = threading.Timer(
0.5 * x,
lambda: subprocess.Popen([
"cvlc",
sound_path,
]),
from pathlib import Path
from fuzzywuzzy import process
import albertv0 as v0
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "Rottentomatoes: Search suggestions for Rottentomatoes"
__version__ = "0.1.0"
__trigger__ = "rt "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = "https://github.com/bergercookie/awesome-albert-plugins"
icon_path = str(Path(__file__).parent / "search_rottentomatoes")
cache_path = Path(v0.cacheLocation()) / "search_rottentomatoes"
config_path = Path(v0.configLocation()) / "search_rottentomatoes"
data_path = Path(v0.dataLocation()) / "search_rottentomatoes"
# set it to the corresponding site for the search at hand
# see: https://github.com/jarun/googler/blob/master/auto-completion/googler_at/googler_at
googler_at = "rottentomatoes.com"
# plugin main functions -----------------------------------------------------------------------
def initialize():
# Called when the extension is loaded (ticked in the settings) - blocking
# create plugin locations
for p in (cache_path, config_path, data_path):
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "Xkcd Comics Fetcher"
__version__ = "0.1"
__trigger__ = "xkcd "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = "https://github.com/bergercookie/xkcd-albert-plugin"
if not which("xkcd-dl"):
raise RuntimeError(
"xkcd-dl not in $PATH - Please install it via pip3 first.")
iconPath = v0.iconLookup("xkcd")
if not iconPath:
iconPath = os.path.join(os.path.dirname(__file__), "image.png")
settings_path = Path(v0.cacheLocation()) / "xkcd"
last_update_path = settings_path / "last_update"
xkcd_dict = Path.home() / ".xkcd_dict.json"
def initialize():
# Called when the extension is loaded (ticked in the settings) - blocking
# create cache location
settings_path.mkdir(parents=False, exist_ok=True)
if not last_update_path.is_file():
update_date_file()
update_xkcd_db()
def finalize():
def notify(
app_name: str,
msg: str,
image=None,
):
Notify.init(app_name)
n = Notify.Notification.new(app_name, msg, image)
n.show()
icon_path = get_icon("saxophone")
stop_icon_path = get_icon("stop_icon")
repeat_icon_path = get_icon("repeat_icon")
cache_path = Path(v0.cacheLocation()) / "saxophone"
pids_path = cache_path / "streams_on"
data_path = Path(v0.dataLocation()) / "saxophone"
json_config = str(Path(__file__).parent / "config" / "saxophone.json")
dev_mode = False
# Stream class --------------------------------------------------------------------------------
def enum(*sequential, **named) -> Enum:
"""
Return a Python Enum with automatic enumeration.
Usage::
from pathlib import Path
from fuzzywuzzy import process
import albertv0 as v0
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "Amazon: Search suggestions for Amazon"
__version__ = "0.1.0"
__trigger__ = "ama "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = "https://github.com/bergercookie/awesome-albert-plugins"
icon_path = str(Path(__file__).parent / "search_amazon")
cache_path = Path(v0.cacheLocation()) / "search_amazon"
config_path = Path(v0.configLocation()) / "search_amazon"
data_path = Path(v0.dataLocation()) / "search_amazon"
# set it to the corresponding site for the search at hand
# see: https://github.com/jarun/googler/blob/master/auto-completion/googler_at/googler_at
googler_at = "amazon.co.uk"
# plugin main functions -----------------------------------------------------------------------
def initialize():
# Called when the extension is loaded (ticked in the settings) - blocking
# create plugin locations
for p in (cache_path, config_path, data_path):
from pathlib import Path
from fuzzywuzzy import process
import albertv0 as v0
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "Google: Search suggestions for Google"
__version__ = "0.1.0"
__trigger__ = "gg "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = "https://github.com/bergercookie/awesome-albert-plugins"
icon_path = str(Path(__file__).parent / "search_google")
cache_path = Path(v0.cacheLocation()) / "search_google"
config_path = Path(v0.configLocation()) / "search_google"
data_path = Path(v0.dataLocation()) / "search_google"
# set it to the corresponding site for the search at hand
# see: https://github.com/jarun/googler/blob/master/auto-completion/googler_at/googler_at
googler_at = ""
# plugin main functions -----------------------------------------------------------------------
def initialize():
# Called when the extension is loaded (ticked in the settings) - blocking
# create plugin locations
for p in (cache_path, config_path, data_path):
__prettyname__ = "Jira Issue Tracking"
__version__ = "0.1.0"
__trigger__ = "jira "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = "https://github.com/bergercookie/jira-albert-plugin"
icon_path = os.path.join(os.path.dirname(__file__), "jira_blue")
icon_path_br = os.path.join(os.path.dirname(__file__), "jira_bold_red")
icon_path_r = os.path.join(os.path.dirname(__file__), "jira_red")
icon_path_y = os.path.join(os.path.dirname(__file__), "jira_yellow")
icon_path_g = os.path.join(os.path.dirname(__file__), "jira_green")
icon_path_lg = os.path.join(os.path.dirname(__file__), "jira_light_green")
# plugin locations
cache_path = Path(v0.cacheLocation()) / "jira"
config_path = Path(v0.configLocation()) / "jira"
data_path = Path(v0.dataLocation()) / "jira"
pass_path = Path().home() / ".password-store"
user_path = config_path / "user"
server_path = config_path / "server"
api_key_path = pass_path / "jira-albert-plugin" / "api-key.gpg"
max_results_to_request = 50
max_results_to_show = 5
fields_to_include = ["assignee", "issuetype", "priority", "project", "status", "summary"]
prio_to_icon = {
"Highest": icon_path_br,
"High": icon_path_r,
from pathlib import Path
from fuzzywuzzy import process
import albertv0 as v0
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "Github: Search suggestions for Github"
__version__ = "0.1.0"
__trigger__ = "gh "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = "https://github.com/bergercookie/awesome-albert-plugins"
icon_path = str(Path(__file__).parent / "search_github")
cache_path = Path(v0.cacheLocation()) / "search_github"
config_path = Path(v0.configLocation()) / "search_github"
data_path = Path(v0.dataLocation()) / "search_github"
# set it to the corresponding site for the search at hand
# see: https://github.com/jarun/googler/blob/master/auto-completion/googler_at/googler_at
googler_at = "github.com"
# plugin main functions -----------------------------------------------------------------------
def initialize():
# Called when the extension is loaded (ticked in the settings) - blocking
# create plugin locations
for p in (cache_path, config_path, data_path):
import albertv0 as v0
import shutil
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "Pass - UNIX Password Manager - fuzzy search"
__version__ = "0.1.0"
__trigger__ = "pass2 "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = (
"https://github.com/bergercookie/awesome-albert-plugins/blob/master/plugins/pass_rlded"
)
icon_path = os.path.join(os.path.dirname(__file__), "pass_rlded")
cache_path = Path(v0.cacheLocation()) / "pass_rlded"
config_path = Path(v0.configLocation()) / "pass_rlded"
data_path = Path(v0.dataLocation()) / "pass_rlded"
pass_dir = Path(
os.environ.get("PASSWORD_STORE_DIR",
os.path.join(os.path.expanduser("~/.password-store/"))))
# passwords cache -----------------------------------------------------------------------------
class PasswordsCacheManager:
def __init__(self):
self.refresh = True
def get_all_gpg_files(self, root: Path) -> Iterable[Path]:
"""Get a list of all the ggp-encrypted files under the given dir."""
from pathlib import Path
from fuzzywuzzy import process
import albertv0 as v0
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "Ted: Search suggestions for Ted"
__version__ = "0.1.0"
__trigger__ = "ted "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = "https://github.com/bergercookie/awesome-albert-plugins"
icon_path = str(Path(__file__).parent / "search_ted")
cache_path = Path(v0.cacheLocation()) / "search_ted"
config_path = Path(v0.configLocation()) / "search_ted"
data_path = Path(v0.dataLocation()) / "search_ted"
# set it to the corresponding site for the search at hand
# see: https://github.com/jarun/googler/blob/master/auto-completion/googler_at/googler_at
googler_at = "ted.com"
# plugin main functions -----------------------------------------------------------------------
def initialize():
# Called when the extension is loaded (ticked in the settings) - blocking
# create plugin locations
for p in (cache_path, config_path, data_path):
from pathlib import Path
from fuzzywuzzy import process
import albertv0 as v0
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "Cppreference: Search suggestions for Cppreference"
__version__ = "0.1.0"
__trigger__ = "cpp "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = "https://github.com/bergercookie/awesome-albert-plugins"
icon_path = str(Path(__file__).parent / "search_cppreference")
cache_path = Path(v0.cacheLocation()) / "search_cppreference"
config_path = Path(v0.configLocation()) / "search_cppreference"
data_path = Path(v0.dataLocation()) / "search_cppreference"
# set it to the corresponding site for the search at hand
# see: https://github.com/jarun/googler/blob/master/auto-completion/googler_at/googler_at
googler_at = "en.cppreference.com"
# plugin main functions -----------------------------------------------------------------------
def initialize():
# Called when the extension is loaded (ticked in the settings) - blocking
# create plugin locations
for p in (cache_path, config_path, data_path):
import albertv0 as v0
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "TL;DR pages from albert."
__version__ = "0.1.0"
__trigger__ = "tldr "
__author__ = "Nikos Koukis"
__dependencies__ = ["git"]
__homepage__ = (
"https://github.com/bergercookie/awesome-albert-plugins/blob/master/plugins//tldr_pages"
)
icon_path = str(Path(__file__).parent / "tldr_pages")
cache_path = Path(v0.cacheLocation()) / "tldr_pages"
config_path = Path(v0.configLocation()) / "tldr_pages"
data_path = Path(v0.dataLocation()) / "tldr_pages"
tldr_root = cache_path / "tldr"
pages_root = tldr_root / "pages"
page_paths: Dict[str, Path] = None
# Is the plugin run in development mode?
in_development = False
# plugin main functions -----------------------------------------------------------------------
def initialize():
from pathlib import Path
from fuzzywuzzy import process
import albertv0 as v0
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "Askubuntu: Search suggestions for Askubuntu"
__version__ = "0.1.0"
__trigger__ = "askubuntu "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = "https://github.com/bergercookie/awesome-albert-plugins"
icon_path = str(Path(__file__).parent / "search_askubuntu")
cache_path = Path(v0.cacheLocation()) / "search_askubuntu"
config_path = Path(v0.configLocation()) / "search_askubuntu"
data_path = Path(v0.dataLocation()) / "search_askubuntu"
# set it to the corresponding site for the search at hand
# see: https://github.com/jarun/googler/blob/master/auto-completion/googler_at/googler_at
googler_at = "askubuntu.com"
# plugin main functions -----------------------------------------------------------------------
def initialize():
# Called when the extension is loaded (ticked in the settings) - blocking
# create plugin locations
for p in (cache_path, config_path, data_path):
__version__ = "0.1.0"
__trigger__ = "jira "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = "https://github.com/bergercookie/jira-albert-plugin"
__simplename__ = "jira"
icon_path = os.path.join(os.path.dirname(__file__), "jira_blue")
icon_path_br = os.path.join(os.path.dirname(__file__), "jira_bold_red")
icon_path_r = os.path.join(os.path.dirname(__file__), "jira_red")
icon_path_y = os.path.join(os.path.dirname(__file__), "jira_yellow")
icon_path_g = os.path.join(os.path.dirname(__file__), "jira_green")
icon_path_lg = os.path.join(os.path.dirname(__file__), "jira_light_green")
# plugin locations
cache_path = Path(v0.cacheLocation()) / __simplename__
config_path = Path(v0.configLocation()) / __simplename__
data_path = Path(v0.dataLocation()) / __simplename__
pass_path = Path().home() / ".password-store"
user_path = config_path / "user"
server_path = config_path / "server"
api_key_path = pass_path / "jira-albert-plugin" / "api-key.gpg"
max_results_to_request = 50
max_results_to_show = 5
fields_to_include = [
"assignee", "issuetype", "priority", "project", "status", "summary"
]
prio_to_icon = {
import webbrowser
from pathlib import Path
import albertv0 as v0
__iid__ = "PythonInterface/v0.2"
__prettyname__ = "Harakiri mail temporary email"
__version__ = "0.1.0"
__trigger__ = "harakiri "
__author__ = "Nikos Koukis"
__dependencies__ = []
__homepage__ = "https://github.com/bergercookie/awesome-albert-plugins/blob/master/plugins/harakiri"
icon_path = str(Path(__file__).parent / "harakiri")
cache_path = Path(v0.cacheLocation()) / "harakiri"
config_path = Path(v0.configLocation()) / "harakiri"
data_path = Path(v0.dataLocation()) / "harakiri"
dev_mode = False
# plugin main functions -----------------------------------------------------------------------
def initialize():
"""Called when the extension is loaded (ticked in the settings) - blocking."""
# create plugin locations
for p in (cache_path, config_path, data_path):
p.mkdir(parents=False, exist_ok=True)