1#!/usr/bin/env python3 2 3# portions copyright 2001, Autonomous Zones Industries, Inc., all rights... 4# err... reserved and offered to the public under the terms of the 5# Python 2.2 license. 6# Author: Zooko O'Whielacronx 7# http://zooko.com/ 8# mailto:zooko@zooko.com 9# 10# Copyright 2000, Mojam Media, Inc., all rights reserved. 11# Author: Skip Montanaro 12# 13# Copyright 1999, Bioreason, Inc., all rights reserved. 14# Author: Andrew Dalke 15# 16# Copyright 1995-1997, Automatrix, Inc., all rights reserved. 17# Author: Skip Montanaro 18# 19# Copyright 1991-1995, Stichting Mathematisch Centrum, all rights reserved. 20# 21# 22# Permission to use, copy, modify, and distribute this Python software and 23# its associated documentation for any purpose without fee is hereby 24# granted, provided that the above copyright notice appears in all copies, 25# and that both that copyright notice and this permission notice appear in 26# supporting documentation, and that the name of neither Automatrix, 27# Bioreason or Mojam Media be used in advertising or publicity pertaining to 28# distribution of the software without specific, written prior permission. 29# 30"""program/module to trace Python program or function execution 31 32Sample use, command line: 33 trace.py -c -f counts --ignore-dir '$prefix' spam.py eggs 34 trace.py -t --ignore-dir '$prefix' spam.py eggs 35 trace.py --trackcalls spam.py eggs 36 37Sample use, programmatically 38 import sys 39 40 # create a Trace object, telling it what to ignore, and whether to 41 # do tracing or line-counting or both. 42 tracer = trace.Trace(ignoredirs=[sys.base_prefix, sys.base_exec_prefix,], 43 trace=0, count=1) 44 # run the new command using the given tracer 45 tracer.run('main()') 46 # make a report, placing output in /tmp 47 r = tracer.results() 48 r.write_results(show_missing=True, coverdir="/tmp") 49""" 50__all__ = ['Trace', 'CoverageResults'] 51import argparse 52import linecache 53import os 54import re 55import sys 56import token 57import tokenize 58import inspect 59import gc 60import dis 61import pickle 62from time import monotonic as _time 63 64try: 65 import threading 66except ImportError: 67 _settrace = sys.settrace 68 69 def _unsettrace(): 70 sys.settrace(None) 71else: 72 def _settrace(func): 73 threading.settrace(func) 74 sys.settrace(func) 75 76 def _unsettrace(): 77 sys.settrace(None) 78 threading.settrace(None) 79 80PRAGMA_NOCOVER = "#pragma NO COVER" 81 82# Simple rx to find lines with no code. 83rx_blank = re.compile(r'^\s*(#.*)?$') 84 85class _Ignore: 86 def __init__(self, modules=None, dirs=None): 87 self._mods = set() if not modules else set(modules) 88 self._dirs = [] if not dirs else [os.path.normpath(d) 89 for d in dirs] 90 self._ignore = { '<string>': 1 } 91 92 def names(self, filename, modulename): 93 if modulename in self._ignore: 94 return self._ignore[modulename] 95 96 # haven't seen this one before, so see if the module name is 97 # on the ignore list. 98 if modulename in self._mods: # Identical names, so ignore 99 self._ignore[modulename] = 1 100 return 1 101 102 # check if the module is a proper submodule of something on 103 # the ignore list 104 for mod in self._mods: 105 # Need to take some care since ignoring 106 # "cmp" mustn't mean ignoring "cmpcache" but ignoring 107 # "Spam" must also mean ignoring "Spam.Eggs". 108 if modulename.startswith(mod + '.'): 109 self._ignore[modulename] = 1 110 return 1 111 112 # Now check that filename isn't in one of the directories 113 if filename is None: 114 # must be a built-in, so we must ignore 115 self._ignore[modulename] = 1 116 return 1 117 118 # Ignore a file when it contains one of the ignorable paths 119 for d in self._dirs: 120 # The '+ os.sep' is to ensure that d is a parent directory, 121 # as compared to cases like: 122 # d = "/usr/local" 123 # filename = "/usr/local.py" 124 # or 125 # d = "/usr/local.py" 126 # filename = "/usr/local.py" 127 if filename.startswith(d + os.sep): 128 self._ignore[modulename] = 1 129 return 1 130 131 # Tried the different ways, so we don't ignore this module 132 self._ignore[modulename] = 0 133 return 0 134 135def _modname(path): 136 """Return a plausible module name for the patch.""" 137 138 base = os.path.basename(path) 139 filename, ext = os.path.splitext(base) 140 return filename 141 142def _fullmodname(path): 143 """Return a plausible module name for the path.""" 144 145 # If the file 'path' is part of a package, then the filename isn't 146 # enough to uniquely identify it. Try to do the right thing by 147 # looking in sys.path for the longest matching prefix. We'll 148 # assume that the rest is the package name. 149 150 comparepath = os.path.normcase(path) 151 longest = "" 152 for dir in sys.path: 153 dir = os.path.normcase(dir) 154 if comparepath.startswith(dir) and comparepath[len(dir)] == os.sep: 155 if len(dir) > len(longest): 156 longest = dir 157 158 if longest: 159 base = path[len(longest) + 1:] 160 else: 161 base = path 162 # the drive letter is never part of the module name 163 drive, base = os.path.splitdrive(base) 164 base = base.replace(os.sep, ".") 165 if os.altsep: 166 base = base.replace(os.altsep, ".") 167 filename, ext = os.path.splitext(base) 168 return filename.lstrip(".") 169 170class CoverageResults: 171 def __init__(self, counts=None, calledfuncs=None, infile=None, 172 callers=None, outfile=None): 173 self.counts = counts 174 if self.counts is None: 175 self.counts = {} 176 self.counter = self.counts.copy() # map (filename, lineno) to count 177 self.calledfuncs = calledfuncs 178 if self.calledfuncs is None: 179 self.calledfuncs = {} 180 self.calledfuncs = self.calledfuncs.copy() 181 self.callers = callers 182 if self.callers is None: 183 self.callers = {} 184 self.callers = self.callers.copy() 185 self.infile = infile 186 self.outfile = outfile 187 if self.infile: 188 # Try to merge existing counts file. 189 try: 190 with open(self.infile, 'rb') as f: 191 counts, calledfuncs, callers = pickle.load(f) 192 self.update(self.__class__(counts, calledfuncs, callers)) 193 except (OSError, EOFError, ValueError) as err: 194 print(("Skipping counts file %r: %s" 195 % (self.infile, err)), file=sys.stderr) 196 197 def is_ignored_filename(self, filename): 198 """Return True if the filename does not refer to a file 199 we want to have reported. 200 """ 201 return filename.startswith('<') and filename.endswith('>') 202 203 def update(self, other): 204 """Merge in the data from another CoverageResults""" 205 counts = self.counts 206 calledfuncs = self.calledfuncs 207 callers = self.callers 208 other_counts = other.counts 209 other_calledfuncs = other.calledfuncs 210 other_callers = other.callers 211 212 for key in other_counts: 213 counts[key] = counts.get(key, 0) + other_counts[key] 214 215 for key in other_calledfuncs: 216 calledfuncs[key] = 1 217 218 for key in other_callers: 219 callers[key] = 1 220 221 def write_results(self, show_missing=True, summary=False, coverdir=None): 222 """ 223 Write the coverage results. 224 225 :param show_missing: Show lines that had no hits. 226 :param summary: Include coverage summary per module. 227 :param coverdir: If None, the results of each module are placed in its 228 directory, otherwise it is included in the directory 229 specified. 230 """ 231 if self.calledfuncs: 232 print() 233 print("functions called:") 234 calls = self.calledfuncs 235 for filename, modulename, funcname in sorted(calls): 236 print(("filename: %s, modulename: %s, funcname: %s" 237 % (filename, modulename, funcname))) 238 239 if self.callers: 240 print() 241 print("calling relationships:") 242 lastfile = lastcfile = "" 243 for ((pfile, pmod, pfunc), (cfile, cmod, cfunc)) \ 244 in sorted(self.callers): 245 if pfile != lastfile: 246 print() 247 print("***", pfile, "***") 248 lastfile = pfile 249 lastcfile = "" 250 if cfile != pfile and lastcfile != cfile: 251 print(" -->", cfile) 252 lastcfile = cfile 253 print(" %s.%s -> %s.%s" % (pmod, pfunc, cmod, cfunc)) 254 255 # turn the counts data ("(filename, lineno) = count") into something 256 # accessible on a per-file basis 257 per_file = {} 258 for filename, lineno in self.counts: 259 lines_hit = per_file[filename] = per_file.get(filename, {}) 260 lines_hit[lineno] = self.counts[(filename, lineno)] 261 262 # accumulate summary info, if needed 263 sums = {} 264 265 for filename, count in per_file.items(): 266 if self.is_ignored_filename(filename): 267 continue 268 269 if filename.endswith(".pyc"): 270 filename = filename[:-1] 271 272 if coverdir is None: 273 dir = os.path.dirname(os.path.abspath(filename)) 274 modulename = _modname(filename) 275 else: 276 dir = coverdir 277 if not os.path.exists(dir): 278 os.makedirs(dir) 279 modulename = _fullmodname(filename) 280 281 # If desired, get a list of the line numbers which represent 282 # executable content (returned as a dict for better lookup speed) 283 if show_missing: 284 lnotab = _find_executable_linenos(filename) 285 else: 286 lnotab = {} 287 if lnotab: 288 source = linecache.getlines(filename) 289 coverpath = os.path.join(dir, modulename + ".cover") 290 with open(filename, 'rb') as fp: 291 encoding, _ = tokenize.detect_encoding(fp.readline) 292 n_hits, n_lines = self.write_results_file(coverpath, source, 293 lnotab, count, encoding) 294 if summary and n_lines: 295 percent = int(100 * n_hits / n_lines) 296 sums[modulename] = n_lines, percent, modulename, filename 297 298 299 if summary and sums: 300 print("lines cov% module (path)") 301 for m in sorted(sums): 302 n_lines, percent, modulename, filename = sums[m] 303 print("%5d %3d%% %s (%s)" % sums[m]) 304 305 if self.outfile: 306 # try and store counts and module info into self.outfile 307 try: 308 pickle.dump((self.counts, self.calledfuncs, self.callers), 309 open(self.outfile, 'wb'), 1) 310 except OSError as err: 311 print("Can't save counts files because %s" % err, file=sys.stderr) 312 313 def write_results_file(self, path, lines, lnotab, lines_hit, encoding=None): 314 """Return a coverage results file in path.""" 315 316 try: 317 outfile = open(path, "w", encoding=encoding) 318 except OSError as err: 319 print(("trace: Could not open %r for writing: %s" 320 "- skipping" % (path, err)), file=sys.stderr) 321 return 0, 0 322 323 n_lines = 0 324 n_hits = 0 325 with outfile: 326 for lineno, line in enumerate(lines, 1): 327 # do the blank/comment match to try to mark more lines 328 # (help the reader find stuff that hasn't been covered) 329 if lineno in lines_hit: 330 outfile.write("%5d: " % lines_hit[lineno]) 331 n_hits += 1 332 n_lines += 1 333 elif rx_blank.match(line): 334 outfile.write(" ") 335 else: 336 # lines preceded by no marks weren't hit 337 # Highlight them if so indicated, unless the line contains 338 # #pragma: NO COVER 339 if lineno in lnotab and not PRAGMA_NOCOVER in line: 340 outfile.write(">>>>>> ") 341 n_lines += 1 342 else: 343 outfile.write(" ") 344 outfile.write(line.expandtabs(8)) 345 346 return n_hits, n_lines 347 348def _find_lines_from_code(code, strs): 349 """Return dict where keys are lines in the line number table.""" 350 linenos = {} 351 352 for _, lineno in dis.findlinestarts(code): 353 if lineno not in strs: 354 linenos[lineno] = 1 355 356 return linenos 357 358def _find_lines(code, strs): 359 """Return lineno dict for all code objects reachable from code.""" 360 # get all of the lineno information from the code of this scope level 361 linenos = _find_lines_from_code(code, strs) 362 363 # and check the constants for references to other code objects 364 for c in code.co_consts: 365 if inspect.iscode(c): 366 # find another code object, so recurse into it 367 linenos.update(_find_lines(c, strs)) 368 return linenos 369 370def _find_strings(filename, encoding=None): 371 """Return a dict of possible docstring positions. 372 373 The dict maps line numbers to strings. There is an entry for 374 line that contains only a string or a part of a triple-quoted 375 string. 376 """ 377 d = {} 378 # If the first token is a string, then it's the module docstring. 379 # Add this special case so that the test in the loop passes. 380 prev_ttype = token.INDENT 381 with open(filename, encoding=encoding) as f: 382 tok = tokenize.generate_tokens(f.readline) 383 for ttype, tstr, start, end, line in tok: 384 if ttype == token.STRING: 385 if prev_ttype == token.INDENT: 386 sline, scol = start 387 eline, ecol = end 388 for i in range(sline, eline + 1): 389 d[i] = 1 390 prev_ttype = ttype 391 return d 392 393def _find_executable_linenos(filename): 394 """Return dict where keys are line numbers in the line number table.""" 395 try: 396 with tokenize.open(filename) as f: 397 prog = f.read() 398 encoding = f.encoding 399 except OSError as err: 400 print(("Not printing coverage data for %r: %s" 401 % (filename, err)), file=sys.stderr) 402 return {} 403 code = compile(prog, filename, "exec") 404 strs = _find_strings(filename, encoding) 405 return _find_lines(code, strs) 406 407class Trace: 408 def __init__(self, count=1, trace=1, countfuncs=0, countcallers=0, 409 ignoremods=(), ignoredirs=(), infile=None, outfile=None, 410 timing=False): 411 """ 412 @param count true iff it should count number of times each 413 line is executed 414 @param trace true iff it should print out each line that is 415 being counted 416 @param countfuncs true iff it should just output a list of 417 (filename, modulename, funcname,) for functions 418 that were called at least once; This overrides 419 `count' and `trace' 420 @param ignoremods a list of the names of modules to ignore 421 @param ignoredirs a list of the names of directories to ignore 422 all of the (recursive) contents of 423 @param infile file from which to read stored counts to be 424 added into the results 425 @param outfile file in which to write the results 426 @param timing true iff timing information be displayed 427 """ 428 self.infile = infile 429 self.outfile = outfile 430 self.ignore = _Ignore(ignoremods, ignoredirs) 431 self.counts = {} # keys are (filename, linenumber) 432 self.pathtobasename = {} # for memoizing os.path.basename 433 self.donothing = 0 434 self.trace = trace 435 self._calledfuncs = {} 436 self._callers = {} 437 self._caller_cache = {} 438 self.start_time = None 439 if timing: 440 self.start_time = _time() 441 if countcallers: 442 self.globaltrace = self.globaltrace_trackcallers 443 elif countfuncs: 444 self.globaltrace = self.globaltrace_countfuncs 445 elif trace and count: 446 self.globaltrace = self.globaltrace_lt 447 self.localtrace = self.localtrace_trace_and_count 448 elif trace: 449 self.globaltrace = self.globaltrace_lt 450 self.localtrace = self.localtrace_trace 451 elif count: 452 self.globaltrace = self.globaltrace_lt 453 self.localtrace = self.localtrace_count 454 else: 455 # Ahem -- do nothing? Okay. 456 self.donothing = 1 457 458 def run(self, cmd): 459 import __main__ 460 dict = __main__.__dict__ 461 self.runctx(cmd, dict, dict) 462 463 def runctx(self, cmd, globals=None, locals=None): 464 if globals is None: globals = {} 465 if locals is None: locals = {} 466 if not self.donothing: 467 _settrace(self.globaltrace) 468 try: 469 exec(cmd, globals, locals) 470 finally: 471 if not self.donothing: 472 _unsettrace() 473 474 def runfunc(self, func, *args, **kw): 475 result = None 476 if not self.donothing: 477 sys.settrace(self.globaltrace) 478 try: 479 result = func(*args, **kw) 480 finally: 481 if not self.donothing: 482 sys.settrace(None) 483 return result 484 485 def file_module_function_of(self, frame): 486 code = frame.f_code 487 filename = code.co_filename 488 if filename: 489 modulename = _modname(filename) 490 else: 491 modulename = None 492 493 funcname = code.co_name 494 clsname = None 495 if code in self._caller_cache: 496 if self._caller_cache[code] is not None: 497 clsname = self._caller_cache[code] 498 else: 499 self._caller_cache[code] = None 500 ## use of gc.get_referrers() was suggested by Michael Hudson 501 # all functions which refer to this code object 502 funcs = [f for f in gc.get_referrers(code) 503 if inspect.isfunction(f)] 504 # require len(func) == 1 to avoid ambiguity caused by calls to 505 # new.function(): "In the face of ambiguity, refuse the 506 # temptation to guess." 507 if len(funcs) == 1: 508 dicts = [d for d in gc.get_referrers(funcs[0]) 509 if isinstance(d, dict)] 510 if len(dicts) == 1: 511 classes = [c for c in gc.get_referrers(dicts[0]) 512 if hasattr(c, "__bases__")] 513 if len(classes) == 1: 514 # ditto for new.classobj() 515 clsname = classes[0].__name__ 516 # cache the result - assumption is that new.* is 517 # not called later to disturb this relationship 518 # _caller_cache could be flushed if functions in 519 # the new module get called. 520 self._caller_cache[code] = clsname 521 if clsname is not None: 522 funcname = "%s.%s" % (clsname, funcname) 523 524 return filename, modulename, funcname 525 526 def globaltrace_trackcallers(self, frame, why, arg): 527 """Handler for call events. 528 529 Adds information about who called who to the self._callers dict. 530 """ 531 if why == 'call': 532 # XXX Should do a better job of identifying methods 533 this_func = self.file_module_function_of(frame) 534 parent_func = self.file_module_function_of(frame.f_back) 535 self._callers[(parent_func, this_func)] = 1 536 537 def globaltrace_countfuncs(self, frame, why, arg): 538 """Handler for call events. 539 540 Adds (filename, modulename, funcname) to the self._calledfuncs dict. 541 """ 542 if why == 'call': 543 this_func = self.file_module_function_of(frame) 544 self._calledfuncs[this_func] = 1 545 546 def globaltrace_lt(self, frame, why, arg): 547 """Handler for call events. 548 549 If the code block being entered is to be ignored, returns `None', 550 else returns self.localtrace. 551 """ 552 if why == 'call': 553 code = frame.f_code 554 filename = frame.f_globals.get('__file__', None) 555 if filename: 556 # XXX _modname() doesn't work right for packages, so 557 # the ignore support won't work right for packages 558 modulename = _modname(filename) 559 if modulename is not None: 560 ignore_it = self.ignore.names(filename, modulename) 561 if not ignore_it: 562 if self.trace: 563 print((" --- modulename: %s, funcname: %s" 564 % (modulename, code.co_name))) 565 return self.localtrace 566 else: 567 return None 568 569 def localtrace_trace_and_count(self, frame, why, arg): 570 if why == "line": 571 # record the file name and line number of every trace 572 filename = frame.f_code.co_filename 573 lineno = frame.f_lineno 574 key = filename, lineno 575 self.counts[key] = self.counts.get(key, 0) + 1 576 577 if self.start_time: 578 print('%.2f' % (_time() - self.start_time), end=' ') 579 bname = os.path.basename(filename) 580 print("%s(%d): %s" % (bname, lineno, 581 linecache.getline(filename, lineno)), end='') 582 return self.localtrace 583 584 def localtrace_trace(self, frame, why, arg): 585 if why == "line": 586 # record the file name and line number of every trace 587 filename = frame.f_code.co_filename 588 lineno = frame.f_lineno 589 590 if self.start_time: 591 print('%.2f' % (_time() - self.start_time), end=' ') 592 bname = os.path.basename(filename) 593 print("%s(%d): %s" % (bname, lineno, 594 linecache.getline(filename, lineno)), end='') 595 return self.localtrace 596 597 def localtrace_count(self, frame, why, arg): 598 if why == "line": 599 filename = frame.f_code.co_filename 600 lineno = frame.f_lineno 601 key = filename, lineno 602 self.counts[key] = self.counts.get(key, 0) + 1 603 return self.localtrace 604 605 def results(self): 606 return CoverageResults(self.counts, infile=self.infile, 607 outfile=self.outfile, 608 calledfuncs=self._calledfuncs, 609 callers=self._callers) 610 611def main(): 612 613 parser = argparse.ArgumentParser() 614 parser.add_argument('--version', action='version', version='trace 2.0') 615 616 grp = parser.add_argument_group('Main options', 617 'One of these (or --report) must be given') 618 619 grp.add_argument('-c', '--count', action='store_true', 620 help='Count the number of times each line is executed and write ' 621 'the counts to <module>.cover for each module executed, in ' 622 'the module\'s directory. See also --coverdir, --file, ' 623 '--no-report below.') 624 grp.add_argument('-t', '--trace', action='store_true', 625 help='Print each line to sys.stdout before it is executed') 626 grp.add_argument('-l', '--listfuncs', action='store_true', 627 help='Keep track of which functions are executed at least once ' 628 'and write the results to sys.stdout after the program exits. ' 629 'Cannot be specified alongside --trace or --count.') 630 grp.add_argument('-T', '--trackcalls', action='store_true', 631 help='Keep track of caller/called pairs and write the results to ' 632 'sys.stdout after the program exits.') 633 634 grp = parser.add_argument_group('Modifiers') 635 636 _grp = grp.add_mutually_exclusive_group() 637 _grp.add_argument('-r', '--report', action='store_true', 638 help='Generate a report from a counts file; does not execute any ' 639 'code. --file must specify the results file to read, which ' 640 'must have been created in a previous run with --count ' 641 '--file=FILE') 642 _grp.add_argument('-R', '--no-report', action='store_true', 643 help='Do not generate the coverage report files. ' 644 'Useful if you want to accumulate over several runs.') 645 646 grp.add_argument('-f', '--file', 647 help='File to accumulate counts over several runs') 648 grp.add_argument('-C', '--coverdir', 649 help='Directory where the report files go. The coverage report ' 650 'for <package>.<module> will be written to file ' 651 '<dir>/<package>/<module>.cover') 652 grp.add_argument('-m', '--missing', action='store_true', 653 help='Annotate executable lines that were not executed with ' 654 '">>>>>> "') 655 grp.add_argument('-s', '--summary', action='store_true', 656 help='Write a brief summary for each file to sys.stdout. ' 657 'Can only be used with --count or --report') 658 grp.add_argument('-g', '--timing', action='store_true', 659 help='Prefix each line with the time since the program started. ' 660 'Only used while tracing') 661 662 grp = parser.add_argument_group('Filters', 663 'Can be specified multiple times') 664 grp.add_argument('--ignore-module', action='append', default=[], 665 help='Ignore the given module(s) and its submodules' 666 '(if it is a package). Accepts comma separated list of ' 667 'module names.') 668 grp.add_argument('--ignore-dir', action='append', default=[], 669 help='Ignore files in the given directory ' 670 '(multiple directories can be joined by os.pathsep).') 671 672 parser.add_argument('filename', nargs='?', 673 help='file to run as main program') 674 parser.add_argument('arguments', nargs=argparse.REMAINDER, 675 help='arguments to the program') 676 677 opts = parser.parse_args() 678 679 if opts.ignore_dir: 680 rel_path = 'lib', 'python{0.major}.{0.minor}'.format(sys.version_info) 681 _prefix = os.path.join(sys.base_prefix, *rel_path) 682 _exec_prefix = os.path.join(sys.base_exec_prefix, *rel_path) 683 684 def parse_ignore_dir(s): 685 s = os.path.expanduser(os.path.expandvars(s)) 686 s = s.replace('$prefix', _prefix).replace('$exec_prefix', _exec_prefix) 687 return os.path.normpath(s) 688 689 opts.ignore_module = [mod.strip() 690 for i in opts.ignore_module for mod in i.split(',')] 691 opts.ignore_dir = [parse_ignore_dir(s) 692 for i in opts.ignore_dir for s in i.split(os.pathsep)] 693 694 if opts.report: 695 if not opts.file: 696 parser.error('-r/--report requires -f/--file') 697 results = CoverageResults(infile=opts.file, outfile=opts.file) 698 return results.write_results(opts.missing, opts.summary, opts.coverdir) 699 700 if not any([opts.trace, opts.count, opts.listfuncs, opts.trackcalls]): 701 parser.error('must specify one of --trace, --count, --report, ' 702 '--listfuncs, or --trackcalls') 703 704 if opts.listfuncs and (opts.count or opts.trace): 705 parser.error('cannot specify both --listfuncs and (--trace or --count)') 706 707 if opts.summary and not opts.count: 708 parser.error('--summary can only be used with --count or --report') 709 710 if opts.filename is None: 711 parser.error('filename is missing: required with the main options') 712 713 sys.argv = opts.filename, *opts.arguments 714 sys.path[0] = os.path.dirname(opts.filename) 715 716 t = Trace(opts.count, opts.trace, countfuncs=opts.listfuncs, 717 countcallers=opts.trackcalls, ignoremods=opts.ignore_module, 718 ignoredirs=opts.ignore_dir, infile=opts.file, 719 outfile=opts.file, timing=opts.timing) 720 try: 721 with open(opts.filename) as fp: 722 code = compile(fp.read(), opts.filename, 'exec') 723 # try to emulate __main__ namespace as much as possible 724 globs = { 725 '__file__': opts.filename, 726 '__name__': '__main__', 727 '__package__': None, 728 '__cached__': None, 729 } 730 t.runctx(code, globs, globs) 731 except OSError as err: 732 sys.exit("Cannot run file %r because: %s" % (sys.argv[0], err)) 733 except SystemExit: 734 pass 735 736 results = t.results() 737 738 if not opts.no_report: 739 results.write_results(opts.missing, opts.summary, opts.coverdir) 740 741if __name__=='__main__': 742 main() 743