frankspin

Edit: 2014-05-23
 
Added some more search context options: subject and starred. Also adjusted the triggers to keep them shorter and simplier to trigger
 
Edit: 2013-12-23
The 1.3 update to Airmail seems to have broke the way this workflow worked. I'll work on getting it fixed.
 
 
I know there is a thread going on in the help portion so I figured I'd share my current Airmail workflow. Right now it has two components: new mail and unified search(Big thank you to David Ferguson for helping me with this one).
 
Compose new mail:
Super basic as all it does it switch to Airmail and open a new composer window.
 
Syntax: airmail new
 
Unified Search:
This relies on Applescript and has two caveats: 1. you have to have unified inbox enabled and 2. if the search field is active it wont work
 
Syntax: airmail search {query}
 
 
At some point I plan to make the compose mail workflow more robust and utilize the Airmail Applescript support, and also expand the unified search to check if the search field is active. I'm just on limited time right now but I at least wanted to get what I have out to peope. Feel free to add or help if you want!
 
Download: https://github.com/fspinillo/alfred-airmail

Just re-uploaded the file to Packal and my GitHub. Please try again!

If you're having trouble getting the workflow to work and you're on V2 I am currently working on a solution. The issue is related to exporting a workflow from V3 and trying to have it run on V3.

Attention: I am no longer actively working on this Workflow. I don't have the time to dedicate to it anymore and provide the kind of updates I'd like. If you want to fork and contribute back to it, please do so via GitHub. I appreciate all the support and kind words shown by users for making this.
 
slackfred
=========

Alfred workflow to interact, and perform various functions with the service Slack
 


Alfred workflow to interact, and perform various functions with the service [slack](http://slack.com/). Now with multi-team support!

I'm currently in the process of getting this updated to work with multiple organizations where possible, as well as adding some extra workflow options like private groups, stars and a few more things. Stay tuned!

## Getting started
1. Install slackfred by visiting the download page in Github or via the [Packal page](http://www.packal.org/workflow/slackfred)
2. Open alfred and type `slt`, then hold `cmd` (apple key) and press `enter`. This will open up the Slack API page. Then look for your team (make sure you're logged in) near the bottom. Next to your team name will be your token.
3. Launch alfred and re-run `slt` to enter your token.

##### Multi-team use instructions
In order to use the workflow with multiple organizations you will need to enter all of your keys as comma seperated strings with **no** spaces.  
Example: `team-org-api-token-1,team-org-api-token-2`

## Currently Available Functionality
* `slk`: Let's you switch easily between channels, groups and IMs. Thanks to buzali for getting this working with Slack's URL scheme.
* `slt`: Set your API Token
  * Open alfred and type `slt`, then paste your token. If you don't have a token, then hold `cmd` to open the API page to get one (look for your team near the bottom of the page).
* `slm`: Send messages to a channel
  * Open alfred and type `slm` to populate channels. Use your arrow keys to select a channel and hit TAB. Then you can enter your message and hit ENTER. * `slf`: Search files
  * Open alfred and type `slf` to search files. Selecting a file opens it in your browser
* `slp`: Set your presence
  * Open alfred and type `slp active` or `slp away`
* `slc`: View, leave and join channels or private groups
  * Open alfred and type `slc` to display a searchable list of channels. Selecting a channel with `alt` leaves and `ctrl` lets you join. Currently only `alt` is functional with groups.
* `slclr`: Clear unread messages
  * This currently only marks Channels as read and not groups. Depending on the size of your organizations this can also take a few seconds to run.
* `slim`: Enter a users name to search for most recent DM messages
* `slr`: Search your starred items
  * Highlight a result and hitting enter opens the web client to that result
* `sls`: Perform a query across all your channels in your organizations
  * Highlight a result and hitting enter opens the web client to that result
  * Depending on the size of your organization this can take a few seconds to run
* `slz`: Snooze teams:
  * After finding a team hit TAB and enter the length of snooze in minutes
  * To turn off snooze to the above and enter 0
 
## To-do
* Create a smoother API key/token process
* Improve speed and performance

This workflow was created with the help of Dean Jackson's library.

This should be in the workflow already. Make sure you have the latest version.

First workflow I'm sharing, so apologies if it's not the best.
 
The workflow is meant to work with HipChat's standalone desktop application for the Mac, not the web app.
 
Status
I liked that HipChat supports quick status messages via keyboard commands so I created a workflow to set your status quickly. It uses Applescript and will trigger a command+tab at the end to quickly switchback to your previous application.
 
Syntax:
hc available [status] hc away [status] hc dnd [status] Status is completely optional by the way since HipChat does not require one when setting your status
 

 
Search
Similar to the status workflow this relies on using Applescript. Since the HipChat application does not have built-in search, it will launch a new browser tab with the results. If you're not logged into HipChat in your browser this may not work properly.
 
Synatx:
hc search [query]
 
Download: https://github.com/fspinillo/Alfred-Workflows

Attention: I am no longer actively working on this Workflow. I don't have the time to dedicate to it anymore and provide the kind of updates I'd like. If you want to fork and contribute back to it, please do so via GitHub. I appreciate all the support and kind words shown by users for making this.
 
slackfred
=========

Alfred workflow to interact, and perform various functions with the service Slack
 


Alfred workflow to interact, and perform various functions with the service [slack](http://slack.com/). Now with multi-team support!

I'm currently in the process of getting this updated to work with multiple organizations where possible, as well as adding some extra workflow options like private groups, stars and a few more things. Stay tuned!

## Getting started
1. Install slackfred by visiting the download page in Github or via the [Packal page](http://www.packal.org/workflow/slackfred)
2. Open alfred and type `slt`, then hold `cmd` (apple key) and press `enter`. This will open up the Slack API page. Then look for your team (make sure you're logged in) near the bottom. Next to your team name will be your token.
3. Launch alfred and re-run `slt` to enter your token.

##### Multi-team use instructions
In order to use the workflow with multiple organizations you will need to enter all of your keys as comma seperated strings with **no** spaces.  
Example: `team-org-api-token-1,team-org-api-token-2`

## Currently Available Functionality
* `slk`: Let's you switch easily between channels, groups and IMs. Thanks to buzali for getting this working with Slack's URL scheme.
* `slt`: Set your API Token
  * Open alfred and type `slt`, then paste your token. If you don't have a token, then hold `cmd` to open the API page to get one (look for your team near the bottom of the page).
* `slm`: Send messages to a channel
  * Open alfred and type `slm` to populate channels. Use your arrow keys to select a channel and hit TAB. Then you can enter your message and hit ENTER. * `slf`: Search files
  * Open alfred and type `slf` to search files. Selecting a file opens it in your browser
* `slp`: Set your presence
  * Open alfred and type `slp active` or `slp away`
* `slc`: View, leave and join channels or private groups
  * Open alfred and type `slc` to display a searchable list of channels. Selecting a channel with `alt` leaves and `ctrl` lets you join. Currently only `alt` is functional with groups.
* `slclr`: Clear unread messages
  * This currently only marks Channels as read and not groups. Depending on the size of your organizations this can also take a few seconds to run.
* `slim`: Enter a users name to search for most recent DM messages
* `slr`: Search your starred items
  * Highlight a result and hitting enter opens the web client to that result
* `sls`: Perform a query across all your channels in your organizations
  * Highlight a result and hitting enter opens the web client to that result
  * Depending on the size of your organization this can take a few seconds to run
* `slz`: Snooze teams:
  * After finding a team hit TAB and enter the length of snooze in minutes
  * To turn off snooze to the above and enter 0
 
## To-do
* Create a smoother API key/token process
* Improve speed and performance

This workflow was created with the help of Dean Jackson's library.

Good catch! I just updated the workflow file to include the library. Can you give it another go? https://github.com/fspinillo/slackfred/blob/master/workflow/Slackfred.alfredworkflow

With regard to the GET parameters, workflow.web isn't very smart. The best thing to do is pass the GET parameters as a dictionary in the params arg, using a bare URL: web.get('https://slack.com/api/search.messages' params=dict(token=api_key, query=query, ...)) .

requests is much smarter in this regard: you can pass GET parameters in the URL and/or via params. In either case, I'd recommend passing query via params as then both requests and workflow.web will ensure it's properly URL-encoded.

Bummer you need to make two requests per API call

Regarding threading: that can be a very tricky topic. In this case, you might be able to whip up something fairly simple using the Pool class from multiprocessing.dummy and its apply_async() or map_async() methods:
 
from multiprocessing.dummy import Pool pool = Pool(5) # allow 5 simultaneous connections results = {} for url, params in urls: future = pool.apply_async(web.get, (url, params)) results[url] = future pool.close() # accept no more jobs pool.wait() # wait for queued jobs to finish and threads to exit # Populate `results` from the return value of the futures for url in results: future = results[url] results[url] = future.get() # Do what you want with results here... With regard to OOP, it doesn't make any difference. I didn't explain the issue very well. It's not so much that the function/class/whatever combines speaking with Alfred and speaking with an API, it's that the responsibilities aren't clearly separated and the code isn't properly layered.

If there's an error, your functions bypass main() and talk directly to Alfred, which is otherwise the job of main(). That's a recipe for confusion. To be clear, it's not a huge deal for your functions to add an error message to the output with wf.add_item(), but they shouldn't be calling wf.send_feedback(). Effectively, that terminates the workflow and the lifetime of the workflow is main()'s responsibility.

To give an analogy: you're the head of procurement (main()) and it's your job to collate all the internal orders and place the monthly order with your supplier (Alfred). You have several members of staff each responsible for different departments' orders. Normally, when they've collated their individual departments' orders, they bring them to you and you consolidate them into a single monthly order to the supplier.

One of your team members (search_slack()) has an annoying habit of drafting his departmental order, but instead of giving it to you, he sometimes contacts the supplier himself and places the monthly order, but only for his stuff. And he doesn't even tell you when he's done this, so everyone else carries on preparing their orders without knowing it's too late to place them and they're wasting their time.

Although that might be the right thing to do sometimes, he isn't in a position to know whether that's the case, and he's clearly overstepping his authority.

In the script, if one of the API keys is invalid, search_slack() reports this, but also silently closes the reporting channel, so all the work done with other, valid API keys is silently thrown in the bin. Equally, any other keys that are invalid will also have their error reports thrown in the bin.

I couldn't find any forecast workflows that were quite to my liking, so I whipped one up that gets a forecast from forecast.io:
 

 
Note: requires at least Mavericks. Not tested on Yosemite.
 
Download: https://github.com/kejadlen/dark-sky.alfredworkflow/releases
GitHub: https://github.com/kejadlen/dark-sky.alfredworkflow

Reddit for Alfred

Find subreddits and browse hot posts on Reddit.



Download

Get Reddit for Alfred from GitHub.

Usage
r/ — Show list of popular subreddits r/<query> — Search for subreddits matching <query> ↩ or ⇥ or ⌘+NUM — Show 50 hottest posts in subreddit r/subreddit/ — Show 50 hottest posts on subreddit <subreddit> r/<subreddit>/<query> — Filter posts by <query> ↩ or ⌘+NUM — Open post URL in default browser ⌘+↩ — Open Reddit comments in default browser ⌘+L — Show full post title in Alfred's Large Text window Note: OS X's "delete word" shortcut (⌥+⌫) is very handy for backing
out of a subreddit.

Description

A fairly rudimentary workflow to browse subreddits.

The subreddit search, r/<query>, uses Reddit's API to search for subreddits
that match <query>. 25 results are retrieved by default.

The subreddit search can be a bit odd, which is due to the oddness of Reddit's
search function.

Search within a subreddit, r/subreddit/<query>, only filters the list of hot
results. 50 results are retrieved by default.

I'm afraid I don't quite understand what it is you're trying to do or what you think would be overwritten/replaced.
 
If you just want to store multiple accounts/datasets in parallel, you might create a dictionary saved via the settings/stored data API that maps account names to a prefix, then use the appropriate prefix for the account in your caching/data/Keychain keys:
 
# `account name:prefix` mapping, e.g. {'Personal': 'account1', 'Work':'account2'} accounts = wf.settings['accounts'] # or accounts = wf.stored_data('accounts')   account = 'Personal' prefix = accounts[account]   api_key = wf.get_password('{}-apikey'.format(prefix)) def wrapper(): url = 'https://api.example.com/v1/whatever.json' r = web.get(url, params={'api_key':api_key}) return r.json() some_cached_data = wf.cached_data('{}-thedata'.format(prefix), wrapper, max_age=0) ... ... Thus, some_cached_data would be stored under the key (filename) account1-thedata for account Personal and account2-thedata for account Work.

Unlikely, but that’s very easy to do, without needing any coding. Take a look at the documentation.

Quite a few people have asked for the ability to execute workflows at certain times. Well, here's (kind of) a solution.
 
Alfred Cron (note: consider this workflow to be a 'beta' right now) with will run any bash command on any interval that you define. Now, this means that you can run any script of any kind (to run a python script, you'd just write: python "/path/to/script.py" 'args'). It also means that you can take advantage of the new External Triggers in Alfred. So, if you want to run a workflow in the background at a certain time, then you can as long as there is an External Trigger for that workflow.
 
Fun idea: if you're decently good at scripting, then you can replace Hazel with this workflow.
 
You can define cron jobs through a nifty little GUI box. Just, see it in action in the GIF below:

 
More detailed documentation is available at http://shawnrice.github.io/alfred-cron.
 
Download it from Packal.
 
Note: Alfred Cron uses the Alfred Bundler framework, so when you first execute the workflow, it will take a moment to install the bundler, Pashua, BashWorkflowHandler, and Terminal Notifier. So, be patient at first. They need to download only once.
 
Also, Alfred Cron makes use of Ctwise's brilliant SetupIconsForTheme, so the workflow will adjust to your Alfred whether it is light or dark.

Just to let you know, your workflow was featured on the blog yesterday:
http://blog.alfredapp.com/2014/11/17/getting-work-done-with-slack-github-and-pinboard/
 
Thanks for creating it

Attention: I am no longer actively working on this Workflow. I don't have the time to dedicate to it anymore and provide the kind of updates I'd like. If you want to fork and contribute back to it, please do so via GitHub. I appreciate all the support and kind words shown by users for making this.
 
slackfred
=========

Alfred workflow to interact, and perform various functions with the service Slack
 


Alfred workflow to interact, and perform various functions with the service [slack](http://slack.com/). Now with multi-team support!

I'm currently in the process of getting this updated to work with multiple organizations where possible, as well as adding some extra workflow options like private groups, stars and a few more things. Stay tuned!

## Getting started
1. Install slackfred by visiting the download page in Github or via the [Packal page](http://www.packal.org/workflow/slackfred)
2. Open alfred and type `slt`, then hold `cmd` (apple key) and press `enter`. This will open up the Slack API page. Then look for your team (make sure you're logged in) near the bottom. Next to your team name will be your token.
3. Launch alfred and re-run `slt` to enter your token.

##### Multi-team use instructions
In order to use the workflow with multiple organizations you will need to enter all of your keys as comma seperated strings with **no** spaces.  
Example: `team-org-api-token-1,team-org-api-token-2`

## Currently Available Functionality
* `slk`: Let's you switch easily between channels, groups and IMs. Thanks to buzali for getting this working with Slack's URL scheme.
* `slt`: Set your API Token
  * Open alfred and type `slt`, then paste your token. If you don't have a token, then hold `cmd` to open the API page to get one (look for your team near the bottom of the page).
* `slm`: Send messages to a channel
  * Open alfred and type `slm` to populate channels. Use your arrow keys to select a channel and hit TAB. Then you can enter your message and hit ENTER. * `slf`: Search files
  * Open alfred and type `slf` to search files. Selecting a file opens it in your browser
* `slp`: Set your presence
  * Open alfred and type `slp active` or `slp away`
* `slc`: View, leave and join channels or private groups
  * Open alfred and type `slc` to display a searchable list of channels. Selecting a channel with `alt` leaves and `ctrl` lets you join. Currently only `alt` is functional with groups.
* `slclr`: Clear unread messages
  * This currently only marks Channels as read and not groups. Depending on the size of your organizations this can also take a few seconds to run.
* `slim`: Enter a users name to search for most recent DM messages
* `slr`: Search your starred items
  * Highlight a result and hitting enter opens the web client to that result
* `sls`: Perform a query across all your channels in your organizations
  * Highlight a result and hitting enter opens the web client to that result
  * Depending on the size of your organization this can take a few seconds to run
* `slz`: Snooze teams:
  * After finding a team hit TAB and enter the length of snooze in minutes
  * To turn off snooze to the above and enter 0
 
## To-do
* Create a smoother API key/token process
* Improve speed and performance

This workflow was created with the help of Dean Jackson's library.

I'm happy to announce that after months of development, I'm ready to make a new workflow and theme repository available to the public as an open beta: Packal. Workflows and themes are taggable and searchable. You can add in the icons, screenshots, long descriptions, and brief ones. There are many different ways to find whatever you need there. Since this is an initial announcement, there isn't much content there yet, except for the workflows and themes that a few kind testers uploaded.
 
Themes are stored as a simple application URL, which means there are no files to download, but, instead, they import directly into Alfred2. Workflows are scanned for viruses after they are submitted but before they are made available publicly. Workflow authors can easily update their workflows just by editing the page and replacing the workflow file there.
 
What is even better is that Packal has its own updater for workflows. So, you have the option to update any workflows that you have downloaded from Packal.
 
I think that these are exciting developments for Alfred, and this sort of repository is what many people have been waiting for since these forums were created.
 
One great advantage for distributing your workflows via Packal is that you do not need to maintain your own download links for your workflows anymore, so you won't need to worry about download limits on sharing services. Another advantage is that it will receive more visibility as it is a place where people can look for workflows and themes without having to page through the impressive number of posts in these forums.
 
So, please, head over to Packal, browse what's there, and, very importantly, submit your own workflows and themes.
 
--Shawn

'ii' will search for your query right away. E.g. if you want to search for "Prometheus" and start typing, Alfred will trigger HTML requests for each letter you type, like "p", then "pr", and so on. This usually slows the things down.
 
'i' on the other hand, waits for a delimiter at the end of your query, like "/" or "." (set in the preferences), and starts a search only after you type it.
 
And yes, you can change 'i' to anything you like. (Preferably, not to 'ii' or 'iprefs', of course.)

Search IMDb in Alfred with movie and TV show ratings shown as results' icons.
  Features: See movie and TV show ratings right in search results When viewing indivial persons or titles, pressing Enter while the second result is selected (the one with a title's or person's name) will open a corresponding IMDb page in your default browser Items with an ellipsis in their title (e.g. “Director...”) are active: Pressing Enter when they are selected will perform corresponding actions (like showing the information about a movie's director or the list of actors starring in that movie) Items with “Press ⇧ to view” in their subtitles (Plot and Poster for movies and Biograghy and Photo for persons) can be viewed right in Alfred: Press Shift (the Quick Look feature must be enabled in Alfred's preferences) to Quick Look them Infinite browsing. For example, you could view info about a movie, then view info about its director, open the list of movies they are known for, select one of them, see the list of actors starring in that movie... and then go back all the way to your initial search results using the “Back” option Icon themes to match both light and dark Alfred themes Support for search term delimiters to increase performance by waiting for user to finish typing and add a predefined character to the end of the query (disabled by default, go to workflow preferences to enable) Download  

It looks like Frank posted the workflow on Packal, which means that you can easily get updates if you re-download the workflow from Packal, and then use the Packal Updater, which can update any workflow downloaded from Packal. It's the easiest way to keep your workflows updated.

Stuff like this is a lot easier done with External Triggers now days.
 
For instance... you have a keyword that goes to an external trigger. That triggers ties to a script filter that shows the list of all boards. Selecting that passes data to run script that, based on what you select, hits another external trigger to another script filter. This time to show the lists for that board or.. if you hit a previous link at some point, go to the previous external trigger. That would be my recommendation

I'm not a big fan of the external triggers method, as I prefer to keep as much of the complexity as possible in my code, where I can comment it, and out of Alfred's UI where it can be difficult to maintain an overview of which element does what (it's not possible to show a connection between a run script action and the external trigger it calls, for example). It's also a lot easier to refactor a workflow in a code editor than in Alfred's UI.
 
What I'd do in this situation is to create a "multi-level" query using a delimiter, e.g. 〉, and show results according to the query.
 
Thus, tlo would show a list of all boards. Hitting ENTER or TAB on a board would autocomplete the query to 'tlo board name 〉 ' (note the trailing space—it's important), and your script filter would then show a list of that board's lists. 'tlo board name 〉 blah' would filter the board's lists on blah. Hitting ENTER or TAB on a list expands the query to  'tlo board name 〉 list name 〉 ' (trailing space again) and your script filter shows the contents of the list and so on.
 
The trailing space is important because you can use that to jump back up a level: if the user deletes the trailing space (i.e. the query now ends with 〉, you pop the last level off the query and go back to the previous list.
 
Carlos's Recent Items workflow uses this technique, as do my Smart Folders and Packal Search workflows. My workflows might be of more use to you as a guide, as they're written in Python (which I think you're using, too).

The idea of cached_data() is to avoid generating/fetching data if the cache is up-to-date. So, instead of passing it the data it should cache, you pass it a function it can call to get fresh data if the cached data is too old/non-existent.
 
You're passing the results of a call to getBoards(). You need to pass the function itself, which cached_data() will then call if necessary.
 
Normally, that looks something like this:
 
def fetch_new_data():     # grab data from a web service/app here     # ...     return new_data data = wf.cached_data('cache-name', fetch_new_data, max_age=600)  
 Note that I'm passing fetch_new_data not fetch_new_data() to cached_data(), i.e. the function itself, not the data returned from calling the function.
 
You can't just pass the function in this case, however, as getBoards() takes an argument.
 
Check out the example script here. Look at the wrapper function and the call to cached_data() (lines 82–89). Note that I pass wrapper to cached_data without calling it.
 
You could also pass lambda api_key: getBoards(api_key) or functools.partial(getBoards, api_key). I wrote a separate wrapper() function in the tutorial to make it clearer and more explicit (lambda is ugly).
 
Does that help?

If you're a big Evernote user, then Carlos's Evernote workflow can be of immense use. If your students turn in assignments electronically (and in terrible file formats), then you could use Pandoctor (an overlay of pandoc) to help you. If you're working with PDFs, then Skimmer might help you. If you need to convert units... If you need to keep your computer awake while you read... If you need to check percent changes...
 
I'm sure there are others. What you could always do is identify tasks that you find yourself doing over and over that might require clicking or other tedious things, and you might be able to turn those into workflows.

I am a college professor, and most of my use of Alfred is for research / bibliographical / writing purposes, but I have a workflow that I update / duplicate each quarter to automatically open materials related to whatever course I am teaching.  Overall it looks like this:
 
Keyword (some abbreviation for the course)
-->
Multiple Files - this launches all the folders with my syllabus, grade books, slides, slides from previous versions of the course that I may be cutting/pasting from, etc.
--> 
Run Script - this is an Applescript with two parts:
1) open my current syllabus and automatically go to the date of the next upcoming class - you can find this here: https://github.com/derickfay/course-creator
2) arrange the files / windows that I just opened according to a corresponding Moom ( http://manytricks.com/moom/ ) template
 
I also use my Keynote to PDF workflow (linked from http://dfay.fastmail.fm.user.fm/alfred/ also in these forums somewhere) after every class to prepare my slides for posting to course web sites.
 
None of these are particularly tied to Alfred - they could all be accomplished by independent Applescripts, but Alfred 1) makes them readily available and 2) with Dropbox syncing, makes them available on all three Macs that I use on a regular basis without worrying about syncing Library or other script folders.