Returns the EVB mode in the TLV.
194810
def get_remote_evb_mode(self, tlv_data):
        
        ret, parsed_val = self._check_common_tlv_format(
            tlv_data, "mode:", "EVB Configuration TLV")
        if not ret:
            return None
        mode_val = parsed_val[1].split()[0].strip()
        return mode_val
1330938
public final PersistenceType getJmsDeliveryMode() {
        if (getHdr2().getChoiceField(JsHdr2Access.JMSDELIVERYMODE) == JsHdr2Access.IS_JMSDELIVERYMODE_EMPTY) {
            return getDerivedJmsDeliveryMode();
        }
        else {
            Byte pType = (Byte) getHdr2().getField(JsHdr2Access.JMSDELIVERYMODE_DATA);
            return PersistenceType.getPersistenceType(pType);
        }
    }
133353
def get_remote_chassis_id_mac(self, tlv_data):
        
        ret, parsed_val = self._check_common_tlv_format(
            tlv_data, "MAC:", "Chassis ID TLV")
        if not ret:
            return None
        mac = parsed_val[1].split('\n')
        return mac[0].strip()
241803
def enable_evb(self):
        
        if self.is_ncb:
            self.run_lldptool(["-T", "-i", self.port_name, "-g", "ncb",
                               "-V", "evb", "enableTx=yes"])
            ret = self.enable_gpid()
            return ret
        else:
            LOG.error("EVB cannot be set on NB")
            return False
185587
def _get_support_sound_mode(self):
        
        if self._receiver_type == AVR_X_2016.type:
            return self._get_support_sound_mode_avr_2016()
        else:
            return self._get_support_sound_mode_avr()
1046998
def get_mode(device_filter):
    """"""
    from .device_filters import IBeaconFilter, EddystoneFilter, BtAddrFilter, EstimoteFilter
    if device_filter is None or len(device_filter) == 0:
        return ScannerMode.MODE_ALL

    mode = ScannerMode.MODE_NONE
    for filtr in device_filter:
        if isinstance(filtr, IBeaconFilter):
            mode |= ScannerMode.MODE_IBEACON
        elif isinstance(filtr, EddystoneFilter):
            mode |= ScannerMode.MODE_EDDYSTONE
        elif isinstance(filtr, EstimoteFilter):
            mode |= ScannerMode.MODE_ESTIMOTE
        elif isinstance(filtr, BtAddrFilter):
            mode |= ScannerMode.MODE_ALL
            break

    return mode
1024452
def get_bl(self):
        """"""

        cell_below_left = CellBorders(self.cell_attributes,
                                      *self.cell.get_below_left_key_rect())
        return cell_below_left.get_r()
1301302
public alluxio.grpc.PMode getMode() {
    return mode_ == null ? alluxio.grpc.PMode.getDefaultInstance() : mode_;
  }
744886
def dSbus_dV(Y, V):
    
    I = Y * V

    diagV = spdiag(V)
    diagIbus = spdiag(I)
    diagVnorm = spdiag(div(V, abs(V))) # Element-wise division.

    dS_dVm = diagV * conj(Y * diagVnorm) + conj(diagIbus) * diagVnorm
    dS_dVa = 1j * diagV * conj(diagIbus - Y * diagV)

    return dS_dVm, dS_dVa
782340
protected int getMode(int mode) {
    int type = FILE_FLAG;
    if (isLink()) {
      type = LINK_FLAG;
    }
    else if (isDirectory()) {
      type = DIR_FLAG;
    }
    return type | (mode & PERM_MASK);
  }
248142
def get_led_mode(self, led_id):
        
        if not self._connected:
            return
        return self._protocol.status.get("OTGW_LED_{}".format(led_id))
1012774
def get_output_mode(output, mode):
    
    if mode != 'auto':
        try:
            return switch_output_mode_auto[mode]
        except KeyError:
            raise ValueError('Mode "{}" is not supported.')

    extension = output.split('.')[-1]
    try:
        return switch_output_mode[extension]
    except KeyError:
        return intermediary_to_schema
111525
def detect_mode(term_hint="xterm-256color"):
    """"""
    if "ANSICON" in os.environ:
        return 16
    elif os.environ.get("ConEmuANSI", "OFF") == "ON":
        return 256
    else:
        term = os.environ.get("TERM", term_hint)
        if term.endswith("-256color") or term in ("xterm", "screen"):
            return 256
        elif term.endswith("-color") or term in ("rxvt",):
            return 16
        else:
            return 256
945217
def _l2rgb(self, mode):
        
        self._check_modes(("L", "LA"))

        bands = ["L"] * 3
        if mode[-1] == "A":
            bands.append("A")
        data = self.data.sel(bands=bands)
        data["bands"] = list(mode)
        return data
23366
def get_mode(self, old_mode=None):
        
        if self.mode is not None:
            return self.mode
        assert self.can_write, "This format does not have a supported output mode."
        if old_mode is None:
            return self.output_modes[0]
        if old_mode in self.output_modes:
            return old_mode
        # now let's get best mode available from supported
        try:
            idx = PILLOW_MODES.index(old_mode)
        except ValueError:
            # maybe some unknown or uncommon mode
            return self.output_modes[0]
        for mode in PILLOW_MODES[idx+1:]:
            if mode in self.output_modes:
                return mode
        # since there is no better one, lets' look for closest one in opposite direction
        opposite = PILLOW_MODES[:idx]
        opposite.reverse()
        for mode in opposite:
            if mode in self.output_modes:
                return mode
1105933
def sound_mode(self):
        """"""
        sound_mode_matched = self._parent_avr.match_sound_mode(
            self._parent_avr.sound_mode_raw)
        return sound_mode_matched
773124
def _get_id2gos(self):
        """"""
        kws = {}
        if self.args.ev_inc is not None:
            kws['ev_include'] = set(self.args.ev_inc.split(','))
        if self.args.ev_exc is not None:
            kws['ev_exclude'] = set(self.args.ev_exc.split(','))
        return self.objanno.get_id2gos(**kws)