edq.util.profile

View Source

 1import cProfile
 2import pstats
 3import runpy
 4import sys
 5import typing
 6
 7import edq.util.dirent
 8import edq.util.pyimport
 9
10def exec_for_profile(
11        run_target: str,
12        imports: typing.Union[typing.List[str], None] = None,
13        is_module: bool = False,
14        module_args: typing.Union[typing.List[str], None] = None,
15        ) -> None:
16    """
17    Exec the specified code for use in a profiler.
18    This does not profile the code, only exec's it.
19
20    Note that this function is calling exec(), which is dangerous for unknown code.
21    You should only profile your own code.
22    """
23
24    if (imports is None):
25        imports = []
26
27    if (module_args is None):
28        module_args = []
29
30    profile_globals = globals().copy()
31    for name in imports:
32        profile_globals[name] = edq.util.pyimport.import_name(name)
33
34    old_argv = sys.argv.copy()
35
36    command = run_target
37    if (is_module):
38        profile_globals['run_module'] = runpy.run_module
39        profile_globals['modname'] = run_target
40        sys.argv = [run_target] + module_args
41
42        command = "run_module(modname, run_name = '__main__')"
43
44    try:
45        exec(command, profile_globals, None)  # pylint: disable=exec-used
46    except SystemExit:
47        # Ignore exists.
48        pass
49    finally:
50        sys.argv = old_argv
51
52def cprofile(
53        run_target: str,
54        imports: typing.Union[typing.List[str], None] = None,
55        is_module: bool = False,
56        module_args: typing.Union[typing.List[str], None] = None,
57        ) -> pstats.Stats:
58    """ Profile some code and get stats back. """
59
60    profiler = cProfile.Profile()
61    profiler.enable()
62
63    exec_for_profile(run_target, imports = imports, is_module = is_module, module_args = module_args)
64
65    profiler.disable()
66
67    return pstats.Stats(profiler)

def exec_for_profile( run_target: str, imports: Optional[List[str]] = None, is_module: bool = False, module_args: Optional[List[str]] = None) -> None: View Source

11def exec_for_profile(
12        run_target: str,
13        imports: typing.Union[typing.List[str], None] = None,
14        is_module: bool = False,
15        module_args: typing.Union[typing.List[str], None] = None,
16        ) -> None:
17    """
18    Exec the specified code for use in a profiler.
19    This does not profile the code, only exec's it.
20
21    Note that this function is calling exec(), which is dangerous for unknown code.
22    You should only profile your own code.
23    """
24
25    if (imports is None):
26        imports = []
27
28    if (module_args is None):
29        module_args = []
30
31    profile_globals = globals().copy()
32    for name in imports:
33        profile_globals[name] = edq.util.pyimport.import_name(name)
34
35    old_argv = sys.argv.copy()
36
37    command = run_target
38    if (is_module):
39        profile_globals['run_module'] = runpy.run_module
40        profile_globals['modname'] = run_target
41        sys.argv = [run_target] + module_args
42
43        command = "run_module(modname, run_name = '__main__')"
44
45    try:
46        exec(command, profile_globals, None)  # pylint: disable=exec-used
47    except SystemExit:
48        # Ignore exists.
49        pass
50    finally:
51        sys.argv = old_argv

Exec the specified code for use in a profiler. This does not profile the code, only exec's it.

Note that this function is calling exec(), which is dangerous for unknown code. You should only profile your own code.

def cprofile( run_target: str, imports: Optional[List[str]] = None, is_module: bool = False, module_args: Optional[List[str]] = None) -> pstats.Stats: View Source

53def cprofile(
54        run_target: str,
55        imports: typing.Union[typing.List[str], None] = None,
56        is_module: bool = False,
57        module_args: typing.Union[typing.List[str], None] = None,
58        ) -> pstats.Stats:
59    """ Profile some code and get stats back. """
60
61    profiler = cProfile.Profile()
62    profiler.enable()
63
64    exec_for_profile(run_target, imports = imports, is_module = is_module, module_args = module_args)
65
66    profiler.disable()
67
68    return pstats.Stats(profiler)

Profile some code and get stats back.