Handling specific Python error within Bash call? [duplicate]

Wouldn't be better to monkey patch profile when no line_profiles is present ?

Something like

try:
    import line_profiles
except:
    import warnings
    warnings.warn("Profile disabled")

    def profile(fn):
        def wrapper(*args, **kw):
            return fn(*args, **kw)
        return wrapper

This way your code runs in either case without complicating matters.

Here's a usable Bash solution that preserves stdout and stderr as separate streams (with the caveat that stderr appears after stdout) and only checks stderr for the error message (which probably is overkill though).

It goes the easy route and simply saves the stderr output to a file. It also handles script names that contain spaces (by properly quoting variable expansions where needed) and/or start with - (by passing -- before the filename to switch off flag processing) as it's an OCD pet peeve of mine.

On success or if there is an error that is not the expected error, the stderr of the first python command is shown. Otherwise (for the expected error), it is hidden.

Usage is $ ./check <script>.

#!/bin/bash

if [[ $# -ne 1 ]]; then
    echo "Expected one argument: the script" >&2
    exit 1
fi

script=$1

if [[ ! -e $script ]]; then
    echo "'$script' does not exist or is not a regular file" >&2
    exit 1
fi

if ! python -- "$script" 2>saved_stderr &&
   grep -q "NameError: name 'profile' is not defined" saved_stderr; then

    # Try again with the kernprof module.
    python -m kernprof -l -v --outfile=/dev/null -- "$script"

else
    # Either success or an unexpected error. Show stderr.
    cat saved_stderr >&2
fi

rm saved_stderr

• To check if the return status of a command is zero (i.e., success), it suffices to do

  if <cmd>; then <if successful>; fi`
  

  ! negates the exit status, so if ! <cmd> ... can be used to check for failure. ! only applies to the python command above, not all of python ... && grep ....

• >&2 redirects stdout to stderr. (It's the same as 1>&2 but saves a single character, which is a bit silly, but I included for illustrative purposes as it's a common idiom.)

Creating a simple Python wrapper would seem a lot more straightforward, because inside Python, you have access to the things which go wrong.

Assuming your $file uses the common __name__ == '__main__' idiom something like this:

if __name__ == '__main__':
    main()

you can create a wrapper something like

import yourfile
try:
    file.main()
except NameError:
    import kernprof
    # hack hack, quickly constructed from looking at main() in kernprof.py
    prof = kernprof.ContextualProfile()
    execfile_ = execfile
    ns = locals()
    try:
        prof.runctx('execfile_(%r, globals())' % (yourfile,), ns, ns)
    finally:
        prof.print_stats()