Return an instance of the MasterControlProgram.

        :rtype: rejected.mcp.MasterControlProgram
199718
def _master_control_program(self):
        
        return mcp.MasterControlProgram(self.config,
                                        consumer=self.args.consumer,
                                        profile=self.args.profile,
                                        quantity=self.args.quantity)
657308
def copy(self):
    
    self_copy = self.dup()
    self_copy._scopes = copy.copy(self._scopes)
    return self_copy
593356
def execute(self):
        
        self.print_info()

        if self._config.command_args.get('destroy') == 'never':
            msg = "Skipping, '--destroy=never' requested."
            LOG.warn(msg)
            return

        if self._config.driver.delegated and not self._config.driver.managed:
            msg = 'Skipping, instances are delegated.'
            LOG.warn(msg)
            return

        self._config.provisioner.destroy()
        self._config.state.reset()
915248
def get_control(self):
        """"""
        # page_control is the widget used for paging
        page_control = self.shellwidget._page_control
        if page_control and page_control.isVisible():
            return page_control
        else:
            return self.shellwidget._control
766296
def get(cls):
        
        if cls.is_twoconspect:
            return cls.subconspect_el.value or None

        input_value = cls.input_el.value.strip()

        # blank user input -> no value was yet set
        if not input_value:
            return None

        mdt = conspectus.mdt_by_name.get(input_value)

        if not mdt:
            alert("Invalid sub-conspect `%s`!" % input_value)
            return None

        return mdt
719956
public Object getControlValue()
    {
        Object objValue = null;
        if (m_iCurrentState == ON)
            objValue = Boolean.TRUE;
        else if (m_iCurrentState == OFF)
            objValue = Boolean.FALSE;
        return objValue;
    }
375549
def _build_master(cls):
        
        ws = cls()
        try:
            from __main__ import __requires__
        except ImportError:
            # The main program does not list any requirements
            return ws

        # ensure the requirements are met
        try:
            ws.require(__requires__)
        except VersionConflict:
            return cls._build_from_requirements(__requires__)

        return ws
1135393
def nvrtcDestroyProgram(self, prog):
        
        code = self._lib.nvrtcDestroyProgram(byref(prog))
        self._throw_on_error(code)
        return
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
125614
def supervisor(self):
        
        supervisor = self._cached_client('supervisor')
        if not self._api_supervisor_session:
            self._api_supervisor_session = self.__create_supervisor_session(
                supervisor,
            )
        return supervisor
628940
def getControls(self):
        '''
        
        '''
        t = self.t_cycle[0]
        i = self.MrkvNow[0]
        self.cNrmNow = self.solution[t].cFunc[i](self.mNrmNow)
145512
def getControls(self):
        '''
        
        '''
        cNrmNow = np.zeros(self.AgentCount) + np.nan
        for t in range(self.T_cycle):
            these = t == self.t_cycle
            cNrmNow[these] = self.solution[t].cFunc(self.mNrmNow[these],self.PrefShkNow[these])
        self.cNrmNow = cNrmNow
        return None
741114
def _get_master_address(self, instance):
        

        master_address = instance.get(MASTER_ADDRESS)
        if master_address is None:
            master_address = instance.get(DEPRECATED_MASTER_ADDRESS)

            if master_address:
                self.log.warning(
                    'The use of `%s` is deprecated. Please use `%s` instead.'
                    % (DEPRECATED_MASTER_ADDRESS, MASTER_ADDRESS)
                )
            else:
                raise Exception('URL for `%s` must be specified in the instance configuration' % MASTER_ADDRESS)

        return master_address
641943
def execute(self):
        
        self.print_info()
        self._config.state.change_state('driver', self._config.driver.name)

        if self._config.driver.delegated and not self._config.driver.managed:
            msg = 'Skipping, instances are delegated.'
            LOG.warn(msg)
            return

        if self._config.state.created:
            msg = 'Skipping, instances already created.'
            LOG.warn(msg)
            return

        self._config.provisioner.create()

        self._config.state.change_state('created', True)
814903
def master_key_required(func):
    ''''''
    def ret(obj, *args, **kw):
        conn = ACCESS_KEYS
        if not (conn and conn.get('master_key')):
            message = '%s requires the master key' % func.__name__
            raise core.ParseError(message)
        func(obj, *args, **kw)
    return ret
780408
def only_on_master(function):
    """"""
    @wraps(function)
    def inner_function(self, *args, **kwargs):
        """Master checking inner function."""
        if not self.is_coordinator:
            message = 'The method or property "{0}" can only be called/used '\
                'on the coordinator in a group'.format(function.__name__)
            raise SoCoSlaveException(message)
        return function(self, *args, **kwargs)
    return inner_function
978093
def process_master(m):
    ''''''
    try:
        s = m.recv(16*1024)
    except Exception:
        time.sleep(0.1)
        return
    # prevent a dead serial port from causing the CPU to spin. The user hitting enter will
    # cause it to try and reconnect
    if len(s) == 0:
        time.sleep(0.1)
        return

    if (mpstate.settings.compdebug & 1) != 0:
        return

    if mpstate.logqueue_raw:
        mpstate.logqueue_raw.put(str(s))

    if mpstate.status.setup_mode:
        if mpstate.system == 'Windows':
           # strip nsh ansi codes
           s = s.replace("\033[K","")
        sys.stdout.write(str(s))
        sys.stdout.flush()
        return

    if m.first_byte and opts.auto_protocol:
        m.auto_mavlink_version(s)
    msgs = m.mav.parse_buffer(s)
    if msgs:
        for msg in msgs:
            sysid = msg.get_srcSystem()
            if sysid in mpstate.sysid_outputs:
                  # the message has been handled by a specialised handler for this system
                  continue
            if getattr(m, '_timestamp', None) is None:
                m.post_message(msg)
            if msg.get_type() == "BAD_DATA":
                if opts.show_errors:
                    mpstate.console.writeln("MAV error: %s" % msg)
                mpstate.status.mav_error += 1