Create a workflow execution item for a plugin step.
343904
public static StepExecutionItem createPluginStepItem(
            final String type,
            final Map configuration,
            final boolean keepgoingOnSuccess,
            final StepExecutionItem handler, final String label
    )
    {
        return createPluginStepItem(type, configuration, keepgoingOnSuccess, handler, label, null);
    }
403498
def set_step_items(glob):
    
    a = glob['args']
    l = glob['logger']
    enabled = getattr(a, a._collisions.get("step") or "step", False)
    # Step context manager, for defining a block of code that can be paused at
    #  its start and end
    class Step(object):
        def __init__(self, message=None, at_end=False):
            self.message = message
            self.at_end = at_end
            
        def __enter__(self):
            if enabled:
                if self.message:
                    l.step(self.message)
                if not self.at_end:
                    std_input("Press enter to continue", {'color': STEP_COLOR,
                                                          'bold': True})
                return self
        
        def __exit__(self, *args):
            if enabled and self.at_end:
                std_input("Press enter to continue", {'color': STEP_COLOR,
                                                      'bold': True})
    glob['Step'] = Step
    # stepping function, for stopping the execution and displaying a message if
    #  any defined
    def step(message=None):
        if enabled:
            if message:
                l.step(message)
            std_input("Press enter to continue", {'color': STEP_COLOR,
                                                  'bold': True})
    glob['step'] = step
357392
def execute_all(self):
        
        for workflow_id in self.workflows:
            if self.workflows[workflow_id].online:
                for interval in self.workflows[workflow_id].requested_intervals:
                    logging.info("Executing workflow {} over interval {}".format(workflow_id, interval))
                    self.workflows[workflow_id].execute(interval)
851334
def add_jobflow_steps(self, jobflow_id, steps):
        
        if type(steps) != types.ListType:
            steps = [steps]
        params = {}
        params['JobFlowId'] = jobflow_id

        # Step args
        step_args = [self._build_step_args(step) for step in steps]
        params.update(self._build_step_list(step_args))

        return self.get_object(
            'AddJobFlowSteps', params, RunJobFlowResponse, verb='POST')
1282564
def execute(self):
        
        stack = self._stack
        callbacks = self._callbacks
        self._stack = []
        self._callbacks = []

        deferred = []

        build = self._nested_future

        pipe = self._pipeline(self.connection_name)
        for item, args, kwargs, ref in stack:
            f = getattr(pipe, item)
            deferred.append(build(f(*args, **kwargs), ref))

        inject_callbacks = getattr(self.parent, '_inject_callbacks')
        inject_callbacks(deferred + callbacks)
1348759
def global_workflow_run(name_or_id, alias=None, input_params={}, always_retry=True, **kwargs):
    
    input_params_cp = Nonce.update_nonce(input_params)
    fully_qualified_version = name_or_id + (('/' + alias) if alias else '')
    return DXHTTPRequest('/%s/run' % fully_qualified_version, input_params_cp, always_retry=always_retry, **kwargs)
620266
def execute(self, resource, **kw):
        
        params = kw.pop('params', {})
        json = kw.pop('json', None)
        task = self.make_request(
            TaskRunFailed,
            method='create',
            params=params,
            json=json,
            resource=resource)

        timeout = kw.pop('timeout', 5)
        wait_for_finish = kw.pop('wait_for_finish', True)
        
        return TaskOperationPoller(
            task=task, timeout=timeout,
            wait_for_finish=wait_for_finish,
            **kw)
502164
public function ExecuteStep()
    {
        if ($this->ProcessStep()) {
            $this->ProcessStepSuccessHook();
            $oBasket = TShopBasket::GetInstance();
            $oBasket->aCompletedOrderStepList[$this->fieldSystemname] = true;
            $oNextStep = $this->GetNextStep();
            $this->JumpToStep($oNextStep);
        }
    }
142149
def create(handler, item_document):
    """"""
    data = {'operation': 'create',
            'item': json.load(item_document)}
    handler.invoke(data)
129350
def _execute_workflow(cls, process_args):
        
        workflow, input_args, log_path = process_args

        if log_path:
            logger = logging.getLogger()
            logger.setLevel(logging.DEBUG)
            handler = cls._get_log_handler(log_path)
            logger.addHandler(handler)

        stats = {'start_time': dt.datetime.now()}
        try:
            _ = workflow.execute(input_args, monitor=True)
        except BaseException:
            stats['error'] = traceback.format_exc()
        stats['end_time'] = dt.datetime.now()

        if log_path:
            handler.close()
            logger.removeHandler(handler)

        return stats
963080
def save(self, fname, mode=None, validate=True, wd=False, inline=False,
             relative=True, pack=False, encoding='utf-8'):
        
        super(WorkflowGenerator, self).save(fname,
                                            mode=mode,
                                            validate=validate,
                                            wd=wd,
                                            inline=inline,
                                            relative=relative,
                                            pack=pack,
                                            encoding=encoding)
238095
def execute(self):
        """"""
        self._collect_garbage()  # Make sure everything is clean
        # TODO (john): Check if dataflow has any 'logical inconsistencies'
        # For example, if there is a forward partitioning strategy but
        # the number of downstream instances is larger than the number of
        # upstream instances, some of the downstream instances will not be
        # used at all

        # Each operator instance is implemented as a Ray actor
        # Actors are deployed in topological order, as we traverse the
        # logical dataflow from sources to sinks. At each step, data
        # producers wait for acknowledge from consumers before starting
        # generating data.
        upstream_channels = {}
        for node in nx.topological_sort(self.logical_topo):
            operator = self.operators[node]
            # Generate downstream data channels
            downstream_channels = self._generate_channels(operator)
            # Instantiate Ray actors
            handles = self.__generate_actors(operator, upstream_channels,
                                             downstream_channels)
            if handles:
                self.actor_handles.extend(handles)
            upstream_channels.update(downstream_channels)
        logger.debug("Running...")
        return self.actor_handles
1177084
public WorkflowStrategy getStrategyForWorkflow(
            final WorkflowExecutionItem workflow,
            PropertyResolver resolver
    )
            throws ExecutionServiceException
    {

        String provider = workflow.getWorkflow().getStrategy();
        String s = builtinProviderSynonyms.get(provider);
        if (null != s) {
            provider = s;
        }
        WorkflowStrategy workflowStrategy = providerOfType(provider);
        if (null != resolver) {
            Description description = DescribableServiceUtil.descriptionForProvider(
                    true,
                    workflowStrategy
            );
            if (description != null) {
                PluginAdapterUtility.configureProperties(
                        resolver,
                        description,
                        workflowStrategy,
                        PropertyScope.Instance
                );
            }
        }
        return workflowStrategy;
    }
1025645
static function create( $workflowID, $typeString )
    {
        $row = array(
            "id" => null,
            "version" => 1,
            "workflow_id" => $workflowID,
            "workflow_type_string" => $typeString,
            "description" => "",
            "placement" => eZPersistentObject::newObjectOrder( eZWorkflowEvent::definition(),
                                                               "placement",
                                                               array( "version" => 1,
                                                                      "workflow_id" => $workflowID ) ) );
        return new eZWorkflowEvent( $row );
    }
881576
def do_execute(self):
        
        for i in range(
                int(self.resolve_option("min")),
                int(self.resolve_option("max")) + 1,
                int(self.resolve_option("step"))):
            self._output.append(Token(i))
        return None
791375
def create_global_steps():
        """"""
        global_step = tf.Variable(0, name="global_step", trainable=False, dtype=tf.int32)
        increment_step = tf.assign(global_step, tf.add(global_step, 1))
        return global_step, increment_step
1064134
def _build_pipeline(self, task):
        """"""

        self.pipeline_steps = []
        kwargs = {}
        if self.default_encoding:
            kwargs["default_encoding"] = self.default_encoding

        steps = task.get('pipeline', [])
        if steps is None:
            self.pipeline_steps = None
        else:
            if not steps:
                steps = task.get('filters', [])
                if steps:
                    util.warn_deprecated(
                        "'filters' key in config is deprecated. 'pipeline' should be used going forward."
                    )

            if not steps:
                steps.append('pyspelling.filters.text')

            for step in steps:
                # Retrieve module and module options
                if isinstance(step, dict):
                    name, options = list(step.items())[0]
                else:
                    name = step
                    options = {}
                if options is None:
                    options = {}

                module = self._get_module(name)
                if issubclass(module, filters.Filter):
                    self.pipeline_steps.append(module(options, **kwargs))
                elif issubclass(module, flow_control.FlowControl):
                    if self.pipeline_steps:
                        self.pipeline_steps.append(module(options))
                    else:
                        raise ValueError("Pipeline cannot start with a 'Flow Control' plugin!")
                else:
                    raise ValueError("'%s' is not a valid plugin!" % name)