The same as calling ``client.getInstructions(build.setID)``

        :returns: A list of instructions.
        :rtype: list
978315
def getInstructions(self):
        '''
        
        '''

        self._instructions = self._client.getInstructions(self.setID)
        return self._instructions
379785
def context_structure(self):
        
        instructions = []
        last_context = Context()
        for instr in self.structure:
            instruction_type = instr['instruction']
            if instruction_type == "FROM":  # reset per stage
                last_context = Context()

            context = Context(envs=dict(last_context.envs),
                              labels=dict(last_context.labels))

            if instruction_type in ["ENV", "LABEL"]:
                val = get_key_val_dictionary(instruction_value=instr['value'],
                                             env_replace=self.env_replace,
                                             envs=last_context.envs)
                context.set_line_value(context_type=instruction_type, value=val)

            instructions.append(context)
            last_context = context
        return instructions
618342
def execute_lite(self, instructions, context=None):
        
        if context:
            self.__cpu.registers = dict(context)

        for instr in instructions:
            self.__execute_one(instr)

        return dict(self.__cpu.registers), self.__mem
609262
def get_build_env(self):
        
        try:
            return self._memo['get_build_env']
        except KeyError:
            pass

        # Create the build environment instance with appropriate
        # overrides.  These get evaluated against the current
        # environment's construction variables so that users can
        # add to existing values by referencing the variable in
        # the expansion.
        overrides = {}
        for odict in self.overridelist:
            overrides.update(odict)

        import SCons.Defaults
        env = self.env or SCons.Defaults.DefaultEnvironment()
        build_env = env.Override(overrides)

        self._memo['get_build_env'] = build_env

        return build_env
826297
def outputs(self_):
        
        outputs = {}
        for cls in classlist(self_.cls):
            for name in dir(cls):
                method = getattr(self_.self_or_cls, name)
                dinfo = getattr(method, '_dinfo', {})
                if 'outputs' not in dinfo:
                    continue
                for override, otype, idx in dinfo['outputs']:
                    if override is not None:
                        name = override
                    outputs[name] = (otype, method, idx)
        return outputs
1242217
def cmd(self):
        
        value = None
        for insndesc in self.structure:
            if insndesc['instruction'] == 'FROM':  # new stage, reset
                value = None
            elif insndesc['instruction'] == 'CMD':
                value = insndesc['value']
        return value
1088931
async def list(self, setname=None):
        
        args = ['list']

        if setname is not None:
            args.append(setname)

        return await self.start(__class__.CMD, *args)
996789
def get_bindings(self):
        
        path = Client.urls['all_bindings']
        bindings = self._call(path, 'GET')
        return bindings
734546
private void addProjectMethods(final List<Instruction> instructions, final Set<ProjectMethod> projectMethods) {
        Set<MethodIdentifier> projectMethodIdentifiers = findUnhandledProjectMethodIdentifiers(instructions, projectMethods);

        for (MethodIdentifier identifier : projectMethodIdentifiers) {
            // TODO cache results -> singleton pool?

            final MethodResult methodResult = visitProjectMethod(identifier);
            if (methodResult == null) {
                continue;
            }

            final List<Instruction> nestedMethodInstructions = interpretRelevantInstructions(methodResult.getInstructions());
            projectMethods.add(new ProjectMethod(identifier, nestedMethodInstructions));
            addProjectMethods(nestedMethodInstructions, projectMethods);
        }
    }
1151274
def __process_instructions(self, inst):
        ""
        to_send = []
        for cmd, msg, com in inst:
            if cmd not in config.CMDS:  # ignore if it is not legal
                continue
            if cmd == 'MSG':
                if self.mode == 's':
                    to_send.append((msg, com))
                if self.color:
                    txt = config.Col.BOLD + msg + config.Col.ENDC
                else:
                    txt = msg
                print(txt)
                if self.issue_alert:
                    os.system(self.alert)
            elif cmd == 'QUIT':
                if self.mode == 's':  # client quit
                    com.close()
                    with self.__client_list_lock:
                        self.clients.remove(com)
                else:  # server quit
                    self.__s.close()
                    self.__make_client()  # wait for new server
            elif cmd == 'ASSUME':
                if self.mode == 'c':  # assume a server role if client
                    self.__s.close()
                    self.__make_server()
        for msg, sender in to_send:
            if self.mode == 'c':
                utils.msg(msg, self.__s)
            else:
                with self.__client_list_lock:
                    for com in self.clients:
                        if com == sender:
                            continue
                        utils.msg(msg, com)
834428
def to_help(self):
        
        result = []
        result.append(self.classname)
        result.append("=" * len(self.classname))
        result.append("")
        result.append("DESCRIPTION")
        result.append("")
        result.append(self.global_info())
        result.append("")
        result.append("OPTIONS")
        result.append("")
        options = javabridge.call(self.jobject, "listOptions", "()Ljava/util/Enumeration;")
        enum = javabridge.get_enumeration_wrapper(options)
        while enum.hasMoreElements():
            opt = Option(enum.nextElement())
            result.append(opt.synopsis)
            result.append(opt.description)
            result.append("")
        return '\n'.join(result)
516431
def instruction_list_to_easm(instruction_list: list) -> str:
    
    result = ""

    for instruction in instruction_list:
        result += "{} {}".format(instruction["address"], instruction["opcode"])
        if "argument" in instruction:
            result += " " + instruction["argument"]
        result += "\n"

    return result
1116231
def fullData(master):
    

    builders = []
    for b in master.config.builders:
        steps = []
        for step in b.factory.steps:
            steps.append(getName(step))
        builders.append(steps)
    return {'builders': builders}
589210
def build_plans(self):
        
        if not self.__build_plans:
            self.__build_plans = BuildPlans(self.__connection)
        return self.__build_plans
506151
private void extractInstructions(InstructionGroup group) {
        for (InstructionGraphNode node : group.getNodes()) {
            if (node != group.getRoot()) {
                AbstractInsnNode insn = node.getInstruction();
                method.instructions.remove(insn);
                group.getInstructions().add(insn);
            }
        }
    }
398258
def get_cmdclass():
    '''
    
    '''
    ret = {}
    cfg = __get_config()
    if cfg is None:
        return
    mapdict = {
        'build': CustomBuild,
        'build_clib': CustomBuildCLib,
        'build_ext': CustomBuildExt,
        'build_py': CustomBuildPy,
        'build_scripts': CustomBuildScripts,
        'install': CustomInstall,
        'install_data': CustomInstallData,
        'install_headers': CustomInstallHeaders,
        'install_lib': CustomInstallLib,
        'install_scripts': CustomInstallScripts,
    }
    for step in cfg.keys():
        if step in mapdict:
            ret[step] = mapdict[step]
    return ret
109958
def get_methods(self):
        
        return [
            ("levels", self.print_levels),
            ("make", self.make_report),
            ("clear", self.clear_report),
            ("show", self.show_report),
            ("write", self.write_report),
        ]