>>> type([1.0 for i in [1]][0]) is type([1 for i in [1]][0]) >>> True
>>> type([1.0 for i in [1]][0]) is type([1 for i in [1]][0]) >>> False
>>> type([1.0 for i in [1]][0]), type([1 for i in [1]][0]) >>> (<class 'float'>, <class 'float'>)
>>> type([1.0 for i in [1]][0]), type([1 for i in [1]][0]) >>> (<type 'float'>, <type 'int'>)
... 6 LOAD_CONST 1 (<code object <listcomp> at 0x7fd91d983270, file "main.py", line 3>) ... 35 LOAD_CONST 1 (<code object <listcomp> at 0x7fd91d983270, file "main.py", line 3>) ...
static Py_hash_t code_hash(PyCodeObject *co) { Py_hash_t h, h0, h1, h2, h3, h4, h5, h6; h0 = PyObject_Hash(co->co_name); if (h0 == -1) return -1; h1 = PyObject_Hash(co->co_code); if (h1 == -1) return -1; h2 = PyObject_Hash(co->co_consts); if (h2 == -1) return -1; h3 = PyObject_Hash(co->co_names); if (h3 == -1) return -1; h4 = PyObject_Hash(co->co_varnames); if (h4 == -1) return -1; h5 = PyObject_Hash(co->co_freevars); if (h5 == -1) return -1; h6 = PyObject_Hash(co->co_cellvars); if (h6 == -1) return -1; h = h0 ^ h1 ^ h2 ^ h3 ^ h4 ^ h5 ^ h6 ^ co->co_argcount ^ co->co_kwonlyargcount ^ co->co_nlocals ^ co->co_flags; if (h == -1) h = -2; return h; }
static PyObject * code_richcompare(PyObject *self, PyObject *other, int op) { PyCodeObject *co, *cp; int eq; PyObject *res; if ((op != Py_EQ && op != Py_NE) || !PyCode_Check(self) || !PyCode_Check(other)) { Py_RETURN_NOTIMPLEMENTED; } co = (PyCodeObject *)self; cp = (PyCodeObject *)other; eq = PyObject_RichCompareBool(co->co_name, cp->co_name, Py_EQ); if (eq <= 0) goto unequal; eq = co->co_argcount == cp->co_argcount; if (!eq) goto unequal; eq = co->co_kwonlyargcount == cp->co_kwonlyargcount; if (!eq) goto unequal; eq = co->co_nlocals == cp->co_nlocals; if (!eq) goto unequal; eq = co->co_flags == cp->co_flags; if (!eq) goto unequal; eq = co->co_firstlineno == cp->co_firstlineno; if (!eq) goto unequal; eq = PyObject_RichCompareBool(co->co_code, cp->co_code, Py_EQ); if (eq <= 0) goto unequal; eq = PyObject_RichCompareBool(co->co_consts, cp->co_consts, Py_EQ); if (eq <= 0) goto unequal; eq = PyObject_RichCompareBool(co->co_names, cp->co_names, Py_EQ); if (eq <= 0) goto unequal; eq = PyObject_RichCompareBool(co->co_varnames, cp->co_varnames, Py_EQ); if (eq <= 0) goto unequal; eq = PyObject_RichCompareBool(co->co_freevars, cp->co_freevars, Py_EQ); if (eq <= 0) goto unequal; eq = PyObject_RichCompareBool(co->co_cellvars, cp->co_cellvars, Py_EQ); if (eq <= 0) goto unequal; if (op == Py_EQ) res = Py_True; else res = Py_False; goto done; unequal: if (eq < 0) return NULL; if (op == Py_NE) res = Py_True; else res = Py_False; done: Py_INCREF(res); return res; }
co_name = <listcomp> co_argcount = 1 co_kwonlyargcount = 0 co_nlocals = 2 co_flags = 83 co_firstlineno = 3 co_code = b'g\x00\x00|\x00\x00]\x0c\x00}\x01\x00d\x00\x00\x91\x02\x00q\x06\x00S' co_consts = (1.0,) co_names = () co_varnames = ('.0', 'i') co_freevars = () co_cellvars = ()
co_consts = (1,)
>>> a = type([1.0 for i in [1]][0]); b = type([1 for i in [1]][0]) >>> print(a, b) >>> <class 'float'> <class 'float'> >>> type([1 for i in [1]][0]) is type([True for i in [1]][0]) >>> True
| #!/usr/bin/env python | |
| #-*- coding: utf-8 -*- | |
| #----------------------------------------------------------------------- | |
| # Author: delimitry | |
| #----------------------------------------------------------------------- | |
| import os | |
| import sys | |
| from PIL import Image | |
| from argparse import ArgumentParser | |
| def find_horizontal_borders(image, border_color): | |
| """ | |
| Find horizontal border lines with defined color | |
| """ | |
| w, h = image.size | |
| pixels = image.load() | |
| horizontals = [] | |
| for j in xrange(h): | |
| for i in xrange(w): | |
| if pixels[i, j] != border_color: | |
| break | |
| else: | |
| horizontals.append(j) | |
| return horizontals | |
| def find_vertial_borders(image, border_color): | |
| """ | |
| Find vertical border lines with defined color | |
| """ | |
| w, h = image.size | |
| pixels = image.load() | |
| verticals = [] | |
| for i in xrange(w): | |
| for j in xrange(h): | |
| if pixels[i, j] != border_color: | |
| break | |
| else: | |
| verticals.append(i) | |
| return verticals | |
| def find_areas(image, border_color): | |
| """ | |
| Find sprite areas and return a list of rectangles (x, y, w, h). | |
| """ | |
| w, h = image.size | |
| horizontals = find_horizontal_borders(image, border_color) | |
| areas = [] | |
| prev_horizontal = 0 | |
| for h in horizontals: | |
| if h - prev_horizontal > 1: | |
| verticals = find_vertial_borders( | |
| image.crop((0, prev_horizontal + 1, w, prev_horizontal + (h - prev_horizontal))), border_color) | |
| prev_vertical = 0 | |
| for v in verticals: | |
| if v - prev_vertical > 1: | |
| areas.append( | |
| (prev_vertical + 1, prev_horizontal + 1, v - prev_vertical - 1, h - prev_horizontal - 1)) | |
| prev_vertical = v | |
| prev_horizontal = h | |
| return areas | |
| def str_to_color(value): | |
| """ | |
| Convert str value to color (tuple of ints) | |
| """ | |
| try: | |
| if ',' not in value or value.count(',') not in (2, 3): | |
| raise | |
| color = tuple([int(x) for x in value.split(',')]) | |
| for c in color: | |
| if not 0 <= c <= 255: | |
| raise | |
| return color | |
| except: | |
| raise Exception('Invalid format of color. Must be (R,G,B) or (R,G,B,A), ' | |
| 'where RGBA channels must be in [0..255]') | |
| def cut_and_save_sprites(image, areas, output_folder): | |
| """ | |
| Cut sprites from image using found areas and save to output folder, grouping them by size | |
| """ | |
| if not os.path.exists(output_folder): | |
| os.makedirs(output_folder) | |
| if not areas: | |
| return | |
| group = 0 | |
| index = 0 | |
| # get [w, h] from first area (x, y, w, h) | |
| prev_size = areas[0][2:4] | |
| for area in areas: | |
| # assume that a new group starts when a new size is found | |
| if area[2:4] != prev_size: | |
| prev_size = area[2:4] | |
| group += 1 | |
| index = 0 | |
| image.crop((area[0], area[1], area[0] + area[2] - 0, area[1] + area[3] - 0)).save( | |
| os.path.join(output_folder, 'group_%02d_index_%03d.png' % (group, index))) | |
| index += 1 | |
| def main(): | |
| # prepare arguments parser | |
| parser = ArgumentParser(usage='%(prog)s [options]', description='Spritesheet image cutter') | |
| parser.add_argument('-i', '--input', dest='input', help='spritesheet image') | |
| parser.add_argument('-c', '--color', dest='color', | |
| help='border RGB/RGBA color (e.g.: 255,0,128 or 0,0,0,255), by default color of top left pixel', default='') | |
| parser.add_argument('-o', '--output', dest='output', | |
| help='output sprites folder, by default current folder', default='./') | |
| parser.add_argument('-v', '--version', action='version', version='Spritesheet image cutter v0.1') | |
| args = parser.parse_args() | |
| if not args.input: | |
| parser.print_help() | |
| sys.exit() | |
| image = Image.open(args.input) | |
| left_top_color = image.getpixel((0, 0)) | |
| if args.color: | |
| try: | |
| border_color = str_to_color(args.color) | |
| except Exception as ex: | |
| sys.exit(ex) | |
| else: | |
| # get top left pixel color if not color passed | |
| border_color = left_top_color | |
| # check color channels | |
| if len(border_color) != len(left_top_color): | |
| print 'Warning: Image color channels number is %d, but you have passed %d.' % ( | |
| len(left_top_color), len(border_color)) | |
| sys.exit() | |
| areas = find_areas(image, border_color) | |
| if not areas: | |
| print 'No sprites were found.' | |
| sys.exit() | |
| print 'Saving %s sprites to "%s"' % (len(areas), os.path.abspath(args.output)) | |
| cut_and_save_sprites(image, areas, args.output) | |
| if __name__ == '__main__': | |
| main() |
def print_last(data):
if data < 8192:
print len(data)
ftp.storbinary('STOR %s' % fn, f, callback=print_last)
And after that I've found that program hangs at the end of file transfer.ftp = ftplib.FTP(self.host, self.username, self.password, timeout=10)
filename = 'logfile.log' with open(filename, 'w') as f: f.write('line 1' + '\n') f.write('line 2' + '\n') f.write('line 3' + '\r') f.write('line 4' + '\r\n') f.write('line 5' + '\n') f.write('line 6' + '\n') f.write('line 7')
filename = 'logfile.log' with open(filename, 'r') as f: for line_num, line in enumerate(f): if line.startswith('line 5'): print '%s: %s' % (line_num + 1, line.strip())
import io import codecs filename = 'logfile.log' with codecs.open(filename, 'r') as f: for line_num, line in enumerate(f): if line.startswith('line 5'): print '%s: %s' % (line_num + 1, line.strip()) with io.open(filename, 'r') as f: for line_num, line in enumerate(f): if line.startswith('line 5'): print '%s: %s' % (line_num + 1, line.strip())
with codecs.open(filename, 'r', encoding='utf-8', errors='replace') as f: for line_num, line in enumerate(f): if line.startswith('line 5'): print '%s: %s' % (line_num + 1, line.strip()) with io.open(filename, 'r', encoding='utf-8', errors='replace') as f: for line_num, line in enumerate(f): if line.startswith('line 5'): print '%s: %s' % (line_num + 1, line.strip())
| #!/usr/bin/evn python | |
| # -*- coding: utf8 -*- | |
| def encode_to_7bit(value): | |
| """ | |
| Encode unsigned int to 7-bit str data | |
| """ | |
| data = [] | |
| number = abs(value) | |
| while number >= 0x80: | |
| data.append((number | 0x80) & 0xff) | |
| number >>= 7 | |
| data.append(number & 0xff) | |
| return ''.join(chr(char) for char in data) | |
| def decode_from_7bit(data): | |
| """ | |
| Decode 7-bit encoded int from str data | |
| """ | |
| result = 0 | |
| for index, char in enumerate(data): | |
| byte_value = ord(char) | |
| result |= (byte_value & 0x7f) << (7 * index) | |
| if byte_value & 0x80 == 0: | |
| break | |
| return result | |
| def test(): | |
| """ | |
| Test encoding and decoding | |
| """ | |
| value = 0 | |
| res = encode_to_7bit(value) | |
| assert res == '\x00', 'Invalid encoding of %s' % value | |
| value = 127 | |
| res = encode_to_7bit(value) | |
| assert res == '\x7f', 'Invalid encoding of %s' % value | |
| value = 256 | |
| res = encode_to_7bit(value) | |
| assert res == '\x80\x02', 'Invalid encoding of %s' % value | |
| value = 0 | |
| res = encode_to_7bit(value) | |
| assert decode_from_7bit(encode_to_7bit(value)) == value, 'Invalid decoding of %s' % value | |
| value = 42 | |
| res = encode_to_7bit(value) | |
| assert decode_from_7bit(encode_to_7bit(value)) == value, 'Invalid decoding of %s' % value | |
| value = 1082376495 | |
| res = encode_to_7bit(value) | |
| assert decode_from_7bit(encode_to_7bit(value)) == value, 'Invalid decoding of %s' % value | |
| if __name__ == '__main__': | |
| try: | |
| test() | |
| print('OK') | |
| except Exception as ex: | |
| print('FAILED: %s' % ex) |
begin # Ch-ch-ch-chip 'n Dale rescue => rangers # Ch-ch-ch-chip 'n Dale when there's danger end
nums = [ '([]<{})', # 0 '([]>{})', # 1 '-~([]>{})', # 2 '-~-~([]>{})', # 3 '-~-~-~([]>{})', # 4 '-~-~-~-~([]>{})', # 5 '-~-~-~-~-~([]>{})', # 6 '-~-~-~-~-~-~([]>{})', # 7 '-~-~-~-~-~-~-~([]>{})', # 8 '~-~([]>{})*~-~([]>{})', # 9 '~-~-~-~([]>{})*~([]>{})', # 10 '-~-~(~-~([]>{})*~-~([]>{}))', # 11 '(-~-~([]>{})<<-~([]>{}))', # 12 '-~(-~-~([]>{})<<-~([]>{}))', # 13 '-~-~-~-~-~-~([]>{})*-~([]>{})', # 14 '~-~([]>{})*~-~-~-~([]>{})', # 15 '(-~([]>{})<<-~-~([]>{}))', # 16 ] numbers_count = len(nums) - 1 def get_number(num): r = '' if num > numbers_count: if num // numbers_count > 1: if num % numbers_count == 0: r += '(%s*%s)' % (get_number(num // numbers_count), numbers_count) else: r += '(%s*%s+%s)' % (get_number(num // numbers_count), numbers_count, num % numbers_count) else: r += '(%s+%s)' % (numbers_count, get_number(num - numbers_count)) else: r = '%s' % num return r def convert_nums(s): res = s for n in xrange(numbers_count, -1, -1): res = res.replace(str(n), nums[n]) res = res.replace('+-', '-') return resExample:
num = 1234567 num_str = get_number(num) num_str = num_str[1:-1] if num_str[0] == '(' and num_str[-1] == ')' else num_str print num_str #((((16+2)*16+13)*16+6)*16+8)*16+7 obfuscated = convert_nums(num_str) print obfuscated #(((((-~([]>{})<<-~-~([]>{}))-~([]>{}))*(-~([]>{})<<-~-~([]>{}))-~(-~-~([]>{})<<-~([]>{})))*(-~([]>{})<<-~-~([]>{}))-~-~-~-~-~([]>{}))*(-~([]>{})<<-~-~([]>{}))-~-~-~-~-~-~-~([]>{}))*(-~([]>{})<<-~-~([]>{}))-~-~-~-~-~-~([]>{}) print eval(obfuscated) #1234567So here the number 1234567 was successfully obfuscated and restored using eval function.
_push: parser stack overflow
Traceback (most recent call last):
File "obfuscation.py", line 51, in
print eval(obfuscated)
MemoryError
So be careful and use nested parentheses carefully :)
