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