set port transmit mode

        :param mode: request transmit mode
        :type mode: ixexplorer.ixe_port.IxeTransmitMode
3126
def set_transmit_mode(self, mode):
        

        self.api.call_rc('port setTransmitMode {} {}'.format(mode, self.uri))
914649
def chmod(self, mode):
        
        self.sftp._log(DEBUG, 'chmod(%s, %r)' % (hexlify(self.handle), mode))
        attr = SFTPAttributes()
        attr.st_mode = mode
        self.sftp._request(CMD_FSETSTAT, self.handle, attr)
865793
public void start(int mode) {

        final String methodName = "start";
        if (TRACE.isEntryEnabled()) {
            SibTr.entry(this, TRACE, methodName);
        }

        final Set listeners;

        synchronized (ACTIVE_MESSAGING_ENGINES) {

            // Do we already have a set of active MEs on this bus?
            Set messagingEngines = (Set) ACTIVE_MESSAGING_ENGINES
                    .get(_messagingEngine.getBusName());

            // If not, create a new set and add it to the map
            if (messagingEngines == null) {

                messagingEngines = new HashSet();
                ACTIVE_MESSAGING_ENGINES.put(_messagingEngine.getBusName(),
                        messagingEngines);

            }

            // Add the activating ME to the set
            messagingEngines.add(_messagingEngine);

            // Get listeners to notify
            listeners = getListeners(_messagingEngine.getBusName());

        }

        // Notify listeners
        for (final Iterator iterator = listeners.iterator(); iterator.hasNext();) {

            final SibRaMessagingEngineListener listener = (SibRaMessagingEngineListener) iterator
                    .next();
            listener.messagingEngineStarting(_messagingEngine);

        }

        if (TRACE.isEntryEnabled()) {
            SibTr.exit(this, TRACE, methodName);
        }

    }
563582
def _checkMode(mode):
    

    if not isinstance(mode, str):
        raise TypeError('The {0} should be a string. Given: {1!r}'.format("mode", mode))

    if mode not in [MODE_RTU, MODE_ASCII]:
        raise ValueError("Unreconized Modbus mode given. Must be 'rtu' or 'ascii' but {0!r} was given.".format(mode))
1084823
def set_querier_mode(self, dpid, server_port):
        """"""
        self.dpid = dpid
        self.server_port = server_port
        if self._querier_thread:
            hub.kill(self._querier_thread)
            self._querier_thread = None
1001522
public void setRadarChartMode(final RadarChart.Mode MODE) {
        if (null == radarChartMode) {
            _radarChartMode = MODE;
            fireTileEvent(RECALC_EVENT);
        } else {
            radarChartMode.set(MODE);
        }
    }
474050
def tmsh_mode(self, delay_factor=1):
        """"""
        delay_factor = self.select_delay_factor(delay_factor)
        self.clear_buffer()
        command = "{}tmsh{}".format(self.RETURN, self.RETURN)
        self.write_channel(command)
        time.sleep(1 * delay_factor)
        self.clear_buffer()
        return None
92426
public void setMode(String mode) {
        checkNotNull(mode, "mode should not be null");
        if (MODE_ASYNC.equals(mode) || MODE_SYNC.equals(mode)) {
            this.mode = mode;
        } else {
            throw new IllegalArgumentException("illegal mode: " + mode);
        }
    }
885725
def setCurrentMode( self, mode ):
        
        self.scene().setCurrentMode(mode)
        self.scene().setSceneRect(0, 0, self.width() - 5, self.height() - 5)
        if ( not self.signalsBlocked() ):
            self.currentModeChanged.emit(mode)
317102
public T setDeployMode(String mode) {
    checkNotNull(mode, "mode");
    builder.deployMode = mode;
    return self();
  }
425882
def reset_mode(self):
        """"""
        self.command(0x18, b"\x01", timeout=0.1)
        self.transport.write(Chipset.ACK)
        time.sleep(0.010)
365543
def set_mode_px4(self, mode, custom_mode, custom_sub_mode):
        ''''''
        if isinstance(mode, str):
            mode_map = self.mode_mapping()
            if mode_map is None or mode not in mode_map:
                print("Unknown mode '%s'" % mode)
                return
            # PX4 uses two fields to define modes
            mode, custom_mode, custom_sub_mode = px4_map[mode]
        self.mav.command_long_send(self.target_system, self.target_component,
                                   mavlink.MAV_CMD_DO_SET_MODE, 0, mode, custom_mode, custom_sub_mode, 0, 0, 0, 0)
160935
def mode(self, target, mode_string=None, tags=None):
        """"""
        params = [target]
        if mode_string:
            params += mode_string
        self.send('MODE', params=params, source=self.nick, tags=tags)
899768
def mode(self, mode=None):
        
        if mode is None:
            return self.__mode
        if mode == const.MODBUS_TCP or mode == const.MODBUS_RTU:
            self.__mode = mode
            return self.__mode
        else:
            return None
819301
def set_mode(how):
    
    global __mode
    if how == "local":
        __mode = how
    elif how == "remote":
        __mode = how
    else:
        raise ValueError("how must be 'local' or 'remote'")
384225
public void setTerminalMode(int mode, int value) throws SshException {
		try {

			encodedModes.write(mode);

			if (version == 1 && mode <= 127) {
				encodedModes.write(value);
			} else {
				encodedModes.writeInt(value);
			}

		} catch (IOException ex) {
			throw new SshException(SshException.INTERNAL_ERROR, ex);
		}
	}
104730
def setmode(mode):
    
    if hasattr(mode, '__getitem__'):
        set_custom_pin_mappings(mode)
        mode = CUSTOM

    assert mode in [BCM, BOARD, SUNXI, CUSTOM]
    global _mode
    _mode = mode