def buildBid(self, command, tokens, index):
        """
        bid control tasker [tasker ...] [at period]
        bid control [me] [at period]
        bid control all [at period]

        control:
           (stop, start, run, abort, ready)

        tasker:
           (tasker, me, all)

        period:
            number
            indirectOne

        indirectOne:
            sharepath [of relative]
            (field, value) in sharepath [of relative]

        """
        self.verifyCurrentContext(tokens, index) #currentStore, currentFramer, currentFrame exist

        try:
            period = None  # no period provided
            sourcePath = None
            sourceField = None
            parms = odict([('taskers', []), ('period', None), ('sources', odict())])
            control = tokens[index]
            index +=1
            if control not in ['start', 'run', 'stop', 'abort', 'ready']:
                msg = "Error building {0}. Bad control = {1}.".format(command, control)
                raise excepting.ParseError(msg, tokens, index)

            taskers = []
            while index < len(tokens):
                if (tokens[index] in ['at']):
                    break  # end of taskers so do not eat yet

                tasker = tokens[index]
                index +=1

                self.verifyName(tasker, command, tokens, index)
                taskers.append(tasker) #resolve later

            if not taskers:
                taskers.append('me')

            while index < len(tokens):  # at option
                connective = tokens[index]
                index += 1

                if connective in ['at']:
                    # parse period direct or indirect
                    try:  #parse direct
                        period = max(0.0, Convert2Num(tokens[index]))  # period is number
                        index += 1  # eat token

                    except __HOLE__:  # parse indirect
                        sourceField, index = self.parseField(tokens, index)
                        sourcePath, index =  self.parseIndirect(tokens, index)

                else:
                    msg = ("Error building {0}. Invalid connective"
                          " '{1}'.".format(command, connective))
                    raise excepting.ParseError(msg, tokens, index)

            actorName = 'Want' + control.capitalize()
            if actorName not in wanting.Want.Registry:
                msg = "Error building  %s. No actor named %s." % (command, actorName)
                raise excepting.ParseError(msg, tokens, index)

            parms['taskers'] = taskers #resolve later
            parms['period'] = period
            parms['source'] = sourcePath
            parms['sourceField'] = sourceField
            act = acting.Act(   actor=actorName,
                                registrar=wanting.Want,
                                parms=parms,
                                human=self.currentHuman,
                                count=self.currentCount)

        except IndexError:
            msg = "Error building %s. Not enough tokens." % (command,)
            raise excepting.ParseError(msg, tokens, index)

        if index != len(tokens):
            msg = "Error building %s. Unused tokens." % (command,)
            raise excepting.ParseError(msg, tokens, index)

        context = self.currentContext
        if context == NATIVE:
            context = ENTER #what is native for this command

        if not self.currentFrame.addByContext(act, context):
            msg = "Error building %s. Bad context '%s'." % (command, context)
            raise excepting.ParseError(msg, tokens, index)

        console.profuse("     Added {0} want '{1}' with parms '{2}'\n".format(
            ActionContextNames[context], act.actor, act.parms))

        return True
dataset/ETHPy150Open ioflo/ioflo/ioflo/base/building.py/Builder.buildBid