More convenience updates in kernprof

CHANGELOG.rst
    Edited entry

kernprof.py
    __doc__
        Updated
    main()
        - Updated function used to find name of the Python executable to
          be more lenient in abbreviating the name, requiring file
          identity (via `os.path.samefile()`) instead of string-path
          equality
        - Added new option `-c`, which causes the positional argument
          to be interpreted as an inline script (as with `python -c`)
          instead of the path to a script file
        - Added special case for `script = -` to read the script to
          profile from stdin

Author: TTsangSC

CHANGELOG.rst

@@ -10,6 +10,8 @@ Changes
 * ENH: Added CLI argument ``-m`` to ``kernprof`` for running a library module as a script; also made it possible for profiling targets to be supplied across multiple ``-p`` flags
 * FIX: Fixed explicit profiling of class methods; added handling for profiling static, bound, and partial methods, ``functools.partial`` objects, (cached) properties, and async generator functions
 * FIX: Fixed namespace bug when running ``kernprof -m`` on certain modules (e.g. ``calendar`` on Python 3.12+).
+* ENH: Added CLI arguments ``-c`` to ``kernprof`` for (auto-)profiling module/package/inline-script execution instead of that of script files; passing ``'-'`` as the script-file name now also reads from and profiles ``stdin``
+
 
 4.2.0
 ~~~~~

kernprof.py

@@ -51,29 +51,31 @@ def main():
 
 .. code::
 
-    usage: kernprof [-h] [-V] [-l] [-b] [-o OUTFILE] [-s SETUP] [-v] [-r] [-u UNIT] [-z] [-i [OUTPUT_INTERVAL]] [-p PROF_MOD] [-m] [--prof-imports] {script | -m module} ...
+    usage: kernprof [-h] [-V] [-l] [-b] [-o OUTFILE] [-s SETUP] [-v] [-r] [-u UNIT] [-z] [-i [OUTPUT_INTERVAL]] [-p PROF_MOD] [--prof-imports]
+                    {path/to/script | -m path.to.module | -c "literal code"} ...
 
     Run and profile a python script.
 
     positional arguments:
-      {script | -m module}  The python script file or module to run
+      {path/to/script | -m path.to.module | -c "literal code"}
+                            The python script file, module, or literal code to run
       args                  Optional script arguments
 
     options:
       -h, --help            show this help message and exit
       -V, --version         show program's version number and exit
       -l, --line-by-line    Use the line-by-line profiler instead of cProfile. Implies --builtin.
       -b, --builtin         Put 'profile' in the builtins. Use 'profile.enable()'/'.disable()', '@profile' to decorate functions, or 'with profile:' to profile a section of code.
-      -o OUTFILE, --outfile OUTFILE
+      -o, --outfile OUTFILE
                             Save stats to <outfile> (default: 'scriptname.lprof' with --line-by-line, 'scriptname.prof' without)
-      -s SETUP, --setup SETUP
-                            Code to execute before the code to profile
+      -s, --setup SETUP     Code to execute before the code to profile
       -v, --view            View the results of the profile in addition to saving it
       -r, --rich            Use rich formatting if viewing output
-      -u UNIT, --unit UNIT  Output unit (in seconds) in which the timing info is displayed (default: 1e-6)
+      -u, --unit UNIT       Output unit (in seconds) in which the timing info is displayed (default: 1e-6)
       -z, --skip-zero       Hide functions which have not been called
-      -i [OUTPUT_INTERVAL], --output-interval [OUTPUT_INTERVAL]
-                            Enables outputting of cumulative profiling results to file every n seconds. Uses the threading module. Minimum value is 1 (second). Defaults to disabled.
+      -i, --output-interval [OUTPUT_INTERVAL]
+                            Enables outputting of cumulative profiling results to file every n seconds. Uses the threading module. Minimum value is 1 (second). Defaults to
+                            disabled.
       -p, --prof-mod PROF_MOD
                             List of modules, functions and/or classes to profile specified by their name or path. List is comma separated, adding the current script path profiles
                             the full script. Multiple copies of this flag can be supplied and the.list is extended. Only works with line_profiler -l, --line-by-line
@@ -216,12 +218,10 @@ def _python_command():
     Return a command that corresponds to :py:obj:`sys.executable`.
     """
     import shutil
-    if shutil.which('python') == sys.executable:
-        return 'python'
-    elif shutil.which('python3') == sys.executable:
-        return 'python3'
-    else:
-        return sys.executable
+    for abbr in 'python', 'python3':
+        if os.path.samefile(shutil.which(abbr), sys.executable):
+            return abbr
+    return sys.executable
 
 
 @contextlib.contextmanager
@@ -332,11 +332,22 @@ def positive_float(value):
     if args is None:
         args = sys.argv[1:]
 
-    # Special case: `kernprof [...] -m <module>` should terminate the
-    # parsing of all subsequent options
-    args, module, post_args = pre_parse_single_arg_directive(args, '-m')
+    # Special cases: `kernprof [...] -m <module>` or
+    # `kernprof [...] -c <script>` should terminate the parsing of all
+    # subsequent options
+    if '-m' in args and '-c' in args:
+        special_mode = min(['-c', '-m'], key=args.index)
+    elif '-m' in args:
+        special_mode = '-m'
+    else:
+        special_mode = '-c'
+    args, thing, post_args = pre_parse_single_arg_directive(args, special_mode)
+    if special_mode == '-m':
+        module, literal_code = thing, None
+    else:
+        module, literal_code = None, thing
 
-    if module is None:  # Normal execution
+    if module is literal_code is None:  # Normal execution
         real_parser, = parsers = [create_parser()]
         help_parser = None
     else:
@@ -383,27 +394,78 @@ def positive_float(value):
                             help="If specified, modules specified to `--prof-mod` will also autoprofile modules that they import. "
                             "Only works with line_profiler -l, --line-by-line")
 
-        if parser is help_parser or module is None:
+        if parser is help_parser or module is literal_code is None:
             parser.add_argument('script',
-                                metavar='{script | -m module}',
-                                help='The python script file or module to run')
+                                metavar='{path/to/script'
+                                ' | -m path.to.module | -c "literal code"}',
+                                help='The python script file, module, or '
+                                'literal code to run')
         parser.add_argument('args', nargs='...', help='Optional script arguments')
 
     # Hand off to the dummy parser if necessary to generate the help
     # text
     options = real_parser.parse_args(args)
     if help_parser and getattr(options, 'help', False):
         # This should raise a `SystemExit`
-        help_parser.parse_args([*args, '-m', module])
+        help_parser.parse_args([*args, '-m', 'dummy'])
     try:
         del options.help
     except AttributeError:
         pass
-    # Add in the pre-partitioned arguments cut off by `-m <module>`
+    # Add in the pre-partitioned arguments cut off by `-m <module>` or
+    # `-c <script>`
     options.args += post_args
     if module is not None:
         options.script = module
 
+    tempfile_source_and_content = None
+    if literal_code is not None:
+        tempfile_source_and_content = 'command', literal_code
+    elif options.script == '-' and not module:
+        tempfile_source_and_content = 'stdin', sys.stdin.read()
+
+    if not tempfile_source_and_content:
+        return _main(options, module)
+
+    # Importing `ast` is IIRC somewhat expensive, so don't do that if we
+    # don't have to
+    import ast
+    import tempfile
+
+    source, content = tempfile_source_and_content
+    file_prefix = f'kernprof-{source}-'
+    with tempfile.NamedTemporaryFile(mode='w',
+                                     prefix=file_prefix,
+                                     suffix='.py') as fobj:
+        # Set up the script to be run
+        try:
+            content = ast.unparse(ast.parse(content))
+        except (
+                # `ast.unparse()` unavailable in Python < 3.9
+                AttributeError,
+                # Big module - shouldn't happen since the script should
+                # just be one inline thing (except when reading from
+                # stdin), which can't be all that complicated
+                RecursionError):
+            pass
+        print(content, file=fobj, flush=True)
+        options.script = fobj.name
+        # Add the tempfile to `--prof-mod`
+        if options.prof_mod:
+            options.prof_mod += ',' + fobj.name
+        else:
+            options.prof_mod = fobj.name
+        # Set the output file to somewhere nicer (also take care of
+        # possible filename clash)
+        if not options.outfile:
+            extension = 'lprof' if options.line_by_line else 'prof'
+            _, options.outfile = tempfile.mkstemp(dir=os.curdir,
+                                                  prefix=file_prefix,
+                                                  suffix='.' + extension)
+        return _main(options, module)
+
+
+def _main(options, module=False):
     if not options.outfile:
         extension = 'lprof' if options.line_by_line else 'prof'
         options.outfile = '%s.%s' % (os.path.basename(options.script), extension)