python类hexdigits()的实例源码

def set_fingerprint(self, fingerprint):
        '''
        If fingerprint is valid, set our stored fingerprint to fingerprint, and
        return True.
        Otherwise, return False.
        Called by TorControlClientProtocol.
        '''
        fingerprint = fingerprint.strip()

        # Do some basic validation of the fingerprint
        if not len(fingerprint) == 40:
            logging.warning("Bad fingerprint length %d: %s", len(fingerprint), fingerprint)
            return False
        if not all(c in string.hexdigits for c in fingerprint):
            logging.warning("Bad fingerprint characters: %s", fingerprint)
            return False

        # Is this the first time we've been told a fingerprint?
        if self.fingerprint is None:
            self.fingerprint = fingerprint
            self.generate_noise()
        else:
            if self.fingerprint != fingerprint:
                logging.warning("Received different fingerprint %s, keeping original fingerprint %s",
                                self.fingerprint, fingerprint)
            else:
                logging.debug("Duplicate fingerprint received %s", fingerprint)

        return True

def get_color(self):
        return ''.join(random.sample(string.hexdigits[:-6], 3))

def get_color(self):
        return ''.join(random.sample(string.hexdigits[:-6], 3))

def get_color(self):
        return ''.join(random.sample(string.hexdigits[:-6], 3))

def get_color(self):
        return ''.join(random.sample(string.hexdigits[:-6], 3))

def ishex(s):
    if(s==None): return False
    if(len(s)==0): return False
    if(isbinary(s)):return False
    for c in s:
        if not c in string.hexdigits: return False
    return True

def is_kodi_hex(text):
    """
    returns True if text is kodi-style hex value
    """
    return len(text) == 8 and all(c in string.hexdigits for c in text)

def step_start(self, char):
        if ' ' == char or '\t' == char:
            # spaces before name
            self.setError(self.ERROR_BAD_CHUNK_START, critical=False)
            return self.STATUS_START
        if char in string.hexdigits:
            return self._add_size_char(char, start=True)
        self.setError(self.ERROR_BAD_CHUNK_HEADER)
        self.setError(self.ERROR_BAD_CHUNK_SIZE)
        return self.STATUS_END

def qname_handler(qname):

    subdomain = qname.split(".")[0]
    if(all(c in string.hexdigits for c in subdomain) and len(subdomain) % 2 == 0):
        data = unhexlify(subdomain)
        print data.split(":")

def is_single_address(self):
        return all([
            all(c in string.hexdigits for c in self.domain),
            all(c in string.hexdigits for c in self.bus),
            all(c in string.hexdigits for c in self.slot),
            all(c in string.hexdigits for c in self.func)])

def random_file_extension(num_digits=8):
    return ''.join(random.choice(string.hexdigits) for _ in range(num_digits))

def random_file_extension(num_digits=8):
    return ''.join(random.choice(string.hexdigits) for _ in range(num_digits))

def validate_hex(form, field):
    data = field.data

    error = ValidationError('%r is not a valid hex color')

    # Strip a leading # for the hex number
    if data.startswith('#'):
        data = data[1:]

    if len(data) not in (3, 6):
        raise error

    if any(c not in string.hexdigits for c in data):
        raise error

def validHex(cmd):
    ishex = all(c in string.hexdigits for c in cmd)
    if len(cmd) == 2 and ishex:
        return cmd
    else:
        parser.error("Please issue a two-character hex command, e.g. 0A")

# Parse commandline arguments

def random_file_extension(num_digits=8):
    return ''.join(random.choice(string.hexdigits) for _ in range(num_digits))

def random_file_extension(num_digits=8):
    return ''.join(random.choice(string.hexdigits) for _ in range(num_digits))

def create_reference(self, name, target, force=False):
        """Create a new reference "name" which points to an object or to
        another reference.

        Based on the type and value of the target parameter, this method tries
        to guess whether it is a direct or a symbolic reference.

        Keyword arguments:

        force
            If True references will be overridden, otherwise (the default) an
            exception is raised.

        Examples::

            repo.create_reference('refs/heads/foo', repo.head.target)
            repo.create_reference('refs/tags/foo', 'refs/heads/master')
            repo.create_reference('refs/tags/foo', 'bbb78a9cec580')
        """
        direct = (
            type(target) is Oid
            or (
                all(c in hexdigits for c in target)
                and GIT_OID_MINPREFIXLEN <= len(target) <= GIT_OID_HEXSZ))

        if direct:
            return self.create_reference_direct(name, target, force)

        return self.create_reference_symbolic(name, target, force)

    #
    # Checkout
    #

def __init__(self, data, prefix=PREFIX):
        self._prefix = prefix
        if all(c in string.hexdigits for c in data):
            self._hex = data
        elif data[0] == "5" or data[0] == "6":
            self._hex = base58CheckDecode(data)
        elif data[0] == "K" or data[0] == "L":
            self._hex = base58CheckDecode(data)[:-2]
        elif data[:len(self._prefix)] == self._prefix:
            self._hex = gphBase58CheckDecode(data[len(self._prefix):])
        else:
            raise ValueError("Error loading Base58 object")

def _parse_str(value):
        """
        Parse a quoted string that should include have C style hex escapped
        characters or alphanumeric and space characters.
        """
        assert value[0] == '"' and value[-1] == '"'
        value = value[1:-1]

        out = []
        while len(value):
            if value[0] in string.letters + string.digits + ' ':
                out.append(value[0])
                value = value[1:]
                continue

            assert value[0] == '\\', 'invalid string: %s' % value
            assert len(value) >= 2, 'invalid quoted string: %s' % value
            if value[1] == '"':
                out.append('"')
                value = value[2:]
                continue

            assert len(value) >= 3, 'invalid hex string: %s' % value
            assert value[1] == 'x', 'invalid hex mark: %s' % value
            assert value[2] in string.hexdigits
            assert value[3] in string.hexdigits
            out.append(chr(int(value[2:4], 16)))
            value = value[4:]

        return ''.join(out)

def __handle_unescape(self, key):
        start = 0
        while True:
            start_js = self.js
            offset = self.js.find(key, start)
            if offset == -1: break

            offset += len(key)
            expr = ''
            extra = ''
            last_c = self.js[offset - 1]
            abort = False
            for i, c in enumerate(self.js[offset:]):
                extra += c
                if c == ')':
                    break
                elif (i > 0 and c == '(') or (c == '[' and last_c != '+'):
                    abort = True
                    break
                elif c == '%' or c in string.hexdigits:
                    expr += c
                last_c = c

            if not abort:
                self.js = self.js.replace(key + extra, urllib.unquote(expr))

                if start_js == self.js:
                    break
            else:
                start = offset