Update Alfred-Workflow

Author: deanishe

README.md

@@ -1,34 +1,45 @@
 
-# StackOverflow Search for Alfred #
+StackOverflow Search for Alfred
+===============================
 
 Search for answers on StackOverflow.com from [Alfred 2 & 3][alfred].
 
 ![](demo.gif "")
 
-## Download ##
+
+Download
+--------
 
 Get StackOverflow for Alfred from [GitHub][gh-releases] or
 [Packal][packal-page].
 
-## Usage ##
+
+Usage
+-----
 
 - `.so <query>` — Search StackOverflow.com for `<query>`.
     See below for syntax.
     - `↩` or ` ⌘+NUM` — Open result in default browser
     - `⌘+L` — Show full question title in Alfred's Large Text window
 
-## Query syntax ##
+
+Query syntax
+------------
 
 By default, words in `<query>` will be search for in the title of posts. To
 specify a tag, prefix it with `.`, e.g. `python` will search for `python` in
 the post title, `.python` will search for the tag `python`.
 
-## Results ##
+
+Results
+-------
 
 Answered questions will be shown first in the list of results (and have a
 tick on their icon).
 
-## Licensing, thanks ##
+
+Licensing, thanks
+-----------------
 
 This workflow is released under the [MIT Licence][mit].
 

StackOverflow-1.2.1.alfredworkflow

@@ -1 +1 @@
-1.2
+1.2.1

StackOverflow-1.2.alfredworkflow

@@ -8,22 +8,13 @@
 # Created on 2014-02-15
 #
 
-"""
-A Python helper library for `Alfred 2 <http://www.alfredapp.com/>`_ Workflow
-authors.
-"""
+"""A helper library for `Alfred <http://www.alfredapp.com/>`_ workflows."""
 
 import os
 
-__title__ = 'Alfred-Workflow'
-__version__ = open(os.path.join(os.path.dirname(__file__), 'version')).read()
-__author__ = 'Dean Jackson'
-__licence__ = 'MIT'
-__copyright__ = 'Copyright 2014 Dean Jackson'
-
-
 # Workflow objects
 from .workflow import Workflow, manager
+from .workflow3 import Variables, Workflow3
 
 # Exceptions
 from .workflow import PasswordNotFound, KeychainError
@@ -68,41 +59,50 @@
     MATCH_SUBSTRING,
 )
 
+
+__title__ = 'Alfred-Workflow'
+__version__ = open(os.path.join(os.path.dirname(__file__), 'version')).read()
+__author__ = 'Dean Jackson'
+__licence__ = 'MIT'
+__copyright__ = 'Copyright 2014 Dean Jackson'
+
 __all__ = [
-    Workflow,
-    manager,
-    PasswordNotFound,
-    KeychainError,
-    ICON_ACCOUNT,
-    ICON_BURN,
-    ICON_CLOCK,
-    ICON_COLOR,
-    ICON_COLOUR,
-    ICON_EJECT,
-    ICON_ERROR,
-    ICON_FAVORITE,
-    ICON_FAVOURITE,
-    ICON_GROUP,
-    ICON_HELP,
-    ICON_HOME,
-    ICON_INFO,
-    ICON_NETWORK,
-    ICON_NOTE,
-    ICON_SETTINGS,
-    ICON_SWIRL,
-    ICON_SWITCH,
-    ICON_SYNC,
-    ICON_TRASH,
-    ICON_USER,
-    ICON_WARNING,
-    ICON_WEB,
-    MATCH_ALL,
-    MATCH_ALLCHARS,
-    MATCH_ATOM,
-    MATCH_CAPITALS,
-    MATCH_INITIALS,
-    MATCH_INITIALS_CONTAIN,
-    MATCH_INITIALS_STARTSWITH,
-    MATCH_STARTSWITH,
-    MATCH_SUBSTRING,
+    'Variables',
+    'Workflow',
+    'Workflow3',
+    'manager',
+    'PasswordNotFound',
+    'KeychainError',
+    'ICON_ACCOUNT',
+    'ICON_BURN',
+    'ICON_CLOCK',
+    'ICON_COLOR',
+    'ICON_COLOUR',
+    'ICON_EJECT',
+    'ICON_ERROR',
+    'ICON_FAVORITE',
+    'ICON_FAVOURITE',
+    'ICON_GROUP',
+    'ICON_HELP',
+    'ICON_HOME',
+    'ICON_INFO',
+    'ICON_NETWORK',
+    'ICON_NOTE',
+    'ICON_SETTINGS',
+    'ICON_SWIRL',
+    'ICON_SWITCH',
+    'ICON_SYNC',
+    'ICON_TRASH',
+    'ICON_USER',
+    'ICON_WARNING',
+    'ICON_WEB',
+    'MATCH_ALL',
+    'MATCH_ALLCHARS',
+    'MATCH_ATOM',
+    'MATCH_CAPITALS',
+    'MATCH_INITIALS',
+    'MATCH_INITIALS_CONTAIN',
+    'MATCH_INITIALS_STARTSWITH',
+    'MATCH_STARTSWITH',
+    'MATCH_SUBSTRING',
 ]

src/version

@@ -1,16 +1,14 @@
 #!/usr/bin/env python
 # encoding: utf-8
 #
-# Copyright © 2014 [email protected]
+# Copyright (c) 2014 [email protected]
 #
 # MIT Licence. See http://opensource.org/licenses/MIT
 #
 # Created on 2014-04-06
 #
 
-"""
-Run background tasks
-"""
+"""Run background tasks."""
 
 from __future__ import print_function, unicode_literals
 
@@ -23,45 +21,49 @@
 
 __all__ = ['is_running', 'run_in_background']
 
-wf = Workflow()
-log = wf.logger
+_wf = None
+
+
+def wf():
+    global _wf
+    if _wf is None:
+        _wf = Workflow()
+    return _wf
 
 
 def _arg_cache(name):
-    """Return path to pickle cache file for arguments
+    """Return path to pickle cache file for arguments.
 
     :param name: name of task
     :type name: ``unicode``
     :returns: Path to cache file
     :rtype: ``unicode`` filepath
 
     """
-
-    return wf.cachefile('{}.argcache'.format(name))
+    return wf().cachefile('{0}.argcache'.format(name))
 
 
 def _pid_file(name):
-    """Return path to PID file for ``name``
+    """Return path to PID file for ``name``.
 
     :param name: name of task
     :type name: ``unicode``
     :returns: Path to PID file for task
     :rtype: ``unicode`` filepath
 
     """
-
-    return wf.cachefile('{}.pid'.format(name))
+    return wf().cachefile('{0}.pid'.format(name))
 
 
 def _process_exists(pid):
-    """Check if a process with PID ``pid`` exists
+    """Check if a process with PID ``pid`` exists.
 
     :param pid: PID to check
     :type pid: ``int``
     :returns: ``True`` if process exists, else ``False``
     :rtype: ``Boolean``
-    """
 
+    """
     try:
         os.kill(pid, 0)
     except OSError:  # not running
@@ -70,8 +72,7 @@ def _process_exists(pid):
 
 
 def is_running(name):
-    """
-    Test whether task is running under ``name``
+    """Test whether task is running under ``name``.
 
     :param name: name of task
     :type name: ``unicode``
@@ -107,32 +108,31 @@ def _background(stdin='/dev/null', stdout='/dev/null',
     :type stderr: filepath
 
     """
+    def _fork_and_exit_parent(errmsg):
+        try:
+            pid = os.fork()
+            if pid > 0:
+                os._exit(0)
+        except OSError as err:
+            wf().logger.critical('%s: (%d) %s', errmsg, err.errno,
+                                 err.strerror)
+            raise err
 
     # Do first fork.
-    try:
-        pid = os.fork()
-        if pid > 0:
-            sys.exit(0)  # Exit first parent.
-    except OSError as e:
-        log.critical("fork #1 failed: (%d) %s\n" % (e.errno, e.strerror))
-        sys.exit(1)
+    _fork_and_exit_parent('fork #1 failed')
+
     # Decouple from parent environment.
-    os.chdir(wf.workflowdir)
-    os.umask(0)
+    os.chdir(wf().workflowdir)
     os.setsid()
+
     # Do second fork.
-    try:
-        pid = os.fork()
-        if pid > 0:
-            sys.exit(0)  # Exit second parent.
-    except OSError as e:
-        log.critical("fork #2 failed: (%d) %s\n" % (e.errno, e.strerror))
-        sys.exit(1)
+    _fork_and_exit_parent('fork #2 failed')
+
     # Now I am a daemon!
     # Redirect standard file descriptors.
-    si = file(stdin, 'r', 0)
-    so = file(stdout, 'a+', 0)
-    se = file(stderr, 'a+', 0)
+    si = open(stdin, 'r', 0)
+    so = open(stdout, 'a+', 0)
+    se = open(stderr, 'a+', 0)
     if hasattr(sys.stdin, 'fileno'):
         os.dup2(si.fileno(), sys.stdin.fileno())
     if hasattr(sys.stdout, 'fileno'):
@@ -142,8 +142,7 @@ def _background(stdin='/dev/null', stdout='/dev/null',
 
 
 def run_in_background(name, args, **kwargs):
-    """Pickle arguments to cache file, then call this script again via
-    :func:`subprocess.call`.
+    r"""Cache arguments then call this script again via :func:`subprocess.call`.
 
     :param name: name of task
     :type name: ``unicode``
@@ -167,40 +166,39 @@ def run_in_background(name, args, **kwargs):
     return immediately and will not run the specified command.
 
     """
-
     if is_running(name):
-        log.info('Task `{}` is already running'.format(name))
+        wf().logger.info('Task `{0}` is already running'.format(name))
         return
 
     argcache = _arg_cache(name)
 
     # Cache arguments
     with open(argcache, 'wb') as file_obj:
         pickle.dump({'args': args, 'kwargs': kwargs}, file_obj)
-        log.debug('Command arguments cached to `{}`'.format(argcache))
+        wf().logger.debug('Command arguments cached to `{0}`'.format(argcache))
 
     # Call this script
     cmd = ['/usr/bin/python', __file__, name]
-    log.debug('Calling {!r} ...'.format(cmd))
+    wf().logger.debug('Calling {0!r} ...'.format(cmd))
     retcode = subprocess.call(cmd)
     if retcode:  # pragma: no cover
-        log.error('Failed to call task in background')
+        wf().logger.error('Failed to call task in background')
     else:
-        log.debug('Executing task `{}` in background...'.format(name))
+        wf().logger.debug('Executing task `{0}` in background...'.format(name))
     return retcode
 
 
 def main(wf):  # pragma: no cover
-    """
+    """Run command in a background process.
+
     Load cached arguments, fork into background, then call
-    :meth:`subprocess.call` with cached arguments
+    :meth:`subprocess.call` with cached arguments.
 
     """
-
     name = wf.args[0]
     argcache = _arg_cache(name)
     if not os.path.exists(argcache):
-        log.critical('No arg cache found : {!r}'.format(argcache))
+        wf.logger.critical('No arg cache found : {0!r}'.format(argcache))
         return 1
 
     # Load cached arguments
@@ -221,23 +219,24 @@ def main(wf):  # pragma: no cover
 
     # Write PID to file
     with open(pidfile, 'wb') as file_obj:
-        file_obj.write('{}'.format(os.getpid()))
+        file_obj.write('{0}'.format(os.getpid()))
 
     # Run the command
     try:
-        log.debug('Task `{}` running'.format(name))
-        log.debug('cmd : {!r}'.format(args))
+        wf.logger.debug('Task `{0}` running'.format(name))
+        wf.logger.debug('cmd : {0!r}'.format(args))
 
         retcode = subprocess.call(args, **kwargs)
 
         if retcode:
-            log.error('Command failed with [{}] : {!r}'.format(retcode, args))
+            wf.logger.error('Command failed with [{0}] : {1!r}'.format(
+                            retcode, args))
 
     finally:
         if os.path.exists(pidfile):
             os.unlink(pidfile)
-        log.debug('Task `{}` finished'.format(name))
+        wf.logger.debug('Task `{0}` finished'.format(name))
 
 
 if __name__ == '__main__':  # pragma: no cover
-    wf.run(main)
+    wf().run(main)