Return the flavour attribute of the BFD file being processed.
433846
def machine(self):
        """"""
        if not self._ptr:
            raise BfdException("BFD not initialized")

        return _bfd.get_bfd_attribute(self._ptr, BfdAttributes.FLAVOUR)
941222
def bfd
      val = config_get('interface_ospf', 'bfd', @interface.name)
      return if val.nil?
      val.include?('disable') ? false : true
    end
833702
def _bnd(self, xloc, dist, cache):
        """"""
        return numpy.log(evaluation.evaluate_bound(
            dist, numpy.e**xloc, cache=cache))
379408
def getRgbd(self):
        '''
        

        '''
        img = Rgb()      
        if self.hasproxy():
            self.lock.acquire()
            img = self.image
            self.lock.release()
        return img
681825
def binary(self):
        
        if isinstance(self.value, int):
            return b_chr(_TAG_ATOM_CACHE_REF) + b_chr(self.value)
        elif isinstance(self.value, TypeUnicode):
            value_encoded = self.value.encode('utf-8')
            length = len(value_encoded)
            if length <= 255:
                return (
                    b_chr(_TAG_SMALL_ATOM_UTF8_EXT) +
                    b_chr(length) + value_encoded
                )
            elif length <= 65535:
                return (
                    b_chr(_TAG_ATOM_UTF8_EXT) +
                    struct.pack(b'>H', length) + value_encoded
                )
            else:
                raise OutputException('uint16 overflow')
        elif isinstance(self.value, bytes):
            length = len(self.value)
            if length <= 255:
                return b_chr(_TAG_SMALL_ATOM_EXT) + b_chr(length) + self.value
            elif length <= 65535:
                return (
                    b_chr(_TAG_ATOM_EXT) +
                    struct.pack(b'>H', length) + self.value
                )
            else:
                raise OutputException('uint16 overflow')
        else:
            raise OutputException('unknown atom type')
746401
def ReadIDsForAllSignedBinaries(self, cursor=None
                                 ):
    """"""
    cursor.execute(
        "SELECT binary_type, binary_path FROM signed_binary_references")
    return [
        rdf_objects.SignedBinaryID(binary_type=binary_type, path=binary_path)
        for binary_type, binary_path in cursor.fetchall()
    ]
274259
def dynamic_symbols_count(self):
        
        if not self._ptr:
            raise BfdException("BFD not initialized")

        return _bfd.get_bfd_attribute(
            self._ptr, BfdAttributes.DYNAMIC_SYMCOUNT)
988645
def default_bg(self) -> Tuple[int, int, int]:
        """"""
        color = self._console_data.back
        return color.r, color.g, color.b
619903
def _get_flavor():
    
    target = op.join("seqcluster", "flavor")
    url = "https://github.com/lpantano/seqcluster.git"
    if not os.path.exists(target):
    #   shutil.rmtree("seqcluster")
        subprocess.check_call(["git", "clone","-b", "flavor", "--single-branch", url])
    return op.abspath(target)
163583
def header_little_endian(self):
        
        if not self._ptr:
            raise BfdException("BFD not initialized")

        return _bfd.get_bfd_attribute(
            self._ptr, BfdAttributes.HEADER_LITTLE_ENDIAN)
1024643
def dbus_lenFD(self, fd):
        
        f = os.fdopen(fd, 'rb')
        result = len(f.read())
        f.close()
        return result
124771
def _get_wrhiercfg(self):
        """"""
        prtfmt = self.gosubdag.prt_attr['fmt']
        prtfmt = prtfmt.replace('{GO} # ', '')
        prtfmt = prtfmt.replace('{D1:5} ', '')
        return {'name2prtfmt':{'ITEM':prtfmt, 'ID':'{GO}{alt:1}'},
                'max_indent': self.usrdct.get('max_indent'),
                'include_only': self.usrdct.get('include_only'),
                'item_marks': self.usrdct.get('item_marks', {}),
                'concise_prt': 'concise' in self.usrset,
                'indent': 'no_indent' not in self.usrset,
                'dash_len': self.usrdct.get('dash_len', 6),
                'sortby': self.usrdct.get('sortby')
               }
1283004
def asBinary(self):
        
        binString = binary.bin(self._value)[2:]
        return '0' * (len(self._value) - len(binString)) + binString
1373614
def symbols_count(self):
        """"""
        if not self._ptr:
            raise BfdException("BFD not initialized")

        return _bfd.get_bfd_attribute(self._ptr, BfdAttributes.SYMCOUNT)
589017
def isfld(xmethod, dmethod, opt):
    

    fld = ['Iter', 'ObjFun', 'DFid', 'RegL1', 'Cnstr']
    if xmethod == 'admm':
        fld.extend(['XPrRsdl', 'XDlRsdl', 'XRho'])
    else:
        if opt['CBPDN', 'BackTrack', 'Enabled']:
            fld.extend(['X_F_Btrack', 'X_Q_Btrack', 'X_ItBt', 'X_L',
                        'X_Rsdl'])
        else:
            fld.extend(['X_L', 'X_Rsdl'])
    if dmethod != 'fista':
        fld.extend(['DPrRsdl', 'DDlRsdl', 'DRho'])
    else:
        if opt['CCMOD', 'BackTrack', 'Enabled']:
            fld.extend(['D_F_Btrack', 'D_Q_Btrack', 'D_ItBt', 'D_L',
                        'D_Rsdl'])
        else:
            fld.extend(['D_L', 'D_Rsdl'])
    fld.append('Time')
    return fld
213253
def show_flavor(self, flavor, **_params):
        """"""
        return self.get(self.flavor_path % (flavor), params=_params)
1306640
def getflags(fd):
    

    flags_ptr = ffi.new('uint64_t*')
    flags_buf = ffi.buffer(flags_ptr)
    fcntl.ioctl(fd, lib.FS_IOC_GETFLAGS, flags_buf)
    return flags_ptr[0]