Python string 模块，printable() 实例源码

def strings(in_file):

    min = 4 

    with open(in_file, "rb") as f: 
        result = ""       
        for c in f.read():
            if c in string.printable:
                result += c.strip()
                continue
            if len(result) >= min:
                yield result
            result = ""
        if len(result) >= min:  # catch result at EOF
            yield result


# --------------------------------------------------------------------------------
# Function      : usage
#
# Purpose       : Proivde a mini help on usage of this program
#
# Parameters    : None
#
# Returns       : None

def __ichr(self):
        addr = self.__stck.pop()
        # Input Routine
        while msvcrt.kbhit():
            msvcrt.getwch()
        while True:
            char = msvcrt.getwch()
            if char in '\x00\xE0':
                msvcrt.getwch()
            elif char in string.printable:
                char = char.replace('\r', '\n')
                msvcrt.putwch(char)
                break
        item = ord(char)
        # Storing Number
        self.__heap.set_(addr, item)

def test_simple_arithmetic_input_generation(self):
        for i in range(self.MAX_ITERATIONS):
            self.TEST_INPUT = ''.join(random.choice(string.printable + '\x00') for i in range(i))
            self.TEST_MUTATIONS = []
            self.TEST_MUTATION_CHECK = []
            self.generate_test_mutations_arithmetic()

            self.func_check(self.TEST_INPUT)
            mutate_seq_walking_bits_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            mutate_seq_two_walking_bits_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            mutate_seq_four_walking_bits_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            mutate_seq_walking_byte_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            mutate_seq_two_walking_bytes_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None)
            mutate_seq_four_walking_bytes_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None)

            mutate_seq_8_bit_arithmetic_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None, set_arith_max=127)
            mutate_seq_16_bit_arithmetic_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None, set_arith_max=127)
            mutate_seq_32_bit_arithmetic_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None, set_arith_max=127)

            for i in range(len(self.TEST_MUTATION_CHECK)):
                self.assertTrue(self.TEST_MUTATION_CHECK[i])

def test_seq_arithmetic_input_generation(self):
        for i in range(1, self.MAX_ITERATIONS+1):
            self.TEST_INPUT = ''.join(random.choice(string.printable + '\x00') for i in range(i))
            self.TEST_MUTATIONS = []
            self.TEST_MUTATION_CHECK = []
            self.generate_test_mutations_seq_arithmetic(i%127)

            self.func_check(self.TEST_INPUT)
            mutate_seq_walking_bits_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            mutate_seq_two_walking_bits_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            mutate_seq_four_walking_bits_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            mutate_seq_walking_byte_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            mutate_seq_two_walking_bytes_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None)
            mutate_seq_four_walking_bytes_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None)

            mutate_seq_8_bit_arithmetic_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None, set_arith_max=(i+1)%127)
            mutate_seq_16_bit_arithmetic_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None, set_arith_max=(i+1)%127)
            mutate_seq_32_bit_arithmetic_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None, set_arith_max=(i+1)%127)

            for i in range(len(self.TEST_MUTATION_CHECK)):
                if(not self.TEST_MUTATION_CHECK[i]):
                    print(str(array('B', self.TEST_INPUT)) + " - " + str(array('B', self.TEST_MUTATIONS[i])))
                self.assertTrue(self.TEST_MUTATION_CHECK[i])

def test_simple_interesting32_input_generation(self):
        for i in range(self.MAX_ITERATIONS):
            self.TEST_INPUT = ''.join(random.choice(string.printable + '\x00') for i in range(i))
            self.TEST_MUTATIONS = []
            self.TEST_MUTATION_CHECK = []
            self.generate_test_mutations_seq_interesting32()

            self.func_check(self.TEST_INPUT)
            mutate_seq_walking_bits_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            mutate_seq_two_walking_bits_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            mutate_seq_four_walking_bits_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            mutate_seq_walking_byte_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            mutate_seq_two_walking_bytes_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None)
            mutate_seq_four_walking_bytes_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None)

            mutate_seq_8_bit_arithmetic_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            mutate_seq_16_bit_arithmetic_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            mutate_seq_32_bit_arithmetic_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)

            mutate_seq_8_bit_interesting_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)         
            mutate_seq_16_bit_interesting_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            mutate_seq_32_bit_interesting_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)

            for i in range(len(self.TEST_MUTATION_CHECK)):
                self.assertTrue(self.TEST_MUTATION_CHECK[i])

def test_is_not_arithmetic_32(self):
        for i in range(self.MAX_ITERATIONS):
            self.TEST_INPUT = ''.join(random.choice(string.printable + '\x00') for i in range(i)) 
            self.TEST_MUTATIONS = []
            self.TEST_MUTATION_CHECK = []
            self.generate_test_mutations_seq_arithmetic_32(i%127)
            for j in range(0, len(self.TEST_INPUT)-3):
                value1 = (ord(self.TEST_INPUT[j]) << 24) + \
                (ord(self.TEST_INPUT[j+1]) << 16) + \
                (ord(self.TEST_INPUT[j+2]) << 8) + \
                ord(self.TEST_INPUT[j+3])

                value2 = (ord(self.TEST_MUTATIONS[j][j]) << 24) + \
                (ord(self.TEST_MUTATIONS[j][j+1]) << 16) + \
                (ord(self.TEST_MUTATIONS[j][j+2]) << 8) + \
                 ord(self.TEST_MUTATIONS[j][j+3])
                swapped_value = swap_32(value2)

                v1 = is_not_arithmetic(value1, value2, 4)
                v2 = is_not_arithmetic(value1, swapped_value, 4)
                self.assertFalse(v1 and v2)

def test_is_not_interesting_32(self):
        for i in range(self.MAX_ITERATIONS):
            self.TEST_INPUT = ''.join(random.choice(string.printable + '\x00') for i in range(i)) 
            self.TEST_MUTATIONS = []
            self.TEST_MUTATION_CHECK = []
            self.generate_test_mutations_seq_interesting32()
            for j in range(len(self.TEST_INPUT)-3):
                value1 = (ord(self.TEST_INPUT[j]) << 24) + \
                (ord(self.TEST_INPUT[j+1]) << 16) + \
                (ord(self.TEST_INPUT[j+2]) << 8) + \
                ord(self.TEST_INPUT[j+3])

                value2 = (ord(self.TEST_MUTATIONS[j][j]) << 24) + \
                (ord(self.TEST_MUTATIONS[j][j+1]) << 16) + \
                (ord(self.TEST_MUTATIONS[j][j+2]) << 8) + \
                 ord(self.TEST_MUTATIONS[j][j+3])
                self.assertFalse(is_not_interesting(value1, value2, 4, True))

def print_nodes():
    import string
    print("\n".join(sorted(nodes.nodes.keys())))
    used_chars = sorted(node.char for node in nodes.nodes.values())
    used_chars += list("0123456789.()")
    printable = string.printable[:-5]
    print("".join(char*(char in used_chars)or" " for char in printable))
    print(printable)
    print("".join(char*(char not in used_chars)or" " for char in printable))    
    print(" ".join(char for char in used_chars if char not in printable and char != "\n"))
    chars = {}
    for node in nodes.nodes.values():
        if node.char in chars:
            if node.char == "":
                continue
            print("DUPLICATE CHARS: %r and %r"%(chars[node.char], node))
        else:
            chars[node.char] = node
    print(chars[input("Char? ")].__name__)
    sys.exit()

def validate_tor_port(tor_port, description):
        '''
        Validate a single Tor ORPort or DirPort entry, using description as
        the port type in any log messages.
        tor_port is an ORPort or DirPort config line.
        Some can be IPv6 *Ports, which have an IPv6 address and a port.
        Others include options, such as NoListen.
        '''
        # Do some basic validation of the port
        # There isn't much we can do here, because port lines vary so much
        if len(tor_port) < 1 or len(tor_port) > 200:
            logging.warning("Bad %s length %d: %s",
                          description, len(tor_port), tor_port)
            return False
        if not all(c in string.printable for c in tor_port):
            logging.warning("Bad %s characters: %s", description, tor_port)
            return False
        return True

def get_sample_info(vt_rep, from_vt):
        '''Parse and extract sample information from JSON line
           Returns a SampleInfo named tuple: md5, sha1, sha256, label_pairs 
        '''
        label_pairs = []
        if from_vt:
            try:
                scans = vt_rep['scans']
            except KeyError:
                return None
            for av, res in scans.items():
                if res['detected']:
                    label = res['result']
                    clean_label = filter(lambda x: x in string.printable, 
                                      label).strip().encode('utf-8').strip()
                    label_pairs.append((av, clean_label))
        else:
            label_pairs = vt_rep['av_labels']

        return SampleInfo(vt_rep['md5'], vt_rep['sha1'], vt_rep['sha256'],
                          label_pairs)

def recognize_format(self):
        for line in self.input.split('\n'):
            if self.format: break
            for format, rex in BytesParser.formats_compiled.items():
                line = BytesParser.make_line_printable(line)

                out(dbg("Trying format %s on ('%s')" % (format, line)))

                if rex.match(line):
                    out(ok("%s has been recognized as %s formatted." % (self.name, format)))
                    self.format = format
                    break

        if not self.format:
            if not all(c in string.printable for c in self.input):
                out(ok("%s has been recognized as RAW bytes." % (self.name)))
                self.format = 'raw'
                return True
            else:
                out(err("Could not recognize input bytes format of the %s!" % self.name))
                return False

        return (len(self.format) > 0)

def Decode_Name(nbname):
    #From http://code.google.com/p/dpkt/ with author's permission.
    try:
        from string import printable

        if len(nbname) != 32:
            return nbname

        l = []
        for i in range(0, 32, 2):
            l.append(chr(((ord(nbname[i]) - 0x41) << 4) | ((ord(nbname[i+1]) - 0x41) & 0xf)))

        return filter(lambda x: x in printable, ''.join(l).split('\x00', 1)[0].replace(' ', ''))

    except:
        return "Illegal NetBIOS name"

def export_ke20k_train_maui():
    '''
    just use the validation dataset
    :return:
    '''
    config  = keyphrase.config.setup_keyphrase_all()   # load settings.
    target_dir = '/Users/memray/Project/seq2seq-keyphrase/dataset/keyphrase/baseline-data/maui/ke20k/train/'

    import emolga,string

    printable = set(string.printable)
    validation_records = emolga.dataset.build_dataset.deserialize_from_file(config['path'] + '/dataset/keyphrase/'+config['data_process_name']+'validation_record_'+str(config['validation_size'])+'.pkl')
    for r_id, r in enumerate(validation_records):
        print(r_id)

        r['title'] = filter(lambda x: x in printable, r['title'])
        r['abstract'] = filter(lambda x: x in printable, r['abstract'])
        r['keyword'] = filter(lambda x: x in printable, r['keyword'])

        with open(target_dir+str(r_id)+'.txt', 'w') as textfile:
            textfile.write(r['title']+'\n'+r['abstract'])

        with open(target_dir + str(r_id) + '.key', 'w') as phrasefile:
            for p in r['keyword'].split(';'):
                phrasefile.write('%s\t1\n' % p)

def _ValidateVisiblePrintableAsciiNotReserved(value, name):
  """Checks if value is a visible printable ASCII string not starting with '!'.

  Whitespace characters are excluded. Printable visible ASCII
  strings starting with '!' are reserved for internal use.

  Args:
    value: The string to validate.
    name: The name of this string; used in the exception message.

  Returns:
    The checked string.

  Raises:
    ValueError: If the string is not visible printable ASCII, or starts with
      '!'.
  """
  for char in value:
    if char not in _VISIBLE_PRINTABLE_ASCII:
      raise ValueError(
          '%r must be visible printable ASCII: %r'
          % (name, value))
  if value.startswith('!'):
    raise ValueError('%r must not start with "!": %r' % (name, value))
  return value

def _ValidateVisiblePrintableAsciiNotReserved(value, name):
  """Checks if value is a visible printable ASCII string not starting with '!'.

  Whitespace characters are excluded. Printable visible ASCII
  strings starting with '!' are reserved for internal use.

  Args:
    value: The string to validate.
    name: The name of this string; used in the exception message.

  Returns:
    The checked string.

  Raises:
    ValueError: If the string is not visible printable ASCII, or starts with
      '!'.
  """
  for char in value:
    if char not in _VISIBLE_PRINTABLE_ASCII:
      raise ValueError(
          '%r must be visible printable ASCII: %r'
          % (name, value))
  if value.startswith('!'):
    raise ValueError('%r must not start with "!": %r' % (name, value))
  return value

def __init__(self, keys=None, buttonmasks=None, screen_shape=(1024, 728)):
        self.keys = []
        if keys is None:
            keys = [c for c in string.printable] + list(constants.KEYMAP.keys())
        for key in (keys or []):
            down = vnc_event.KeyEvent.by_name(key, down=True)
            up = vnc_event.KeyEvent.by_name(key, down=False)
            self.keys.append(down)
            self.keys.append(up)
        self._key_set = set(self.keys)

        self.screen_shape = screen_shape
        if self.screen_shape is not None:
            self.buttonmasks = []
            if buttonmasks is None:
                buttonmasks = range(256)
            for buttonmask in buttonmasks:
                self.buttonmasks.append(buttonmask)
            self._buttonmask_set = set(self.buttonmasks)

def getchars(type, need_char=False):
    flag = str(type)
    chars = []
    if type in pystrs.base_dic_type and not need_char:
        if flag == pystrs.base_dic_type[0]:
            chars = string.digits
        elif flag == pystrs.base_dic_type[1]:
            chars = string.ascii_lowercase
        elif flag == pystrs.base_dic_type[2]:
            chars = string.ascii_uppercase
        elif flag == pystrs.base_dic_type[3]:
            chars = string.printable[:36]
        elif flag == pystrs.base_dic_type[4]:
            chars = string.digits + string.ascii_uppercase
        elif flag == pystrs.base_dic_type[5]:
            chars = string.ascii_letters
        elif flag == pystrs.base_dic_type[6]:
            chars = string.printable[:62]
        return chars
    elif need_char:
        return type

def clean_token(token):

    token = token.replace('"', '"')
    token = token.replace(''', "'")
    token = token.replace(chr(int("85",16)), "...")
    token = token.replace(chr(int("91",16)), "'")
    token = token.replace(chr(int("92",16)), "'")
    token = token.replace(chr(int("93",16)), '"')
    token = token.replace(chr(int("94",16)), '"')
    token = token.replace(chr(int("96",16)), '-') 

    if not is_printable(token):
        sys.stderr.write('TOKEN NOT PRINTABLE: '+''.join([str(c) for c in token if c in string.printable ]) + '\n')
        return "<UNK>"
    else:
        return token

def data_repr(data):

    def hexdump(src, length=0x10):
        lines = []
        for c in xrange(0, len(src), length):

            lines.append("%08x:  %-*s  |%s|\n" % 
                (c, length*3, 
                ' '.join('%02x' % ord(x) for x in src[c:c+length]), 
                ''.join(x if 0x20 < ord(x) < 0x7f else '.' for x in src[c:c+length]))
            )

        return ''.join(lines)

    if all(c in string.printable for c in data):
        return '\n'+data

    else:
        return '\n'+hexdump(data)

# STARTTLS interception code based on:
# https://github.com/ipopov/starttls-mitm

def get_dtb_model(filename, min_length=4):
    """ Finds the first printable string in a file with length greater
        than min_length. Replaces spaces with underscores.
    """
    with open(filename, errors="ignore") as f:
        result = ""
        for c in f.read():
            if c in string.printable:
                result += c
                continue
            if len(result) >= min_length:
                return result.replace(" ", "_")
            result = ""
        if len(result) >= min_length:  # catch result at EOF
            return result.replace(" ", "_")
    return None

def strings(s, min_length=4):
    strings_result = list()
    result = str()

    for c in s:
        try:
            c = chr(c)
        except TypeError:
            # In Python 2, c is already a chr
            pass
        if c in string.printable:
            result += c
        else:
            if len(result) >= min_length:
                strings_result.append(result)
            result = str()

    return strings_result

def serialPoller(self):
    start = True
    def addText(self, text):
        tb = self.consoleBody.get_buffer()
        tb.insert(tb.get_end_iter(), text)
    while True:
        if self.serialConnection:
            try:
                data = self.serialConnection.read()
                d2 = ''
                for i in data:
                    if i in string.printable:
                        d2 += i
                gobject.idle_add(addText, self, d2)
            except:
                pass
        else:
            try:
                self.serialConnection = serial.serial_for_url(self.serialLocation)
                self.serialConnection.baudrate = self.baudrate
            except:
                pass
            time.sleep(0.1)

def inlineSerialPoller(self):
    start = True
    def addText(self, text):
        tb = self.serialConsoleBody.get_buffer()
        tb.insert(tb.get_end_iter(), text)
    while True:
        if self.serialConnection:
            try:
                data = self.serialConnection.read()
                d2 = ''
                for i in data:
                    if i in string.printable:
                        d2 += i
                gobject.idle_add(addText, self, d2)
            except:
                pass
        else:
            try:
                self.serialConnection = serial.serial_for_url(self.serialLocation)
                self.serialConnection.baudrate = self.baudrate
            except:
                pass
            time.sleep(0.1)

def _escape(cls, iterable):
        try:
            while True:
                ch = next(iterable)
                # if it's a single backslash, then double it.
                if ch == '\\':
                    yield '\\'
                    yield '\\'
                # if it's a known escapable character, then return it
                elif ch in cls.cmap:
                    yield '\\'
                    yield cls.cmap[ch]
                # otherwise, it should be printable and doesn't need to be escaped
                elif ch in string.printable:
                    yield ch
                # we don't know, so let python handle it
                else:
                    # FIXME: replace this repr() hack with a proper \x encoding
                    yield repr(ch)[1:-1]
        except StopIteration: pass

def Decode_Name(nbname):
    #From http://code.google.com/p/dpkt/ with author's permission.
    try:
        from string import printable

        if len(nbname) != 32:
            return nbname

        l = []
        for i in range(0, 32, 2):
            l.append(chr(((ord(nbname[i]) - 0x41) << 4) | ((ord(nbname[i+1]) - 0x41) & 0xf)))

        return filter(lambda x: x in printable, ''.join(l).split('\x00', 1)[0].replace(' ', ''))

    except:
        return "Illegal NetBIOS name"

def check_yara(self, data):
        ret = []
        if self.rules:
            yarahits = self.rules.match(data=data)
            if yarahits:
              for hit in yarahits:
                ret.append("YARA: %s" % hit.rule)
                #for key, val in hit.strings.iteritems():
                for (key,stringname,val) in hit.strings:
                    makehex = False
                    for char in val:
                        if char not in string.printable:
                            makehex = True
                            break
                    if makehex == True:
                        ret.append("   %s => %s" % (hex(key), binascii.hexlify(val)))
                    else:
                        ret.append("   %s => %s" % (hex(key), val))
        return '\n'.join(ret)

def decrypt(keys, cipher_text):
    """
    ???????
    :param keys: list(), ?? [11, 22, 33 ,44]
    :param cipher_text: str(), ???? 16 ???, ?? "5b0dcfc68c8d58e9c5680e4c"
    :return: str(), ??????, ?? "hello,world!"
    """
    result_list = [int() for j in range(len(cipher_text) // 2)]

    for i in range(0, len(cipher_text), 6):
        temp = int(cipher_text[i:i + 6], 16)
        for j in range(3):
            temp &= (1 << 24) - 1
            temp = (temp << 17) | (temp >> 7)
            temp ^= keys[temp & 3] << 8
        result_list[i // 2] = (temp & 0xff0000) >> 16
        result_list[i // 2 + 1] = (temp & 0xff00) >> 8
        result_list[i // 2 + 2] = (temp & 0xff)
        # ?????, ??????, ???????????????
        for j in range(3):
            if chr(result_list[i // 2 + j]) not in string.printable:
                return ""

    return "".join([chr(each) for each in result_list])

def getCharset(num,addchar):
    char = ""
    charset = { '1': s.ascii_lowercase, 
                '2': s.ascii_uppercase,
                '3': s.digits,
                '4': s.hexdigits,
                '5': s.punctuation,
                '6': s.printable}


    if num is 1:
        return charset['1']
    else:
        num = num.split(',')

    for i in num:
        if 1 <= int(i) <= 6:
            i= '%s' % i
            char += charset[i]
        else:
            print "Number %s out of range." % (i)

    return char+''.join(addchar)

def getInfoViaCOTP(device):
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.settimeout(1) # 1 second timeout
    sock.connect((device['ip_address'], 102)) ## Will setup TCP/SYN with port 102
    cotpconnectresponse = hexlify(send_and_recv(sock, '03000016'+'11e00000000500c1020600c2020600c0010a'))
    if not cotpconnectresponse[10:12] == 'd0':
        print('COTP Connection Request failed, no route to IP '+device['ip_address']+'?')
        return []

    data = '720100b131000004ca0000000200000120360000011d00040000000000a1000000d3821f0000a3816900151653657276657253657373696f6e5f3742363743433341a3822100150b313a3a3a362e303a3a3a12a3822800150d4f4d532b204465627567676572a38229001500a3822a001500a3822b00048480808000a3822c001211e1a304a3822d001500a1000000d3817f0000a38169001515537562736372697074696f6e436f6e7461696e6572a2a20000000072010000'
    tpktlength = str(hex((len(data)+14)/2))[2:] ## Dynamically find out the data length
    cotpdata = send_and_recv(sock, '030000'+tpktlength+'02f080'+data)

    ## It is sure that the CPU state is NOT in this response
    print('Hardware: '+cotpdata.split(';')[2])
    print('Firmware: '+filter(lambda x: x in string.printable, cotpdata.split(';')[3].replace('@','.')))

    sock.close()

def get_links_from(job, city, page):
    '''''
    @job:????
    @city:???????
    @page????????
    @urls???????????????

    ****************?????????**********************
    ?????????
    '''
    urls=[]
    for i in range(page):
        url = "http://sou.zhaopin.com/jobs/searchresult.ashx?jl={}&kw={}&p={}".format(str(city),str(job),i)
        url = quote(url, safe=string.printable)
        info = get_content(url,headers)
        soup = BeautifulSoup(info,"lxml")#??????“lxml”
        link_urls = soup.select('td.zwmc a')
        for url in link_urls:
            urls.append(url.get('href'))
    return (urls)


#url = "http://s.yingjiesheng.com/result.jsp?keyword=%E6%95%B0%E6%8D%AE%E6%8C%96%E6%8E%98&city=217&start=0&period=0&sort=score&jobtype=1"
#get_links_from('??','????', 5)

def generate_input(self, size):
        return ''.join(random.choice(string.printable + '\x00') for i in range(size))

def generate_test_mutations_arithmetic(self):
        self.TEST_MUTATIONS = []
        for i in range(len(self.TEST_INPUT)):
            value = ""
            while True:
                value = self.TEST_INPUT[:i] + random.choice(string.printable) + self.TEST_INPUT[i+1:]
                if value != self.TEST_INPUT:
                    break
            self.TEST_MUTATIONS.append(value)
            self.TEST_MUTATION_CHECK.append(False)

def test_simple_interesting8_input_generation(self):
        for i in range(self.MAX_ITERATIONS):
            self.TEST_INPUT = ''.join(random.choice(string.printable + '\x00') for i in range(i))
            self.TEST_MUTATIONS = []
            self.TEST_MUTATION_CHECK = []
            self.generate_test_mutations_seq_interesting8()

            self.func_check(self.TEST_INPUT)

            mutate_seq_walking_bits_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            mutate_seq_two_walking_bits_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            mutate_seq_four_walking_bits_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            mutate_seq_walking_byte_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            mutate_seq_two_walking_bytes_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None)
            mutate_seq_four_walking_bytes_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None)

            mutate_seq_8_bit_arithmetic_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            mutate_seq_16_bit_arithmetic_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            mutate_seq_32_bit_arithmetic_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)

            mutate_seq_8_bit_interesting_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            #mutate_seq_16_bit_interesting_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)
            #mutate_seq_32_bit_interesting_array(array('B', self.TEST_INPUT), self.func_check, effector_map=None, skip_null=None)

            for i in range(len(self.TEST_MUTATION_CHECK)):
                if(not self.TEST_MUTATION_CHECK[i]):
                    print(str(array('B', self.TEST_INPUT)) + " - " + str(array('B', self.TEST_MUTATIONS[i])))
                self.assertTrue(self.TEST_MUTATION_CHECK[i])

def test_is_not_arithmetic_8(self):
        for i in range(self.MAX_ITERATIONS):
            self.TEST_INPUT = ''.join(random.choice(string.printable + '\x00') for i in range(i)) 
            self.TEST_MUTATIONS = []
            self.TEST_MUTATION_CHECK = []
            self.generate_test_mutations_seq_arithmetic(i%127)
            for j in range(len(self.TEST_INPUT)):
                self.assertFalse(is_not_arithmetic(ord(self.TEST_INPUT[j]), ord(self.TEST_MUTATIONS[j][j]), 1, set_arith_max=(i+1)%127))

def test_is_not_arithmetic_16(self):
        for i in range(self.MAX_ITERATIONS):
            self.TEST_INPUT = ''.join(random.choice(string.printable + '\x00') for i in range(i)) 
            self.TEST_MUTATIONS = []
            self.TEST_MUTATION_CHECK = []
            self.generate_test_mutations_seq_arithmetic_16(i%127)
            for j in range(len(self.TEST_INPUT)-1):
                value1 = (ord(self.TEST_INPUT[j]) << 8) + ord(self.TEST_INPUT[j+1])
                value2 = (ord(self.TEST_MUTATIONS[j][j]) << 8) + ord(self.TEST_MUTATIONS[j][j+1])
                swapped_value = swap_16(value2)

                v1 = is_not_arithmetic(value1, value2, 2, set_arith_max=(i+1)%127)
                v2 = is_not_arithmetic(value1, swapped_value, 2, set_arith_max=(i+1)%127)
                self.assertFalse(v1 and v2)

def test_is_not_interesting_8(self):
        for i in range(self.MAX_ITERATIONS):
            self.TEST_INPUT = ''.join(random.choice(string.printable + '\x00') for i in range(i)) 
            self.TEST_MUTATIONS = []
            self.TEST_MUTATION_CHECK = []
            self.generate_test_mutations_seq_interesting8()
            for j in range(len(self.TEST_INPUT)):
                v1 = is_not_interesting(ord(self.TEST_INPUT[j]), ord(self.TEST_MUTATIONS[j][j]), 1, False)
                self.assertFalse(v1 and v2)

def insert_char(self, c):
        """Given an integer character, insert that character in the current
        line. Stop when the maximum line length is reached.

        """
        if c not in string.printable:
            return
        para_idx, line_idx, char_idx = self.paragraph
        line = list(self.line)
        line.insert(char_idx, c)
        char_idx += 1
        self.line = "".join(line)
        self._char_index_to_yx(para_idx, char_idx)

def insertAtCursor(self, b):
        if b == '\r':
            self.x = 0
        elif b == '\n' or self.x >= self.width:
            self.x = 0
            self._scrollDown()
        if b in string.printable and b not in '\r\n':
            ch = (b, self._currentCharacterAttributes())
            if self.modes.get(insults.modes.IRM):
                self.lines[self.y][self.x:self.x] = [ch]
                self.lines[self.y].pop()
            else:
                self.lines[self.y][self.x] = ch
            self.x += 1

def keystrokeReceived(self, keyID, modifier):
        m = self.keyHandlers.get(keyID)
        if m is not None:
            m()
        elif keyID in string.printable:
            self.characterReceived(keyID, False)
        else:
            log.msg("Received unhandled keyID: %r" % (keyID,))

def get_random_string(length):
        """
        returns a random string with size length (numerical, alphabetical and some random other signs)
        """
        result = ""
        for _ in range(0, length):
            result += random.choice(string.printable)
        return result

def __init__(self, s):

        self.s = s
        self.printable = set(string.printable)
        self.iterable = self._is_iterable()

def _printable(self):

        out = filter(lambda x: x in self.printable, self.s)

        return out

def _stringify_iter(self):

        out = []

        for i in range(self.length):

            temp = filter(lambda x: x in self.printable, self.s[i])
            temp = temp.encode('ascii')
            out.append(temp)

        return out

def generate_section_signatures(self, pe, name, sig_length=512):
        """Generates signatures for all the sections in a PE file.

        If the section contains any data a signature will be created
        for it. The signature name will be a combination of the
        parameter 'name' and the section number and its name.
        """

        section_signatures = list()

        for idx, section in enumerate(pe.sections):

            if section.SizeOfRawData < sig_length:
                continue

            #offset = pe.get_offset_from_rva(section.VirtualAddress)
            offset = section.PointerToRawData

            sig_name = '%s Section(%d/%d,%s)' % (
                name, idx + 1, len(pe.sections),
                ''.join([c for c in section.Name if c in string.printable]))

            section_signatures.append(
                self.__generate_signature(
                    pe, offset, sig_name, ep_only=False,
                    section_start_only=True,
                    sig_length=sig_length) )

        return '\n'.join(section_signatures)+'\n'

def __str__(self):
        """Return the escaped ASCII representation of the string."""

        def convert_char(char):
            if char in string.printable:
                return char
            else:
                return r'\x%02x' % ord(char)

        if self.string:
            return ''.join([convert_char(c) for c in self.string])

        return ''

def make_line_printable(line):
        return ''.join([c if c in string.printable else '.' for c in line])

def __add__(self, other):
    if type(other) == list:
      return ClemencyBuffer(self._buf + other)
    elif type(other) == str:
      assert all(c in printable for c in other)
      return self + ClemencyBuffer.from_string(other)
    elif type(other) == type(self):
      return ClemencyBuffer(self._buf + other._buf)
    else:
      assert False

def is_printable(self):
    '''
    Returns True if all the characters in the buffer are ASCII printable characters.
    '''
    return all((0 <= c <= 255) for c in self._buf)

def to_printable_string(self):
    '''
    If this buffer is printable, returns a string version of it. Otherwise fails.
    '''
    assert self.is_printable(), "Buffer %s is not printable" % self._buf
    return ''.join(chr(c) for c in self._buf)