bytecode_version, co, out=None, showasm=None, showast=False,

timestamp=None, showgrammar=False, code_objects={},

source_size=None, is_pypy=False, magic_int=None):

"""

assert iscode(co)

# store final output stream for case of error

real_out = out or sys.stdout

co_pypy_str = 'PyPy ' if is_pypy else ''

run_pypy_str = 'PyPy ' if IS_PYPY else ''

print('# uncompyle6 version %s\n'

'# %sPython bytecode %s%s\n# Decompiled from: %sPython %s' %

(VERSION, co_pypy_str, bytecode_version,

" (%d)" % magic_int if magic_int else "",

run_pypy_str, '\n# '.join(sys.version.split('\n'))),

file=real_out)

if co.co_filename:

print('# Embedded file name: %s' % co.co_filename,

file=real_out)

if timestamp:

print('# Compiled at: %s' % datetime.datetime.fromtimestamp(timestamp),

file=real_out)

if source_size:

print('# Size of source mod 2**32: %d bytes' % source_size,

file=real_out)

try:

pysource.deparse_code(bytecode_version, co, out, showasm, showast,

showgrammar, code_objects=code_objects,

is_pypy=is_pypy)

except pysource.SourceWalkerError as e:

# deparsing failed

showgrammar=False):

"""

filename = check_object_path(filename)

code_objects = {}

(version, timestamp, magic_int, co, is_pypy,

source_size) = load_module(filename, code_objects)

if type(co) == list:

for con in co:

decompile(version, con, outstream, showasm, showast,

timestamp, showgrammar, code_objects=code_objects,

is_pypy=is_pypy, magic_int=magic_int)

else:

decompile(version, co, outstream, showasm, showast,

timestamp, showgrammar,

code_objects=code_objects, source_size=source_size,

is_pypy=is_pypy, magic_int=magic_int)

showasm=None, showast=False, do_verify=False,

showgrammar=False, raise_on_error=False,

do_linemaps=False):

"""

def _get_outstream(outfile):

dir = os.path.dirname(outfile)

failed_file = outfile + '_failed'

if os.path.exists(failed_file):

os.remove(failed_file)

try:

os.makedirs(dir)

except OSError:

pass

return open(outfile, 'w')

tot_files = okay_files = failed_files = verify_failed_files = 0

for filename in files:

infile = os.path.join(in_base, filename)

if not os.path.exists(infile):

sys.stderr.write("File '%s' doesn't exist. Skipped\n"

% infile)

continue

# print (infile, file=sys.stderr)

if outfile: # outfile was given as parameter

outstream = _get_outstream(outfile)

elif out_base is None:

outstream = sys.stdout

if do_linemaps or do_verify:

prefix = os.path.basename(filename)

if prefix.endswith('.py'):

prefix = prefix[:-len('.py')]

junk, outfile = tempfile.mkstemp(suffix=".py",

prefix=prefix)

# Unbuffer output if possible

buffering = -1 if sys.stdout.isatty() else 0

sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', buffering)

tee = subprocess.Popen(["tee", outfile], stdin=subprocess.PIPE)

os.dup2(tee.stdin.fileno(), sys.stdout.fileno())

os.dup2(tee.stdin.fileno(), sys.stderr.fileno())

else:

if filename.endswith('.pyc'):

outfile = os.path.join(out_base, filename[0:-1])

else:

outfile = os.path.join(out_base, filename) + '_dis'

outstream = _get_outstream(outfile)

# print(outfile, file=sys.stderr)

# Try to uncompile the input file

try:

decompile_file(infile, outstream, showasm, showast, showgrammar)

tot_files += 1

except (ValueError, SyntaxError, ParserError, pysource.SourceWalkerError) as e:

sys.stdout.write("\n")

sys.stderr.write("\n# file %s\n# %s\n" % (infile, e))

failed_files += 1

except KeyboardInterrupt:

if outfile:

outstream.close()

os.remove(outfile)

sys.stdout.write("\n")

sys.stderr.write("\nLast file: %s " % (infile))

raise

# except:

# failed_files += 1

# if outfile:

# outstream.close()

# os.rename(outfile, outfile + '_failed')

# else:

# sys.stderr.write("\n# %s" % sys.exc_info()[1])

# sys.stderr.write("\n# Can't uncompile %s\n" % infile)

else: # uncompile successful

if outfile:

if do_linemaps:

mapping = line_number_mapping(infile, outfile)

outstream.write("\n\n## Line number correspondences\n")

import pprint

s = pprint.pformat(mapping, indent=2, width=80)

s2 = '##' + '\n##'.join(s.split("\n")) + "\n"

outstream.write(s2)

outstream.close()

if do_verify:

weak_verify = do_verify == 'weak'

try:

msg = verify.compare_code_with_srcfile(infile, outfile, weak_verify=weak_verify)

if not outfile:

if not msg:

print('\n# okay decompiling %s' % infile)

okay_files += 1

else:

print('\n# %s\n\t%s', infile, msg)

except verify.VerifyCmpError as e:

print(e)

verify_failed_files += 1

os.rename(outfile, outfile + '_unverified')

sys.stderr.write("### Error Verifying %s\n" % filename)

sys.stderr.write(str(e) + "\n")

if not outfile:

if raise_on_error:

raise

pass

pass

pass

elif do_verify:

sys.stderr.write("\n### uncompile successful, but no file to compare against\n")

pass

else:

okay_files += 1

if not outfile:

mess = '\n# okay decompiling'

# mem_usage = __memUsage()

print(mess, infile)

if outfile:

sys.stdout.write("%s\r" %

status_msg(do_verify, tot_files, okay_files, failed_files, verify_failed_files))

sys.stdout.flush()

if outfile:

sys.stdout.write("\n")

sys.stdout.flush()

mi = open('/proc/self/stat', 'r')

mu = mi.readline().split()[22]

mi.close()

verify_failed_files):

if tot_files == 1:

if failed_files:

return "\n# decompile failed"

elif verify_failed_files:

return "\n# decompile verify failed"

else:

return "\n# Successfully decompiled file"

pass

pass

mess = "decompiled %i files: %i okay, %i failed" % (tot_files, okay_files, failed_files)

if do_verify:

mess += (", %i verify failed" % verify_failed_files)