Public: Trigger step

 step          - Step Hash.
 input         - Input Hash.
 output        - Output Hash.
 output_by_tag - Output by tag Hash.

 Returns output Hash.
761715
def trigger_step(step, input, output, output_by_tag)
      arguments = step['arguments'] || {}

      # TODO: Move to a normal object: TriggerArgument
      step['arguments'] = transform_arguments(arguments, output, input)
      step['arguments'] = add_config_argument(arguments)

      # TODO: Move to a normal object: TriggerArgument
      output = plugin_manager.action_from_step(step)
      output_by_tag[step['tag']] = output if step.key? 'tag'

      output.merge(output_by_tag)
    end
325566
def on_step_end(self, **kwargs):
        ""
        if not self.learn.gan_trainer.gen_mode: self.learn.opt.lr /= self.mult_lr
686735
def step(steps = 1)
      steps.times do
        @instruction = Instruction.new(@memory.read(@PC))
        @PC += 1

        op  = @instruction.op
        a   = get_operand(@instruction.a)
        b   = get_operand(@instruction.b) if @instruction.b

        if @skip
          @skip = false
        else
          if b # Basic Instruction
            result = self.send(op, a.value, b.value)
          else # Non-Basic Instruction
            result = self.send(op, a.value)
          end
          a.write(result) if result
        end

        # Notify observers
        changed
        notify_observers(self)
      end
    end
970833
def step limit, step=1
      return to_enum(:step, limit, step) unless block_given?

      date = self
      comp_op = %w(== <= >=)[step <=> 0]
      while date.send comp_op, limit
        yield date
        date += step
      end
      self
    end
172080
def run_step(self, rewriter):
        
        assert rewriter, ("FileRewriter instance required to run "
                          "FileInRewriterStep.")
        rewriter.files_in_to_out(in_path=self.path_in, out_path=self.path_out)
945996
def on_step_begin(self, step, logs={}):
        
        for callback in self.callbacks:
            # Check if callback supports the more appropriate `on_step_begin` callback.
            # If not, fall back to `on_batch_begin` to be compatible with built-in Keras callbacks.
            if callable(getattr(callback, 'on_step_begin', None)):
                callback.on_step_begin(step, logs=logs)
            else:
                callback.on_batch_begin(step, logs=logs)
141197
def _get_step_inout(step):
    
    inputs = []
    outputs = []
    prescatter = collections.defaultdict(list)
    remapped = {}
    assert step.outputs_record_schema["type"] == "record"
    output_names = set([])
    for outp in step.outputs_record_schema["fields"]:
        outputs.append({"id": outp["name"]})
        output_names.add(outp["name"])
    assert step.inputs_record_schema["type"] == "record"
    for inp in step.inputs_record_schema["fields"]:
        source = inp["source"].split("#")[-1].replace("/", ".")
        # Check if we're unpacking from a record, and unpack from our object
        if "valueFrom" in inp:
            attr_access = "['%s']" % inp["name"]
            if inp["valueFrom"].find(attr_access) > 0:
                source += ".%s" % inp["name"]
                if isinstance(inp["type"], dict) and isinstance(inp["type"].get("items"), dict):
                    if inp["type"]["items"].get("type") == "array" and "inputBinding" in inp["type"]:
                        source, prescatter = _unpack_object_array(inp, source, prescatter)
        # Avoid clashing input and output names, WDL requires unique
        if inp["name"] in output_names:
            new_name = inp["name"] + "_input"
            remapped[inp["name"]] = new_name
            inp["name"] = new_name
        inputs.append({"id": inp["name"], "value": source})
    return inputs, outputs, remapped, dict(prescatter)
129449
def run_step(self):
        """"""
        rewriter = StreamRewriter(self.context.iter_formatted_strings)
        super().run_step(rewriter)
1364832
def run_steps(node: Node, pipeline: RenderingPipeline, **args):
    """"""
    for step in pipeline.steps:
        result = step(node, pipeline=pipeline, **args)
        if isinstance(result, dict):
            args = {**args, **result}
602118
function getStep(step) {
        var template = grunt.file.read(templates.stepTemplate),
            stepTemplate;

        stepTemplate = grunt.template.process(template, {
            data: {
                status: step.result ? step.result.status : '',
                errorDetails: step.result ? toHtmlEntities(step.result.error_message) : '',
                duration: step.result.duration ? calculateDuration(step.result.duration) : 'no data',
                tableOutline: (step.arguments && step.arguments.length > 0) ? step.arguments[0].rows : step.rows,
                name: step.keyword + (step.name ? step.name : '')
            }
        });
        return stepTemplate;
    }
1013033
def step(self, **args):
        
        if self.verbosity > 0:
            print("Network.step() called with:", args)
        # First, copy the values into either activations or targets:
        retargs = self.preStep(**args)
        if retargs: args = retargs # replace the args
        # Propagate activation through network:
        self.propagate(**args)
        retargs = self.postPropagate(**args)
        if retargs: args = retargs # replace the args
        # Next, take care of any Auto-association, and copy
        # activations to targets
        for aa in self.association:
            (inName, outName) = aa
            inLayer = self.getLayer(inName)
            if inLayer.type not in ['Input', "Hidden"]:
                raise LayerError('Associated input layer not type \'Input\' or \'Hidden\'.', \
                                   inLayer.type)
            outLayer = self.getLayer(outName)
            if not outLayer.type == 'Output':
                raise LayerError('Associated output layer not type \'Output\'.', \
                                   outLayer.type)
            outLayer.copyTargets(inLayer.activation)
        # Compute error, and back prop it:
        retargs = self.preBackprop(**args)
        if retargs: args = retargs # replace the args
        (error, correct, total, pcorrect) = self.backprop(**args) # compute_error()
        if self.verbosity > 2 or self.interactive:
            self.display()
            if self.interactive:
                self.prompt()
        retargs = self.postBackprop(**args)
        if retargs: args = retargs # replace the args
        # if learning is true, and need to update weights here:
        if self.learning and not self.batch:
            self.change_weights() # else change weights in sweep
        retargs = self.postStep(**args)
        if retargs: args = retargs # replace the args
        self.reportPattern()
        return (error, correct, total, pcorrect)
1090909
def to_drake_step(inputs, output):
    
    i = [output._yaml_filename]
    i.extend(map(lambda i: i._target_filename, list(inputs)))
    i.extend(output.dependencies)

    # add source file of output and its non-target inputs
    # if they're not in the drain library
    objects = get_inputs(output, target=False)
    objects.add(output)
    sources = set([os.path.abspath(inspect.getsourcefile(o.__class__)) for o in objects])
    i.extend([s for s in sources if not s.startswith(os.path.dirname(__file__))])

    output_str = '%' + output.__class__.__name__
    if output.name:
        output_str += ', %' + output.name
    if output.target:
        output_str += ', ' + os.path.join(output._target_filename)
    return '{output} <- {inputs} [method:drain]\n\n'.format(
            output=output_str, inputs=str.join(', ', i))
1106840
def _step(self):
        

        # Pull and check data
        input_bag = self._get()

        # Sent through the stack
        results = self._stack(input_bag)

        # self._exec_time += timer.duration
        # Put data onto output channels

        if isinstance(results, GeneratorType):
            while True:
                try:
                    # if kill flag was step, stop iterating.
                    if self._killed:
                        break
                    result = next(results)
                except StopIteration:
                    # That's not an error, we're just done.
                    break
                else:
                    # Push data (in case of an iterator)
                    self._put(self._cast(input_bag, result))
        elif results:
            # Push data (returned value)
            self._put(self._cast(input_bag, results))
        else:
            # case with no result, an execution went through anyway, use for stats.
            # self._exec_count += 1
            pass
1013592
def run_step(self):
        """"""
        formatted_replacements = self.context.get_formatted_iterable(
            self.replace_pairs)

        iter = StreamReplacePairsRewriterStep.iter_replace_strings(
            formatted_replacements)
        rewriter = StreamRewriter(iter)
        super().run_step(rewriter)
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
563302
def starting_step(x, step_width)
      if (x % step_width) == 0
        x
      else
        x - (x % step_width) + step_width
      end
    end
742243
def run(self, steps=None):
        
        try:
            while self.instruction_pointer < len(self.code):
                self.step()

                if steps is not None:
                    steps -= 1
                    if steps == 0:
                        break
        except StopIteration:
            pass
        except EOFError:
            pass
        return self