Python Workflow.run方法代码示例

# 需要导入模块: from workflow import Workflow [as 别名]
# 或者: from workflow.Workflow import run [as 别名]
    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())

# 需要导入模块: from workflow import Workflow [as 别名]
# 或者: from workflow.Workflow import run [as 别名]
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()

# 需要导入模块: from workflow import Workflow [as 别名]
# 或者: from workflow.Workflow import run [as 别名]
    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')

# 需要导入模块: from workflow import Workflow [as 别名]
# 或者: from workflow.Workflow import run [as 别名]
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

# 需要导入模块: from workflow import Workflow [as 别名]
# 或者: from workflow.Workflow import run [as 别名]
    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')

# 需要导入模块: from workflow import Workflow [as 别名]
# 或者: from workflow.Workflow import run [as 别名]
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))

# 需要导入模块: from workflow import Workflow [as 别名]
# 或者: from workflow.Workflow import run [as 别名]
    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))

# 需要导入模块: from workflow import Workflow [as 别名]
# 或者: from workflow.Workflow import run [as 别名]
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)
        )

# 需要导入模块: from workflow import Workflow [as 别名]
# 或者: from workflow.Workflow import run [as 别名]
                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))

# 需要导入模块: from workflow import Workflow [as 别名]
# 或者: from workflow.Workflow import run [as 别名]
 def execute(self):
     wf = Workflow()
     self.wf = wf
     self.log = wf.logger
     sys.exit(wf.run(self.main))

# 需要导入模块: from workflow import Workflow [as 别名]
# 或者: from workflow.Workflow import run [as 别名]
        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))

# 需要导入模块: from workflow import Workflow [as 别名]
# 或者: from workflow.Workflow import run [as 别名]
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 Workflow [as 别名]
# 或者: from workflow.Workflow import run [as 别名]
#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)

# 需要导入模块: from workflow import Workflow [as 别名]
# 或者: from workflow.Workflow import run [as 别名]
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)

# 需要导入模块: from workflow import Workflow [as 别名]
# 或者: from workflow.Workflow import run [as 别名]
    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)