Remove unused _print_statement_sub function in py3compat #12010

IPython/utils/py3compat.py

@@ -1,194 +1,191 b''
 # coding: utf-8
 """Compatibility tricks for Python 3. Mainly to do with unicode.
 
 This file is deprecated and will be removed in a future version.
 """
 import functools
 import os
 import sys
 import re
 import shutil
 import types
 import platform
 
 from .encoding import DEFAULT_ENCODING
 
 
 def decode(s, encoding=None):
     encoding = encoding or DEFAULT_ENCODING
     return s.decode(encoding, "replace")
 
 def encode(u, encoding=None):
     encoding = encoding or DEFAULT_ENCODING
     return u.encode(encoding, "replace")
 
 
 def cast_unicode(s, encoding=None):
     if isinstance(s, bytes):
         return decode(s, encoding)
     return s
 
 def cast_bytes(s, encoding=None):
     if not isinstance(s, bytes):
         return encode(s, encoding)
     return s
 
 def buffer_to_bytes(buf):
     """Cast a buffer object to bytes"""
     if not isinstance(buf, bytes):
         buf = bytes(buf)
     return buf
 
 def _modify_str_or_docstring(str_change_func):
     @functools.wraps(str_change_func)
     def wrapper(func_or_str):
         if isinstance(func_or_str, (str,)):
             func = None
             doc = func_or_str
         else:
             func = func_or_str
             doc = func.__doc__
 
         # PYTHONOPTIMIZE=2 strips docstrings, so they can disappear unexpectedly
         if doc is not None:
             doc = str_change_func(doc)
 
         if func:
             func.__doc__ = doc
             return func
         return doc
     return wrapper
 
 def safe_unicode(e):
     """unicode(e) with various fallbacks. Used for exceptions, which may not be
     safe to call unicode() on.
     """
     try:
         return str(e)
     except UnicodeError:
         pass
 
     try:
         return repr(e)
     except UnicodeError:
         pass
 
     return u'Unrecoverably corrupt evalue'
 
 # shutil.which from Python 3.4
 def _shutil_which(cmd, mode=os.F_OK | os.X_OK, path=None):
     """Given a command, mode, and a PATH string, return the path which
     conforms to the given mode on the PATH, or None if there is no such
     file.
 
     `mode` defaults to os.F_OK | os.X_OK. `path` defaults to the result
     of os.environ.get("PATH"), or can be overridden with a custom search
     path.
 
     This is a backport of shutil.which from Python 3.4
     """
     # Check that a given file can be accessed with the correct mode.
     # Additionally check that `file` is not a directory, as on Windows
     # directories pass the os.access check.
     def _access_check(fn, mode):
         return (os.path.exists(fn) and os.access(fn, mode)
                 and not os.path.isdir(fn))
 
     # If we're given a path with a directory part, look it up directly rather
     # than referring to PATH directories. This includes checking relative to the
     # current directory, e.g. ./script
     if os.path.dirname(cmd):
         if _access_check(cmd, mode):
             return cmd
         return None
 
     if path is None:
         path = os.environ.get("PATH", os.defpath)
     if not path:
         return None
     path = path.split(os.pathsep)
 
     if sys.platform == "win32":
         # The current directory takes precedence on Windows.
         if not os.curdir in path:
             path.insert(0, os.curdir)
 
         # PATHEXT is necessary to check on Windows.
         pathext = os.environ.get("PATHEXT", "").split(os.pathsep)
         # See if the given file matches any of the expected path extensions.
         # This will allow us to short circuit when given "python.exe".
         # If it does match, only test that one, otherwise we have to try
         # others.
         if any(cmd.lower().endswith(ext.lower()) for ext in pathext):
             files = [cmd]
         else:
             files = [cmd + ext for ext in pathext]
     else:
         # On other platforms you don't have things like PATHEXT to tell you
         # what file suffixes are executable, so just pass on cmd as-is.
         files = [cmd]
 
     seen = set()
     for dir in path:
         normdir = os.path.normcase(dir)
         if not normdir in seen:
             seen.add(normdir)
             for thefile in files:
                 name = os.path.join(dir, thefile)
                 if _access_check(name, mode):
                     return name
     return None
 
 PY3 = True
 
 # keep reference to builtin_mod because the kernel overrides that value
 # to forward requests to a frontend.
 def input(prompt=''):
     return builtin_mod.input(prompt)
 
 builtin_mod_name = "builtins"
 import builtins as builtin_mod
 
 
 which = shutil.which
 
 def isidentifier(s, dotted=False):
     if dotted:
         return all(isidentifier(a) for a in s.split("."))
     return s.isidentifier()
 
 getcwd = os.getcwd
 
 MethodType = types.MethodType
 
 def execfile(fname, glob, loc=None, compiler=None):
     loc = loc if (loc is not None) else glob
     with open(fname, 'rb') as f:
         compiler = compiler or compile
         exec(compiler(f.read(), fname, 'exec'), glob, loc)
 
 # Refactor print statements in doctests.
 _print_statement_re = re.compile(r"\bprint (?P<expr>.*)$", re.MULTILINE)
-def _print_statement_sub(match):
-    expr = match.groups('expr')
-    return "print(%s)" % expr
 
 # Abstract u'abc' syntax:
 @_modify_str_or_docstring
 def u_format(s):
     """"{u}'abc'" --> "'abc'" (Python 3)
 
     Accepts a string or a function, so it can be used as a decorator."""
     return s.format(u='')
 
 
 PY2 = not PY3
 PYPY = platform.python_implementation() == "PyPy"
 
 # Cython still rely on that as a Dec 28 2019
 # See https://github.com/cython/cython/pull/3291 and
 # https://github.com/ipython/ipython/issues/12068
 def no_code(x, encoding=None):
         return x
 unicode_to_str = cast_bytes_py2 = no_code