Convert str_to_unicode to str function call.

IPython/core/logger.py

@@ -1,220 +1,219
 """Logger class for IPython's logging facilities.
 """
 
 #*****************************************************************************
 #       Copyright (C) 2001 Janko Hauser <[e-mail]> and
 #       Copyright (C) 2001-2006 Fernando Perez <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
 #****************************************************************************
 # Modules and globals
 
 # Python standard modules
 import glob
 import io
 import os
 import time
 
-from IPython.utils.py3compat import str_to_unicode
 
 #****************************************************************************
 # FIXME: This class isn't a mixin anymore, but it still needs attributes from
 # ipython and does input cache management.  Finish cleanup later...
 
 class Logger(object):
     """A Logfile class with different policies for file creation"""
 
     def __init__(self, home_dir, logfname='Logger.log', loghead=u'',
                  logmode='over'):
 
         # this is the full ipython instance, we need some attributes from it
         # which won't exist until later. What a mess, clean up later...
         self.home_dir = home_dir
 
         self.logfname = logfname
         self.loghead = loghead
         self.logmode = logmode
         self.logfile = None
 
         # Whether to log raw or processed input
         self.log_raw_input = False
 
         # whether to also log output
         self.log_output = False
 
         # whether to put timestamps before each log entry
         self.timestamp = False
 
         # activity control flags
         self.log_active = False
 
     # logmode is a validated property
     def _set_mode(self,mode):
         if mode not in ['append','backup','global','over','rotate']:
             raise ValueError('invalid log mode %s given' % mode)
         self._logmode = mode
 
     def _get_mode(self):
         return self._logmode
 
     logmode = property(_get_mode,_set_mode)
 
     def logstart(self, logfname=None, loghead=None, logmode=None,
                  log_output=False, timestamp=False, log_raw_input=False):
         """Generate a new log-file with a default header.
 
         Raises RuntimeError if the log has already been started"""
 
         if self.logfile is not None:
             raise RuntimeError('Log file is already active: %s' %
                                self.logfname)
 
         # The parameters can override constructor defaults
         if logfname is not None: self.logfname = logfname
         if loghead is not None: self.loghead = loghead
         if logmode is not None: self.logmode = logmode
 
         # Parameters not part of the constructor
         self.timestamp = timestamp
         self.log_output = log_output
         self.log_raw_input = log_raw_input
 
         # init depending on the log mode requested
         isfile = os.path.isfile
         logmode = self.logmode
 
         if logmode == 'append':
             self.logfile = io.open(self.logfname, 'a', encoding='utf-8')
 
         elif logmode == 'backup':
             if isfile(self.logfname):
                 backup_logname = self.logfname+'~'
                 # Manually remove any old backup, since os.rename may fail
                 # under Windows.
                 if isfile(backup_logname):
                     os.remove(backup_logname)
                 os.rename(self.logfname,backup_logname)
             self.logfile = io.open(self.logfname, 'w', encoding='utf-8')
 
         elif logmode == 'global':
             self.logfname = os.path.join(self.home_dir,self.logfname)
             self.logfile = io.open(self.logfname, 'a', encoding='utf-8')
 
         elif logmode == 'over':
             if isfile(self.logfname):
                 os.remove(self.logfname)
             self.logfile = io.open(self.logfname,'w', encoding='utf-8')
 
         elif logmode == 'rotate':
             if isfile(self.logfname):
                 if isfile(self.logfname+'.001~'):
                     old = glob.glob(self.logfname+'.*~')
                     old.sort()
                     old.reverse()
                     for f in old:
                         root, ext = os.path.splitext(f)
                         num = int(ext[1:-1])+1
                         os.rename(f, root+'.'+repr(num).zfill(3)+'~')
                 os.rename(self.logfname, self.logfname+'.001~')
             self.logfile = io.open(self.logfname, 'w', encoding='utf-8')
 
         if logmode != 'append':
             self.logfile.write(self.loghead)
 
         self.logfile.flush()
         self.log_active = True
 
     def switch_log(self,val):
         """Switch logging on/off. val should be ONLY a boolean."""
 
         if val not in [False,True,0,1]:
             raise ValueError('Call switch_log ONLY with a boolean argument, '
                              'not with: %s' % val)
 
         label = {0:'OFF',1:'ON',False:'OFF',True:'ON'}
 
         if self.logfile is None:
             print("""
 Logging hasn't been started yet (use logstart for that).
 
 %logon/%logoff are for temporarily starting and stopping logging for a logfile
 which already exists. But you must first start the logging process with
 %logstart (optionally giving a logfile name).""")
 
         else:
             if self.log_active == val:
                 print('Logging is already',label[val])
             else:
                 print('Switching logging',label[val])
                 self.log_active = not self.log_active
                 self.log_active_out = self.log_active
 
     def logstate(self):
         """Print a status message about the logger."""
         if self.logfile is None:
             print('Logging has not been activated.')
         else:
             state = self.log_active and 'active' or 'temporarily suspended'
             print('Filename       :', self.logfname)
             print('Mode           :', self.logmode)
             print('Output logging :', self.log_output)
             print('Raw input log  :', self.log_raw_input)
             print('Timestamping   :', self.timestamp)
             print('State          :', state)
 
     def log(self, line_mod, line_ori):
         """Write the sources to a log.
 
         Inputs:
 
         - line_mod: possibly modified input, such as the transformations made
           by input prefilters or input handlers of various kinds. This should
           always be valid Python.
 
         - line_ori: unmodified input line from the user. This is not
           necessarily valid Python.
         """
 
         # Write the log line, but decide which one according to the
         # log_raw_input flag, set when the log is started.
         if self.log_raw_input:
             self.log_write(line_ori)
         else:
             self.log_write(line_mod)
 
     def log_write(self, data, kind='input'):
         """Write data to the log file, if active"""
 
         #print 'data: %r' % data # dbg
         if self.log_active and data:
             write = self.logfile.write
             if kind=='input':
                 if self.timestamp:
-                    write(str_to_unicode(time.strftime('# %a, %d %b %Y %H:%M:%S\n',
+                    write(str(time.strftime('# %a, %d %b %Y %H:%M:%S\n',
                                         time.localtime())))
                 write(data)
             elif kind=='output' and self.log_output:
                 odata = u'\n'.join([u'#[Out]# %s' % s
                                    for s in data.splitlines()])
                 write(u'%s\n' % odata)
             self.logfile.flush()
 
     def logstop(self):
         """Fully stop logging and close log file.
 
         In order to start logging again, a new logstart() call needs to be
         made, possibly (though not necessarily) with a new filename, mode and
         other options."""
 
         if self.logfile is not None:
             self.logfile.close()
             self.logfile = None
         else:
             print("Logging hadn't been started.")
         self.log_active = False
 
     # For backwards compatibility, in case anyone was using this.
     close_log = logstop

IPython/core/magics/logging.py

@@ -1,184 +1,183
 """Implementation of magic functions for IPython's own logging.
 """
 #-----------------------------------------------------------------------------
 #  Copyright (c) 2012 The IPython Development Team.
 #
 #  Distributed under the terms of the Modified BSD License.
 #
 #  The full license is in the file COPYING.txt, distributed with this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Stdlib
 import os
 import sys
 
 # Our own packages
 from IPython.core.magic import Magics, magics_class, line_magic
 from warnings import warn
-from IPython.utils.py3compat import str_to_unicode
 
 #-----------------------------------------------------------------------------
 # Magic implementation classes
 #-----------------------------------------------------------------------------
 
 @magics_class
 class LoggingMagics(Magics):
     """Magics related to all logging machinery."""
 
     @line_magic
     def logstart(self, parameter_s=''):
         """Start logging anywhere in a session.
 
         %logstart [-o|-r|-t] [log_name [log_mode]]
 
         If no name is given, it defaults to a file named 'ipython_log.py' in your
         current directory, in 'rotate' mode (see below).
 
         '%logstart name' saves to file 'name' in 'backup' mode.  It saves your
         history up to that point and then continues logging.
 
         %logstart takes a second optional parameter: logging mode. This can be one
         of (note that the modes are given unquoted):
 
         append
             Keep logging at the end of any existing file.
 
         backup
             Rename any existing file to name~ and start name.
 
         global
             Append to  a single logfile in your home directory.
 
         over
             Overwrite any existing log.
 
         rotate
             Create rotating logs: name.1~, name.2~, etc.
 
         Options:
 
           -o
             log also IPython's output. In this mode, all commands which
             generate an Out[NN] prompt are recorded to the logfile, right after
             their corresponding input line. The output lines are always
             prepended with a '#[Out]# ' marker, so that the log remains valid
             Python code.
 
           Since this marker is always the same, filtering only the output from
           a log is very easy, using for example a simple awk call::
 
             awk -F'#\\[Out\\]# ' '{if($2) {print $2}}' ipython_log.py
 
           -r
             log 'raw' input.  Normally, IPython's logs contain the processed
             input, so that user lines are logged in their final form, converted
             into valid Python.  For example, %Exit is logged as
             _ip.magic("Exit").  If the -r flag is given, all input is logged
             exactly as typed, with no transformations applied.
 
           -t
             put timestamps before each input line logged (these are put in
             comments).
         """
 
         opts,par = self.parse_options(parameter_s,'ort')
         log_output = 'o' in opts
         log_raw_input = 'r' in opts
         timestamp = 't' in opts
 
         logger = self.shell.logger
 
         # if no args are given, the defaults set in the logger constructor by
         # ipython remain valid
         if par:
             try:
                 logfname,logmode = par.split()
             except:
                 logfname = par
                 logmode = 'backup'
         else:
             logfname = logger.logfname
             logmode = logger.logmode
         # put logfname into rc struct as if it had been called on the command
         # line, so it ends up saved in the log header Save it in case we need
         # to restore it...
         old_logfile = self.shell.logfile
         if logfname:
             logfname = os.path.expanduser(logfname)
         self.shell.logfile = logfname
 
         loghead = u'# IPython log file\n\n'
         try:
             logger.logstart(logfname, loghead, logmode, log_output, timestamp,
                             log_raw_input)
         except:
             self.shell.logfile = old_logfile
             warn("Couldn't start log: %s" % sys.exc_info()[1])
         else:
             # log input history up to this point, optionally interleaving
             # output if requested
 
             if timestamp:
                 # disable timestamping for the previous history, since we've
                 # lost those already (no time machine here).
                 logger.timestamp = False
 
             if log_raw_input:
                 input_hist = self.shell.history_manager.input_hist_raw
             else:
                 input_hist = self.shell.history_manager.input_hist_parsed
 
             if log_output:
                 log_write = logger.log_write
                 output_hist = self.shell.history_manager.output_hist
                 for n in range(1,len(input_hist)-1):
                     log_write(input_hist[n].rstrip() + u'\n')
                     if n in output_hist:
-                        log_write(str_to_unicode(repr(output_hist[n])),'output')
+                        log_write(str(repr(output_hist[n])),'output')
             else:
                 logger.log_write(u'\n'.join(input_hist[1:]))
                 logger.log_write(u'\n')
             if timestamp:
                 # re-enable timestamping
                 logger.timestamp = True
 
             print ('Activating auto-logging. '
                    'Current session state plus future input saved.')
             logger.logstate()
 
     @line_magic
     def logstop(self, parameter_s=''):
         """Fully stop logging and close log file.
 
         In order to start logging again, a new %logstart call needs to be made,
         possibly (though not necessarily) with a new filename, mode and other
         options."""
         self.shell.logger.logstop()
 
     @line_magic
     def logoff(self, parameter_s=''):
         """Temporarily stop logging.
 
         You must have previously started logging."""
         self.shell.logger.switch_log(0)
 
     @line_magic
     def logon(self, parameter_s=''):
         """Restart logging.
 
         This function is for restarting logging which you've temporarily
         stopped with %logoff. For starting logging for the first time, you
         must use the %logstart function, which allows you to specify an
         optional log filename."""
 
         self.shell.logger.switch_log(1)
 
     @line_magic
     def logstate(self, parameter_s=''):
         """Print the status of the logging system."""
 
         self.shell.logger.logstate()

IPython/core/tests/test_profile.py

@@ -1,164 +1,164
 # coding: utf-8
 """Tests for profile-related functions.
 
 Currently only the startup-dir functionality is tested, but more tests should
 be added for:
 
     * ipython profile create
     * ipython profile list
     * ipython profile create --parallel
     * security dir permissions
 
 Authors
 -------
 
 * MinRK
 
 """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import os
 import shutil
 import sys
 import tempfile
 
 from unittest import TestCase
 
 import nose.tools as nt
 
 from IPython.core.profileapp import list_profiles_in, list_bundled_profiles
 from IPython.core.profiledir import ProfileDir
 
 from IPython.testing import decorators as dec
 from IPython.testing import tools as tt
 from IPython.utils import py3compat
 from IPython.utils.process import getoutput
 from IPython.utils.tempdir import TemporaryDirectory
 
 #-----------------------------------------------------------------------------
 # Globals
 #-----------------------------------------------------------------------------
 TMP_TEST_DIR = tempfile.mkdtemp()
 HOME_TEST_DIR = os.path.join(TMP_TEST_DIR, "home_test_dir")
 IP_TEST_DIR = os.path.join(HOME_TEST_DIR,'.ipython')
 
 #
 # Setup/teardown functions/decorators
 #
 
 def setup():
     """Setup test environment for the module:
 
             - Adds dummy home dir tree
     """
     # Do not mask exceptions here.  In particular, catching WindowsError is a
     # problem because that exception is only defined on Windows...
     os.makedirs(IP_TEST_DIR)
 
 
 def teardown():
     """Teardown test environment for the module:
 
             - Remove dummy home dir tree
     """
     # Note: we remove the parent test dir, which is the root of all test
     # subdirs we may have created.  Use shutil instead of os.removedirs, so
     # that non-empty directories are all recursively removed.
     shutil.rmtree(TMP_TEST_DIR)
 
 
 #-----------------------------------------------------------------------------
 # Test functions
 #-----------------------------------------------------------------------------
 def win32_without_pywin32():
     if sys.platform == 'win32':
         try:
             import pywin32
         except ImportError:
             return True
     return False
     
 
 class ProfileStartupTest(TestCase):
     def setUp(self):
         # create profile dir
         self.pd = ProfileDir.create_profile_dir_by_name(IP_TEST_DIR, 'test')
         self.options = ['--ipython-dir', IP_TEST_DIR, '--profile', 'test']
         self.fname = os.path.join(TMP_TEST_DIR, 'test.py')
         
     def tearDown(self):
         # We must remove this profile right away so its presence doesn't
         # confuse other tests.
         shutil.rmtree(self.pd.location)
 
     def init(self, startup_file, startup, test):
         # write startup python file
         with open(os.path.join(self.pd.startup_dir, startup_file), 'w') as f:
             f.write(startup)
         # write simple test file, to check that the startup file was run
         with open(self.fname, 'w') as f:
             f.write(py3compat.doctest_refactor_print(test))
 
     def validate(self, output):
         tt.ipexec_validate(self.fname, output, '', options=self.options)
 
     @dec.skipif(win32_without_pywin32(), "Test requires pywin32 on Windows")
     def test_startup_py(self):
         self.init('00-start.py', 'zzz=123\n', 
                   py3compat.doctest_refactor_print('print zzz\n'))
         self.validate('123')
 
     @dec.skipif(win32_without_pywin32(), "Test requires pywin32 on Windows")
     def test_startup_ipy(self):
         self.init('00-start.ipy', '%xmode plain\n', '')
         self.validate('Exception reporting mode: Plain')
 
     
 def test_list_profiles_in():
     # No need to remove these directories and files, as they will get nuked in
     # the module-level teardown.
     td = tempfile.mkdtemp(dir=TMP_TEST_DIR)
-    td = py3compat.str_to_unicode(td)
+    td = str(td)
     for name in ('profile_foo', 'profile_hello', 'not_a_profile'):
         os.mkdir(os.path.join(td, name))
     if dec.unicode_paths:
         os.mkdir(os.path.join(td, u'profile_ünicode'))
     
     with open(os.path.join(td, 'profile_file'), 'w') as f:
         f.write("I am not a profile directory")
     profiles = list_profiles_in(td)
     
     # unicode normalization can turn u'ünicode' into u'u\0308nicode',
     # so only check for *nicode, and that creating a ProfileDir from the
     # name remains valid
     found_unicode = False
     for p in list(profiles):
         if p.endswith('nicode'):
             pd = ProfileDir.find_profile_dir_by_name(td, p)
             profiles.remove(p)
             found_unicode = True
             break
     if dec.unicode_paths:
         nt.assert_true(found_unicode)
     nt.assert_equal(set(profiles), {'foo', 'hello'})
 
 
 def test_list_bundled_profiles():
     # This variable will need to be updated when a new profile gets bundled
     bundled = sorted(list_bundled_profiles())
     nt.assert_equal(bundled, [])
 
 
 def test_profile_create_ipython_dir():
     """ipython profile create respects --ipython-dir"""
     with TemporaryDirectory() as td:
         getoutput([sys.executable, '-m', 'IPython', 'profile', 'create',
              'foo', '--ipython-dir=%s' % td])
         profile_dir = os.path.join(td, 'profile_foo')
         assert os.path.exists(profile_dir)
         ipython_config = os.path.join(profile_dir, 'ipython_config.py')
         assert os.path.exists(ipython_config)
         

IPython/terminal/magics.py

@@ -1,206 +1,206
 """Extra magics for terminal use."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 
 from logging import error
 import os
 import sys
 
 from IPython.core.error import TryNext, UsageError
 from IPython.core.inputsplitter import IPythonInputSplitter
 from IPython.core.magic import Magics, magics_class, line_magic
 from IPython.lib.clipboard import ClipboardEmpty
 from IPython.utils.text import SList, strip_email_quotes
 from IPython.utils import py3compat
 
 def get_pasted_lines(sentinel, l_input=py3compat.input, quiet=False):
     """ Yield pasted lines until the user enters the given sentinel value.
     """
     if not quiet:
         print("Pasting code; enter '%s' alone on the line to stop or use Ctrl-D." \
               % sentinel)
         prompt = ":"
     else:
         prompt = ""
     while True:
         try:
-            l = py3compat.str_to_unicode(l_input(prompt))
+            l = str(l_input(prompt))
             if l == sentinel:
                 return
             else:
                 yield l
         except EOFError:
             print('<EOF>')
             return
 
 
 @magics_class
 class TerminalMagics(Magics):
     def __init__(self, shell):
         super(TerminalMagics, self).__init__(shell)
         self.input_splitter = IPythonInputSplitter()
 
     def store_or_execute(self, block, name):
         """ Execute a block, or store it in a variable, per the user's request.
         """
         if name:
             # If storing it for further editing
             self.shell.user_ns[name] = SList(block.splitlines())
             print("Block assigned to '%s'" % name)
         else:
             b = self.preclean_input(block)
             self.shell.user_ns['pasted_block'] = b
             self.shell.using_paste_magics = True
             try:
                 self.shell.run_cell(b)
             finally:
                 self.shell.using_paste_magics = False
 
     def preclean_input(self, block):
         lines = block.splitlines()
         while lines and not lines[0].strip():
             lines = lines[1:]
         return strip_email_quotes('\n'.join(lines))
 
     def rerun_pasted(self, name='pasted_block'):
         """ Rerun a previously pasted command.
         """
         b = self.shell.user_ns.get(name)
 
         # Sanity checks
         if b is None:
             raise UsageError('No previous pasted block available')
         if not isinstance(b, str):
             raise UsageError(
                 "Variable 'pasted_block' is not a string, can't execute")
 
         print("Re-executing '%s...' (%d chars)"% (b.split('\n',1)[0], len(b)))
         self.shell.run_cell(b)
 
     @line_magic
     def autoindent(self, parameter_s = ''):
         """Toggle autoindent on/off (if available)."""
 
         self.shell.set_autoindent()
         print("Automatic indentation is:",['OFF','ON'][self.shell.autoindent])
 
     @line_magic
     def cpaste(self, parameter_s=''):
         """Paste & execute a pre-formatted code block from clipboard.
 
         You must terminate the block with '--' (two minus-signs) or Ctrl-D
         alone on the line. You can also provide your own sentinel with '%paste
         -s %%' ('%%' is the new sentinel for this operation).
 
         The block is dedented prior to execution to enable execution of method
         definitions. '>' and '+' characters at the beginning of a line are
         ignored, to allow pasting directly from e-mails, diff files and
         doctests (the '...' continuation prompt is also stripped).  The
         executed block is also assigned to variable named 'pasted_block' for
         later editing with '%edit pasted_block'.
 
         You can also pass a variable name as an argument, e.g. '%cpaste foo'.
         This assigns the pasted block to variable 'foo' as string, without
         dedenting or executing it (preceding >>> and + is still stripped)
 
         '%cpaste -r' re-executes the block previously entered by cpaste.
         '%cpaste -q' suppresses any additional output messages.
 
         Do not be alarmed by garbled output on Windows (it's a readline bug).
         Just press enter and type -- (and press enter again) and the block
         will be what was just pasted.
 
         IPython statements (magics, shell escapes) are not supported (yet).
 
         See also
         --------
         paste: automatically pull code from clipboard.
 
         Examples
         --------
         ::
 
           In [8]: %cpaste
           Pasting code; enter '--' alone on the line to stop.
           :>>> a = ["world!", "Hello"]
           :>>> print " ".join(sorted(a))
           :--
           Hello world!
         """
         opts, name = self.parse_options(parameter_s, 'rqs:', mode='string')
         if 'r' in opts:
             self.rerun_pasted()
             return
 
         quiet = ('q' in opts)
 
         sentinel = opts.get('s', u'--')
         block = '\n'.join(get_pasted_lines(sentinel, quiet=quiet))
         self.store_or_execute(block, name)
 
     @line_magic
     def paste(self, parameter_s=''):
         """Paste & execute a pre-formatted code block from clipboard.
 
         The text is pulled directly from the clipboard without user
         intervention and printed back on the screen before execution (unless
         the -q flag is given to force quiet mode).
 
         The block is dedented prior to execution to enable execution of method
         definitions. '>' and '+' characters at the beginning of a line are
         ignored, to allow pasting directly from e-mails, diff files and
         doctests (the '...' continuation prompt is also stripped).  The
         executed block is also assigned to variable named 'pasted_block' for
         later editing with '%edit pasted_block'.
 
         You can also pass a variable name as an argument, e.g. '%paste foo'.
         This assigns the pasted block to variable 'foo' as string, without
         executing it (preceding >>> and + is still stripped).
 
         Options:
 
           -r: re-executes the block previously entered by cpaste.
 
           -q: quiet mode: do not echo the pasted text back to the terminal.
 
         IPython statements (magics, shell escapes) are not supported (yet).
 
         See also
         --------
         cpaste: manually paste code into terminal until you mark its end.
         """
         opts, name = self.parse_options(parameter_s, 'rq', mode='string')
         if 'r' in opts:
             self.rerun_pasted()
             return
         try:
             block = self.shell.hooks.clipboard_get()
         except TryNext as clipboard_exc:
             message = getattr(clipboard_exc, 'args')
             if message:
                 error(message[0])
             else:
                 error('Could not get text from the clipboard.')
             return
         except ClipboardEmpty:
             raise UsageError("The clipboard appears to be empty")
 
         # By default, echo back to terminal unless quiet mode is requested
         if 'q' not in opts:
             write = self.shell.write
             write(self.shell.pycolorize(block))
             if not block.endswith('\n'):
                 write('\n')
             write("## -- End pasted text --\n")
 
         self.store_or_execute(block, name)
 
     # Class-level: add a '%cls' magic only on Windows
     if sys.platform == 'win32':
         @line_magic
         def cls(self, s):
             """Clear screen.
             """
             os.system("cls")