Merge pull request #1245 from gbrandonp/pythonw-py3k

pythonw py3k fixes for issue  #1226

IPython/utils/encoding.py

@@ -0,0 +1,56 b''
+# coding: utf-8
+"""
+Utilities for dealing with text encodings
+"""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2008-2012  The IPython Development Team
+#
+#  Distributed under the terms of the BSD License.  The full license is in
+#  the file COPYING, distributed as part of this software.
+#-----------------------------------------------------------------------------
+
+#-----------------------------------------------------------------------------
+# Imports
+#-----------------------------------------------------------------------------
+import sys
+import locale
+
+# to deal with the possibility of sys.std* not being a stream at all
+def get_stream_enc(stream, default=None):
+    """Return the given stream's encoding or a default.
+
+    There are cases where sys.std* might not actually be a stream, so
+    check for the encoding attribute prior to returning it, and return
+    a default if it doesn't exist or evaluates as False. `default'
+    is None if not provided.
+    """
+    if not hasattr(stream, 'encoding') or not stream.encoding:
+        return default
+    else:
+        return stream.encoding
+
+# Less conservative replacement for sys.getdefaultencoding, that will try
+# to match the environment.
+# Defined here as central function, so if we find better choices, we
+# won't need to make changes all over IPython.
+def getdefaultencoding():
+    """Return IPython's guess for the default encoding for bytes as text.
+
+    Asks for stdin.encoding first, to match the calling Terminal, but that
+    is often None for subprocesses.  Fall back on locale.getpreferredencoding()
+    which should be a sensible platform default (that respects LANG environment),
+    and finally to sys.getdefaultencoding() which is the most conservative option,
+    and usually ASCII.
+    """
+    enc = get_stream_enc(sys.stdin)
+    if not enc or enc=='ascii':
+        try:
+            # There are reports of getpreferredencoding raising errors
+            # in some cases, which may well be fixed, but let's be conservative here.
+            enc = locale.getpreferredencoding()
+        except Exception:
+            pass
+    return enc or sys.getdefaultencoding()
+
+DEFAULT_ENCODING = getdefaultencoding()

IPython/config/loader.py

@@ -26,6 +26,7 b' import sys'
 from IPython.external import argparse
 from IPython.utils.path import filefind, get_ipython_dir
 from IPython.utils import py3compat, text, warn
+from IPython.utils.encoding import DEFAULT_ENCODING
 
 #-----------------------------------------------------------------------------
 # Exceptions
@@ -439,7 +440,7 b' class KeyValueConfigLoader(CommandLineConfigLoader):'
         """decode argv if bytes, using stin.encoding, falling back on default enc"""
         uargv = []
         if enc is None:
-            enc = text.getdefaultencoding()
+            enc = DEFAULT_ENCODING
         for arg in argv:
             if not isinstance(arg, unicode):
                 # only decode if not already decoded
@@ -603,7 +604,7 b' class ArgParseConfigLoader(CommandLineConfigLoader):'
     def _parse_args(self, args):
         """self.parser->self.parsed_data"""
         # decode sys.argv to support unicode command-line options
-        enc = text.getdefaultencoding()
+        enc = DEFAULT_ENCODING
         uargs = [py3compat.cast_unicode(a, enc) for a in args]
         self.parsed_data, self.extra_args = self.parser.parse_known_args(uargs)
 

IPython/core/macro.py

@@ -11,6 +11,7 b' import re'
 import sys
 
 from IPython.utils import py3compat
+from IPython.utils.encoding import DEFAULT_ENCODING
 
 coding_declaration = re.compile(r"#\s*coding[:=]\s*([-\w.]+)")
 
@@ -35,7 +36,7 b' class Macro(object):'
                 lines.append(line)
         code = "\n".join(lines)
         if isinstance(code, bytes):
-            code = code.decode(enc or sys.getdefaultencoding())
+            code = code.decode(enc or DEFAULT_ENCODING)
         self.value = code + '\n'
     
     def __str__(self):

IPython/core/magic.py

@@ -58,6 +58,7 b' from IPython.core.pylabtools import mpl_runner'
 from IPython.testing.skipdoctest import skip_doctest
 from IPython.utils import py3compat
 from IPython.utils import openpy
+from IPython.utils.encoding import DEFAULT_ENCODING
 from IPython.utils.io import file_read, nlprint
 from IPython.utils.module_paths import find_mod
 from IPython.utils.path import get_py_filename, unquote_filename
@@ -614,7 +615,7 b' Currently the magic system has the following functions:\\n"""'
             except IOError,msg:
                 print msg
                 return
-            page.page(self.shell.inspector.format(file(filename).read()))
+            page.page(self.shell.inspector.format(open(filename).read()))
 
     def magic_psearch(self, parameter_s=''):
         """Search for object in namespaces by wildcard.
@@ -950,7 +951,7 b' Currently the magic system has the following functions:\\n"""'
                 try:
                     vstr = str(var)
                 except UnicodeEncodeError:
-                    vstr = unicode(var).encode(sys.getdefaultencoding(),
+                    vstr = unicode(var).encode(DEFAULT_ENCODING,
                                                'backslashreplace')
                 vstr = vstr.replace('\n','\\n')
                 if len(vstr) < 50:
@@ -1542,7 +1543,7 b' Currently the magic system has the following functions:\\n"""'
                   `dump_file`+'.',sys_exit
         if text_file:
             text_file = unquote_filename(text_file)
-            pfile = file(text_file,'w')
+            pfile = open(text_file,'w')
             pfile.write(output)
             pfile.close()
             print '\n*** Profile printout saved to text file',\

IPython/core/page.py

@@ -203,7 +203,7 b' def page(strng, start=0, screen_lines=0, pager_cmd=None):'
                 retval = 1
             else:
                 tmpname = tempfile.mktemp('.txt')
-                tmpfile = file(tmpname,'wt')
+                tmpfile = open(tmpname,'wt')
                 tmpfile.write(strng)
                 tmpfile.close()
                 cmd = "%s < %s" % (pager_cmd,tmpname)

IPython/core/splitinput.py

@@ -24,6 +24,7 b' import re'
 import sys
 
 from IPython.utils import py3compat
+from IPython.utils.encoding import get_stream_enc
 
 #-----------------------------------------------------------------------------
 # Main function
@@ -53,7 +54,8 b' def split_user_input(line, pattern=None):'
     and the rest.
     """
     # We need to ensure that the rest of this routine deals only with unicode
-    line = py3compat.cast_unicode(line, sys.stdin.encoding or 'utf-8')
+    encoding = get_stream_enc(sys.stdin, 'utf-8')
+    line = py3compat.cast_unicode(line, encoding)
 
     if pattern is None:
         pattern = line_split

IPython/external/path/_path.py

@@ -602,7 +602,7 b' class path(unicode):'
         u'\x85', u'\r\x85', and u'\u2028'.
 
         (This is slightly different from when you open a file for
-        writing with fopen(filename, "w") in C or file(filename, 'w')
+        writing with fopen(filename, "w") in C or open(filename, 'w')
         in Python.)
 
 

IPython/external/pexpect/_pexpect.py

@@ -352,7 +352,7 b' class spawnb(object):'
         Example log input and output to a file::
 
             child = pexpect.spawn('some_command')
-            fout = file('mylog.txt','w')
+            fout = open('mylog.txt','w')
             child.logfile = fout
 
         Example log to stdout::

IPython/frontend/terminal/interactiveshell.py

@@ -31,6 +31,7 b' from IPython.core.usage import interactive_usage, default_banner'
 from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
 from IPython.core.pylabtools import pylab_activate
 from IPython.testing.skipdoctest import skip_doctest
+from IPython.utils.encoding import get_stream_enc
 from IPython.utils import py3compat
 from IPython.utils.terminal import toggle_set_term_title, set_term_title
 from IPython.utils.process import abbrev_cwd
@@ -319,7 +320,7 b' class TerminalInteractiveShell(InteractiveShell):'
 
         for i in range(hlen - hlen_before_cell):
             self.readline.remove_history_item(hlen - i - 1)
-        stdin_encoding = sys.stdin.encoding or "utf-8"
+        stdin_encoding = get_stream_enc(sys.stdin, 'utf-8')
         self.readline.add_history(py3compat.unicode_to_str(source_raw.rstrip(),
                                     stdin_encoding))
         return self.readline.get_current_history_length()
@@ -472,7 +473,7 b' class TerminalInteractiveShell(InteractiveShell):'
                 self.showtraceback()
             else:
                 try:
-                    f = file(err.filename)
+                    f = open(err.filename)
                     try:
                         # This should be inside a display_trap block and I
                         # think it is.

IPython/testing/tools.py

@@ -42,9 +42,10 b' except ImportError:'
 
 from IPython.config.loader import Config
 from IPython.utils.process import find_cmd, getoutputerror
-from IPython.utils.text import list_strings, getdefaultencoding
+from IPython.utils.text import list_strings
 from IPython.utils.io import temp_pyfile, Tee
 from IPython.utils import py3compat
+from IPython.utils.encoding import DEFAULT_ENCODING
 
 from . import decorators as dec
 from . import skipdoctest
@@ -322,7 +323,7 b' else:'
     # so we need a class that can handle both.
     class MyStringIO(StringIO):
         def write(self, s):
-            s = py3compat.cast_unicode(s, encoding=getdefaultencoding())
+            s = py3compat.cast_unicode(s, encoding=DEFAULT_ENCODING)
             super(MyStringIO, self).write(s)
 
 notprinted_msg = """Did not find {0!r} in printed output (on {1}):

IPython/utils/PyColorize.py

@@ -281,7 +281,7 b' If no filename is given, or if filename is -, read standard input."""'
         stream = sys.stdin
     else:
         try:
-            stream = file(fname)
+            stream = open(fname)
         except IOError,msg:
             print >> sys.stderr, msg
             sys.exit(1)

IPython/utils/_process_posix.py

@@ -26,6 +26,7 b' from .autoattr import auto_attr'
 from ._process_common import getoutput, arg_split
 from IPython.utils import text
 from IPython.utils import py3compat
+from IPython.utils.encoding import DEFAULT_ENCODING
 
 #-----------------------------------------------------------------------------
 # Function definitions
@@ -128,7 +129,7 b' class ProcessHandler(object):'
         int : child's exitstatus
         """
         # Get likely encoding for the output.
-        enc = text.getdefaultencoding()
+        enc = DEFAULT_ENCODING
         
         # Patterns to match on the output, for pexpect.  We read input and
         # allow either a short timeout or EOF

IPython/utils/_process_win32.py

@@ -29,6 +29,7 b' from subprocess import STDOUT'
 from ._process_common import read_no_interrupt, process_handler, arg_split as py_arg_split
 from . import py3compat
 from . import text
+from .encoding import DEFAULT_ENCODING
 
 #-----------------------------------------------------------------------------
 # Function definitions
@@ -94,7 +95,7 b' def _find_cmd(cmd):'
 
 def _system_body(p):
     """Callback for _system."""
-    enc = text.getdefaultencoding()
+    enc = DEFAULT_ENCODING
     for line in read_no_interrupt(p.stdout).splitlines():
         line = line.decode(enc, 'replace')
         print(line, file=sys.stdout)

IPython/utils/io.py

@@ -14,6 +14,7 b' from __future__ import print_function'
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
+import os
 import sys
 import tempfile
 
@@ -70,6 +71,11 b' class IOStream:'
     def close(self):
         pass
 
+# setup stdin/stdout/stderr to sys.stdin/sys.stdout/sys.stderr
+devnull = open(os.devnull, 'a')
+stdin = IOStream(sys.stdin, fallback=devnull)
+stdout = IOStream(sys.stdout, fallback=devnull)
+stderr = IOStream(sys.stderr, fallback=devnull)
 
 class IOTerm:
     """ Term holds the file or file-like objects for handling I/O operations.
@@ -82,14 +88,10 b' class IOTerm:'
     # this class will make it easier to embed it into other environments which
     # are not a normal terminal (such as a GUI-based shell)
     def __init__(self, stdin=None, stdout=None, stderr=None):
-        self.stdin  = IOStream(stdin, sys.stdin)
-        self.stdout = IOStream(stdout, sys.stdout)
-        self.stderr = IOStream(stderr, sys.stderr)
-
-# setup stdin/stdout/stderr to sys.stdin/sys.stdout/sys.stderr
-stdin = IOStream(sys.stdin)
-stdout = IOStream(sys.stdout)
-stderr = IOStream(sys.stderr)
+        mymodule = sys.modules[__name__]
+        self.stdin  = IOStream(stdin, mymodule.stdin)
+        self.stdout = IOStream(stdout, mymodule.stdout)
+        self.stderr = IOStream(stderr, mymodule.stderr)
 
 
 class Tee(object):

IPython/utils/jsonutil.py

@@ -17,6 +17,7 b' import types'
 from datetime import datetime
 
 from IPython.utils import py3compat
+from IPython.utils.encoding import DEFAULT_ENCODING
 from IPython.utils import text
 next_attr_name = '__next__' if py3compat.PY3 else 'next'
 
@@ -135,7 +136,7 b' def json_clean(obj):'
         return obj
     
     if isinstance(obj, bytes):
-        return obj.decode(text.getdefaultencoding(), 'replace')
+        return obj.decode(DEFAULT_ENCODING, 'replace')
     
     if isinstance(obj, container_to_list) or (
         hasattr(obj, '__iter__') and hasattr(obj, next_attr_name)):

IPython/utils/py3compat.py

@@ -6,19 +6,22 b' import sys'
 import re
 import types
 
+from .encoding import DEFAULT_ENCODING
+
 orig_open = open
 
 def no_code(x, encoding=None):
     return x
 
 def decode(s, encoding=None):
-    encoding = encoding or sys.stdin.encoding or sys.getdefaultencoding()
+    encoding = encoding or DEFAULT_ENCODING
     return s.decode(encoding, "replace")
 
 def encode(u, encoding=None):
-    encoding = encoding or sys.stdin.encoding or sys.getdefaultencoding()
+    encoding = encoding or DEFAULT_ENCODING
     return u.encode(encoding, "replace")
-    
+
+
 def cast_unicode(s, encoding=None):
     if isinstance(s, bytes):
         return decode(s, encoding)

IPython/utils/text.py

@@ -16,7 +16,6 b' Utilities for working with strings and text.'
 
 import __main__
 
-import locale
 import os
 import re
 import shutil
@@ -34,29 +33,6 b' from IPython.utils.data import flatten'
 # Code
 #-----------------------------------------------------------------------------
 
-# Less conservative replacement for sys.getdefaultencoding, that will try
-# to match the environment.
-# Defined here as central function, so if we find better choices, we
-# won't need to make changes all over IPython.
-def getdefaultencoding():
-    """Return IPython's guess for the default encoding for bytes as text.
-
-    Asks for stdin.encoding first, to match the calling Terminal, but that
-    is often None for subprocesses.  Fall back on locale.getpreferredencoding()
-    which should be a sensible platform default (that respects LANG environment),
-    and finally to sys.getdefaultencoding() which is the most conservative option,
-    and usually ASCII.
-    """
-    enc = sys.stdin.encoding
-    if not enc or enc=='ascii':
-        try:
-            # There are reports of getpreferredencoding raising errors
-            # in some cases, which may well be fixed, but let's be conservative here.
-            enc = locale.getpreferredencoding()
-        except Exception:
-            pass
-    return enc or sys.getdefaultencoding()
-
 def unquote_ends(istr):
     """Remove a single pair of quotes from the endpoints of a string."""
 

IPython/zmq/iostream.py

@@ -4,7 +4,7 b' from io import StringIO'
 
 from session import extract_header, Message
 
-from IPython.utils import io, text
+from IPython.utils import io, text, encoding
 
 #-----------------------------------------------------------------------------
 # Globals
@@ -69,7 +69,7 b' class OutStream(object):'
         else:
             # Make sure that we're handling unicode
             if not isinstance(string, unicode):
-                enc = text.getdefaultencoding()
+                enc = encoding.DEFAULT_ENCODING
                 string = string.decode(enc, 'replace')
             
             self._buffer.write(string)

IPython/zmq/kernelapp.py

@@ -251,7 +251,7 b' class KernelApp(BaseIPythonApplication):'
     def init_blackhole(self):
         """redirects stdout/stderr to devnull if necessary"""
         if self.no_stdout or self.no_stderr:
-            blackhole = file(os.devnull, 'w')
+            blackhole = open(os.devnull, 'w')
             if self.no_stdout:
                 sys.stdout = sys.__stdout__ = blackhole
             if self.no_stderr: