def test_workflow_update_methods(self): """Workflow update methods""" def fake(wf): return Workflow().reset() # Initialise with outdated version wf = Workflow(update_settings={ 'github_slug': 'deanishe/alfred-workflow-dummy', 'version': 'v2.0', 'frequency': 1, }) wf.run(fake) # Check won't have completed yet self.assertFalse(wf.update_available) # wait for background update check self.assertTrue(is_running('__workflow_update_check')) while is_running('__workflow_update_check'): time.sleep(0.05) time.sleep(1) # There *is* a newer version in the repo self.assertTrue(wf.update_available) # Mock out subprocess and check the correct command is run c = WorkflowMock() with c: self.assertTrue(wf.start_update()) # wf.logger.debug('start_update : {}'.format(c.cmd)) self.assertEquals(c.cmd[0], '/usr/bin/python') self.assertEquals(c.cmd[2], '__workflow_update_install') # Grab the updated release data, then reset the cache update_info = wf.cached_data('__workflow_update_status') wf.reset() # Initialise with latest available release wf = Workflow(update_settings={ 'github_slug': 'deanishe/alfred-workflow-dummy', 'version': update_info['version'], }) wf.run(fake) # Wait for background update check self.assertTrue(is_running('__workflow_update_check')) while is_running('__workflow_update_check'): time.sleep(0.05) # Remote version is same as the one we passed to Workflow self.assertFalse(wf.update_available) self.assertFalse(wf.start_update())
def main(): """This method is installed as a console script entry point by setuptools It uses the command line arguments specified by opts() to generate a Workflow object and adds to it several WorkflowStages. If the needed command line arguments are not passed, the user is asked to enter them. The generated Workflow object is then executed with run() """ args = opts().parse_args() if args.help == 'all': opts().print_help() return elif args.help == 'stages': print WorkflowStage.longhelp() return logging.basicConfig( level=getattr(logging, args.logging.upper()), format='%(levelname)s: %(asctime)s in %(name)s - %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p' ) w = Workflow() if not args.stages: print 'Stages not given with --stages argument' print WorkflowStage.shorthelp() stages = raw_input( 'Enter space separated stage specifiers (e.g. "1 2 3"): ').split() else: stages = args.stages classmap = {cls.spec: cls for cls in all_subclasses(WorkflowStage)} for stage_spec in stages: try: w.append(classmap[stage_spec](args)) except KeyError as e: logging.error( 'No valid stage specifier {0} - use "--help stages" to see ' 'stage specifiers for this software'.format(stage_spec)) raise w.run()
def test_run_single_sensor_usecase(self): usecase = 'mms3' mmdtype = 'mmd3' w = Workflow(usecase, Period('1991-01-01', '1992-01-01')) w.add_primary_sensor('avhrr.n10', (1986, 11, 17), (1991, 9, 16)) w.add_primary_sensor('avhrr.n11', (1988, 11, 8), (1994, 12, 31)) w.add_primary_sensor('avhrr.n12', (1991, 9, 16), (1998, 12, 14)) w.run(mmdtype, log_dir='.', with_history=True, simulation=True) with open('mms3.status', 'r') as status: self.assertEqual('337 created, 0 running, 0 backlog, 337 processed, 0 failed\n', status.readline()) with open('mms3.report', 'r') as report: self.assertEqual(337, len(report.readlines())) os.remove('mms3.status') os.remove('mms3.report')
class YahooTransitAlfredWorkflow(object): YAHOO_TRANSIT_SEARCH_URL = 'http://transit.yahoo.co.jp/search/result?flatlon=&from=%s&tlatlon=&to=%s' ICON_URL = 'icon.png' def __init__(self): self.wf = Workflow() self.log = self.wf.logger def run(self): sys.exit(self.wf.run(self.main)) def main(self, wf): self.log.debug('start') args = wf.args queries = args[0].split() if len(queries) > 1: self.src, self.dst = queries[0:2] self.src = urllib.quote(self.src.encode('utf-8')) self.dst = urllib.quote(self.dst.encode('utf-8')) informations = self._fetch_transit_informations() for info in informations: wf.add_item(info.title, info.description, arg=info.url, valid=True, icon=self.ICON_URL) else: wf.add_item('transit <origin> <destination>') wf.send_feedback() def _get_url(self): return self.YAHOO_TRANSIT_SEARCH_URL % (self.src, self.dst) def _fetch_transit_informations(self): url = self._get_url() response = web.get(url) self.redirect_url = response.url soup = BeautifulSoup(response.content) routes = soup.select('[id^=route]') return [self._parse_information_from_node(route) for route in routes] def _parse_information_from_node(self, node): id = node['id'] base_url = self._get_url() url = '%s#%s' % (base_url, id) summary = node.select('.routeSummary')[0] time = summary.select('li.time span')[0].getText() duration = summary.select('li.time')[0].getText() duration = duration.replace(time, '') transfer = summary.select('li.transfer')[0].getText() fare = summary.select('li.fare')[0].getText() humanized_fare = fare.replace('[priic]', '') info = TransitInformation(time, duration, transfer, humanized_fare, url) return info
def execute(self): global LOG wf = Workflow() self.wf = wf LOG = wf.logger self.minus = get_default(wf.settings, 'minus', self.minus_default) self.plus = get_default(wf.settings, 'plus', self.plus_default) sys.exit(wf.run(self.main))
def run_workflow(a, b, c, d, e, f, g, h, i, j): workflow1 = Workflow(weibullmodels[i], windrosemodels[b], turbmodels[c], None, depthmodels[h], farm_support_cost_models[j], None, oandm_given_costs, cablemodels[d], infield_efficiency, thrust_coefficient, thrustmodels[f], wakemodels[a], mergingmodels[e], power, powermodels[g], aep_average, other_costs, total_costs, LPC) nbins = 25 # Number of wind speeds bins for the discretisation of the Weibull distribution. real_angle = 30.0 # Angle [degrees] per wind sector in measured windrose. artif_angle = 1.0 # Desired angle [degrees] resolution for wake analysis. workflow1.windrose.nbins = nbins workflow1.windrose.artificial_angle = artif_angle workflow1.windrose.real_angle = real_angle workflow1.print_output = True workflow1.run("layout.dat") print workflow1.runtime, "seconds runtime" power2.reset() thrust_coefficient2.reset() with open("output.dat", "a", 1) as output2: output2.write("{}\t{}\t{}\n".format(workflow1.aep, workflow1.finance, workflow1.runtime))
def test_run_dual_sensor_usecase_without_arc(self): usecase = 'mms1' mmdtype = 'mmd1' w = Workflow(usecase, Period('1991-01-01', '1992-01-01')) w.add_primary_sensor('avhrr.n10', (1986, 11, 17), (1991, 9, 16)) w.add_primary_sensor('avhrr.n11', (1988, 11, 8), (1994, 12, 31)) w.add_primary_sensor('avhrr.n12', (1991, 9, 16), (1998, 12, 14)) w.add_secondary_sensor('avhrr.n10', (1986, 11, 17), (1991, 9, 16)) w.add_secondary_sensor('avhrr.n11', (1988, 11, 8), (1994, 12, 31)) w.add_secondary_sensor('avhrr.n12', (1991, 9, 16), (1998, 12, 14)) w.run(mmdtype, log_dir='.', simulation=True, without_arc=True) with open('mms1.status', 'r') as status: self.assertEqual('203 created, 0 running, 0 backlog, 203 processed, 0 failed\n', status.readline()) with open('mms1.report', 'r') as report: self.assertEqual(203, len(report.readlines())) os.remove('mms1.status') os.remove('mms1.report')
class ListHandler(object): """ The new way of fetching and displaying lists. Converting over to this. """ def __init__( self, query='', cache_timeout=60 * 10 ): self.workflow = Workflow() self.query = query self.cache_timeout = cache_timeout @property def cache_key(self): return self.__class__.__name__ def run(self): result = self.workflow.run(self._run) self.workflow.send_feedback() sys.exit(result) def fetch(self): raise NotImplementedError def _run(self, workflow): items = workflow.cached_data( self.cache_key, self.fetch, self.cache_timeout ) if self.query: items = self.filtered_items(items, self.query) for item in items: self.add_item(item) def add_item(self, item): raise NotImplementedError def filtered_items(self, items, query): return self.workflow.filter( query, items, key=lambda x: str(x) )
tm = utcnow.astimezone(tz).strftime('%H:%M') times.append((tm, tz.zone.replace('_', ' '))) times.sort() # Display times in Alfred for tm, name in times: self.wf.add_item('{} {}'.format(tm, name)) self.wf.send_feedback() # This is a standard Python idiom for running a .py file when it's # called directly. It's good practice to do this, as it means the file # can be imported by other files without it executing. if __name__ == '__main__': # Create an instance of our helper wf = Workflow() # Set the global `log` instance log = wf.logger # Set the global `decode` function decode = wf.decode # Create our workflow object demo = Demo() # Run it. If the inner function (demo.run) returns a non-zero # (`None` counts as zero) value, Alfred will recognise the workflow # as having failed. `wf.run` will catch any exceptions raised by # `demo.run`, display them in Alfred and return 1 to `sys.exit`, # indicating that the workflow failed. sys.exit(wf.run(demo.run))
output.append(VMDetails( m.name, m.id, get_vm_state(m.state), '/Applications/VirtualBox.app')) return output def get_vm_state(state_const): for state, constant in constants.all_values('MachineState').iteritems(): if constant == state_const: return state return None def get_vm_screenshot(): global currentVM if currentVM is None: return '' icon = '%s/%s.png' % (wf.cachedir, hash(currentVM.name)) if 'Parallels' in currentVM.type: os.popen("""prlctl capture "%s" --file "%s" """ % (currentVM.name, icon)) else: os.popen("""VBoxManage controlvm "%s" screenshotpng "%s" """ % (currentVM.name, icon)) return icon if __name__ == '__main__': wf = Workflow() sys.exit(wf.run(complete))
from workflow import Workflow usecase = 'mms2' mmdtype = 'mmd2' w = Workflow(usecase) w.add_primary_sensor('atsr.1', '1991-08-01', '1996-09-01') w.add_primary_sensor('atsr.1', '1996-10-01', '1996-11-01') w.add_primary_sensor('atsr.1', '1996-12-30', '1997-02-01') w.add_primary_sensor('atsr.1', '1997-03-01', '1997-04-01') w.add_primary_sensor('atsr.1', '1997-05-01', '1997-06-01') w.add_primary_sensor('atsr.1', '1997-07-01', '1997-09-01') w.add_primary_sensor('atsr.1', '1997-10-01', '1997-11-01') w.add_primary_sensor('atsr.1', '1997-12-01', '1997-12-18') w.add_primary_sensor('atsr.2', '1995-06-01', '1996-01-01') w.add_primary_sensor('atsr.2', '1996-07-01', '2003-06-23') w.add_primary_sensor('atsr.3', '2002-05-20', '2012-04-09') w.set_samples_per_month(300000) w.run(mmdtype, hosts=[('localhost', 48)])
code=request_token ) WF.save_password( 'pocket_access_token', user_credentials['access_token'] ) # We don't need the cache anymore. Clear it for security reasons WF.clear_cache() except RateLimitException: WF.logger.error('RateLimitException') def refresh_list(): # pragma: no cover if not is_running('pocket_refresh'): cmd = ['/usr/bin/python', WF.workflowfile('pocket_refresh.py')] run_in_background('pocket_refresh', cmd) def get_icon(name): name = '%s-dark' % name if is_dark() else name return 'icons/%s.png' % name def is_dark(): rgb = [int(x) for x in WF.alfred_env['theme_background'][5:-6].split(',')] return (0.299 * rgb[0] + 0.587 * rgb[1] + 0.114 * rgb[2]) / 255 < 0.5 if __name__ == '__main__': WF.run(main) # pragma: no cover
from workflow import Workflow usecase = 'mms14' mmdtype = 'mmd14' w = Workflow(usecase) # the following lines define the full MMD tb 2016-08-01 #w.add_primary_sensor('atsr.3', '2002-05-20', '2012-04-09') #w.add_primary_sensor('amsre', '2002-06-01', '2011-10-05') # the following lines define the test MMD tb 2016-08-01 w.add_primary_sensor('atsr.3', '2008-05-01', '2008-06-01') w.add_secondary_sensor('amsre', '2008-05-01', '2008-06-01') w.set_samples_per_month(100000) w.run(mmdtype, hosts=[('localhost', 8)])
from workflow import Workflow usecase = 'mms3' mmdtype = 'mmd3' w = Workflow(usecase) w.add_primary_sensor('atsr.1', '1991-08-01', '1996-09-01') w.add_primary_sensor('atsr.1', '1996-10-01', '1996-11-01') w.add_primary_sensor('atsr.1', '1996-12-30', '1997-02-01') w.add_primary_sensor('atsr.1', '1997-03-01', '1997-04-01') w.add_primary_sensor('atsr.1', '1997-05-01', '1997-06-01') w.add_primary_sensor('atsr.1', '1997-07-01', '1997-09-01') w.add_primary_sensor('atsr.1', '1997-10-01', '1997-11-01') w.add_primary_sensor('atsr.1', '1997-12-01', '1997-12-18') w.add_primary_sensor('atsr.2', '1995-06-01', '1996-01-01') w.add_primary_sensor('atsr.2', '1996-07-01', '2003-06-23') w.add_primary_sensor('atsr.3', '2002-05-20', '2012-04-09') w.set_samples_per_month(0) w.run(mmdtype, hosts=[('localhost', 24)], calls=[('sampling-start', 1)], with_history=True)
from workflow import Period from workflow import Workflow usecase = 'mms7' mmdtype = 'mmd7' w = Workflow(usecase, Period('2012-07-02', '2015-01-01')) w.add_primary_sensor('avhrr_f.m02', '2007-03-01', '2014-04-01') w.add_secondary_sensor('amsr2', '2012-07-02', '2015-04-01') w.set_samples_per_month(5000000) w.run(mmdtype, hosts=[('localhost', 12)], without_arc=True)
:rtype: ``list`` """ scriptdirs = [ os.path.join(APP_SCRIPT_DIRECTORY, app_name), os.path.join(APP_SUPPORT_DIRECTORY, app_name, 'Scripts') ] scripts = [] for scriptdir in scriptdirs: # scriptdir = os.path.join(APP_SCRIPT_DIRECTORY, app_name) if not os.path.isdir(scriptdir): self.wf.logger.debug( 'App script directory does not exists : {!r}'.format( scriptdir)) continue for root, dirnames, filenames in os.walk(scriptdir): for filename in filenames: ext = os.path.splitext(filename)[1] if ext.lower() not in SCRIPT_EXTENSIONS: continue scripts.append(os.path.join(root, filename)) self.wf.logger.debug('{} scripts found for app {!r}'.format( len(scripts), app_name)) return scripts if __name__ == '__main__': wf = Workflow() app = ScriptRunner() wf.run(app.run)
w = Workflow(usecase) w.add_primary_sensor('atsr.1', '1991-08-01', '1996-09-01') w.add_primary_sensor('atsr.1', '1996-10-01', '1996-11-01') w.add_primary_sensor('atsr.1', '1997-01-01', '1997-02-01') w.add_primary_sensor('atsr.1', '1997-03-01', '1997-04-01') w.add_primary_sensor('atsr.1', '1997-05-01', '1997-06-01') w.add_primary_sensor('atsr.1', '1997-07-01', '1997-08-01') w.add_primary_sensor('atsr.1', '1997-10-01', '1997-11-01') w.add_primary_sensor('atsr.1', '1997-12-01', '1997-12-18') w.add_primary_sensor('atsr.2', '1995-06-01', '1996-01-01') w.add_primary_sensor('atsr.2', '1996-07-01', '2003-06-23') w.add_primary_sensor('atsr.3', '2002-05-20', '2012-04-09') #w.add_secondary_sensor('avhrr.n10', '1986-11-17', '1991-09-17') w.add_secondary_sensor('avhrr.n11', '1988-11-08', '1994-09-14') w.add_secondary_sensor('avhrr.n12', '1991-09-16', '1998-12-15') w.add_secondary_sensor('avhrr.n14', '1995-01-01', '2000-01-01') w.add_secondary_sensor('avhrr.n15', '1998-10-26', '2000-08-01') w.add_secondary_sensor('avhrr.n15', '2000-09-01', '2003-04-09') w.add_secondary_sensor('avhrr.n15', '2003-12-21', '2010-08-01') w.add_secondary_sensor('avhrr.n16', '2001-01-01', '2003-04-09') w.add_secondary_sensor('avhrr.n16', '2003-12-21', '2011-01-01') w.add_secondary_sensor('avhrr.n17', '2002-07-10', '2003-04-09') w.add_secondary_sensor('avhrr.n17', '2003-12-21', '2010-10-01') w.add_secondary_sensor('avhrr.n18', '2005-06-05', '2014-01-01') w.add_secondary_sensor('avhrr.n19', '2009-02-06', '2014-01-01') w.add_secondary_sensor('avhrr.m02', '2006-11-21', '2014-01-01') w.set_samples_per_month(40000000) w.run(mmdtype, hosts=[('localhost', 48)], selected_only=True)
def main(wf): update_settings(wf) # Get the current setting current_setting = wf.settings['date-format'] # These are the date formats the workflow supports for key in sorted(DATE_MAPPINGS.keys()): # Indicate the current setting for the user if key == current_setting: title_setting = key + ' *' else: title_setting = key # You know what? There's not point letting them set the format to the current format. It's # a waste of effort. wf.add_item(title=title_setting, subtitle=DATE_MAPPINGS[key]['name'], valid=(key != current_setting), arg=key) wf.send_feedback() if __name__ == '__main__': workFlow = Workflow(default_settings=DEFAULT_WORKFLOW_SETTINGS) sys.exit(workFlow.run(main))
arg=data['title'], valid=True) wf.send_feedback() def remove(wf): link = wf.args[1] data = wf.stored_data('pycrastinator') data = [item for item in data if item['link'] != link] wf.store_data('pycrastinator', data) if __name__ == '__main__': wf = Workflow() wf.data_serializer = 'json' command = wf.args[0] if not wf.stored_data('pycrastinator'): wf.store_data('pycrastinator', []) if command == 'add': sys.exit(wf.run(add)) elif command == 'confirm': sys.exit(wf.run(confirm)) elif command == 'remove': sys.exit(wf.run(remove)) else: sys.exit(wf.run(main))
def set_clipboard(url): clipboard = os.popen(""" osascript -e 'set the clipboard to "%s"' """ % url).readline() return 'Link copied to clipboard' def archive_item(item_id): access_token = wf.get_password('pocket_access_token') pocket_instance = Pocket(config.CONSUMER_KEY, access_token) try: pocket_instance.archive(item_id, wait=False) return 'Link archived' except Exception: return 'Connection error' def delete_item(item_id): access_token = wf.get_password('pocket_access_token') pocket_instance = Pocket(config.CONSUMER_KEY, access_token) try: pocket_instance.delete(item_id, wait=False) return 'Link deleted' except Exception: return 'Connection error' if __name__ == '__main__': wf = Workflow() sys.exit(wf.run(execute))
def _split_query(self, query): if not query or DELIMITER not in query: return None, query elif query.endswith(DELIMITER): # trailing space deleted raise GoBack(query.rstrip(DELIMITER).strip()) return [s.strip() for s in query.split(DELIMITER)] def _update(self, force=False): """Update cached data""" log.debug('Updating workflow lists...') args = ['/usr/bin/python', self.wf.workflowfile('update_workflows.py')] if force: args.append('--force-update') log.debug('update command : %r', args) retcode = run_in_background('update', args) if retcode: log.debug('Update failed with code %r', retcode) print('Update failed') return 1 if force: print('Updating workflow list…'.encode('utf-8')) return 0 if __name__ == '__main__': wf = Workflow() log = wf.logger pk = PackalWorkflow() wf.run(pk.run)
# -*- coding: utf-8 -*- # !/usr/bin/env python3 import yaml import argparse from workflow import Workflow def __arg_parse(): parser = argparse.ArgumentParser() parser.add_argument('-c', '--config', help=' config file', required=True) return parser.parse_args() if __name__ == '__main__': args = __arg_parse() print(args) config_file = open(args.config, encoding='utf-8') configs = yaml.load(config_file) workflow = Workflow(configs) workflow.run(1)
#w.add_primary_sensor('avhrr.n12', '1991-09-16', '1998-12-15') #w.add_primary_sensor('avhrr.n14', '1995-01-01', '2000-01-01') #w.add_primary_sensor('avhrr.n15', '1998-10-26', '2003-04-09') #w.add_primary_sensor('avhrr.n15', '2003-12-21', '2011-01-01') #w.add_primary_sensor('avhrr.n16', '2001-01-01', '2003-04-09') #w.add_primary_sensor('avhrr.n16', '2003-12-21', '2011-01-01') #w.add_primary_sensor('avhrr.n17', '2002-07-10', '2003-04-09') #w.add_primary_sensor('avhrr.n17', '2003-12-21', '2011-01-01') #w.add_primary_sensor('avhrr.n18', '2005-06-05', '2014-01-01') #w.add_primary_sensor('avhrr.n19', '2009-02-06', '2014-01-01') #w.add_primary_sensor('avhrr.m02', '2006-11-21', '2014-01-01') w.add_secondary_sensor('avhrr.n07', '1981-09-01', '1985-02-01') w.add_secondary_sensor('avhrr.n08', '1983-05-04', '1985-10-03') w.add_secondary_sensor('avhrr.n09', '1985-02-25', '1988-11-07') w.add_secondary_sensor('avhrr.n10', '1986-11-17', '1991-09-17') w.add_secondary_sensor('avhrr.n11', '1988-11-08', '1994-09-14') #w.add_secondary_sensor('avhrr.n12', '1991-09-16', '1998-12-15') #w.add_secondary_sensor('avhrr.n14', '1995-01-01', '2000-01-01') #w.add_secondary_sensor('avhrr.n15', '1998-10-26', '2003-04-09') #w.add_secondary_sensor('avhrr.n15', '2003-12-21', '2011-01-01') #w.add_secondary_sensor('avhrr.n16', '2001-01-01', '2003-04-09') #w.add_secondary_sensor('avhrr.n16', '2003-12-21', '2011-01-01') #w.add_secondary_sensor('avhrr.n17', '2002-07-10', '2003-04-09') #w.add_secondary_sensor('avhrr.n17', '2003-12-21', '2010-10-01') #w.add_secondary_sensor('avhrr.n18', '2005-06-05', '2014-01-01') #w.add_secondary_sensor('avhrr.n19', '2009-02-06', '2014-01-01') #w.add_secondary_sensor('avhrr.m02', '2006-11-21', '2014-01-01') w.set_samples_per_month(40000000) w.run(mmdtype, hosts=[('localhost', 48)], selected_only=True)
# w.add_primary_sensor('avhrr.n10', '1986-11-17', '1991-09-17') # w.add_primary_sensor('avhrr.n11', '1988-11-08', '1995-01-01') # w.add_primary_sensor('avhrr.n12', '1991-09-16', '1998-12-15') # w.add_primary_sensor('avhrr.n14', '1995-01-01', '2002-10-08') # w.add_primary_sensor('avhrr.n15', '1998-10-26', '2013-01-01') # w.add_primary_sensor('avhrr.n16', '2001-01-01', '2013-01-01') # w.add_primary_sensor('avhrr.n17', '2002-06-25', '2013-01-01') # w.add_primary_sensor('avhrr.n18', '2005-05-20', '2015-12-01') # w.add_primary_sensor('avhrr.n19', '2009-02-07', '2015-12-01') # w.add_primary_sensor('avhrr.m02', '2006-10-30', '2015-12-01') # this one does the after-failure-processing 2016-03-09 #w.add_primary_sensor('avhrr.n14', '1995-01-01', '2002-10-08') #w.add_primary_sensor('avhrr.n15', '2006-12-01', '2013-01-01') #w.add_primary_sensor('avhrr.n16', '2006-01-01', '2013-01-01') #w.add_primary_sensor('avhrr.n17', '2005-12-01', '2013-01-01') #w.add_primary_sensor('avhrr.n18', '2005-11-01', '2015-12-01') #w.add_primary_sensor('avhrr.n19', '2009-02-07', '2015-12-01') #w.add_primary_sensor('avhrr.m02', '2006-10-30', '2015-12-01') # this one does the after-failure-processing 2016-04-15 #w.add_primary_sensor('avhrr.n15', '2010-04-01', '2013-01-01') #w.add_primary_sensor('avhrr.n16', '2010-11-01', '2013-01-01') #w.add_primary_sensor('avhrr.n17', '2010-10-01', '2013-01-01') #w.add_primary_sensor('avhrr.n18', '2011-01-01', '2015-12-01') #w.add_primary_sensor('avhrr.n19', '2011-01-01', '2015-12-01') #w.add_primary_sensor('avhrr.m02', '2011-01-01', '2015-12-01') w.set_samples_per_month(0) w.run(mmdtype, hosts=[('localhost', 8)], calls=[('sampling-start.sh', 1), ('coincidence-start.sh', 1)], with_history=True)
if self.arg == 'True': self.zotquery.update_clone() self.zotquery.update_json() return 0 update, spot = self.zotquery.is_fresh() if update: if spot == 'Clone': self.zotquery.update_clone() elif spot == 'JSON': self.zotquery.update_json() return 0 #----------------------------------------------------------------------------- # Main Script #----------------------------------------------------------------------------- def main(wf): """Accept Alfred's args and pipe to workflow class""" argv = docopt(config.__usage__, argv=wf.args, version=config.__version__) log.info(wf.args) pd = ZotWorkflow(wf) res = pd.run(argv) if res: print(res) if __name__ == '__main__': sys.exit(WF.run(main))
# -*-coding:utf-8 -*- # Created date: 2021-05-02 # @Author : Shuang Song # @Contact : [email protected] # GitHub : https://github.com/SongshGeo # Research Gate: https://www.researchgate.net/profile/Song_Shuang9 import sys from datetime import date from workflow import Workflow reload(sys) sys.setdefaultencoding("utf-8") def main(wf): # Get query from Alfred query = wf.args[0] d = date.today().strftime("%Y-%m-%d") text = """创建日期: %s\n中译:\n变体:""" % d with open(query, 'w') as markdown_file: markdown_file.write(text) markdown_file.close() pass if __name__ == u"__main__": workflow = Workflow() sys.exit(workflow.run(main))
from workflow import Period from workflow import Workflow usecase = 'mms6b' mmdtype = 'mmd6' w = Workflow(usecase, Period('2012-07-02', '2015-01-01')) w.add_primary_sensor('amsr2', '2012-07-02', '2015-04-01') w.set_samples_per_month(3000000) w.run(mmdtype, hosts=[('localhost', 24)], calls=[('sampling-start.sh', 1), ('coincidence-start.sh', 2), ('sub-start.sh', 2), ('mmd-start.sh', 2)], with_history=True, without_arc=True)
if request_token: try: user_credentials = Pocket.get_credentials( consumer_key=config.CONSUMER_KEY, code=request_token) WF.save_password('pocket_access_token', user_credentials['access_token']) # We don't need the cache anymore. Clear it for security reasons WF.clear_cache() except RateLimitException: WF.logger.error('RateLimitException') def refresh_list(): # pragma: no cover if not is_running('pocket_refresh'): cmd = ['/usr/bin/python', WF.workflowfile('pocket_refresh.py')] run_in_background('pocket_refresh', cmd) def get_icon(name): name = '%s-dark' % name if is_dark() else name return 'icons/%s.png' % name def is_dark(): rgb = [int(x) for x in WF.alfred_env['theme_background'][5:-6].split(',')] return (0.299 * rgb[0] + 0.587 * rgb[1] + 0.114 * rgb[2]) / 255 < 0.5 if __name__ == '__main__': WF.run(main) # pragma: no cover
for item in res['web']: wf.add_item( title = ', '.join(item['value']), subtitle = item['key'], copytext = ', '.join(item['value']), arg = ', '.join(item['value']), valid = True, ) else: wf.add_item( title = errorInfo[str(error_code)], subtitle = wf.args[0], ) except urllib2.URLError: wf.add_item( title = u'网络异常', subtitle = u'请检查网络设置', ) except: wf.add_item( title = u'未知错误', subtitle = u'未知错误', ) finally: wf.send_feedback() if __name__ == '__main__': wf = Workflow() sys.exit(wf.run(translate))
hipchat_search = wflw.cached_data('alfred-hipchat', wrapper, max_age=wflw.settings['cache_max_age']) if query: hipchat_search = wflw.filter(query, hipchat_search, key=search_hipchat_names, min_score=20) if hipchat_search: for item in hipchat_search: wflw.add_item( title=item['name'], subtitle=item['description'], arg=json.dumps(item), valid=True ) wflw.send_feedback() if __name__ == u"__main__": WF = Workflow() if 'api_url' not in WF.settings: WF.settings['api_url'] = "https://api.hipchat.com" if 'timeout' not in WF.settings: WF.settings['timeout'] = 5 if 'cache_max_age' not in WF.settings: WF.settings['cache_max_age'] = 180 sys.exit(WF.run(main))
def _parse_args(self): """Parse command-line arguments with argparse""" parser = ArgumentParser() parser.add_argument( 'action', choices=('search', 'config', 'edit_client_rules', 'setclient', 'toggle', 'compose', 'reload', 'update', 'help')) parser.add_argument('query', nargs='?', default='') return parser.parse_args(self.wf.args) if __name__ == '__main__': wf = Workflow( update_settings=UPDATE_SETTINGS, default_settings=DEFAULT_SETTINGS, # libraries=[os.path.join(os.path.dirname(__file__), 'libs')], ) # wf.magic_prefix = 'wf:' log = wf.logger app = MailToApp() sys.exit(wf.run(app.run))
def get_all_files(root_dir): for lists in os.listdir(root_dir): path = os.path.join(root_dir, lists) if os.path.isdir(path): get_all_files(path) else: ALL_FILES.append(path) def upload_file(wf): count = 0 q = Auth(access_key, secret_key) get_all_files(PATH) for f_path in ALL_FILES: key = f_path[len(PATH):] token = q.upload_token(bucket_name, key, 3600) put_file(token, key, f_path) count += 1 wf.add_item('删除 %s 个旧文件' % DELETE_COUNT) wf.add_item('成功上传 %s 个文件' % count) wf.send_feedback() if __name__ == '__main__': clear_qiniu() wf = Workflow() sys.exit(wf.run(upload_file))
from workflow import Workflow usecase = 'mms12' mmdtype = 'mmd12' w = Workflow(usecase) w.add_primary_sensor('avhrr_f.m01', '2012-12-13', '2016-01-04') w.add_primary_sensor('avhrr_f.m02', '2007-03-01', '2016-01-04') w.set_samples_per_month(0) w.run(mmdtype, hosts=[('localhost', 8)], calls=[('sampling-start.sh', 1), ('coincidence-start.sh', 1)], with_history=True)
action, vault_id = wf.args else: vault_id = None if vault_id == "lpass-cli_login": subprocess.check_output('/usr/bin/osascript TerminalLoginLaunch', shell=True) sys.exit(1) processed_info = dict() lp_show = '/usr/local/bin/lpass show {}'.format(vault_id) raw_info = subprocess.check_output(lp_show, shell=True) for row in raw_info.split('\n'): try: if "Username:"******"Username"] = row.split("Username:"******"Password" in row: processed_info["Password"] = row.split("Password:"******"__main__": wf = Workflow() sys.exit(wf.run(parse_arguments))
# Delete argument cache file os.unlink(argcache) pidfile = _pid_file(name) # Fork to background _background() # Write PID to file with open(pidfile, 'wb') as file: file.write('{}'.format(os.getpid())) # Run the command try: log.debug('Task `{}` running'.format(name)) log.debug('cmd : {!r}'.format(args)) retcode = subprocess.call(args, **kwargs) if retcode: log.error('Command failed with [{}] : {!r}'.format(retcode, args)) finally: if os.path.exists(pidfile): os.unlink(pidfile) log.debug('Task `{}` finished'.format(name)) if __name__ == '__main__': # pragma: no cover wf.run(main)
#!/usr/bin/python # encoding: utf-8 # # Copyright (c) 2016 Dean Jackson <*****@*****.**> # # MIT Licence. See http://opensource.org/licenses/MIT # # Created on 2016-07-9 # """ """ from __future__ import print_function, unicode_literals, absolute_import import sys from workflow import Workflow log = None def main(wf): """Do nothing.""" log.debug('datadir=%r', wf.datadir) if __name__ == '__main__': wf = Workflow() log = wf.logger sys.exit(wf.run(main))
raise KeyError('Bundle ID unknown : {}'.format(bid)) def _split_query(self, query): if not query or not DELIMITER in query: return None, query elif query.endswith(DELIMITER): # trailing space deleted raise GoBack(query.rstrip(DELIMITER).strip()) return [s.strip() for s in query.split(DELIMITER)] def _update(self, force=False): """Update cached data""" log.debug('Updating workflow lists...') args = ['/usr/bin/python', self.wf.workflowfile('update_workflows.py')] if force: args.append('--force-update') log.debug('update command : {}'.format(args)) retcode = run_in_background('update', args) if retcode: log.debug('Update failed with code {}'.format(retcode)) print('Update failed') return 1 print('Updating workflow list…'.encode('utf-8')) return 0 if __name__ == '__main__': wf = Workflow() log = wf.logger pk = PackalWorkflow() wf.run(pk.run)
return result def main(wf): try: # Get API key from Keychain api_key = wf.get_password('gitlab_api_key') api_url = wf.settings.get('api_url', 'https://gitlab.com/api/v4/projects') # Retrieve projects from cache if available and no more than 600 # seconds old def wrapper(): return get_projects(api_key, api_url) projects = wf.cached_data('projects', wrapper, max_age=3600) # Record our progress in the log file log.debug('{} gitlab projects cached'.format(len(projects))) except PasswordNotFound: # API key has not yet been set # Nothing we can do about this, so just log it wf.logger.error('No API key saved') if __name__ == u"__main__": wf = Workflow() log = wf.logger wf.run(main)
for item in vpnList: subtitle = '(' + item['status'] + ')' + item['type'] actionArg = item['id'] + ',' + item['type'] if item['status'] == VPN_STATUS_CONNECTED: actionArg = 'off,' + actionArg else: actionArg = 'on,' + actionArg icon = ICON_ON if item['status'] == VPN_STATUS_CONNECTED else ICON_OFF workflow.add_item(title=item['name'], subtitle=subtitle, icon=icon, arg=actionArg, valid=True) workflow.send_feedback() return 0 else: # Do action to switch vpn. vpnControl, vpnId, vpnType = args.query.split(',') if vpnControl == 'on': connect(workflow, vpnId, vpnType) elif vpnControl == 'onsequence': vpnIds = vpnId.split(':') vpnTypes = vpnType.split(':') connectSequence(workflow, vpnIds, vpnTypes) else: disconnect(vpnId) return 0 if __name__=="__main__": workflow = Workflow() sys.exit(workflow.run(main))
# -*- coding: utf-8 -*- # !/usr/bin/env python3 import yaml import argparse from workflow import Workflow def __arg_parse(): parser = argparse.ArgumentParser() parser.add_argument('-c', '--config', help=' config file', required=True) return parser.parse_args() if __name__ == '__main__': args = __arg_parse() config_file = open(args.config, encoding='utf-8') configs = yaml.load(config_file) workflow = Workflow(configs) workflow.run(0)
from workflow import Workflow usecase = "mms14" mmdtype = "mmd14" w = Workflow(usecase) # the following lines define the full MMD tb 2016-08-01 # w.add_primary_sensor('atsr.3', '2002-05-20', '2012-04-09') # w.add_primary_sensor('amsre', '2002-06-01', '2011-10-05') # the following lines define the test MMD tb 2016-08-01 w.add_primary_sensor("atsr.3", "2008-05-01", "2008-06-01") w.add_secondary_sensor("amsre", "2008-05-01", "2008-06-01") w.set_samples_per_month(100000) w.run(mmdtype, hosts=[("localhost", 8)])
def execute(self): wf = Workflow() self.wf = wf self.log = wf.logger sys.exit(wf.run(self.main))
def execute(self): global LOG wf = Workflow() LOG = wf.logger sys.exit(wf.run(self.main))
phonetic_type) else '' username = sys.argv[sys.argv.index('-username') + 1] if '-username' in sys.argv else None password = sys.argv[sys.argv.index('-password') + 1] if '-password' in sys.argv else None filepath = sys.argv[sys.argv.index('-filepath') + 1] if '-filepath' in sys.argv else os.path.join( os.environ['HOME'], 'Documents/Alfred-youdao-wordbook.xml') textpath = sys.argv[sys.argv.index('-textpath') + 1] if '-textpath' in sys.argv else os.path.join( os.environ['HOME'], 'Documents/youdao-wordbook.md') m2 = hashlib.md5() m2.update(password) password_md5 = m2.hexdigest() item = { "word": params[0], "trans": params[1], "phonetic": phonetic, "tags": "Alfred", "progress": "-1", } saver = SaveWord(username, password_md5, filepath, textpath, item) wf = Workflow() sys.exit(wf.run(saver.save))
def delete_item(item_id): rdb_client = get_client(wf) try: rdb_client.delete_bookmark(item_id) return 'Link deleted' except ServerNotFoundError: return 'Connection error' def authorize(username, password): import config try: user_credentials = xauth( config.CONSUMER_KEY, config.CONSUMER_SECRET, username, password) if len(user_credentials) == 2: wf.save_password( 'readability_oauth_token', user_credentials[0]) wf.save_password( 'readability_oauth_token_secret', user_credentials[1]) return 'Workflow authorized.' except: pass return 'Authorization failed.' if __name__ == '__main__': wf = Workflow() sys.exit(wf.run(execute))
for name in names: wf.add_item("Post %s" % name, "via %s" % device, arg=name, icon=ICON_FILE_NAME, valid=True) wf.send_feedback() def main_post(wf): with open(IRKIT_CONFIG_JSON_PATH, 'r') as f: config = json.loads(f.read()) client = Client(config) name = wf.args[1] client.post_signal(name) wf.send_feedback() def config_not_found(wf): wf.add_item(u'%s is not found' % CONFIG_FILE_NAME, icon=ICON_ERROR) wf.send_feedback() if __name__ == '__main__': wf = Workflow(update_settings={ 'github_slug': 'giginet/alfred-irkit-workflow', 'version': open(os.path.join(os.path.dirname(__file__), 'version')).read(), }) args = wf.args if not os.path.exists(IRKIT_CONFIG_JSON_PATH): sys.exit(wf.run(config_not_found)) if len(args) >= 2 and args[0] == '--post': sys.exit(wf.run(main_post)) sys.exit(wf.run(main_search))
def add_action(wf, unit_from, unit_to, rate): try: rate = float(rate) unit_from = unit_from.upper() unit_to = unit_to.upper() table = wf.stored_data(TABLENAME) table[(unit_from, unit_to)] = rate table[(unit_to, unit_from)] = 1 / rate wf.store_data(TABLENAME, table) print('1%s = %s%s' % (unit_from, number_to_string(rate), unit_to), file=sys.stdout) print('1%s = %s%s' % (unit_to, number_to_string(1/rate), unit_from), file=sys.stdout) sys.stdout.flush() except ValueError: pass def main(wf): query0 = wf.args[0] if 'add' in query0: [_, unit_from, unit_to, rate] = query0.split(',') add_action(wf, unit_from, unit_to, rate) if __name__ == '__main__': wf = Workflow() exited = wf.run(main) sys.exit(exited)
parts = urlparse.urlsplit(clipboard) if not parts.scheme or not parts.netloc: return None return {'url': clipboard, 'title': None} def add_link(item, tags): if item: try: return POCKET.add(url=item['url'], title=item['title'], tags=','.join(tags))[0] except InvalidQueryException: pass return None def add_and_archive_link(link, tags): result = add_link(link, tags) if (not result or 'status' not in result or 'item' not in result or 'item_id' not in result['item']): WF.logger.debug(result) return False POCKET.archive(result['item']['item_id'], wait=False) return True if __name__ == '__main__': WF.run(main)
if len(actions) > 0: for action in actions: wf.add_item(action['name'], action['description'], uid=action['name'], autocomplete=action['autocomplete'], arg=action['arg'], valid=action['valid'], icon=helpers.get_icon(wf, 'chevron-right')) else: wf.add_item('No action found for "%s"' % query, autocomplete='', icon=helpers.get_icon(wf, 'info')) if len(wf._items) == 0: query_name = query[query.find(' ') + 1:] wf.add_item('No formula found for "%s"' % query_name, autocomplete='%s ' % query[:query.find(' ')], icon=helpers.get_icon(wf, 'info')) wf.send_feedback() # refresh cache cmd = ['/usr/bin/python', wf.workflowfile('brew_refresh.py')] run_in_background('brew_refresh', cmd) if __name__ == '__main__': wf = Workflow(update_settings={'github_slug': GITHUB_SLUG}) sys.exit(wf.run(main))
def main(wf): url = 'http://127.0.0.1:50761/api/list' r = web.get(url) # throw an error if request failed # Workflow will catch this and show it to the user r.raise_for_status() # Parse the JSON returned by pinboard and extract the posts result = r.json() items = result['data'] # Loop through the returned posts and add an item for each to # the list of results for Alfred for item in items: on = item.get('on', False) wf.add_item(title=item['title'], subtitle=get_subtitle(item), arg=item['id'], valid=True, icon='on.png' if on else 'off.png') # Send the results to Alfred as XML wf.send_feedback() if __name__ == '__main__': my_wf = Workflow() sys.exit(my_wf.run(main))